{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Multiple Regression"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let's grab a small little data set of Blue Book car values:"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [],
"source": [
"import pandas as pd\n",
"import matplotlib.pyplot as plt\n",
"\n",
"df = pd.read_excel('http://cdn.sundog-soft.com/Udemy/DataScience/cars.xls')\n"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" Mileage Price\n",
"Mileage \n",
"(0, 10000] 5588.629630 24096.714451\n",
"(10000, 20000] 15898.496183 21955.979607\n",
"(20000, 30000] 24114.407104 20278.606252\n",
"(30000, 40000] 33610.338710 19463.670267\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"C:\\Users\\Frank\\AppData\\Local\\Temp\\ipykernel_2772\\1994202671.py:5: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n",
" groups = df1.groupby(pd.cut(df1['Mileage'],bins)).mean()\n"
]
},
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 640x480 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"%matplotlib inline\n",
"import numpy as np\n",
"df1=df[['Mileage','Price']]\n",
"bins = np.arange(0,50000,10000)\n",
"groups = df1.groupby(pd.cut(df1['Mileage'],bins)).mean()\n",
"print(groups.head())\n",
"groups['Price'].plot.line()\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can use pandas to split up this matrix into the feature vectors we're interested in, and the value we're trying to predict.\n",
"\n",
"Note how we are avoiding the make and model; regressions don't work well with ordinal values, unless you can convert them into some numerical order that makes sense somehow.\n",
"\n",
"Let's scale our feature data into the same range so we can easily compare the coefficients we end up with."
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
" const Mileage Cylinder Doors\n",
"0 1.0 -1.417485 0.52741 0.556279\n",
"1 1.0 -1.305902 0.52741 0.556279\n",
"2 1.0 -0.810128 0.52741 0.556279\n",
"3 1.0 -0.426058 0.52741 0.556279\n",
"4 1.0 0.000008 0.52741 0.556279\n",
".. ... ... ... ...\n",
"799 1.0 -0.439853 0.52741 0.556279\n",
"800 1.0 -0.089966 0.52741 0.556279\n",
"801 1.0 0.079605 0.52741 0.556279\n",
"802 1.0 0.750446 0.52741 0.556279\n",
"803 1.0 1.932565 0.52741 0.556279\n",
"\n",
"[804 rows x 4 columns]\n",
" OLS Regression Results \n",
"==============================================================================\n",
"Dep. Variable: Price R-squared: 0.360\n",
"Model: OLS Adj. R-squared: 0.358\n",
"Method: Least Squares F-statistic: 150.0\n",
"Date: Mon, 03 Mar 2025 Prob (F-statistic): 3.95e-77\n",
"Time: 10:37:38 Log-Likelihood: -8356.7\n",
"No. Observations: 804 AIC: 1.672e+04\n",
"Df Residuals: 800 BIC: 1.674e+04\n",
"Df Model: 3 \n",
"Covariance Type: nonrobust \n",
"==============================================================================\n",
" coef std err t P>|t| [0.025 0.975]\n",
"------------------------------------------------------------------------------\n",
"const 2.134e+04 279.405 76.388 0.000 2.08e+04 2.19e+04\n",
"Mileage -1272.3412 279.567 -4.551 0.000 -1821.112 -723.571\n",
"Cylinder 5587.4472 279.527 19.989 0.000 5038.754 6136.140\n",
"Doors -1404.5513 279.446 -5.026 0.000 -1953.085 -856.018\n",
"==============================================================================\n",
"Omnibus: 157.913 Durbin-Watson: 0.069\n",
"Prob(Omnibus): 0.000 Jarque-Bera (JB): 257.529\n",
"Skew: 1.278 Prob(JB): 1.20e-56\n",
"Kurtosis: 4.074 Cond. No. 1.03\n",
"==============================================================================\n",
"\n",
"Notes:\n",
"[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"C:\\Users\\Frank\\AppData\\Local\\Temp\\ipykernel_2772\\2726360189.py:8: SettingWithCopyWarning: \n",
"A value is trying to be set on a copy of a slice from a DataFrame.\n",
"Try using .loc[row_indexer,col_indexer] = value instead\n",
"\n",
"See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
" X[['Mileage', 'Cylinder', 'Doors']] = scale.fit_transform(X[['Mileage', 'Cylinder', 'Doors']].values)\n"
]
}
],
"source": [
"import statsmodels.api as sm\n",
"from sklearn.preprocessing import StandardScaler\n",
"scale = StandardScaler()\n",
"\n",
"X = df[['Mileage', 'Cylinder', 'Doors']]\n",
"y = df['Price']\n",
"\n",
"X[['Mileage', 'Cylinder', 'Doors']] = scale.fit_transform(X[['Mileage', 'Cylinder', 'Doors']].values)\n",
"\n",
"# Add a constant column to our model so we can have a Y-intercept\n",
"X = sm.add_constant(X)\n",
"\n",
"print (X)\n",
"\n",
"est = sm.OLS(y, X).fit()\n",
"\n",
"print(est.summary())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The table of coefficients above gives us the values to plug into an equation of form:\n",
" B0 + B1 * Mileage + B2 * cylinders + B3 * doors\n",
" \n",
"In this example, it's pretty clear that the number of cylinders is more important than anything based on the coefficients.\n",
"\n",
"Could we have figured that out earlier?"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"Doors\n",
"2 23807.135520\n",
"4 20580.670749\n",
"Name: Price, dtype: float64"
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"y.groupby(df.Doors).mean()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Surprisingly, more doors does not mean a higher price! (Maybe it implies a sport car in some cases?) So it's not surprising that it's pretty useless as a predictor here. This is a very small data set however, so we can't really read much meaning into it.\n",
"\n",
"How would you use this to make an actual prediction? Start by scaling your multiple feature variables into the same scale used to train the model, then just call est.predict() on the scaled features:"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1. 3.07256589 1.96971667 0.55627894]\n",
"[27658.15707316]\n"
]
}
],
"source": [
"scaled = scale.transform([[45000, 8, 4]])\n",
"scaled = np.insert(scaled[0], 0, 1) #Need to add that constant column in again.\n",
"print(scaled)\n",
"predicted = est.predict(scaled)\n",
"print(predicted)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Activity"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Mess around with the fake input data, and see if you can create a measurable influence of number of doors on price. Have some fun with it - why stop at 4 doors?"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python [conda env:base] *",
"language": "python",
"name": "conda-base-py"
},
"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.3"
}
},
"nbformat": 4,
"nbformat_minor": 4
}