{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# <div style=\"color:#fff;display:fill;border-radius:10px;background-color:#004F98;text-align:center;letter-spacing:0.1px;overflow:hidden;padding:20px;color:white;overflow:hidden;margin:0;font-size:100%\">Car Price Prediction</div>","metadata":{}},{"cell_type":"markdown","source":"## <span style='color:#2E8BC0'> 0| Import Libraries</span>","metadata":{}},{"cell_type":"code","source":"import numpy as np\nimport pandas as pd\nimport matplotlib.pyplot as plt\nimport seaborn as sns\nsns.set()\n%matplotlib inline","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## <span style='color:#2E8BC0'> 1| Reading Dataset</span>","metadata":{}},{"cell_type":"code","source":"dataset = pd.read_csv('data.csv')\ndf=dataset.copy()\ndf.head()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"len(df)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df.shape","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df.columns","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"###   Understanding Data\n__As we see, this dataset contains multiple columns:__\n\n\n> make: make of a car (BMW, Toyota, and so on)\n\n> model: model of a car\n\n> year: year when the car was manufactured\n\n> engine_fuel_type: type of fuel the engine needs (diesel, electric, and so on)\n\n> engine_hp: horsepower of the engine\n\n> engine_cylinders: number of cylinders in the engine\n\n> transmission_type: type of transmission (automatic or manual)\n\n> driven_wheels: front, rear, all\n\n> number_of_doors: number of doors a car has\n\n> market_category: luxury, crossover, and so on\n\n> vehicle_size: compact, midsize, or large\n\n> vehicle_style: sedan or convertible\n\n> highway_mpg: miles per gallon (mpg) on the highway\n\n> city_mpg: miles per gallon in the city\n\n> popularity: number of times the car was mentioned in a Twitter stream\n\n> msrp: manufacturer’s suggested retail price","metadata":{}},{"cell_type":"code","source":"df.info()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"for col in df.columns:\n    print( col,':', df[col].nunique() )\n    print(df[col].value_counts().nlargest(5))\n    print('\\n' + '*' * 20 + '\\n')","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## <span style='color:#2E8BC0'> 2| Data Wrangling (Simple Data Processing )</span>","metadata":{}},{"cell_type":"code","source":"## ===> Small chars in columns\ndf.columns = df.columns.str.lower().str.replace(' ', '_')\n\nstring_columns = list(df.dtypes[df.dtypes == 'object'].index)\nprint(string_columns)\n\nfor col in string_columns:\n    df[col] = df[col].str.lower().str.replace(' ', '_')","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df.columns","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df.rename(columns={'msrp':'price'}, inplace=True)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df.sample()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## <span style='color:#2E8BC0'> 3| Exploratory Data Analysis (EDA) & Data Visualization</span>","metadata":{}},{"cell_type":"code","source":"pd.options.display.float_format ='{:,.2f}'.format  ## ==> 2 numbers after, to explore\ndf.describe()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"> You can observe the scale, expected distribution, abnormal values and ... etc","metadata":{}},{"cell_type":"code","source":"df.describe(include=['O'])","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"plt.figure(figsize=(15, 7))\n\nsns.histplot(df.price, bins=40)\nplt.ylabel('Frequency')\nplt.xlabel('Price')\nplt.title('Distribution of prices')\n\nplt.show()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"## ==> This is a long tail distribution, which is a typical situation for many items with low prices and very few expensive ones.\n\nplt.figure(figsize=(6, 4))\n\nsns.histplot(df.price[df.price < 80000], bins=40)\nplt.ylabel('Frequency')\nplt.xlabel('Price')\nplt.title('Distribution of prices')\n\nplt.show()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"The long tail makes it quite difficult for us to see the distribution, but it has an even stronger effect on a model: such distribution can greatly confuse the model, so it won’t learn well enough.\n\n> One way to solve this problem is log transformation.","metadata":{}},{"cell_type":"code","source":"df['log_price'] = np.log1p(df.price)\n\nplt.figure(figsize=(6, 4))\n\nsns.histplot(df.log_price, bins=40)\nplt.ylabel('Frequency')\nplt.xlabel('Log(Price + 1)')\nplt.title('Distribution of prices after log tranformation')\n\nplt.show()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df.price.skew()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df.log_price.skew()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## <span style='color:#2E8BC0'> 4| Data Wrangling (Check missing values) & Hints of Preprocessing</span>","metadata":{}},{"cell_type":"code","source":"df.isnull().sum()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"> Keep in mind that we will need to handle missing values to correctly train our machine.\n\n> But at least, Our target (price) has no missing values.","metadata":{}},{"cell_type":"code","source":"string_columns  ## ==> Incoding data","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"## ==> Average price of bmw in data set \n\ndf.make.value_counts()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df.groupby('make').mean()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df.groupby('make').mean()['price']['bmw']","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df[df['year'] >= 2015]","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## <span style='color:#2E8BC0'> 5| Validation Framework  </span>","metadata":{}},{"cell_type":"code","source":"from IPython.display import Image\nfrom IPython.core.display import HTML ","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"Image(url= \"https://camo.githubusercontent.com/58d30d710bfafa6e022ad86d0ee1cd441095603a58101bc3bccd70885249807d/68747470733a2f2f766974616c666c75782e636f6d2f77702d636f6e74656e742f75706c6f6164732f323032302f31322f486f6c642d6f75742d6d6574686f642d666f722d6d6f64656c2d73656c656374696f6e2e706e67\", width=800, height=400)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"np.random.seed(2)     # Fixes the random seed to make sure that the results are reproducible\n\nn = len(df) \n\nn_val = int(0.2 * n)\nn_test = int(0.2 * n)\nn_train = n - (n_val + n_test)\n\nprint('No. of rows for training : ', n_train)\nprint('No. of rows for validation : ', n_val)\nprint('No. of rows for testing : ', n_test)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"idx = np.arange(n)\nprint(idx)\nnp.random.shuffle(idx)\nprint(idx)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df_shuffled = df.iloc[idx]\nprint(df.index)\nprint(df_shuffled.index)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df_shuffled","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df_train = df_shuffled.iloc[:n_train].copy()\ndf_val = df_shuffled.iloc[n_train:n_train+n_val].copy()\ndf_test = df_shuffled.iloc[n_train+n_val:].copy()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df_train.shape\ndf_val.shape\ndf_test.shape\n\n\nprint(\"Shape of Train :\", df_train.shape )\nprint(\"Shape of Val :\", df_val.shape )\nprint(\"Shape of Test :\", df_test.shape )","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"## ==> Divide Y\n\ny_train = df_train.log_price.values\ny_val = df_val.log_price.values\ny_test = df_test.log_price.values","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"base = ['engine_hp', 'engine_cylinders', 'highway_mpg', 'city_mpg', 'popularity']   # Think about Numerical only\n#base = ['engine_hp', 'engine_cylinders']                                   # Think about High Correlation","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df[base]","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df[base].isnull().sum()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"## ==> Handling Missing Values\ndef prepare_X(df):\n    df_num = df[base]\n    df_num = df_num.fillna(df_num.mean())\n    X = df_num.values\n    return X","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## <span style='color:#2E8BC0'> 6| Linear Regression  </span>","metadata":{}},{"cell_type":"code","source":"Image(url= \"https://camo.githubusercontent.com/c20de60b0e248bc10ff86ff61cb23f18862335512707f6a0cc06b94289413765/68747470733a2f2f6d69726f2e6d656469756d2e636f6d2f6d61782f313430302f312a475341634e3947377374554a5162754f6875304845672e706e67\", width=800, height=400)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"Image(url= \"https://camo.githubusercontent.com/2348c7c266e942867663e1df650e5cd0dfcdc5be8ca76110a6dcc909518ebda9/68747470733a2f2f6c6561726e696e672e6f7265696c6c792e636f6d2f6170692f76322f65707562732f75726e3a6f726d3a626f6f6b3a393738313631373239363831392f66696c65732f4f454250532f496d616765732f30325f31302d4571756174696f6e5f322d392e706e67\", width=200, height=100)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"Image(url= \"https://camo.githubusercontent.com/29218925efd4e8119865c3e2d25fab388468e91b1c1140cbaff086eecfdc731f/68747470733a2f2f6c6561726e696e672e6f7265696c6c792e636f6d2f6170692f76322f65707562732f75726e3a6f726d3a626f6f6b3a393738313631373239363831392f66696c65732f4f454250532f496d616765732f30325f31302d4571756174696f6e5f322d31302e706e67\", width=700, height=600)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df_train.corr()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"plt.figure(figsize=(15,8))\n_=sns.heatmap(df_train.corr(), annot = True)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def linear_regression(xi):\n    n =len(xi)                # Number of features used\n    \n    pred = w0                 # Initial / Base prediction\n    \n    for j in range(n):\n        pred += w[j]*xi[j]     # Formula = w0 +sigma[0:n-1]{w[j]*xi[j]}\n    \n    return pred","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"Image(url= \"https://camo.githubusercontent.com/2c4ba18c01cdb22ac6ebc1f2ed1d7d2990282cebf38e5f16e8f90efa919e3abf/68747470733a2f2f6d69726f2e6d656469756d2e636f6d2f6d61782f3536302f312a375a69576d36784146346f57695966576b6c554d45772e6a706567\", width=700, height=600)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## <span style='color:#2E8BC0'> 7| Linear Regression Training and Evaluation by Root Mean Square Error  </span>","metadata":{}},{"cell_type":"code","source":"def train_linear_regression(X, y):\n    ones = np.ones(X.shape[0])\n    X = np.column_stack([ones, X])\n\n    XTX = X.T.dot(X)\n    XTX_inv = np.linalg.inv(XTX)\n    w = XTX_inv.dot(X.T).dot(y)\n    \n    return w[0], w[1:]","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"X_train = prepare_X(df_train)\nw_0, w = train_linear_regression(X_train, y_train)\ny_pred = w_0 + X_train.dot(w)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"sns.histplot(y_train, label='target')\nsns.histplot(y_pred, label='prediction', color='red')\n\nplt.legend()\n\nplt.ylabel('Frequency')\nplt.xlabel('Log(Price + 1)')\nplt.title('Predictions vs actual distribution')\n\nplt.show()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## <span style='color:#2E8BC0'> 8| Model Evaluation  </span>","metadata":{}},{"cell_type":"code","source":"Image(url= \"data:image/png;base64,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\", width=400, height=600)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def rmse(y, y_pred):\n    error = y_pred - y\n    mse = (error ** 2).mean()\n    return np.sqrt(mse)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"rmse(y_train, y_pred)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"X_val = prepare_X(df_val)\ny_pred = w_0 + X_val.dot(w)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"rmse(y_val, y_pred)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## <span style='color:#2E8BC0'> 9| Simple Feature Engineering  </span>","metadata":{}},{"cell_type":"code","source":"base\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"sorted(df.year.unique())","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def prepare_X(df):\n    df = df.copy()\n    features = base.copy()\n\n    df['age'] = 2017 - df.year    # Because the dataset was created in 2017 (which we can verify by checking df_train.year.max())\n    features.append('age')\n    \n    df_num = df[features]\n    df_num = df_num.fillna(df_num.mean())\n    X = df_num.values\n    return X","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"X_train = prepare_X(df_train)\nw_0, w = train_linear_regression(X_train, y_train)\ny_pred = w_0 + X_train.dot(w)\nprint('Train RMSE: ', rmse(y_train, y_pred))\n\nX_val = prepare_X(df_val)\ny_pred = w_0 + X_val.dot(w)\nprint('Validation RMSE: ', rmse(y_val, y_pred))","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"plt.figure(figsize=(6, 4))\n\n\nsns.histplot(y_val, label='target', color='blue', alpha=0.6, bins=40)\nsns.histplot(y_pred, label='prediction', color='green', alpha=0.8, bins=40)\n\nplt.legend()\n\nplt.ylabel('Frequency')\nplt.xlabel('Log(Price + 1)')\nplt.title('Predictions vs actual distribution')\n\nplt.show()\n","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## <span style='color:#2E8BC0'> 10| Handling Categorical Variables </span>","metadata":{}},{"cell_type":"code","source":"df.number_of_doors.unique()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df.number_of_doors.value_counts()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"Image(url= \"https://camo.githubusercontent.com/984c5f0df0021d6dcd14eda0ce51218991ab4ffad1afb9732c7b05a78f68147a/68747470733a2f2f6c6561726e696e672e6f7265696c6c792e636f6d2f6170692f76322f65707562732f75726e3a6f726d3a626f6f6b3a393738313631373239363831392f66696c65732f4f454250532f496d616765732f30325f32342e706e67\", width=500, height=600)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"Image(url= \"https://camo.githubusercontent.com/4db096ca1748e33830c54d28326481a250bae1406d2cd1680df113b2236182ab/68747470733a2f2f6c6561726e696e672e6f7265696c6c792e636f6d2f6170692f76322f65707562732f75726e3a6f726d3a626f6f6b3a393738313631373239363831392f66696c65732f4f454250532f496d616765732f30325f32352e706e67\", width=500, height=600)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df['make'].value_counts().head(10)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def prepare_X(df):\n    df = df.copy()\n    features = base.copy()\n\n    df['age'] = 2017 - df.year\n    features.append('age')\n\n    for v in [2, 3, 4]:\n        feature = 'num_doors_%s' % v\n        df[feature] = (df['number_of_doors'] == v).astype(int)\n        features.append(feature)\n\n    for v in ['chevrolet', 'ford', 'volkswagen', 'toyota', 'dodge']:\n        feature = 'is_make_%s' % v\n        df[feature] = (df['make'] == v).astype(int)\n        features.append(feature)\n\n    df_num = df[features]\n    df_num = df_num.fillna(df_num.mean())\n    X = df_num.values\n    return X","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"X_train = prepare_X(df_train)\nw_0, w = train_linear_regression(X_train, y_train)\n\ny_pred = w_0 + X_train.dot(w)\nprint('train:', rmse(y_train, y_pred))\n\nX_val = prepare_X(df_val)\ny_pred = w_0 + X_val.dot(w)\nprint('validation:', rmse(y_val, y_pred))","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df['engine_fuel_type'].value_counts()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def prepare_X(df):\n    df = df.copy()\n    features = base.copy()\n\n    df['age'] = 2017 - df.year\n    features.append('age')\n    \n    for v in [2, 3, 4]:\n        feature = 'num_doors_%s' % v\n        df[feature] = (df['number_of_doors'] == v).astype(int)\n        features.append(feature)\n\n    for v in ['chevrolet', 'ford', 'volkswagen', 'toyota', 'dodge']:\n        feature = 'is_make_%s' % v\n        df[feature] = (df['make'] == v).astype(int)\n        features.append(feature)\n\n    for v in ['regular_unleaded', 'premium_unleaded_(required)', \n              'premium_unleaded_(recommended)', 'flex-fuel_(unleaded/e85)']:\n        feature = 'is_type_%s' % v\n        df[feature] = (df['engine_fuel_type'] == v).astype(int)\n        features.append(feature)\n        \n    df_num = df[features]\n    df_num = df_num.fillna(0)\n    X = df_num.values\n    return X","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"X_train = prepare_X(df_train)\nw_0, w = train_linear_regression(X_train, y_train)\n\ny_pred = w_0 + X_train.dot(w)\nprint('train:', rmse(y_train, y_pred))\n\nX_val = prepare_X(df_val)\ny_pred = w_0 + X_val.dot(w)\nprint('validation:', rmse(y_val, y_pred))","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df['transmission_type'].value_counts()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df['driven_wheels'].value_counts()","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\ndf['market_category'].value_counts().head(5)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"df['vehicle_size'].value_counts().head(5)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\ndf['vehicle_style'].value_counts().head(5)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def prepare_X(df):\n    df = df.copy()\n    features = base.copy()\n\n    df['age'] = 2017 - df.year\n    features.append('age')\n    \n    for v in [2, 3, 4]:\n        feature = 'num_doors_%s' % v\n        df[feature] = (df['number_of_doors'] == v).astype(int)\n        features.append(feature)\n\n    for v in ['chevrolet', 'ford', 'volkswagen', 'toyota', 'dodge']:\n        feature = 'is_make_%s' % v\n        df[feature] = (df['make'] == v).astype(int)\n        features.append(feature)\n\n    for v in ['regular_unleaded', 'premium_unleaded_(required)', \n              'premium_unleaded_(recommended)', 'flex-fuel_(unleaded/e85)']:\n        feature = 'is_type_%s' % v\n        df[feature] = (df['engine_fuel_type'] == v).astype(int)\n        features.append(feature)\n\n    for v in ['automatic', 'manual', 'automated_manual']:\n        feature = 'is_transmission_%s' % v\n        df[feature] = (df['transmission_type'] == v).astype(int)\n        features.append(feature)\n        \n    df_num = df[features]\n    df_num = df_num.fillna(df_num.mean())\n    X = df_num.values\n    return X","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"\nX_train = prepare_X(df_train)\nw_0, w = train_linear_regression(X_train, y_train)\n\ny_pred = w_0 + X_train.dot(w)\nprint('train:', rmse(y_train, y_pred))\n\nX_val = prepare_X(df_val)\ny_pred = w_0 + X_val.dot(w)\nprint('validation:', rmse(y_val, y_pred))","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def prepare_X(df):\n    df = df.copy()\n    features = base.copy()\n\n    df['age'] = 2017 - df.year\n    features.append('age')\n    \n    for v in [2, 3, 4]:\n        feature = 'num_doors_%s' % v\n        df[feature] = (df['number_of_doors'] == v).astype(int)\n        features.append(feature)\n\n    for v in ['chevrolet', 'ford', 'volkswagen', 'toyota', 'dodge']:\n        feature = 'is_make_%s' % v\n        df[feature] = (df['make'] == v).astype(int)\n        features.append(feature)\n\n    for v in ['regular_unleaded', 'premium_unleaded_(required)', \n              'premium_unleaded_(recommended)', 'flex-fuel_(unleaded/e85)']:\n        feature = 'is_type_%s' % v\n        df[feature] = (df['engine_fuel_type'] == v).astype(int)\n        features.append(feature)\n\n    for v in ['automatic', 'manual', 'automated_manual']:\n        feature = 'is_transmission_%s' % v\n        df[feature] = (df['transmission_type'] == v).astype(int)\n        features.append(feature)\n\n    for v in ['front_wheel_drive', 'rear_wheel_drive', 'all_wheel_drive', 'four_wheel_drive']:\n        feature = 'is_driven_wheels_%s' % v\n        df[feature] = (df['driven_wheels'] == v).astype(int)\n        features.append(feature)\n\n    for v in ['crossover', 'flex_fuel', 'luxury', 'luxury,performance', 'hatchback']:\n        feature = 'is_mc_%s' % v\n        df[feature] = (df['market_category'] == v).astype(int)\n        features.append(feature)\n\n    for v in ['compact', 'midsize', 'large']:\n        feature = 'is_size_%s' % v\n        df[feature] = (df['vehicle_size'] == v).astype(int)\n        features.append(feature)\n\n    for v in ['sedan', '4dr_suv', 'coupe', 'convertible', '4dr_hatchback']:\n        feature = 'is_style_%s' % v\n        df[feature] = (df['vehicle_style'] == v).astype(int)\n        features.append(feature)\n\n    df_num = df[features]\n    df_num = df_num.fillna(df_num.mean())\n    X = df_num.values\n    return X","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"X_train = prepare_X(df_train)\nw_0, w = train_linear_regression(X_train, y_train)\n\ny_pred = w_0 + X_train.dot(w)\nprint('train:', rmse(y_train, y_pred))\n\nX_val = prepare_X(df_val)\ny_pred = w_0 + X_val.dot(w)\nprint('validation:', rmse(y_val, y_pred))","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"w.astype(int)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## <span style='color:#2E8BC0'> 11| Regularization in Machine Learning </span>","metadata":{}},{"cell_type":"code","source":"Image(url= \"data:image/png;base64,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\", width=500, height=600)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"def train_linear_regression_reg(X, y, r=0.0):\n    ones = np.ones(X.shape[0])\n    X = np.column_stack([ones, X])\n\n    XTX = X.T.dot(X)\n    reg = r * np.eye(XTX.shape[0])\n    XTX = XTX + reg\n\n    XTX_inv = np.linalg.inv(XTX)\n    w = XTX_inv.dot(X.T).dot(y)\n    \n    return w[0], w[1:]","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"X_train = prepare_X(df_train)","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"for r in [0, 0.001, 0.01, 0.1, 1, 10]:\n    w_0, w = train_linear_regression_reg(X_train, y_train, r=r)\n    print('%5s, %.2f, %.2f, %.2f' % (r, w_0, w[13], w[21]))","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"X_train = prepare_X(df_train)\nw_0, w = train_linear_regression_reg(X_train, y_train, r=0)\n\ny_pred = w_0 + X_train.dot(w)\nprint('train', rmse(y_train, y_pred))\n\nX_val = prepare_X(df_val)\ny_pred = w_0 + X_val.dot(w)\nprint('val', rmse(y_val, y_pred))","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"X_train = prepare_X(df_train)\nw_0, w = train_linear_regression_reg(X_train, y_train, r=0.01)\n\ny_pred = w_0 + X_train.dot(w)\nprint('train', rmse(y_train, y_pred))\n\nX_val = prepare_X(df_val)\ny_pred = w_0 + X_val.dot(w)\nprint('val', rmse(y_val, y_pred))","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"X_train = prepare_X(df_train)\nX_val = prepare_X(df_val)\n\nfor r in [0.000001, 0.0001, 0.001, 0.01, 0.1, 1, 5, 10]:\n    w_0, w = train_linear_regression_reg(X_train, y_train, r=r)\n    y_pred = w_0 + X_val.dot(w)\n    print('%6s' %r, rmse(y_val, y_pred))","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"X_train = prepare_X(df_train)\nw_0, w = train_linear_regression_reg(X_train, y_train, r=0.01)\n\nX_val = prepare_X(df_val)\ny_pred = w_0 + X_val.dot(w)\nprint('validation:', rmse(y_val, y_pred))\n\nX_test = prepare_X(df_test)\ny_pred = w_0 + X_test.dot(w)\nprint('test:', rmse(y_test, y_pred))","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## <span style='color:#2E8BC0'> 12| Using the Linear </span>","metadata":{}},{"cell_type":"code","source":"i = 2\nad = df_test.iloc[i].to_dict()\nad","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"X_test = prepare_X(pd.DataFrame([ad]))\ny_pred = w_0 + X_test.dot(w)\nsuggestion = np.expm1(y_pred)\nsuggestion","metadata":{},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"","metadata":{},"execution_count":null,"outputs":[]}]}