Independent Samples T-test

We can now use the ttest_ind() function from scipy.stats to conduct the t-test. This function expects two numpy arrays as arguments; pandas Series also work:

In[11]: stats.ttest_ind(usa_cars['mpg'], europe_cars['mpg'])

Out[11]: Ttest_indResult(statistic=-8.534455914399228,
            pvalue=6.306531719750568e-16)

Unfortunately, the output here is rather scarce: while it does include the p-value, it doesn’t include the confidence interval. To run a t-test with more output, check out the researchpy module.

Let’s move on to analyzing our continuous variables. We’ll start with a correlation matrix. We can use the corr() method from pandas, including only the relevant variables:

In[12]: mpg[['mpg','horsepower','weight']].corr()

Out[12]:
                 mpg  horsepower    weight
mpg         1.000000   -0.778427 -0.832244
horsepower -0.778427    1.000000  0.864538
weight     -0.832244    0.864538  1.000000

Next, let’s visualize the relationship between weight and mpg with a scatterplot as shown in Figure 13-4:

In[13]: sns.scatterplot(x='weight', y='mpg', data=mpg)
        plt.title('Relationship between weight and mileage')

Figure 13-4. Scatterplot of mpg by weight

Alternatively, we could produce scatterplots across all pairs of our dataset with the pairplot() function from seaborn. Histograms of each variable are included along the diagonal, as seen in Figure 13-5:

In[14]: sns.pairplot(mpg[['mpg','horsepower','weight']])

Figure 13-5. Pairplot of mpg, horsepower, and weight

Linear Regression

Now it’s time for a linear regression. To do this, we’ll use linregress() from scipy, which also looks for two numpy arrays or pandas Series. We’ll specify which variable is our independent and dependent variable with the x and y arguments, respectively:

In[15]: # Linear regression of weight on mpg
        stats.linregress(x=mpg['weight'], y=mpg['mpg'])

Out[15]: LinregressResult(slope=-0.007647342535779578,
   intercept=46.21652454901758, rvalue=-0.8322442148315754,
   pvalue=6.015296051435726e-102, stderr=0.0002579632782734318)

Again, you’ll see that some of the output you may be used to is missing here. Be careful: the rvalue included is the correlation coefficient, not R-square. For a richer linear regression output, check out the statsmodels module.

Last but not least, let’s overlay our regression line to a scatterplot. seaborn has a separate function to do just that: regplot(). As usual, we’ll specify our independent and dependent variables, and where to get the data. This results in Figure 13-6:

In[16]: # Fit regression line to scatterplot
        sns.regplot(x="weight", y="mpg", data=mpg)
        plt.xlabel('Weight (lbs)')
        plt.ylabel('Mileage (mpg)')
        plt.title('Relationship between weight and mileage')

Figure 13-6. Scatterplot with fit regression line of mpg by weight

Train/Test Split and Validation

At the end of Chapter 9 you learned how to apply a train/test split when building a linear regression model in R.

We will use the train_test_split() function to split our dataset into four DataFrames: not just by training and testing but also independent and dependent variables. We’ll pass in a DataFrame containing our independent variable first, then one containing the dependent variable. Using the random_state argument, we’ll seed the random number generator so the results remain consistent for this example:

In[17]: X_train, X_test, y_train, y_test =
        model_selection.train_test_split(mpg[['weight']], mpg[['mpg']],
        random_state=1234)

By default, the data is split 75/25 between training and testing subsets:

In[18]:  y_train.shape

Out[18]: (294, 1)


In[19]:  y_test.shape

Out[19]: (98, 1)

Now, let’s fit the model to the training data. First we’ll specify the linear model with LinearRegression(), then we’ll train the model with regr.fit(). To get the predicted values for the test dataset, we can use predict(). This results in a numpy array, not a pandas DataFrame, so the head() method won’t work to print the first few rows. We can, however, slice it:

In[20]:  # Create linear regression object
         regr = linear_model.LinearRegression()

         # Train the model using the training sets
         regr.fit(X_train, y_train)

         # Make predictions using the testing set
         y_pred = regr.predict(X_test)

         # Print first five observations
         y_pred[:5]

Out[20]:  array([[14.86634263],
         [23.48793632],
         [26.2781699 ],
         [27.69989655],
         [29.05319785]])

The coef_ attribute returns the coefficient of our test model:

In[21]:  regr.coef_

Out[21]: array([[-0.00760282]])

To get more information about the model, such as the coefficient p-values or R-squared, try fitting it with the statsmodels package.

For now, we’ll evaluate the performance of the model on our test data, this time using the metrics submodule of sklearn. We’ll pass in our actual and predicted values to the r2_score() and mean_squared_error() functions, which will return the R-squared and RMSE, respectively.

In[22]:  metrics.r2_score(y_test, y_pred)

Out[22]: 0.6811923996681357


In[23]:  metrics.mean_squared_error(y_test, y_pred)

Out[23]: 21.63348076436662