{
"cells": [
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [],
"source": [
"# !pip install scikit-learn\n",
"# !pip install numpy\n",
"# !pip install pandas\n",
"# !pip install matplotlib\n",
"# !pip install seaborn"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"import sklearn\n",
"import numpy as np\n",
"import pandas as pd\n",
"import matplotlib.pyplot as plt\n",
"import seaborn as sns\n"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"10\n",
"10\n"
]
}
],
"source": [
"weights = [87,81,82,92,90,61,86,66,69,69]\n",
"heights = [187,174,179,192,188,160,179,168,168,174]\n",
"print(len(weights))\n",
"print(len(heights))"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"
\n",
" \n",
" \n",
" height \n",
" weight \n",
" \n",
" \n",
" \n",
" \n",
" 0 \n",
" 187 \n",
" 87 \n",
" \n",
" \n",
" 1 \n",
" 174 \n",
" 81 \n",
" \n",
" \n",
" 2 \n",
" 179 \n",
" 82 \n",
" \n",
" \n",
"
\n",
"
"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"#weight와 height간의 산점도\n",
"sns.scatterplot(data = body_df, x ='weight', y='height' )\n",
"plt.title('Weight vs. Height')\n",
"plt.xlabel('weight(kg)')\n",
"plt.ylabel('height(cm)')"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"sklearn.linear_model._base.LinearRegression"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#선형회귀 훈련(적합)\n",
"from sklearn.linear_model import LinearRegression\n",
"model_lr = LinearRegression()\n",
"type(model_lr)"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [],
"source": [
"# DataFrame[]: Series(데이터 프레임의 컬럼)\n",
"# DaraFream[[]]: DataFrame\n",
"\n",
"x = body_df[['weight']]\n",
"y = body_df[['height']]"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"
\n",
" \n",
" \n",
" weight \n",
" \n",
" \n",
" \n",
" \n",
" 0 \n",
" 87 \n",
" \n",
" \n",
" 1 \n",
" 81 \n",
" \n",
" \n",
" 2 \n",
" 82 \n",
" \n",
" \n",
"
\n",
"
\n",
"\n",
"
\n",
" \n",
" \n",
" height \n",
" \n",
" \n",
" \n",
" \n",
" 0 \n",
" 187 \n",
" \n",
" \n",
" 1 \n",
" 174 \n",
" \n",
" \n",
" 2 \n",
" 179 \n",
" \n",
" \n",
"
\n",
"
LinearRegression() In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. ` for more details.\n",
" |\n",
" | positive : bool, default=False\n",
" | When set to ``True``, forces the coefficients to be positive. This\n",
" | option is only supported for dense arrays.\n",
" |\n",
" | .. versionadded:: 0.24\n",
" |\n",
" | Attributes\n",
" | ----------\n",
" | coef_ : array of shape (n_features, ) or (n_targets, n_features)\n",
" | Estimated coefficients for the linear regression problem.\n",
" | If multiple targets are passed during the fit (y 2D), this\n",
" | is a 2D array of shape (n_targets, n_features), while if only\n",
" | one target is passed, this is a 1D array of length n_features.\n",
" |\n",
" | rank_ : int\n",
" | Rank of matrix `X`. Only available when `X` is dense.\n",
" |\n",
" | singular_ : array of shape (min(X, y),)\n",
" | Singular values of `X`. Only available when `X` is dense.\n",
" |\n",
" | intercept_ : float or array of shape (n_targets,)\n",
" | Independent term in the linear model. Set to 0.0 if\n",
" | `fit_intercept = False`.\n",
" |\n",
" | n_features_in_ : int\n",
" | Number of features seen during :term:`fit`.\n",
" |\n",
" | .. versionadded:: 0.24\n",
" |\n",
" | feature_names_in_ : ndarray of shape (`n_features_in_`,)\n",
" | Names of features seen during :term:`fit`. Defined only when `X`\n",
" | has feature names that are all strings.\n",
" |\n",
" | .. versionadded:: 1.0\n",
" |\n",
" | See Also\n",
" | --------\n",
" | Ridge : Ridge regression addresses some of the\n",
" | problems of Ordinary Least Squares by imposing a penalty on the\n",
" | size of the coefficients with l2 regularization.\n",
" | Lasso : The Lasso is a linear model that estimates\n",
" | sparse coefficients with l1 regularization.\n",
" | ElasticNet : Elastic-Net is a linear regression\n",
" | model trained with both l1 and l2 -norm regularization of the\n",
" | coefficients.\n",
" |\n",
" | Notes\n",
" | -----\n",
" | From the implementation point of view, this is just plain Ordinary\n",
" | Least Squares (scipy.linalg.lstsq) or Non Negative Least Squares\n",
" | (scipy.optimize.nnls) wrapped as a predictor object.\n",
" |\n",
" | Examples\n",
" | --------\n",
" | >>> import numpy as np\n",
" | >>> from sklearn.linear_model import LinearRegression\n",
" | >>> X = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])\n",
" | >>> # y = 1 * x_0 + 2 * x_1 + 3\n",
" | >>> y = np.dot(X, np.array([1, 2])) + 3\n",
" | >>> reg = LinearRegression().fit(X, y)\n",
" | >>> reg.score(X, y)\n",
" | 1.0\n",
" | >>> reg.coef_\n",
" | array([1., 2.])\n",
" | >>> reg.intercept_\n",
" | np.float64(3.0...)\n",
" | >>> reg.predict(np.array([[3, 5]]))\n",
" | array([16.])\n",
" |\n",
" | Method resolution order:\n",
" | LinearRegression\n",
" | sklearn.base.MultiOutputMixin\n",
" | sklearn.base.RegressorMixin\n",
" | LinearModel\n",
" | sklearn.base.BaseEstimator\n",
" | sklearn.utils._estimator_html_repr._HTMLDocumentationLinkMixin\n",
" | sklearn.utils._metadata_requests._MetadataRequester\n",
" | builtins.object\n",
" |\n",
" | Methods defined here:\n",
" |\n",
" | __init__(self, *, fit_intercept=True, copy_X=True, n_jobs=None, positive=False)\n",
" | Initialize self. See help(type(self)) for accurate signature.\n",
" |\n",
" | __sklearn_tags__(self)\n",
" |\n",
" | fit(self, X, y, sample_weight=None)\n",
" | Fit linear model.\n",
" |\n",
" | Parameters\n",
" | ----------\n",
" | X : {array-like, sparse matrix} of shape (n_samples, n_features)\n",
" | Training data.\n",
" |\n",
" | y : array-like of shape (n_samples,) or (n_samples, n_targets)\n",
" | Target values. Will be cast to X's dtype if necessary.\n",
" |\n",
" | sample_weight : array-like of shape (n_samples,), default=None\n",
" | Individual weights for each sample.\n",
" |\n",
" | .. versionadded:: 0.17\n",
" | parameter *sample_weight* support to LinearRegression.\n",
" |\n",
" | Returns\n",
" | -------\n",
" | self : object\n",
" | Fitted Estimator.\n",
" |\n",
" | set_fit_request(self: sklearn.linear_model._base.LinearRegression, *, sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$') -> sklearn.linear_model._base.LinearRegression from sklearn.utils._metadata_requests.RequestMethod.__get__.\n",
" | Request metadata passed to the ``fit`` method.\n",
" |\n",
" | Note that this method is only relevant if\n",
" | ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).\n",
" | Please see :ref:`User Guide ` on how the routing\n",
" | mechanism works.\n",
" |\n",
" | The options for each parameter are:\n",
" |\n",
" | - ``True``: metadata is requested, and passed to ``fit`` if provided. The request is ignored if metadata is not provided.\n",
" |\n",
" | - ``False``: metadata is not requested and the meta-estimator will not pass it to ``fit``.\n",
" |\n",
" | - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.\n",
" |\n",
" | - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.\n",
" |\n",
" | The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the\n",
" | existing request. This allows you to change the request for some\n",
" | parameters and not others.\n",
" |\n",
" | .. versionadded:: 1.3\n",
" |\n",
" | .. note::\n",
" | This method is only relevant if this estimator is used as a\n",
" | sub-estimator of a meta-estimator, e.g. used inside a\n",
" | :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.\n",
" |\n",
" | Parameters\n",
" | ----------\n",
" | sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED\n",
" | Metadata routing for ``sample_weight`` parameter in ``fit``.\n",
" |\n",
" | Returns\n",
" | -------\n",
" | self : object\n",
" | The updated object.\n",
" |\n",
" | set_score_request(self: sklearn.linear_model._base.LinearRegression, *, sample_weight: Union[bool, NoneType, str] = '$UNCHANGED$') -> sklearn.linear_model._base.LinearRegression from sklearn.utils._metadata_requests.RequestMethod.__get__.\n",
" | Request metadata passed to the ``score`` method.\n",
" |\n",
" | Note that this method is only relevant if\n",
" | ``enable_metadata_routing=True`` (see :func:`sklearn.set_config`).\n",
" | Please see :ref:`User Guide ` on how the routing\n",
" | mechanism works.\n",
" |\n",
" | The options for each parameter are:\n",
" |\n",
" | - ``True``: metadata is requested, and passed to ``score`` if provided. The request is ignored if metadata is not provided.\n",
" |\n",
" | - ``False``: metadata is not requested and the meta-estimator will not pass it to ``score``.\n",
" |\n",
" | - ``None``: metadata is not requested, and the meta-estimator will raise an error if the user provides it.\n",
" |\n",
" | - ``str``: metadata should be passed to the meta-estimator with this given alias instead of the original name.\n",
" |\n",
" | The default (``sklearn.utils.metadata_routing.UNCHANGED``) retains the\n",
" | existing request. This allows you to change the request for some\n",
" | parameters and not others.\n",
" |\n",
" | .. versionadded:: 1.3\n",
" |\n",
" | .. note::\n",
" | This method is only relevant if this estimator is used as a\n",
" | sub-estimator of a meta-estimator, e.g. used inside a\n",
" | :class:`~sklearn.pipeline.Pipeline`. Otherwise it has no effect.\n",
" |\n",
" | Parameters\n",
" | ----------\n",
" | sample_weight : str, True, False, or None, default=sklearn.utils.metadata_routing.UNCHANGED\n",
" | Metadata routing for ``sample_weight`` parameter in ``score``.\n",
" |\n",
" | Returns\n",
" | -------\n",
" | self : object\n",
" | The updated object.\n",
" |\n",
" | ----------------------------------------------------------------------\n",
" | Data and other attributes defined here:\n",
" |\n",
" | __abstractmethods__ = frozenset()\n",
" |\n",
" | __annotations__ = {'_parameter_constraints': }\n",
" |\n",
" | ----------------------------------------------------------------------\n",
" | Data descriptors inherited from sklearn.base.MultiOutputMixin:\n",
" |\n",
" | __dict__\n",
" | dictionary for instance variables\n",
" |\n",
" | __weakref__\n",
" | list of weak references to the object\n",
" |\n",
" | ----------------------------------------------------------------------\n",
" | Methods inherited from sklearn.base.RegressorMixin:\n",
" |\n",
" | score(self, X, y, sample_weight=None)\n",
" | Return the coefficient of determination of the prediction.\n",
" |\n",
" | The coefficient of determination :math:`R^2` is defined as\n",
" | :math:`(1 - \\frac{u}{v})`, where :math:`u` is the residual\n",
" | sum of squares ``((y_true - y_pred)** 2).sum()`` and :math:`v`\n",
" | is the total sum of squares ``((y_true - y_true.mean()) ** 2).sum()``.\n",
" | The best possible score is 1.0 and it can be negative (because the\n",
" | model can be arbitrarily worse). A constant model that always predicts\n",
" | the expected value of `y`, disregarding the input features, would get\n",
" | a :math:`R^2` score of 0.0.\n",
" |\n",
" | Parameters\n",
" | ----------\n",
" | X : array-like of shape (n_samples, n_features)\n",
" | Test samples. For some estimators this may be a precomputed\n",
" | kernel matrix or a list of generic objects instead with shape\n",
" | ``(n_samples, n_samples_fitted)``, where ``n_samples_fitted``\n",
" | is the number of samples used in the fitting for the estimator.\n",
" |\n",
" | y : array-like of shape (n_samples,) or (n_samples, n_outputs)\n",
" | True values for `X`.\n",
" |\n",
" | sample_weight : array-like of shape (n_samples,), default=None\n",
" | Sample weights.\n",
" |\n",
" | Returns\n",
" | -------\n",
" | score : float\n",
" | :math:`R^2` of ``self.predict(X)`` w.r.t. `y`.\n",
" |\n",
" | Notes\n",
" | -----\n",
" | The :math:`R^2` score used when calling ``score`` on a regressor uses\n",
" | ``multioutput='uniform_average'`` from version 0.23 to keep consistent\n",
" | with default value of :func:`~sklearn.metrics.r2_score`.\n",
" | This influences the ``score`` method of all the multioutput\n",
" | regressors (except for\n",
" | :class:`~sklearn.multioutput.MultiOutputRegressor`).\n",
" |\n",
" | ----------------------------------------------------------------------\n",
" | Methods inherited from LinearModel:\n",
" |\n",
" | predict(self, X)\n",
" | Predict using the linear model.\n",
" |\n",
" | Parameters\n",
" | ----------\n",
" | X : array-like or sparse matrix, shape (n_samples, n_features)\n",
" | Samples.\n",
" |\n",
" | Returns\n",
" | -------\n",
" | C : array, shape (n_samples,)\n",
" | Returns predicted values.\n",
" |\n",
" | ----------------------------------------------------------------------\n",
" | Methods inherited from sklearn.base.BaseEstimator:\n",
" |\n",
" | __getstate__(self)\n",
" | Helper for pickle.\n",
" |\n",
" | __repr__(self, N_CHAR_MAX=700)\n",
" | Return repr(self).\n",
" |\n",
" | __setstate__(self, state)\n",
" |\n",
" | __sklearn_clone__(self)\n",
" |\n",
" | get_params(self, deep=True)\n",
" | Get parameters for this estimator.\n",
" |\n",
" | Parameters\n",
" | ----------\n",
" | deep : bool, default=True\n",
" | If True, will return the parameters for this estimator and\n",
" | contained subobjects that are estimators.\n",
" |\n",
" | Returns\n",
" | -------\n",
" | params : dict\n",
" | Parameter names mapped to their values.\n",
" |\n",
" | set_params(self, **params)\n",
" | Set the parameters of this estimator.\n",
" |\n",
" | The method works on simple estimators as well as on nested objects\n",
" | (such as :class:`~sklearn.pipeline.Pipeline`). The latter have\n",
" | parameters of the form ``__`` so that it's\n",
" | possible to update each component of a nested object.\n",
" |\n",
" | Parameters\n",
" | ----------\n",
" | **params : dict\n",
" | Estimator parameters.\n",
" |\n",
" | Returns\n",
" | -------\n",
" | self : estimator instance\n",
" | Estimator instance.\n",
" |\n",
" | ----------------------------------------------------------------------\n",
" | Methods inherited from sklearn.utils._metadata_requests._MetadataRequester:\n",
" |\n",
" | get_metadata_routing(self)\n",
" | Get metadata routing of this object.\n",
" |\n",
" | Please check :ref:`User Guide ` on how the routing\n",
" | mechanism works.\n",
" |\n",
" | Returns\n",
" | -------\n",
" | routing : MetadataRequest\n",
" | A :class:`~sklearn.utils.metadata_routing.MetadataRequest` encapsulating\n",
" | routing information.\n",
" |\n",
" | ----------------------------------------------------------------------\n",
" | Class methods inherited from sklearn.utils._metadata_requests._MetadataRequester:\n",
" |\n",
" | __init_subclass__(**kwargs)\n",
" | Set the ``set_{method}_request`` methods.\n",
" |\n",
" | This uses PEP-487 [1]_ to set the ``set_{method}_request`` methods. It\n",
" | looks for the information available in the set default values which are\n",
" | set using ``__metadata_request__*`` class attributes, or inferred\n",
" | from method signatures.\n",
" |\n",
" | The ``__metadata_request__*`` class attributes are used when a method\n",
" | does not explicitly accept a metadata through its arguments or if the\n",
" | developer would like to specify a request value for those metadata\n",
" | which are different from the default ``None``.\n",
" |\n",
" | References\n",
" | ----------\n",
" | .. [1] https://www.python.org/dev/peps/pep-0487\n",
"\n"
]
}
],
"source": [
"help(sklearn.linear_model.LinearRegression)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"y = 0.86x + 109.37\n",
"를 활용하여 예측 컬럼을 추가\n",
"에러값을 각각 계산\n",
"양수를 만들기 위해 제곱 -> 모두 값을 더함(MSE)"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"
\n",
" \n",
" \n",
" height \n",
" weight \n",
" \n",
" \n",
" \n",
" \n",
" 0 \n",
" 187 \n",
" 87 \n",
" \n",
" \n",
" 1 \n",
" 174 \n",
" 81 \n",
" \n",
" \n",
" 2 \n",
" 179 \n",
" 82 \n",
" \n",
" \n",
"
\n",
"
\n",
"\n",
"
\n",
" \n",
" \n",
" height \n",
" weight \n",
" pred \n",
" \n",
" \n",
" \n",
" \n",
" 0 \n",
" 187 \n",
" 87 \n",
" 184.403858 \n",
" \n",
" \n",
" 1 \n",
" 174 \n",
" 81 \n",
" 179.228784 \n",
" \n",
" \n",
" 2 \n",
" 179 \n",
" 82 \n",
" 180.091296 \n",
" \n",
" \n",
"
\n",
"
\n",
"\n",
"
\n",
" \n",
" \n",
" height \n",
" weight \n",
" pred \n",
" error \n",
" \n",
" \n",
" \n",
" \n",
" 0 \n",
" 187 \n",
" 87 \n",
" 184.403858 \n",
" 2.596142 \n",
" \n",
" \n",
" 1 \n",
" 174 \n",
" 81 \n",
" 179.228784 \n",
" -5.228784 \n",
" \n",
" \n",
" 2 \n",
" 179 \n",
" 82 \n",
" 180.091296 \n",
" -1.091296 \n",
" \n",
" \n",
"
\n",
"
\n",
"\n",
"
\n",
" \n",
" \n",
" height \n",
" weight \n",
" pred \n",
" error \n",
" error^2 \n",
" \n",
" \n",
" \n",
" \n",
" 0 \n",
" 187 \n",
" 87 \n",
" 184.403858 \n",
" 2.596142 \n",
" 6.739951 \n",
" \n",
" \n",
" 1 \n",
" 174 \n",
" 81 \n",
" 179.228784 \n",
" -5.228784 \n",
" 27.340178 \n",
" \n",
" \n",
" 2 \n",
" 179 \n",
" 82 \n",
" 180.091296 \n",
" -1.091296 \n",
" 1.190927 \n",
" \n",
" \n",
"
\n",
"
"
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"sns.scatterplot(data = body_df, x = 'weight', y = 'height')\n",
"sns.lineplot(data = body_df, x = 'weight', y = 'pred', color = 'red')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"선형회귀 모델 평가\n",
"-회귀(숫자를 맞추는 방법) : MSE(수동계산은 10)\n",
"-R Square: 평균대비 설명력, 0이면 제일 낮음, 1일 수록 높음"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [],
"source": [
"from sklearn.metrics import mean_squared_error\n",
"from sklearn.metrics import r2_score"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [],
"source": [
"from sklearn.metrics import mean_squared_error, r2_score\n"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"10.152939045376309"
]
},
"execution_count": 25,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# 평가함수는 공통적으로 정답(실제 true), 예측값(pred)\n",
"y_true = body_df['height']\n",
"y_pred = body_df['pred']\n",
"mean_squared_error(y_true,y_pred)"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.8899887415172141"
]
},
"execution_count": 26,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"r2_score(y_true,y_pred)"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[184.40385835],\n",
" [179.22878362],\n",
" [180.09129608],\n",
" [188.71642061],\n",
" [186.99139571],\n",
" [161.97853455],\n",
" [183.54134589],\n",
" [166.29109682],\n",
" [168.87863418],\n",
" [168.87863418]])"
]
},
"execution_count": 27,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# 예측값 알아내는 또다른 코드 predict()\n",
"y_pred2 = model_lr.predict(body_df[['weight']])\n",
"y_pred2"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"10.152939045376309"
]
},
"execution_count": 28,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"mean_squared_error(y_true,y_pred2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"-Seaborn 시각화 라이블리는 기본적으로 데이터셋을 제공"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"\n",
"\n",
"
\n",
" \n",
" \n",
" total_bill \n",
" tip \n",
" sex \n",
" smoker \n",
" day \n",
" time \n",
" size \n",
" \n",
" \n",
" \n",
" \n",
" 0 \n",
" 16.99 \n",
" 1.01 \n",
" Female \n",
" No \n",
" Sun \n",
" Dinner \n",
" 2 \n",
" \n",
" \n",
" 1 \n",
" 10.34 \n",
" 1.66 \n",
" Male \n",
" No \n",
" Sun \n",
" Dinner \n",
" 3 \n",
" \n",
" \n",
" 2 \n",
" 21.01 \n",
" 3.50 \n",
" Male \n",
" No \n",
" Sun \n",
" Dinner \n",
" 3 \n",
" \n",
" \n",
"
\n",
"
LinearRegression() In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. "
]
},
"execution_count": 35,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"sns.scatterplot(data = tips_df, x= tips_df['total_bill'], y=tips_df['tip'])"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {},
"outputs": [],
"source": [
"# y(tip) = w1*x(totall_bill) + w0\n",
"w1_tip = model_lr2.coef_[0][0]\n",
"w0_tip = model_lr2.intercept_[0]"
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"y = 0.11x + 0.92\n"
]
}
],
"source": [
"print('y = {}x + {}'.format(w1_tip.round(2),w0_tip.round(2)))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"전체 결제금액이 1달러 오를 때 팁은 0.11달러씩 추가된다.\n",
"100달러 오를 때, 팁은 11달러 씩 추가된다."
]
},
{
"cell_type": "code",
"execution_count": 50,
"metadata": {},
"outputs": [],
"source": [
"# 예측값 생성\n",
"y_true_tip = tips_df['tip']\n",
"y_pred_tip = model_lr2.predict(tips_df[['total_bill']])\n",
"\n",
"#y_pred_tip도 tips_df에 컬럼으로 넣어주기\n",
"tips_df['pred'] = y_pred_tip \n"
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0 1.01\n",
"1 1.66\n",
"2 3.50\n",
"3 3.31\n",
"4 3.61\n",
"Name: tip, dtype: float64"
]
},
"execution_count": 43,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"y_true_tip[:5]"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[2.70463616],\n",
" [2.00622312],\n",
" [3.12683472],\n",
" [3.40725019],\n",
" [3.5028225 ]])"
]
},
"execution_count": 44,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"y_pred_tip[:5]"
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1.036019442011377"
]
},
"execution_count": 46,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"mean_squared_error(y_true_tip, y_pred_tip)"
]
},
{
"cell_type": "code",
"execution_count": 47,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.45661658635167657"
]
},
"execution_count": 47,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"r2_score(y_true_tip, y_pred_tip)\n",
"\n",
"# 45%정도는 상당히 낮은 확률이므로 그렇게 좋은 데이터는 아니다!"
]
},
{
"cell_type": "code",
"execution_count": 54,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
""
]
},
"execution_count": 54,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAjIAAAHHCAYAAACle7JuAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAa45JREFUeJzt3XlcVPX6B/DPMDDsDAiioKAk5I6ilimoqa2mqdlmWi6VmVte63fTbmZ2u5m32+ZaWi6ZWpmprbdMC9drLphabhgKiYkozDAMMAOc3x/HGRiYnRlmzvB5v168inPOnPPMAec8fJfnKxMEQQARERGRBPl5OgAiIiIiZzGRISIiIsliIkNERESSxUSGiIiIJIuJDBEREUkWExkiIiKSLCYyREREJFlMZIiIiEiymMgQERGRZDGRIaIG+fnnnyGTyfDzzz/b/Zo1a9ZAJpPh0KFDNo+99dZbceuttxq/P3/+PGQyGdasWWPc9vLLL0MmkzkQtXfztfdD5E5MZIgkSCaT2fVlT3Lx2muvYevWrW6P2ZP0ej1iYmKQkZFh8RhBEJCQkIAePXoYt50/fx4TJkxAu3btEBQUhJYtW6J///6YN2+ewzG0bdvWrp9Z7QSNiGzz93QAROS4devWmXz/0UcfYfv27fW2d+zY0ea5XnvtNdx///0YMWKEK0N0mR9++KHB5wgICMADDzyA999/HxcuXECbNm3qHbNr1y78+eef+Nvf/gYAyM7Oxk033YTg4GBMnDgRbdu2xaVLl3DkyBEsXLgQ8+fPdyiGd955BxqNxvj9t99+i40bN+Ltt99GTEyMcXvfvn0xduxYzJ4928l3S9S0MJEhkqCxY8eafP+///0P27dvr7fdFygUCpecZ8yYMXjvvfewceNGs0nChg0b4Ofnh4cffhgA8Pbbb0Oj0eDo0aP1Ep+CggKHr183Ufzrr7+wceNGjBgxAm3btq13vL8/P56J7MGuJSIfVVpaimeffRYJCQkIDAxE+/bt8Z///Ae1F7yXyWQoLS3F2rVrjV0b48ePBwBcuHABU6ZMQfv27REcHIzo6Gg88MADOH/+vMti1Gq1eOqppxAdHY2IiAg89thjKCoqMjmm7hgZZ6Wnp6Nt27bYsGFDvX16vR6ff/45Bg4ciPj4eADAuXPn0Lp1a7OtN7GxsQ2OxxpzY2RkMhmmTZuG9evXo3379ggKCkLPnj2xa9cut8ZC5O2YyBD5IEEQcO+99+Ltt9/GXXfdhbfeegvt27fH//3f/2HWrFnG49atW4fAwED069cP69atw7p16/DUU08BAA4ePIh9+/bh4YcfxqJFizB58mTs2LEDt956K7RarUvinDZtGk6ePImXX34Zjz32GNavX48RI0aYJFuuIpPJ8Mgjj+D48eP47bffTPb997//xbVr1zBmzBjjtjZt2iAvLw87d+50eSzOyszMxMyZMzF27Fi88soruHr1Ku666y6cOHHC06EReY5ARJI3depUofY/561btwoAhFdffdXkuPvvv1+QyWRCdna2cVtoaKgwbty4eufUarX1tu3fv18AIHz00UfGbT/99JMAQPjpp5/sjnf16tUCAKFnz56CTqczbv/3v/8tABC2bdtm3DZgwABhwIABxu9zcnIEAMLq1auN2+bNmyfY83H222+/CQCEOXPmmGx/+OGHhaCgIEGlUhm3nThxQggODhYACN27dxeeeeYZYevWrUJpaand79OaN954QwAg5OTk1Ntn7v0AEAAIhw4dMm67cOGCEBQUJIwcOdIlMRFJEVtkiHzQt99+C7lcjhkzZphsf/bZZyEIAr777jub5wgODjb+v16vx9WrV5GcnIzIyEgcOXLEJXFOmjQJAQEBxu+ffvpp+Pv749tvv3XJ+evq1KkT0tLS8Mknnxi3lZaW4ssvv8TQoUMRERFh3N65c2ccPXoUY8eOxfnz5/Huu+9ixIgRaNGiBVauXOmW+Gzp06cPevbsafw+MTERw4cPx/fff4+qqiqPxETkaUxkiHzQhQsXEB8fj/DwcJPthllMFy5csHmOsrIyvPTSS8YxNjExMWjevDmKi4uhUqlcEmdKSorJ92FhYYiLi3PpOJy6xowZg5ycHOzbtw8AsHXrVmi1WpNuJYMbb7wR69atQ2FhIY4dO4bXXnsN/v7+mDRpEn788Ue3xWhJ3ftliFGr1eLKlSuNHg+RN2AiQ0RmTZ8+Hf/617/w4IMP4rPPPsMPP/yA7du3Izo6GtXV1Z4Oz2mjR4+Gn5+fcdDvhg0bEBUVhSFDhlh8jVwuR9euXTFnzhxs2bIFALB+/fpGiZeIrGMiQ+SD2rRpg/z8fJSUlJhsP3XqlHG/gaUKsp9//jnGjRuHN998E/fffz9uv/12ZGRkoLi42GVxnj171uR7jUaDS5cumZ2O7Crx8fEYOHAgNm3ahMuXL2P79u24//777Z7m3atXLwDApUuX3BajJXXvFwCcOXMGISEhaN68eaPHQ+QNmMgQ+aAhQ4agqqoKS5YsMdn+9ttvQyaT4e677zZuCw0NNZucyOXyerOHFi9e7NKxGCtWrIBerzd+v3z5clRWVprE5w5jxoxBQUEBnnrqKej1erPdSrt37zaJzcAwfqd9+/bGbZcuXcKpU6fMHu9K+/fvNxmflJeXh23btuGOO+6AXC5367WJvBUrLhH5oGHDhmHgwIH4xz/+gfPnz6Nbt2744YcfsG3bNsycORPt2rUzHtuzZ0/8+OOPeOuttxAfH4+kpCT07t0bQ4cOxbp166BUKtGpUyfs378fP/74I6Kjo10Wp06nw+DBg/Hggw/i9OnTWLZsGTIyMnDvvfe67BrmjBo1ClOmTMG2bduQkJCA/v371ztm4cKFOHz4MO677z6kpqYCAI4cOYKPPvoIzZo1w8yZM43HzpkzB2vXrkVOTo5bW5O6dOmCO++8EzNmzEBgYCCWLVsGAA5XGSbyJUxkiHyQn58fvvzyS7z00kv49NNPsXr1arRt2xZvvPEGnn32WZNj33rrLUyaNAkvvvgiysrKMG7cOPTu3Rvvvvsu5HI51q9fj/LycqSnp+PHH3/EnXfe6bI4lyxZgvXr1+Oll16CXq/H6NGjsWjRIrcvmBgREYFhw4Zh06ZNGD16tNnrvfDCC9iwYQMyMzOxfv16aLVaxMXF4eGHH8bcuXORlJTk1hjNGTBgAPr06YP58+cjNzcXnTp1wpo1a4yJFlFTJBPqth0TEZHXkclkmDp1ar3uQqKmjmNkiIiISLLYtURELlNWVmazxkyzZs1cthAkERETGSJymU8//RQTJkywesxPP/3kkkUgiYgAjpEhIhe6dOlSvQUZ6+rZsyeioqIaKSIi8nVMZIiIiEiyONiXiIiIJMvnx8hUV1cjPz8f4eHhbq9NQURERK4hCAJKSkoQHx8PPz/L7S4+n8jk5+cjISHB02EQERGRE/Ly8tC6dWuL+30+kQkPDwcg3oiIiAgPR0NERET2UKvVSEhIMD7HLfH5RMbQnRQREcFEhoiISGJsDQvhYF8iIiKSLCYyREREJFlMZIiIiEiymMgQERGRZDGRISIiIsliIkNERESSxUSGiIiIJIuJDBEREUkWExkiIiKSLCYyREREJFkeTWR27dqFYcOGIT4+HjKZDFu3bjXZLwgCXnrpJcTFxSE4OBi33XYbzp4965lgiYiIyEil1eFcgQZZuUU4d0UDlVbnkTg8msiUlpaiW7duWLp0qdn9//73v7Fo0SK89957OHDgAEJDQ3HnnXeivLy8kSMlIiIig/ziMkzbmIXBb2Vi5LJ9GPxmJqZvzEJ+cVmjxyITBEFo9KuaIZPJsGXLFowYMQKA2BoTHx+PZ599Fs899xwAQKVSoUWLFlizZg0efvhhu86rVquhVCqhUqm4aCQREVEDqbQ6TNuYhd1nC+vt658Sg8Wj06AMUTT4OvY+v712jExOTg7++usv3HbbbcZtSqUSvXv3xv79+y2+rqKiAmq12uSLiIiIXKNQozObxADArrOFKNQ0bheT1yYyf/31FwCgRYsWJttbtGhh3GfOggULoFQqjV8JCQlujZOIiKgpUZfrre4vsbHf1bw2kXHWnDlzoFKpjF95eXmeDomIiMhnRAQFWN0fbmO/q3ltItOyZUsAwOXLl022X7582bjPnMDAQERERJh8ERERkWvEhCnQPyXG7L7+KTGICWv4+BhHeG0ik5SUhJYtW2LHjh3GbWq1GgcOHECfPn08GBkREVHTpQxR4PVRqfWSmf4pMVg4KtUlA30d4d+oV6tDo9EgOzvb+H1OTg6OHj2KZs2aITExETNnzsSrr76KlJQUJCUlYe7cuYiPjzfObCIiIqLGFx8ZjMWj01Co0aGkXI/woADEhCkaPYkBPJzIHDp0CAMHDjR+P2vWLADAuHHjsGbNGvz9739HaWkpJk2ahOLiYmRkZOC///0vgoKCPBUyERERQWyZ8UTiUpfX1JFxF9aRISIikh7J15EhIiIisoWJDBEREUkWExkiIiKSLCYyREREJFlMZIiIiEiymMgQERGRZDGRISIiIsliIkNERESSxUSGiIiIJIuJDBEREUkWExkiIiKSLCYyREREJFlMZIiIiEiymMgQERGRZDGRISIiIsliIkNERESSxUSGiIiIJIuJDBEREUkWExkiIiKSLCYyREREJFlMZIiIiEiymMgQERGRZDGRISIiIsliIkNERESSxUSGiIiIJIuJDBEREUmWv6cDICIiIvdQaXUo1OigLtcjIjgAMaEKKEMUng7LpZjIEBER+aD84jI8v/kYdp8tNG7rnxKD10elIj4y2IORuRa7loiIiHyMSqurl8QAwK6zhZi9+RhUWp2HInM9JjJEREQ+plCjq5fEGOw6W4hCDRMZIiIi8lLqcr3V/SU29ksJExkiIiIfExEUYHV/uI39UsJEhoiIyMfEhCnQPyXG7L7+KTGICfOdmUtMZIiIiHyMMkSB10el1ktm+qfEYOGoVJ+ags3p10RERD4oPjIYi0enoVCjQ0m5HuFBAYgJYx0ZIiIikghliO8lLnWxa4mIiIgki4kMERERSRYTGSIiIpIsJjJEREQkWUxkiIiISLKYyBAREZFkMZEhIiIiyWIiQ0RERJLFRIaIiIgki4kMERERSRYTGSIiIpIsJjJEREQkWUxkiIiISLKYyBAREZFkMZEhIiIiyWIiQ0RERJLFRIaIiIgki4kMERERSRYTGSIiIpIsJjJEREQkWUxkiIiISLKYyBAREZFkMZEhIiIiyWIiQ0RERJLFRIaIiIgki4kMERERSRYTGSIiIpIsr05kqqqqMHfuXCQlJSE4OBjt2rXDP//5TwiC4OnQiIiIyAv4ezoAaxYuXIjly5dj7dq16Ny5Mw4dOoQJEyZAqVRixowZng6PiIiIPMyrE5l9+/Zh+PDhuOeeewAAbdu2xcaNG/HLL794ODIiIiLyBl7dtdS3b1/s2LEDZ86cAQD8+uuv2LNnD+6++26Lr6moqIBarTb5IiIiIt/k1S0ys2fPhlqtRocOHSCXy1FVVYV//etfGDNmjMXXLFiwAPPnz2/EKImIiMhTvLpF5rPPPsP69euxYcMGHDlyBGvXrsV//vMfrF271uJr5syZA5VKZfzKy8trxIiJiIioMckEL54ClJCQgNmzZ2Pq1KnGba+++io+/vhjnDp1yq5zqNVqKJVKqFQqREREuCtUIiIiciF7n99e3SKj1Wrh52caolwuR3V1tYciIiIiIm/i1WNkhg0bhn/9619ITExE586dkZWVhbfeegsTJ070dGhERETkBby6a6mkpARz587Fli1bUFBQgPj4eIwePRovvfQSFAqFXedg1xIREZH02Pv89upExhWYyBAREUmPT4yRISIiIrKGiQwRERFJFhMZIiIikiwmMkRERCRZTGSIiIhIsry6jgwRETUtKq0OhRod1OV6RAQHICZUAWWIfeU2qGliIkNERF4hv7gMz28+ht1nC43b+qfE4PVRqYiPDPZgZOTN2LVEREQep9Lq6iUxALDrbCFmbz4GlVbnocjI2zGRISIijyvU6OolMQa7zhaiUMNEhsxjIkNERB6nLtdb3V9iYz81XUxkiIjI4yKCAqzuD7exn5ouJjJERORxMWEK9E+JMbuvf0oMYsI4c4nMYyJDREQepwxR4PVRqfWSmf4pMVg4KpVTsMkiTr8mIiKvEB8ZjMWj01Co0aGkXI/woADEhLGODFnHRIaIiLyGMoSJCzmGXUtEREQkWUxkiIiISLKYyBAREZFkMZEhIiIiyWIiQ0RERJLFRIaIiIgki4kMERERSRYTGSIiIpIsJjJEREQkWUxkiIiISLKYyBAREZFkMZEhIiIiyWIiQ0RERJLFRIaIiIgki4kMERERSRYTGSIiIpIsJjJEREQkWUxkiIiISLKYyBAREZFkMZEhIiIiyWIiQ0RERJLFRIaIiIgky9/TARAREZHrqbQ6FGp0UJfrEREcgJhQBZQhCk+H5XJMZIiIfERTeXCRbfnFZXh+8zHsPlto3NY/JQavj0pFfGSwByNzPSYyREQ+oCk9uMg6lVZX73cBAHadLcTszceweHSaTyW4HCNDRCRxth5cKq3OQ5GRJxRqdPV+Fwx2nS1Eoca3fh+YyBARSVxTe3CRdepyvdX9JTb2Sw0TGSIiiWtqDy6yLiIowOr+cBv7pYaJDBGRxDW1BxdZFxOmQP+UGLP7+qfEICbMd8bHAExkiIgkr6k9uMg6ZYgCr49Krfc70T8lBgtHpfrUQF8AkAmCIHg6CHdSq9VQKpVQqVSIiIjwdDhEkiX1qb1Sj9+W/OIyzN58DLvqzFpaOCoVcZy11CQZfudLyvUIDwpATJi0fuftfX5z+jUR2ST1qb1Sj98e8ZHBWDw6TdIPLnItZUjT+Pmza4mIrJL61F6px+8IZYgC7WLD0D0xCu1iw5rEQ4yIiQwRWSX1qb1Sj5+IrGMiQ0RWSX1qr9TjJyLrmMgQkVVSn9or9fiJyDomMkRkldSn9ko9fiKyjokMEVkl9ZoUUo+fiKxjHRkisovUa1JIPX6ipoZ1ZIjIpaRek0Lq8ROReexaIiIiIsliIkNERESSxUSGiIiIHCcIwO7dwJgxQEGBx8JgIkNERET2KykB3nsP6NYN6N8f2LABWLXKY+FwsC8RERHZ9vvvwPLlwNq1YjIDACEhYovMPfd4LCwmMkRERGSeXg9s3QosWwb8/HPN9vbtgSlTgMceAyIjPRSciIkMERERmbp4EVi5ElixArh0SdwmlwPDh4sJzKBBgEzm2RivYyJDRERE4uDdn38Gli4VW2GqqsTtLVoAkyaJX61bezJCs5jIEBERNWUqFfDRR2L30alTNdv79wemTgVGjAAU3ltM0utnLV28eBFjx45FdHQ0goOD0bVrVxw6dMjTYRERuYxKq8O5Ag2ycotw7ooGKq3O0yFRU/Drr8DkyUCrVsCMGWISExYmdh0dPw5kZgIPPujVSQzg5S0yRUVFSE9Px8CBA/Hdd9+hefPmOHv2LKKiojwdGhGRS+QXl+H5zcew+2yhcVv/lBi8PioV8ZHBHoyMfFJFBbB5s9j6sndvzfbOncUEZuxYQGLrEnr1opGzZ8/G3r17sXv3bqfPwUUjichbqbQ6TNuYZZLEGPRPicHi0WlcH4pcIzcXeP994IMPaorX+fsDo0aJCUy/fl4zeNfAJxaN/PLLL3HnnXfigQceQGZmJlq1aoUpU6bgySeftPiaiooKVFRUGL9Xq9WNESoRSZxhdWx1uR4RwQGICXX/IpOFGp3ZJAYAdp0tRKFGx0SGnFddDfz4ozh49+uvxe8BsSvpqaeAJ54A4uI8G6MLeHUi88cff2D58uWYNWsWXnjhBRw8eBAzZsyAQqHAuHHjzL5mwYIFmD9/fiNHSkRS5qnuHXW53ur+Ehv7icwqKgJWrxaL12Vn12wfPFhsfbn3XrE1xkd4ddeSQqFAr169sG/fPuO2GTNm4ODBg9i/f7/Z15hrkUlISGDXEhGZ5cnunXMFGgx+K9Pi/h2zBqBdbJhbrk0+6PBhcezLxo1AWZm4TakExo8XB/V26ODR8BzlE11LcXFx6NSpk8m2jh07YvPmzRZfExgYiMDAQHeHRkQO8ES3jb082b0TE6ZA/5QY7LKQRMWEecc9Ii9WXg589pnYffTLLzXbu3UTp04/8ggQGuq5+BqBVycy6enpOH36tMm2M2fOoE2bNh6KiIgc5e2zcjzZvaMMUeD1UamYvfmYSTLTPyUGC0elek2yR17ojz/EhRtXrQKuXhW3KRTAAw+I3Ud9+njd4F138epE5m9/+xv69u2L1157DQ8++CB++eUXrFixAitWrPB0aERkB5VWVy+JAcSWjtmbj3nFrJyIoACr+8Nt7G+o+MhgLB6dhkKNDiXleoQHBSAmzHtarMiLVFUB//2v2H303XdiJV4AaNNG7DqaOBGIjfVsjB7g1YnMTTfdhC1btmDOnDl45ZVXkJSUhHfeeQdjxozxdGhEZAcpzMrxhu4dZQgTF7KisFBseXnvPSAnp2b7XXeJrS9DhojrIDVRXp3IAMDQoUMxdOhQT4dBRE6Qwqwcdu+QVxIE4MABsfXls8/EQnYAEBUltrxMngwkJ3s2Ri/h9YkMEUmXp7tt7MXuHfIaWq0462jZMuDIkZrtvXqJg3cfeggI9vzYMm/CRIaI3MYbum3sxe4d8qgzZ8S6L2vWAMXF4rbAQGD0aLH76KabPBmdV2MiQ0QOcWQqNbttiKyorBQr7i5bBmzfXrP9hhuAp58GJkwAoqM9F59EMJEhIrs5M5Wa3TZEdVy+LK559P77QF6euE0mA4YOFVtf7rgD8PPzbIwSwkSGiOzSkKnUvtpt482F/sjLCIK42vTSpeLq0/rrA91jYsQ1j556Cmjb1qMhSpXTicyhQ4dw8uRJAGK13V69erksKCLyPlKYSt2YvL3QH3kJjQb4+GOx++j48ZrtffqIrS/33w8EBXkuPh/gcCLz559/YvTo0di7dy8iIyMBAMXFxejbty8++eQTtG7d2tUxEpEXkMJU6sYihUJ/5GG//y4O3l27FigpEbeFhABjxojjX9LSPBufD3G4E+6JJ56AXq/HyZMnce3aNVy7dg0nT55EdXU1nnjiCXfESEReQCpTqRuDPa1T1ATp9cDnnwMDBwKdOwNLlohJzI03Au+8A1y8CKxYwSTGxRxukcnMzMS+ffvQvn1747b27dtj8eLF6Nevn0uDIyLvIaWp1O7G1ikykZ8vJigrVgCXLonb/PyA4cPF7qPBg5vMukee4HAik5CQAL2+/j/SqqoqxMfHuyQoIvI+nEpdg61TBEEAfv5ZHPuyZYu4DhIAtGgBTJoEPPkkkJDg0RCbCocTmTfeeAPTp0/H0qVLjQN8Dx06hGeeeQb/+c9/XB4gEXkPTqUWsXWqCVOpgHXrxATm+oQXAED//mLry8iR4irU1GhkgmBYPtM+UVFR0Gq1qKyshL+/mAcZ/j80NNTk2GvXrrkuUiep1WoolUqoVCpERER4Ohwi8hH5xWUWW6fiOGvJ9xw7JiYvH38MlJaK28LCgEcfFQfvdu3q2fh8kL3Pb4dbZN55552GxEVE5BPYOtUE6HRizZdly4A9e2q2d+okrns0dizAP5A9zuFEZty4ce6Ig4hIcny10F+Tl5srVt394AOgoEDc5u8P3Hef2H3Uvz8H73oRuxIZtVptbNZRq9VWj2X3DRERSU51NfDjj2Lry1dfid8DQHy8WHX3iSfE/yevY1ciExUVhUuXLiE2NhaRkZGQmclEBUGATCZDlWHkNhERkbcrKhJXnF6+HDh7tmb74MFi68uwYUAAZ6F5M7sSmZ07d6JZs2YAgNWrVyMhIQFyudzkmOrqauTm5ro+QiIiIlc7ckRc92jjRqCsTNwWEQGMHy8O3u3QwaPhkf0cnrUkl8uNrTO1Xb16FbGxsV7XIsNZS0REBAAoLwc++0zsPjpwoGZ7aqo4eHfMGKDO7FvyHLfNWjJ0IdWl0WgQxIWviIjI2+TkAO+9B3z4IXD1qrhNoQAeeEDsPurTh4N3JczuRGbWrFkAAJlMhrlz5yIkJMS4r6qqCgcOHED37t1dHiARETlPpdWhUKODulyPiOAAxIQ2kZlWVVXA99+L3UfffSdW4gWAxERg8mTg8ceBOj0LJE12JzJZWVkAxBaZ48ePQ1GrcqFCoUC3bt3w3HPPuT5CImpSmuyD1w0uFZfh5zNXEBseiIrKahRp9fgl5xpuvbG57xbtKywEVq0SW2Bycmq233mn2H00ZAhQZ4wnSZvdicxPP/0EAJgwYQLeffddjjfxYnwQkFTlF5fh+c3HTFaW7p8Sg9dHpSLegw9eKf6bUml1uHBNi6+P5WNv9lXj9vTkaCTFhCJEIff692A3QQB++UVsffnsM6CiQtweFQVMnCi2wCQnezZGchuHB/tKTVMb7OutDwIiW1RaHaZtzDL53TXonxKDxaPTPPLgleq/qQuFpXhh63GTJMYgPTkar43oijYxEh/YqtWKs46WLRNnIRn07Cm2vjz8MBDsvT8jss7e57dfI8ZEbqbS6up94ALArrOFmL35GFRanYciI7KtUKMzm8QA4u9woabxf3+l/G+qVFdpNokBgL3ZV1Gqq2zkiFzozBlg1iygVSuxUN2RI0BgIDBunNgyc+gQMGECk5gmwuFZS+S97HkQ+ExTMvkcdbne6v4SG/vdQcr/pkp11kthaG3s9zqVlcA334jdR9u312y/4Qax7suECUB0tOfiI49hIuNDvPFBQGSviCDr1VPDbex3B1v/porLvLdFJjLY+v1S2tjvNS5fFtc8ev99IC9P3CaTAffcI06dvvNOwI+dC00ZExkf4o0PAmpczg5K9cRg1rrXDAvyR/+UGOyyMEYmJqx+PO6O29a/qQp9NVRay60yzsTnqvcUGx6IfikxZluU+qXEAADOXdF458BlQQD27hXHvnz+OaC/nlDGxIjTpidPBtq2NftSV/5OSHGQt4GUY3cUExkfEhOmcPhBQL7D2UGpnhjMau6at3eMxasjuuDFrSdMfof7p8Rg4ajUeh/CjRF3TJjCYjKQnhyNfX9cRYuIILMPCGfic+V7UoYosHBUKmZvPmZyP/slR2NCelsMX7oXWl2Vdw1c1miA9evFBObYsZrtffqIrS/33w9YKbzqyvsn1UHegLRjdwZnLfmY/OKyeh9chgeBz9aNIKdn/HhippC1a97eMRavjuwKTXklSsr1CA8KQExY/b8kGzPuc1c0eGnbiXpTmCekJ2HGxixseKI3uidGNTg+d70nw1/mqjI9yvVV2PfHVazak2MyRsaTs8IAACdPisnL2rVASYm4LThYXDLg6aeBHj1snsKV989bZ9DZQ8qx1+W2JQrIu8VHBmPx6DQUanRWHwTkW5wdlOqJwazWrrn9ZAFm312JdrFhTp/D1XHLAKQlRmFiehIqKqsR6O+HrLxizNiYBa2uymyXrTPxues9KUPEf//nCjS4b/k+l5/faXo9sG2bmMBcr1MGALjxRrH1Zdw4IDLS7tO58v5JeZC3lGN3FhMZH2T44KKmw9mB3p4YIO6KazZm3NGhChzLK8aSndn19lnqsnUmPne/J6+ZDJCfD6xcCaxYIf4/IA7WHT5cTGAGDXJq8K4r35/X3CsnSDl2ZzGRIfIBzg709sQAcVdcszHjVoYo8LqZsSaWxu44G5+735NHJwMIAvDzz2Lry5Yt4jpIANCiBfDkk8CkSUBCQoMu4cr3J+WJE1KO3Vmcs0bkAwwDvc2xNtDb2dc1hCuu2dhxG7psd8wagK1T+mLHrAFYPDrN4rgzZ+Jz93vyxM8aKhWwZAnQubPY0vL552IS068f8MknQG4u8M9/NjiJAVz7/jxyr1xEyrE7i4kMkQ8wtBrU/QCz1mrQkNd5IlZXn8NRyhAF2sWGoXtiFNrFhlm9hjPxufs9Neo9O35cnCLdqhUwfbo4mDcsTBy4e+wYsGsX8NBDgMJ113Tl+/PE75erSDl2Z3HWEpEPMcxQcXSgt7Ov80Ssrj6HOzkTn7vfk9vOr9MBmzeL3Ud79tRs79RJHPvy6KNAI3wGu/L9efvvlzVSjt3A3uc3ExkiInJebq44cHflSqCgQNzm7w+MHCku3Ni/v1iJl8hBnH5NRETuUV0N7Nghrnv01Vfi9wAQHw889ZS4kGN8vGdjpCaDiQwReURTKqHuM4qKgDVrgOXLgbNna7YPGiR2H917LxDgvlkx/J0hc5jIEFGja2ol1CXvyBFx7MuGDUBZmbgtIkIsWvf000DHjm4Pgb8zZAnHyBBRo/KlEuq+pF5rh7waym+2id1HBw7UHJiaKo59eeQRcSZSI8XG35mmh2NkiMgrNcUS6t6udmtH6+K/MPbodxjz24+ARiUeEBAAPPCA2H3Ut2+jD97l7wxZw0SGiBpVUyyh7s1UWh1mb8qC/Icf8GHWtxh47hD8IDbUFzZribAZUxH09CQgNtZjMfJ3hqxhIkNEjaopllD3WoWFqFy0HK8uWopE1WXj5sykHliXdg92tuuF7U8PsrmIp7vxd4asYSJDRI3KUEJ9l4XxDr5YQt2rCALwyy/i4N1PP0V0RQWiARQHhWFT19uwvvvdON+slfFwb2jt4O8MWcNEhogalTOLMJILaLXi+kbLlgGHDxs3l3dLw9z4/viqYz+UBwTVe5k3tHbwd4asYSJDRI3OsAij1EuoO8ojdVDOnhXrvqxeDRQXi9sCA4GHHwamTEFF5264/MlRlHt5a0dT/Z0h25jIEJFHKEOa1kOoUeugVFUBX38ttr788EPN9qQkse7LxIlAdDQAQAlIprWjqf3OkH1YR4aIyM0arQ7K5cvAhx8C778vroEEiFOlhwwRa7/ceSfg52cxRrZ2kDdhHRkiIi/h1jooggDs3Su2vnz+OaC/Pjg3Olpc8+ipp8SWGBvY2kFSxUSGiMjN3FIHRaMB1q8XE5hjx2q233KLWLjugQeAoPqDd4l8DRMZIiI3c2kdlJMnxcG7a9cCarW4LThYXDJgyhSgR48GREokPUxkiMjjfH1V4wbXQdHrgW3bxNaXn36q2Z6SIiYv48YBUVEujppIGpjIEJFHNYVVjZ2ug5KfD6xcCaxYIf4/IA7WvfdecfDuoEEWB+8SNRWctURkJ19pNfCW96HS6lBQUoHca1rIZDIcyS3Cqj050OqqAPjmqsZ2zQwSBCAzU2x92bIFqKwUt7doATz5JDBpEpCQ0PjBEzUyzloiciFfaTXwlvdhLo705GgsGp2GGRuzoNVV+eSqxlZnBqnVwEcfiQnMyZM12/v1E7uP7rsPUPjOvSByFbZJEtmg0urqPXQBcdrs7M3HoNLqPBSZY7zlfViKY2/2Vazem4OJGTVThb1hnR+3O35cLFIXHw9Mny4mMaGhwOTJ4mykXbvEKrxMYojMYosMkQ1urQHSiLzlfViLY2/2VUxMr0lkvGGdH8AN3XE6HfDFF2Lry+7dNds7dhTHvjz6KMCucCK7MJEhssEtNUCc1JAHqre8D1txVFRWA/CedX5c2h2XmysO3F25EigoELf5+wMjR4rdRwMGiJV4ichuTGSIbHBpDZAGaOgD1Vveh604Av39vGadH1vdcXYNRq6uBnbsEFtfvvxS/B4Qu5ImTRIH8MbHu+kdEPk+jpEhssFQA8Scxmo1cMX4Fm94H7bi6JcSg+TmYVg8Og1xXjCI2p7uOIuKioB33hG7i+64A9i6VUxiBg4UlxI4fx6YN49JDFEDMZEhssFQA6Tuw7cxWw0a9EC9zhveh604/j0qFW1iQj3eEmPgVHfckSPiGketWgF/+xtw5ow43mX6dOD334GdO4FRo4AA7xj/QyR17FoiskN8ZDAWj05zenXghg4WdfSBaul6DX0fruItcdhid3dceTmwaZPYffS//9UckJoqjn0ZMwYIC3NjpERNFxMZIjs5uzqwKwaL2nqghgb641yBBupyPUIV/jicW4R/fv27SXE5w/W8ZZVjb4nDGltLCzQvvAi8tRr48EOg8PoxAQHA/feLs4/69uXgXSI3Y2VfIjdSaXWYtjHLbLeQI5VrVVodpm/MMvtA7ZcSgyFd4zDni+PGbenJ0ZiQnmQsLufo9ahGfnGZydICMqEaU8uzMe3UDwja/r1YiRcQq+1Ongw8/rhYhZeIGsTe57ekEpnXX38dc+bMwTPPPIN33nnHrtcwkXEdbylt7wh3xGw4p6pMh5BAf/jJZPD3kyHazLnPFWgw+K1M4/chCjkmZiQhLSESFZXVaBcbishgBTTllTZjrPtABcTkZNqgZOw7dxVdWylRUVmNoAA5juQW4fd8FTrFK7FkZ7bx+B2zBqBdrHNdHO7++Tt7fpVWh2KtHqW6SpTqqhAZHIDY8ECXx3Yt9xIUH61B7Po1CMg9X7PzjjvE1pchQ8Sp1GQkxc8M8h4+t0TBwYMH8f777yM1NdXToTRJ3lLa3hHuiNlSaf0J6UlY8O1JzB/exeTctce2hCjkWDQ6Dav35mDJzmzj96/s/R17s6/ajNHcuJIAPxmyCzU4eP4a3vnxbL2Y/Ot0azhbK8bdP39nz3+puAwXrmmxeOdZk3vY7/oA5gbHJgjAwYNQLlsG5SefABUV4vbISGDiRLEFJiWlYdfwUVL8zCBpksSsJY1GgzFjxmDlypWI4lL1jc5bSts7wh0x2yqt3z4uot65a49tmZiRhNV7c4wP3Lrf2xOjMkSBdrFh6J4YhXaxYSivqsaHe+qfwxCTMsR0bI0ztWLc/fN39vwqrQ4/n7lSL4kBgN0NjU2rBVatAm66CejdG1i7VkxievQQx8NcvAi8+SaTGAuk+JlB0iWJRGbq1Km45557cNttt9k8tqKiAmq12uSLGsYVU38bmztitlVaPy0hst65a9dMSUuINHng1v3emRirqwWL59ibfRX+8poWmf4pMQgLEgcFZ+UW4dwVjV0PFHf//J09f6FGh9jwwAbfQxNnzwLPPgu0bi2OdTl8GAgMBB57DDhwADh0SGyJCQlx7LxNjBQ/M0i6vL5r6ZNPPsGRI0dw8OBBu45fsGAB5s+f7+aomhZvKW3vCHfEbG9p/drnNtRMmb35mHF/3eMbEqNWV2l1f5FWPEf/lBi8OqIL/rHlOH48WWDcb09Tv7t//s6eX12ud8k9RFUV8M034tTp77+v2Z6UJC7mOGECEGO+gB+ZJ8XPDJIur05k8vLy8Mwzz2D79u0ICgqy6zVz5szBrFmzjN+r1WokJCS4K8QmwVtK2zvCHTHbU1rf3LkNY1suqcrNHt+QGJXB1gdOxoQqsGPWAIQF+ddLYgD7Su27++fv7PkjggJwrdT6X/ZWY7t8Wewmev99cQ0kQJwqPWSIWPvlrrsAP0k0WnsdKX5mkHR59b/Sw4cPo6CgAD169IC/vz/8/f2RmZmJRYsWwd/fH1VVVfVeExgYiIiICJMvahhvKW3vCHfEbO2c6cnRyMortnhuZYgCccogk9dn5RUjPTm6QTHaep+tIoPRLjYMmvLKekmMga2mfnf//J09f0yYAgUlFY7dQ0EA9u4VC9QlJAD/+IeYxERHA3//O3DuHPD112IywyTGaVL8zCDp8up/qYMHD8bx48dx9OhR41evXr0wZswYHD16FHK53NMhNgneUtreEe6I2dI5DTOETl9SWz133dev2pODCelJyKjzIHYkRnvfZ0Oa+t3983f2/MoQBW69sTmmD0qpl8z0q/tajUZseeneHcjIADZsAPR64JZbgI8+Av78E1i4UOxOogaT4mcGSZek6sgAwK233oru3buzjowHGGpCeHNJ+brcEXNNHRk9QhRyyP1kkFuoI2MrpojgAIQG+kNTXtmgGG29z7r1bOqyp76Mu3/+zp6/dh0Zra4Kytp1ZE6eBJYvF2cdGQb+BwcDjzwidh/16OGy+Kk+KX5mkPfwuToy5HlSKClflztibug5yyuroa+qhq5KgK6qGqGA00Xq7I3JVql9e5r6XXUvLRVJc/b89V6n1wNffikO3t25s2Z7SoqYvIwbB7CMQ6OQ4mcGSY/kWmQcxRYZ8ia5V0sxZ8txkynDGcnReG1kVyRGh7r12pYqAy8clYq4RipQ5tYiaZcuAStWiF/5+eI2Pz/g3nvFBGbwYI57IZIQn1yiwBlMZMgVXFFq/bK6HLM+O2q27klGcjTefLA7WkTYNzvPWZ5s6nfVulMmBAHIzBRbX7ZsASqvT0ePjQWefBJ46ilxUC8RSQ67lohcxFWtCEWlOovF2/ZkX0VRqc7tiYwnm/rtKZJmd2xqNbBunZjA/P57zfaMDHHdo/vuAxTs0uBaR9QUMJEhssJWqXVHWhHU5daL19naL3UuKZJ2/LiYvKxbB5SWittCQ4FHHxWL13EtNiOudURNBRMZIitc2YoQEWT9n5ut/VJlaBVwugCgTgd88YWYwOzeXbO9Y0dx7MtjjwHsNjbhygScyNv55icnkYu4stR6VKgCGcnR2GNhjExUqPQfLHW7MoL8/TDvy9/w48kCTBuUjPTkaLPda2ZnTuXliQN3V64Uq/ACgFwOjBwpdh8NGCBW4qV6XNqNR+TlmMgQWeHKUustIoLw2siueGHLcZNkxjBryd3jY9zNXFdGRnI0xqcnYd+5q1i1JweLRqcBgEkyY1IkrbpanDK9dKk4hbr6+lpK8fHApEniAN74+EZ9X1LEtY6oKWEiQ2SFK+qv1JYYHYo3H+yOolId1OWViAjyR1SoQvJJjKWujD3ZVyEAmJiRhCU7szFjYxYmZiRhYnoSlMEBiApRiDOnKkqBd94Xi9edOVNzgoEDxe6j4cOBAK7PYy+udURNCRMZIitqr15trv6KMkRh7E7RVOgRFaJAtSBAq6tCqa4KkbWrzEJ84GvKK1Gmr0J0mMKuWSTOzDxRaXUoKKlAcZkeoQo5QgP9ERksPrxsncuZ61nrytibfRUT08XS/1pdFZbszAYAbJ3SF+0unhXHvqxfD5SViS+IiBCL1k2eDHTqZPW6ZF5MmAL9UmLM/kz6ca0jj+JMMtdjIkOS1VgfCIbVq83VXzF0pxy+UISlj/QQH9Q/ZZt0nfRLicG/R6VCAByeReLMzJP84jI8//kx7M6ueU16cjTm39sFr397Ej+eqlk8su65LhZpceGqFsVlegQFyLHjVAFOX1Jj/vAuVme6mOvKCFHIMTEjCWkJkQhR+GPV+JtwJLcIH/98GgOPZaLDffOBwwdrXtC1qzj2ZcwYIKxhlY4JmDowGdWCYPK7mJ4cjakDkz0YVdPGmWTuwYJ4JEne8IFQu8DbtEHJiFcG4Zvjl8wOZl1wX1d8e+ySSXJhYKkYnDMF5FRaHaZtyDJ7nYzkaHRPjDK2iNQ9V0l5JZ7/4li9B9+E9CR8+ksu/vNAN4uJYt21nEIUciwanYbVe3OM52td/Bf+fiETdx34Boqia+KBAQHA/feL3Ufp6Ry86yLnCjQYtmSPMZGsqKxGoL8fsvKKsWpPDr6altHgZTHIMW4pCOnjWBCPfJa3TC2t3Z2SlhAJABYL3sWGB5pNLgDLs0icmXlSqNFZvM6e7KuYkF5/deddZwtRUFKBV776rV78hu/TEqOsznSpO5ZoYkYSVu/Nwb6zV3DrH0cwNusbDDp3CH4Q/26qbNUa/lOeBh5/HGjRwuw5yXnqcr1JN15dHOzb+DiTzH2YyJDkeMMHgkqrQ0VlFZaN6YGgADn8/WTQVFguaFdRWW31fOYeLM7MPLH1GktxqMr02G0hCTOMcbH28Ks7luim8Gro1q/Aa0e/Q5viv4zH7WqbhnU97sHsxc+iXXyk1VjNxsnxBXbhYF/vw5lk7sNEhjyiIQ8kT38gmOvWWv9Eb6sF35wpBufMw8jWayzFEaKQW31dRWW1zYdffGQwlqVUonr7BoTduhkDdBUAAFVgKDZ1vQ0fpw3B+WatAABTKx3v0faG7kSpcPVsO2o4Jpfuw0SGGl1DH0ie/ECw1K21/4+raKUMsljwraCkwuEHi6MPI5VWB38/mcXZKhnJ0cjKKzZ7rlCF9Y+CyOAAyw8/rRb49FNg2TKEHTpk3Hy8RTt81OMefNWxP8oDTKeXO/oz8pbuRKmwZ7YdNS4ml+7DNe2pUdl6IKm0OpvnMHwgmOPuDwRL3Vqr9uSgpTIY0wemID052mRfv5QYDLyxOV4flVovbmsPFsPDyJ7X5BeXYdrGLNy9aDfG9W1bL4b05Gi8fG8XnLqkNnuuyJAAi/c0IzkabaJD6seYnQ08+yzQujUwcSJw6BAQGAg89hg0P+/GG69+jE2pd9RLYpz5GdnTnUimDLPtdswagK1T+mLHrAFYPDoNcWy98ghH/j2TYzhriRpV3dktde2YNcCu2RT5xWUW/9p05wd1Vm4RRi7bZ3ZfiEKOrVP7QiH3g1ZXBa2uCkozdWTMTeO2xtZr6s6GqD3tGQBaRQYjOECOyJCaOjLmzmXunvZLicGCkV3RulmIuKGqCvjmG7H2y/ffG4+raJ0IzYQnEPDE44hIjLd4Pmd/RtbuOyDWpOmeGOXQOYk8wZnPgKaKs5bIK7lqfIu12i7uZK1bS6urglzmh7YxNYmY4UPrj8JS41ggR6e9KkOsv6+6rRV1Z6vsmDUAbWJCTc5njtV7WlAAfPgh8N57QG4uAECQyfBrlz54p/3t2JXUA9U6Ofpvz8Pro6IQHxns0p8RxxeQr7D175kcx0SGGpUrH0ie+EBwpJ/b3Fig2zvG4uV7O6NcX+2ymTeuHPxc+56qSitQ8tMuVK18H1HfboNMf/080dGoeGw85sT2xRfFgSavrztmxVU/I44vICJLmMhQo/L0A8kV03f/cU9HjCsqg0wmw5HcIqzak4NebaJM+rnNjQUKUcjx0M2J+PvmY/UWTXR25o1Kq0NwgNw4DdwQj1ZXZTzG4dYKjQbFH6yB6q1FaJN31rg5+4bOiP6/mYgaPxZ/qivxhYUuQndMgefgVSKyhIkMNSpPPpAaOlvK3Ov7pcTg2xn9EBUSYBK7ucGphiJxdWc1OTLzpva6TspgBeZuPVFvKYJFo9MwY2MWtLoqx5LDU6eA5cshrFmDSLUakQDK/AOxrdMAfJw2BCdaJqN/QAwWV/t5ZAq8p7oTXY21cIhci4kMNTpPPJAcnb5b92ETFuhv9vW7zxbipW0nsHh0msl2cw/6tIRIi5VW7WnFqJ1ITRuUjKzcIouVeCdmJOFYXrHt5LCyEti2TRy8u3MnAEAGICcqDh+n3YNNXW+DOqhmTI8hTk+NWZH6+ALWwiFyPSYy5BGN/UBypBqwuYfNhid6O1RN2NyD3pnqvga1E7EQhRx3dGqBtIRIjOndpl6X0t7sq5h7Tyc8mZFk+R5fugSsXAmsWAFcvChu8/MDhg1D9v2P4vbjCggy89UZSsr1SIoJlXwXYWNjLRwi92AiQ02CvV0hlh42xWWOdaWYGwvkTHVfA0MiZliM8Y3/njJZUqBul1K5vqr+Q1EQgF27xNaXL74QW2MAIDYWePJJYNIkIDERsgINhBOWp8iHBwV4vouwzureUmjVcHRpDSkma0SewESGmgR7u0IsPWwcTUJqP+gPXSjCxIwkNA8PRL/kGIsrYFtrxTAkYpbG2dTuUlqyM9s0HrUaWLdOTGB+/71me0aGuOr0ffeJheyus3dAtse6COskMYCYCDy/+RiWNEKrhrMJhiPjitgFRWQ/JjLkUyw9ZOx9OFt62GTlFVtcfqBfSgyqBAHnrmhMHmqGB32RVo+5W49j1Z4cLBqdhmoI9WYt2WrFMCRi1sbZGBZ3NL6fEyfE5GXdOkCjEQ8KDQXGjhUTmNRUs+dxpLWlsbsIC0oqLK7uvfv6Kt7eOmDc3mSaXVBEjmEiQz7D1kPm9VGpmLftBNrHRSAtIRIVldWICglAYrOa8vuWHjaGJMRPJjM5f0ZyNMb1bYsRS/caZwnVfajN3XbC2A00Y2MWJmYkYWJ6EgAgsVmISeVfSwyJmK1xNjKdDu/KzkB51/8Bu3fX7OjYUUxeHn0UUCqtngPw3hlCtrr4VDb2N0RDEwx7k2lvWN2dSEqYyJBPMDxkDl8owrRBycZEJShAjswzVzCkS0vERwZj3rDOmPPFMazak2Ms43/2sgb6ympABuirqrH+id5QBgdABkAmEwfpqssqUVBSjjcf6IaS8kqoyvQo11dh3x9XMXvzMeO5KiqrkXetFABQpqvCNa0OE9KT0C0h0jgYt3aLynfP9EOBpgLFZXroKquhqag0aUkytDCpynR4YUhH+MtlCFHITerEhCjkeObGINyx90u0vm0iAgoLAACCXA7N3cNw8ZHxqO4/AKFBAYgMCIDtNMaUAIhTmbxAqI1Vui2t4m2rO8ie7qKGJhj2tnR5enV3V7F2T10x/odjiMiAiQz5hEKNDocvFGHR6DSs3ptjkiykJ0ejzw3iIopzthzH4dxi43Gr9uRg6SM9cEldjiU/ZZt0+aQnR2NCehI2HLiAR3q3wfe//YX05Bi0iw3DuQIN7lu+zzj41nBNw/f/9/mv9c5VezCuQUm5HoIALNl51mTwbv+UGLw6ogte+fp3/HiywLi9X3I0PhzXC4+vPQRtRSUGXzyOBZf3IObV/8JPEFtrLoc1w96BI9Hm+Zl49Ps/of21Cvh1L9KTozF9UAraNAuxudaRt47RCFX4W+ziS0+ONruKt633Yu97dUWCYU9Lly8sx2Dpni4clQoBaPDvlrf+fpJncPVr8gnqcr3VgbBzt51AsVaP3WcLTY6bmJGES6qyekmM4XWr9+agU7wSq/fmoENchHGFbkuDb63FsHqv2ApUW1igPxbXSWIA8S/8F7YcR4c404XSdmdfxZpvjmKdZj92fDAZH65/AbE/fgs/oRr7ElPx9PDZSJ+8CrM6jcRbJzUm19ubfRWLd57Fz2euWF1l3BUrlLtLZEgApg+qv8K4IUkzLIxpYOu9XFaX2/1eXZVgKEPE9ba6J0ahXWxYvVYET67u7grW7vnPZ66Ig7Ub8Lvlzb+f5BlskSGfEBEUYHUg7O6zhSjVidONax9nWCHa3F/4hu0T08WZQIb/1i4IV/ea9gzGNUhPjoZWV4U9Fq69J/sqJtQ6vvPlcxh75BuM+D0TwZUVAICqsHCsu1GsvJsdk2j1erW3WesGaUgXirub+5UhCrRpFoKhqfGYmJ6EispqBPr7oaCkAm1rjXWy970Uldr/XhtreQ2pL8dg7Z7HhgdaHKxt7/gfjiGiupjIkE+ICVPg/NVSq8cYunRqD5i1NXi29jGG/9YuCFf39bbOZ9hv6La6oqmwery+VIsRv/2Ex458jR75p43b1SkdsTBpIEa++Txe/vi4zevV3WatG8TZLpTGau6PiwzGkC4tTbpnerWJMvvwsvVe1OWVVvfXfq+NmWB462Bre1i75w0pCmnP+e09B/kWJjLkE5QhCrSOsv6wVAYHoH9KjElNGFv1YWofY/hv7YJw5wtLzR5rSeuoYHw4rhey8ooxY2NWvaUNjMepLuORo99h0IqduKvoGgBA5+eP79qnY12PIXj6hcew/qPDeDQ60q7Y626r3Q1StxWlWYii3oDi2sx1oTT2lGF7p33b6g6KCLL+EVj3vTZmgiHV5Ris3fOGFIW05/z2noN8CxMZ8hktI4KsNv3Hhgfi9VGpyDxzxThgNCuvGPHKIKsDSA01ZLLyiusVhJP7ydAvJcb4ALdWbyY9ORo//H7ZpOvpsroc/ZKjsTv7KmRCNQb8cQRjs77BoHOH4CfOF8LF8ObY0P0ufJZ6B66ERYmx/KnC7R1jEREcYHJ9c7HX3VZQUoFebaIAWG5FWTX+Jkxcc7BeMmOpC8Vbm/ttdQdFhTreXSTVBKOxWLvnBSUVDe6ea6wuPpIODvYln2FoJak7ULJ203/89W6Jf43oin4pMVi1JwdxymBMG5hsdgDphPQk/J6vwoT0JJy+pK7XhdAiIggLa11z1Z4cTEhPQkadc/VLicH0QSlYtSfH5PxxymDMTIvGgnPf4+cVk7Dm85dx27mD8IOAslsHYcmMN9B/8gdY2vchYxIzIT0J569oMHdoJ7y07QTG9W1bL3ZL15s+KAUDb2xunNptqRVl6U/ZmDu0k8X7WJe3Nvfb+p1oERFk83eGHGPtng+8sXmD77c9/86paZEJgiB4Ogh3UqvVUCqVUKlUiIiIsP0CkjxDV4mtpn/DcaUVekQGK1ANAVpdFbS6KoQF+sNPJoMAAX4yGeR+MkRbGbha+5oRwQEIDfSHprzSJAYA12vC6BGikCP41yOIXL0S4ds2w69CHCtTGaGEZvRYyJ+ejPBuXWrVkRFfI/cTYwkN9Mdzm341rr9Uu45NZHAA2sWGIej6IFjDa0MV/ogMCTC+h3MFGgx+y/KaStv/1h9+MpldXSi2zrVj1gC0iw2zuN/dbP1O2Ps7Q/azdk9dcb/5M/N99j6/2bVEkmNrZoy9Tf+u7CIwd64WZv7dKWVVwDebxKUDDh2q2ZGWBkydCv/RoxEZEmIzxnMFGmNLSt0ie4CYOLQwM7W3NlutKKUVleieGGX1GANvb+639bNmd5HrWbunrrjf/JmRARMZkhRvLoRlNcHKzgbeew9YtQooKhK3KRTAQw8BU6cCN98slhG2kyu6clw5aFLqU4aJSLqYyJBk2LMMgacemGYTrHZReCs0HzEffQB8/33NwW3bAk8/DUyYADRv7tT1wgKt/9MNtbEfcH0ripSnDBORdDGRIcmwZxkCTzw06w6ajS4txkPHfsAjy79DjPqKeJBMBtx9t7hw4113AXLrawbZopD7WZ0dpZDbHsfvjlYUNvcTUWNjIkOSYc8yBEtcXK/EHoUaHXafuYIeF0/h0axvMOT0HgRWiYXWrgVHoGzsOIQ/MwURnTu47JrFZTpj1V9z60OpynQAQm2eh60oRCR1TGRIMuxZhqDR65WUliJg9Qf4Zs1idC74w7g5K6491vUYgm869MPb427BDdGhELSuiy0sMACjVx7AxIwkk1L9hkJ7X03LsPtcbEUhIiljIkMu4e41dgD7liFotHolp04By5cDa9YgUa0GAJT7K7Ct4wCs63EPTrRMNh4a6O+HP66U4rVvTrpsUHJMmAK92kSZTeq8YZYQEVFjYSJDDdZYM4nsWYYgWNGwsSdWVVYCX34JLF0K7Nxp3FzVrh0+6TkU/255C1TB4SYvMVTXTUuIdGm5fs4SIiISMZGhBmnsNXZaRgRZLcl/JLcYLSOCXPsgv3QJ+OAD4P33gYsXxW1+fsCwYcCUKZDfdhsGFJfjuy+OmaxkbRivsuHABeM2V5br97bxLY3RKucKUomTiOzDRIYaxF1r7Fh62ChDFPjn8C74x9bjZge5ztiYhZvbNmv4g0kQgF27xMJ1X3whtsYA4nTpJ58EJk0C2rQxHt66WQgWjkrFhataFJfpjeNVNhy4gEd6t8GMjVnGY13Z/eUt41u8ub5PbVKJk4jsx0SGGsTRwmz2/DVseNgcvlBkLL1/vrAUraNC0DIiEKUVOkxMT8LsuztAU16FsCB/FKjL8fzmY9DqqqAq0+NcgQaqMh1Cri814G9jiYGaN6QGPv5YTGB++824ubJvOq48OhEXB96NkPAQhAb6I7LO4N2wQH9cuKZFl1YRyLtWhrSESADAjI1ZJosvhgcF+FSrQGO3yjlLKnGSNPnSv2mpYSJDDeJIdVh7/hquXfTOXL2Y2zrG4sV7OmHV3tP1WmReH5WKGRuzUK6vwn3L95nsm5CehAXfnsT84V3M/+V94oSYvKxbB2g04rbQUGDsWBSMmYBnTwO7swuB1UeM55w+KAUJkcFo1UxcUqBQo8OcL45j2qBkZOUWma3x0j8lBkEBfpi2MctnWgW8deXruqQSJ0kPW/o8i6tfU4MYqsOaU3v2jK2/hlVaHYCah42lejEd4iLqdSsBYi2V1XtzMPeejtj3h/l97eMiTK4FnQ749FNgwACga1dxFpJGA3ToACxaBFy8CNVbi2qSmDrnXLzzLHadvYKLRVoANa1ThhWwza1I/drIrpj35W8274OzVFodzhVokJVbhHNXNA0+nz28deXruqQSJ0mLvZ9t5D5skaEGsXf2jL1/DRseNpbqxVirI7M3+ypm390B//zmpNl9E9OTsGRnNorO5ED5xXpg5Urgr7/EA+RyYORIsfLurbca1z0qLNDUS2LqnvPCVS3CAv2NrVNaXRVmbMyqV+MluXkYdFXV+PFkgc374AxP/VXoyjWb3EkqcZK0sKXP85jIUIPZM3vG3r+GDQ+bispqs8dZ2m7wZ1GZyXgUI0FA2J6f8d6Wd9HmP78AVdePiYsTB+4++STQqlW9l9mKu6KyGhWV1SjU6EzWLqq7InX/lBgsHp2GPwrdUwfHk+M/vH3lawOpxEnSwpY+z2MiQy5ha/aMvX8Nx4Qp0C8lBoH+5ns9LW03qLvGUES5BqNO7MDYrO/Q7tqfNTtuvVVsfRkxAgiwHJutuA3xlJTr0S42zGbrVESQ9WZmZ1sFPPlXoVRq2kglTpIWtvR5HhMZahT2/jWsDFFgwciu2H32itlFEbPyipGRHG1Sr6X2eQpKKgAAnS7/gUePfI3hJzMRohe3VYSEYtctd+OWf7+I8J7dGhx3enI0LqvLka8qx8juYmuOudapsCB/lFZUIiu3CM1C3dMq4Om/Cr2tpo0lUomTpIMtfZ7HRIYaRd2/hkMUckzMSELfG6IR6O+HwlKd8bjWzUIw4MbmuKltM8z/6jfsrpW0nLqkxmsju+LFrSfq/1U9tD2Ct36BXp+/g5Rzx4378lrdAM3jT2Fp3M34x8O9Ee7AeBFD3HW7bdKTozF9YApCA+XYl11o8mFVu3Uqv7gMz2361fjaEIUcq8bfBAHi2lDW7oMjvOGvQm+paWOLVOIkaWBLn+fJBEEQPB2EO6nVaiiVSqhUKkRERHg6nCZPpdXhaqkOAoCXt50wSVLMTcUu1upRqquEVlcFZXAAYsMDoQxRGGs2lJTrEVWQjxafrEXQ2tVAofhBIgQEoOiuYSiZ+CR0t/SFXO5nXx0ZK3H/pS5HsVZvXAbhp9MFOJZXjHnDOiMxuv5K0yqtrt40a0BMZuYO7YSb2kZBJpPZvA/2xjd9Y5bFvwpZI4XIvWp/JrGlzzXsfX4zkaFGZ+kBDzjw0K2uBn74QVz36JtvxEq8ANC6NTB5MvD440DLli6JtVCjQ5Ug4J91WodsxXyuQIPBb2VaPHfmc7fixW0nGnYfaskvLsO8bSfQPi4CaQmRqKisRlRIABKbhaBVVIjd5yEi8gb2Pr/ZtUSNztGBqbUrZkaWqdFy80YEf7gS+OOPmhfefrs4eHfoUMC/Yb/W5lqNPhzXy2wSYylmwPa4lVJdpUsH6MZHBmPesM6Y88WxejOmWJiLiHwVExlqdOYe8IaxImkJkbhaqgOuaBATqoBWV4W/bz4G1a59ePTItxh2aheCKq/P/FEqgQkTxBaY9u3turatMuKGWizdEiJNqvPamvZtbjCtrXErpeamids4pzUqrQ5zthyvl3CxBD8R+TImMtTo6j7gQxRys8sRDG4ThhdKjuPv7yxC10tnjdtPtGiH/931EB544zkom0fZfV1bBeNq12IZ37etSSy2pn2bG0xrazZDZLBrB+i6Ywo2148hIm/HRIYaXd0HfN3lCNoU5WNM1nd48Ph2RJaL6x5VyP3xdYd++DjtHmTFtwdkMgwUAqC085r2FIyrnQjUbYHJyis2Ox0csDzF0tZshhCF3KXTNl09BZvrxxCRFDCRoUZX9wGflhCJZT+exuA/DuHRI9/i1pzDxmPzlC1Q8fgTeFDfCddCTNMWRx7M9rRW1E4E6rbArNqTg0Wj0wDAJJmxNcXSVt0SV07bdOUUbK4UTURSwUSGPMLwgC/KuQj5qiXYtWIFWqvFNYiqIcPPN/TEuh73IDOpB5Y8ehOurT9S7xyOPJhttVaoyvSIDKk5X90WmNrrJ029NRlBAXIog+2bYmmtbokrC7S5sjAX148hIqlgIkONTxCA/fuhXLYMyk2bxFWoARQFhePT1NuxofvdyI2KMx5ubnyKow9mW60V5foqKOSBuL1jLLafLDDbAqPVVeFYXjHG3JyIOBd2rbiqQJsrC3N5ulIwEZG9mMhQ4yktBTZsAJYtA44eNW6u7HUTVnW9C29GdUdFQKDJS/rVWnbAwJkHs62lBvb9cRXvZZ7Dgvu6oqKyGocuFOHERRX+dtuNmDFIQHiQP0IV/ogMCfDqlghXtfA0tJvK2wcJe3t8RGQ/ry6It2DBAnzxxRc4deoUgoOD0bdvXyxcuBDt7ZxqCzTtgniOflg78+FueE1xmQ6hCjEv9vMTF29UlekRFhSA2Is5CF/9AbB2LaBSAQCqA4OgGfUA/J5+GmEZfZBfXFavJaFfSgxeG9kVMkFAia4KmopKhAX6QwYAMiAkQA45AFWFWPk3IigAAXIZrpbqEB7kj0B/P5SU6xERrECFvhqqcj2CA+QQBGDn6ct4P/MPpCVGYkJ6EmZvPoaHb07E0K5x0OoqERroD1WZHiHXq/jK/fwgCDDuk8kAfz8ZmocF2n2PGvrQNHceAG55IKu0Onx74i/EhgeiorIaQQFyHMktwqo9OejVJsrsGBlDfEVaHfRV1dh77ipW7cmBVleFfikx+OfwLohyQyLo6P1tyCDmutcKCxTX0VKVMSEicjWfqOx711134eGHH8ZNN92EyspKvPDCCzhx4gR+//13hIbWLwlvTlNNZBz9sHbmw93ca9KTozEhPQmf7DuH6aWnoH1nMfrkHDXu/yu2NVZ2vhOfd70NquBwk2tcLNLiwlUtisv0CPT3w/GLKvS5oRlW7voDD/duYzKzCQD6Jcdg6sB2mLj2ELTXa7IYrj9jYxZuuaEZnr+rI175+jeT14nrJCUjOiwQ3564hHX7L+D1Ualmzz9tUDK0uip8sOePeueYkJ6ET37JxSvDuzh0j5yZ+WPuPP1SYjB1YDImrjlofP+umlWUX1yG5z8/ht3ZddaXGpSCts1C0LLO+a39LszYmAWtrgrpydEYmhqPATc2d9msJ0fvb0OqSpu7VkZyNMbXeo+c1UXkOj6RyNR15coVxMbGIjMzE/3797frNU0xkXH0w9qZD3dLr2muuYa//7kbd+39EuGFlwEAVTI/HE1Nh3rCE5iYHwVBZjrmxfDh//znv5oUc5s2KBlZuUVIS4wyKU5XW3pyNNISo0xqvhi2AbD6unu6xiFfVW71uH7J0bi7axxe2HLC4rWP5RU7dI8M79nemT/WzmPu/Td0bSVX/v7Uje/Dcb2wdt95l8x6cub+2lo2YsesAWgXG+bQteq+R65tReQa9j6/rVf58jKq690SzZo1s3hMRUUF1Gq1yVdTY8+Mk9qKtXqM79sWy8b0wKrxN2HaoGRjl4q54+tdQxBwc94JLNn6OvYtn4AHtq1EeOFlFIYokTPpGfR/6gOMuut5VN9xZ70kxnCNolJdvYq0aQmR2Jt91fhfcwz7zW2z9boWEUE2j9t9/Thr17brHtVh6TXmWDuPuffvyLkdvZ65czsSX0VldYPjczZOwPlBzI68R1e9PyKyj2QG+1ZXV2PmzJlIT09Hly5dLB63YMECzJ8/vxEj8z6OfFjnF5fhxa2mZe3Tk6OxaHSasbnc3Ie7ulyP0AotRv72Ex7N+gbtC3ON+w626oSAaVPwYGErvDOuNy5enzptrcy/uryy3jbD8baWBzC339Zr7D3G1nGGfZbukTX2zvyxdR5z8TVkVpGjcTsSn2EGmitmPTlzf50dxOzoz4Czuogaj2QSmalTp+LEiRPYs2eP1ePmzJmDWbNmGb9Xq9VISEhwd3hexd4Pa2PRszqtEYbWiYkZSViyM7v+h/uJE7jhrUU4sP5jhOnKAADagEBs7TQQ63oMwcnYG/Dh8F7QrT1kMnXaWpn/sCB5vW2G420tD2Buv63XGI5pHh4Imcz2cbb2mXsAuqpAna3zmIvP0eUNHLle3XPbG196cjSy8oobHJ+913Vm2QhLU/od/Rm44v0RkX0k0bU0bdo0fP311/jpp5/QunVrq8cGBgYiIiLC5KupMXxYm1P7w9qe5nLj8Tod8NlnwIABQNeuUK5eiTBdGbKbtca8255C76kf4YW7puFk7A3GB1btB1e/5GhcVpebvVZ6cjQK1BVIT4422V77HHX31X6t4Rp1t2XlFSPDyusuq8vxw++X8f1vly2e31bcWXnFFh+A9v4cbLF2HnPv35nlDey9nrlz2xOfYeDvqj05DY7P2TiBmlo7dV9na0q/Iz8DV70/IrKPVycygiBg2rRp2LJlC3bu3ImkpCRPhyQJ9n5Y22ouB4A3bmkG5euvAm3aAA89BOzaBcjlwKhRKNz2LV5ZuAlrew5DSaA4i8zwwPo9X2V8cKUnR2NCRhLilMH1EoZ+KTGYkJ6E5zcfw4T0JJP9q/bkYPrAFJzKV9fbB4iziqYPTMGqPTnGbbUfmL/nqzB3aOd6r0tPjsa0gSmIUwZj1Z4crNqTY/H80walmI3bcJ1Tl9QWH4DOPjTtPU+/lBhMH2T6/p1d3qAhcVuLb96wzuiVGIW0xCjM2JiFXm2iGhyfs3EaGGrt7Jg1AFun9MWOWQOweHSa1SKHlq6VUev3zZ5rE5HrefWspSlTpmDDhg3Ytm2bSe0YpVKJ4GD7pjc2xVlLBoaaF5YKo1mcwSEI6HvhV6zQ/IKw/34DVIlTe9GyJTBpkvjVqhUuFZfh5zNXEKcMQlCAHBHBAfADIPMDAuV+UJfpERggx5HcYvzz698BiN1VfW+IRmCAHyKDFQgL8seLW45j+8kChCjkmJiRhB6JUfCXyxAdokCAvwwBcj/oro9BqBYATXklwoL8EaoQ68ioKypRqqtCeJA/FHI/XC3VISzIH0H+ftCU6xEepEBFZTXU5WJdmBCFHAfPF2Hel78Zpy0brt33hmjj8gNhQf6o0FWhVF8JP5kMggBoKsQ6Mn4yQO5gHZmGLkFg7jwAXHJuV8Td2PE5G6crrxUWJNaRUZe5/9pETY1PTL+WWRi8sHr1aowfP96uczTlRMYWlVaH6RuzjOMFIso1GHViB8ZmfYd21/6sOfDWW4EpU4ARI4CAmvE19k59NXz4GwrM+fnJ4O8nQ/T14mG1i+GFKORYNDqtXk0XV9fnMFeAz/DXtCuXHyAiIuf4RCLjCkxkrMsvLsOytz9Hp23rMeL3nxGiF5cDqA4Ph99jjwFPPw107lzvdY7W47BVuMyQ7FQLAl756rd6A5ANx7uyPkdj/SXPcvhERI6z9/ktmVlL5GIVFcDnnyN+2TK8um9fzeYOnVA9eTKCJ44HwsPNvlSl1aGisgrLxvQwKV1v6KYBTKefGmdH1Wm92XW2ELM3HzMmJ8oQBc4VaMwmMYbjXbnqsqsWa7TGVZV9iYjIPCYyTc2FC8B77wEffghcuSJu8/cH7r8fmDIFgRkZsDYf2VIp+tp1ZwAgWFEzndqewmX2DkCumyB5c0uHvQkcERE5j4lMU1BdDfzwg7jq9NdfA4bexNatgaeeAp54QhzIa4OlB3PdujP9kmNQpNVDpRUTFEeSE3trg0ihpcORBI6IiJzj1dOvqYGuXQPefBO48Ubg7ruBr74Sk5jbbgO++ALIyQFefNGuJAawr+5MenI0xqW3xYpd53BNK5Zpt5achCjkiLrepZSVW4RqQcCC+7oal0iozVCfw1ZLh0rreHl4lVZnjOHcFY1T56jLVZV9iYjIMrbI+KJDh4ClS4FPPgHKrxdzUyqBCROAyZOBWlPZHWHrwRwe5I+J6UmQyWS4v2cC/lKVI9BfbrGaaohCjlXjb8KLW0+YrLLcLyUGq8bfVG9VZ0N9jnMFGpe2dLirdcdVlX2JiMgyJjK+oqwM+PRTsfvo4MGa7d27A1OnAqNHA6GhDbqErZaVyGAF3t1x1mTadL/rCcjCUal4vs5057lDO2HpzmyTJAYAdp8thAzAdzP6oUirqzejyFAPZmJGEtISIlFRWW0y6NiRlg53jmNxthw+ERHZj9Ovpe7cOXHw7qpVYlcSACgUwIMPiglM795WB+86om7dmdoWjOyCb45fwh4r06YB0+Jo1YKA29/eZfF6dadwG/xxRYM/Ckvr1ZoxVNu9ISYUNzSv/zpzHJ1G7ijWqyEicg6nX/uyqirg22/F1pf//rdme5s2Yt2XiROB5s1dfllDmXZzs5ZSW0dizpYTZl9n6O5pFxtm0rqRlVtk9XqWWlZCA/3rJTGAOE5HBuDNB7vb94bg/nEshnL4jVV5loioqWEiIyVXrojTpt97T5xGDYitLXfdJVbevftucR0kOzkzfTlUIceQrnEY37ctKiqrEejvh6y8YuQWaa1fq0yPcwUaqMv1UAYHIDTQH8EBcqu1aIIC5MjKLaoXm6a8sl4SY7An+yo05ZVoYWfjW1ig6T+Bel1WCrlx9pWzHK1X4+3Tyj2B94SILGEi4+0EAfjf/8TBu5s2iatQA0CzZmLLy+TJQLt2Dp/W3ADXfikx+OfwLogKCbD4kCjU6DDni+P1tn84rpfx/82NXwkK8MOwJXsAwOwSBHVr0WQkR+Pr45ewZGc2ANPBt65sRVHI/ZCeHI292VdNlkcwXLfutd1NCtPKGxvvCRFZwzEy3qq0FNiwQew+Onq0ZvvNN4utLw8+CNixcKZKq8PVUh0qqwVUCwK0FZUIDwrAoQtF+OfXv5u0gABiQjE0NR4Dbmxe7yGh0upwpkCDB97bX+860wYl49fcIhzOLTabqPRLjsa49CT8lq/CLznXzLaopCdHIy0xCkdzizA+PcmkwB5QM9amUKNz2biWX/OKcEWjw+q9OUhLjEJWbpHZ2Fy9PII5jqxf1VTwnhA1XfY+v1lHxtucPg3MnAm0aiWuMn30KBAUJE6dPngQOHAAGDfOriQmv7gMz276FX8UlmL+V7/hrnd2477l+3H727vw9bF8LBqdVq9ey97sq4gND6xXjyW/uAzTNmZBXWa+tWPVnhzMHdoZL97T0ez4ld3ZV7F6bw4Gto+12C20N/sqhnSNQ/fEqHpJDFAz1sYwG8gcR2cDhQUGYMbGLKQlRuHOzi0sxma4tjvZU0CvqeE9ISJbmMh4g8pKYMsWsVBdhw7Au+8CKpXYZfTmm8DFi+KspF69bJ/rOsO04g5xERYHxq7em4OJGUn1XltRWW3ykKg9RTkrrxjpydH1XqPVVSG/uAw3tgi3mqjYjluPJTuz6yUxBiXleuOg47rJTO1aM/aKCVOgV5soLNmZjbxrZVaPdXcBOxbQq4/3hIhs4RgZT/rrL2DlSuD998VkBQD8/IChQ8Xuo9tvF793guEv2fF925qM96htb/ZVTEyvn8gE+ovXNDwkav9VvGpPDhZdn0pdOzHpnxKDuMggnLtSajUuSwmKQViQ9cHKhiJyrpoNZEiKZm8+Znzftq7taoaBrJXVAlaNv8nswGd3Xt+bsaggEdnCRKaxCQKwe7c49mXzZrE1BhCnSz/xhLj2UZs2Db6M4S/Zispqq8fV3Z+eHI2svGIANQ+J2n8Va3VVmLExCxMzkjAxPQkVldVoGx2CVtfH01y10dTv7yczDq6tKz05GgXqCov763YbuWr1akNSVKzVo19KjMXxGO4oYGfvIpxNtYAeiwoSkS3sWmosJSXA8uVAaiowYIBYhbeyEujbF1i/HsjLA157zSVJDFDzl6ytVoba+w0F5VbtyTF5SBjOFaKQY9qgZCwenYZOcRGQyWT4/ZIaQQFyY1LRJjoEGWa6ngzn35NdiAnpSfWOybh+7ec3HzO735luI0coQxRoExOKhS7qsrKHtUU4a3f7ufu9ezNXdiMSkW/irCV3++03sfXlo48AjUbcFhICjB0rFq/r3t0tlzVU4U1NiLQ6E2f+vZ3xR6HYHZSVV4xVe3LQq02USeVZlVaH5zb9ioduTqw33iYjORqv35eK1s1CjNv+vKbFnC3H602XfWV4F6jLdAgLEuvIaMorjd1CYUH+KK2ohLpMrBNSd39jFpEzdPW4+9q2qgp/OyPDuFZVU39gN9bPhIi8Byv7epJOB2zdKiYwmbUeVO3bi2Nfxo0TF3F0I8NfsvO2ncCE6+Ng6o5pMSQrIYH+KCoV1zQamhqHqBAFWkQEmZzr5Xs74++bj5mcI0QhR/fEKORe06KgpBzKEAXCAv2hr6rG3KGdrk/3roIyuPaDp2a9J1tF6+wtaudqruqyssXWQFZdZTU6xbv390QqGutnQkTSw0TGlf78E1ixQhzA+9df4ja5HBg+XFz3aOBAl617ZI/4yGD854FuuFqqw8vDOqOqWoBWZ5pY2FtsrFxfXS+JMVc8LiM52qQGjOFcfAjVx4GsREQNx0SmoQQB2LlTbH3Ztk1cBwkAWrYU68A8+STQurXHwrP2l6wjKz/XbT2YmJFkdlr3nuyrEK7vX7Iz2yWrSPsqDmQlImo4DvZ1VnExsGgR0LGjWP/liy/EJGbAAOCzz4DcXGD+fI8mMbY4UmysbutBWkKk1XoxaQmRFs9FIg5kJWtUWh3OFWiQlVuEc1c0JgUqiagGW2ScNWqU2BIDAGFh4riXp58GOnf2bFwOcKTYWN3WA0endbNwmXlcHZvM4fpSRPZji4yzJkwQk5Zly4D8fGDJEkklMYBjYzTqth44Mq277rnIlDJEgXaxYeieGIV2sWFMYpo4W12+bJkhMsUWGWeNHg2MGdOog3ddzdExGrVbD6oFwWLxuNpF9Sydy1GG6bfqcnF6dkwoWy3IN9nT5cvffaIaTGScJbdeSl8Kapfn31WnCdvSGI3ag4cXmnlt7VlLts5lLzazU1PC9aWIHMOCeNSgYmN1X1u7sJ0rxnuotDpM25hlcdkAzoYiX2OrUOKOWQPQLjasESMi8gwWxCO7NaTYmLsLlUmhmZ3dXuRKnJZP5BgmMk5orAeXs9fxlQerSqtDRWUVlo3pgaAAudlVoT3dzM5uL3I1Z7p8iZoyJjIOaqwHl7PX8ZUHq72rQntyNpQjBQWJHMFp+UT24/RrBzTWtEhnr+Mr0zYdWRXak83sjhQUJHIUp+UT2YeJjAMa68Hl7HV85cFq7X0YqgZ7QzM7Z5cQEXkeu5Yc0FgPLmev4ysPVlvvQxkc4BXdNlz0kYjI89gi44DGenA5ex1febDaeh9Rbp4pZS/D7BJzPN3tRUTUVDCRcUBjPbicvY6vPFil8j646CMRkeexIJ6D8ovLLE6LjHPxrCVnrtNY8bmblN5HQwoKEhGRefY+v5nIOKGxHlzOXsdXHqy+8j6IiMhxrOzrRu6uZtvQ6zRWfO7mK++DiIjch2NkiIiISLKYyBAREZFkMZEhIiIiyWIiQ0RERJLFRIaIiIgki4kMERERSRYTGSIiIpIsJjJEREQkWUxkiIiISLKYyBAREZFk+fwSBYalpNRqtYcjISIiInsZntu2loT0+USmpKQEAJCQkODhSIiIiMhRJSUlUCqVFvf7/OrX1dXVyM/PR3h4OGQymafD8TlqtRoJCQnIy8tz2eriZBvvu+fw3nsG77vneOreC4KAkpISxMfHw8/P8kgYn2+R8fPzQ+vWrT0dhs+LiIjgh4sH8L57Du+9Z/C+e44n7r21lhgDDvYlIiIiyWIiQ0RERJLFRIYaJDAwEPPmzUNgYKCnQ2lSeN89h/feM3jfPcfb773PD/YlIiIi38UWGSIiIpIsJjJEREQkWUxkiIiISLKYyBAREZFkMZEhu+zatQvDhg1DfHw8ZDIZtm7darJfEAS89NJLiIuLQ3BwMG677TacPXvWM8H6kAULFuCmm25CeHg4YmNjMWLECJw+fdrkmPLyckydOhXR0dEICwvDqFGjcPnyZQ9F7BuWL1+O1NRUYwGwPn364LvvvjPu5z1vHK+//jpkMhlmzpxp3MZ77x4vv/wyZDKZyVeHDh2M+735vjORIbuUlpaiW7duWLp0qdn9//73v7Fo0SK89957OHDgAEJDQ3HnnXeivLy8kSP1LZmZmZg6dSr+97//Yfv27dDr9bjjjjtQWlpqPOZvf/sbvvrqK2zatAmZmZnIz8/Hfffd58Gopa9169Z4/fXXcfjwYRw6dAiDBg3C8OHD8dtvvwHgPW8MBw8exPvvv4/U1FST7bz37tO5c2dcunTJ+LVnzx7jPq++7wKRgwAIW7ZsMX5fXV0ttGzZUnjjjTeM24qLi4XAwEBh48aNHojQdxUUFAgAhMzMTEEQxPscEBAgbNq0yXjMyZMnBQDC/v37PRWmT4qKihI++OAD3vNGUFJSIqSkpAjbt28XBgwYIDzzzDOCIPD33Z3mzZsndOvWzew+b7/vbJGhBsvJycFff/2F2267zbhNqVSid+/e2L9/vwcj8z0qlQoA0KxZMwDA4cOHodfrTe59hw4dkJiYyHvvIlVVVfjkk09QWlqKPn368J43gqlTp+Kee+4xuccAf9/d7ezZs4iPj8cNN9yAMWPGIDc3F4D333efXzSS3O+vv/4CALRo0cJke4sWLYz7qOGqq6sxc+ZMpKeno0uXLgDEe69QKBAZGWlyLO99wx0/fhx9+vRBeXk5wsLCsGXLFnTq1AlHjx7lPXejTz75BEeOHMHBgwfr7ePvu/v07t0ba9asQfv27XHp0iXMnz8f/fr1w4kTJ7z+vjORIZKIqVOn4sSJEyb91uQ+7du3x9GjR6FSqfD5559j3LhxyMzM9HRYPi0vLw/PPPMMtm/fjqCgIE+H06Tcfffdxv9PTU1F79690aZNG3z22WcIDg72YGS2sWuJGqxly5YAUG8E++XLl437qGGmTZuGr7/+Gj/99BNat25t3N6yZUvodDoUFxebHM9733AKhQLJycno2bMnFixYgG7duuHdd9/lPXejw4cPo6CgAD169IC/vz/8/f2RmZmJRYsWwd/fHy1atOC9bySRkZG48cYbkZ2d7fW/80xkqMGSkpLQsmVL7Nixw7hNrVbjwIED6NOnjwcjkz5BEDBt2jRs2bIFO3fuRFJSksn+nj17IiAgwOTenz59Grm5ubz3LlZdXY2KigreczcaPHgwjh8/jqNHjxq/evXqhTFjxhj/n/e+cWg0Gpw7dw5xcXFe/zvPriWyi0ajQXZ2tvH7nJwcHD16FM2aNUNiYiJmzpyJV199FSkpKUhKSsLcuXMRHx+PESNGeC5oHzB16lRs2LAB27ZtQ3h4uLE/WqlUIjg4GEqlEo8//jhmzZqFZs2aISIiAtOnT0efPn1wyy23eDh66ZozZw7uvvtuJCYmoqSkBBs2bMDPP/+M77//nvfcjcLDw43jvwxCQ0MRHR1t3M577x7PPfcchg0bhjZt2iA/Px/z5s2DXC7H6NGjvf933tPTpkgafvrpJwFAva9x48YJgiBOwZ47d67QokULITAwUBg8eLBw+vRpzwbtA8zdcwDC6tWrjceUlZUJU6ZMEaKiooSQkBBh5MiRwqVLlzwXtA+YOHGi0KZNG0GhUAjNmzcXBg8eLPzwww/G/bznjaf29GtB4L13l4ceekiIi4sTFAqF0KpVK+Ghhx4SsrOzjfu9+b7LBEEQPJRDERERETUIx8gQERGRZDGRISIiIsliIkNERESSxUSGiIiIJIuJDBEREUkWExkiIiKSLCYyREREJFlMZIhIssaPH2939ehbb70VM2fOtHpM27Zt8c477xi/l8lk2Lp1KwDg/PnzkMlkOHr0qFOxEpF7MJEhIpeyJ2FwxWvc4eDBg5g0aZKnwyAiB3CtJSKi65o3b+7pEIjIQWyRISKXGT9+PDIzM/Huu+9CJpNBJpPh/PnzyMzMxM0334zAwEDExcVh9uzZqKystPqaqqoqPP7440hKSkJwcDDat2+Pd999t0HxVVZWYtq0aVAqlYiJicHcuXNRe5WWul1LROT92CJDRC7z7rvv4syZM+jSpQteeeUVAEBVVRWGDBmC8ePH46OPPsKpU6fw5JNPIigoCC+//LLZ1zRv3hzV1dVo3bo1Nm3ahOjoaOzbtw+TJk1CXFwcHnzwQafiW7t2LR5//HH88ssvOHToECZNmoTExEQ8+eSTLrsHRNS4mMgQkcsolUooFAqEhISgZcuWAIB//OMfSEhIwJIlSyCTydChQwfk5+fj+eefx0svvWT2NQAgl8sxf/584/dJSUnYv38/PvvsM6cTmYSEBLz99tuQyWRo3749jh8/jrfffpuJDJGEsWuJiNzq5MmT6NOnD2QymXFbeno6NBoN/vzzT6uvXbp0KXr27InmzZsjLCwMK1asQG5urtOx3HLLLSZx9OnTB2fPnkVVVZXT5yQiz2IiQ0Re6ZNPPsFzzz2Hxx9/HD/88AOOHj2KCRMmQKfTeTo0IvIi7FoiIpdSKBQmLRwdO3bE5s2bIQiCsTVk7969CA8PR+vWrc2+xnBM3759MWXKFOO2c+fONSi2AwcOmHz/v//9DykpKZDL5Q06LxF5DltkiMil2rZtiwMHDuD8+fMoLCzElClTkJeXh+nTp+PUqVPYtm0b5s2bh1mzZsHPz8/sa6qrq5GSkoJDhw7h+++/x5kzZzB37lwcPHiwQbHl5uZi1qxZOH36NDZu3IjFixfjmWeeccXbJiIPYSJDRC713HPPQS6Xo1OnTmjevDn0ej2+/fZb/PLLL+jWrRsmT56Mxx9/HC+++KLF1+Tm5uKpp57Cfffdh4ceegi9e/fG1atXTVpnnPHYY4+hrKwMN998M6ZOnYpnnnmGBfCIJE4m1C6iQERERCQhbJEhIiIiyWIiQ0SSl5ubi7CwMItfDZmyTUTejV1LRCR5lZWVOH/+vMX9bdu2hb8/J2kS+SImMkRERCRZ7FoiIiIiyWIiQ0RERJLFRIaIiIgki4kMERERSRYTGSIiIpIsJjJEREQkWUxkiIiISLKYyBAREZFk/T9dy66fldn+owAAAABJRU5ErkJggg==",
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"#시각화\n",
"sns.scatterplot(data = tips_df, x= tips_df['total_bill'], y=tips_df['tip'])\n",
"plt.title('Total_bill VS. Tip')\n",
"sns.lineplot(data = tips_df, x = 'total_bill', y = 'pred', color = 'red')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"-선형회귀\n",
"단순선형회귀: x 변수가 1개\n",
"다중선형회귀: x 변수가 2개 이상"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.12.8"
}
},
"nbformat": 4,
"nbformat_minor": 2
}