使用Python线性回归预测Steam游戏的打折的幅度

# Plotting heat map as part of EDA
sns.heatmap(df.corr(),cmap="YlGnBu",annot=True)
plt.show()

# A compiled function to automatically split data, make and score models. And showing you what's the most relevant features.
def RSquare(df, col):
    X, y = df.drop(col,axis=1), df[col]

    X, X_test, y, y_test = train_test_split(X, y, test_size=.2, random_state=10) #hold out 20% of the data for final testing

    #this helps with the way kf will generate indices below
    X, y = np.array(X), np.array(y)
    
    kf = KFold(n_splits=5, shuffle=True, random_state = 50)
    cv_lm_r2s, cv_lm_reg_r2s, cv_lm_poly_r2s, cv_lasso_r2s = [], [], [], [] #collect the validation results for both models

    for train_ind, val_ind in kf.split(X,y):

        X_train, y_train = X[train_ind], y[train_ind]
        X_val, y_val = X[val_ind], y[val_ind]

        #simple linear regression
        lm = LinearRegression()
        lm_reg = Ridge(alpha=1)
        lm_poly = LinearRegression()

        lm.fit(X_train, y_train)
        cv_lm_r2s.append(lm.score(X_val, y_val))

        #ridge with feature scaling
        scaler = StandardScaler()
        X_train_scaled = scaler.fit_transform(X_train)
        X_val_scaled = scaler.transform(X_val)
        lm_reg.fit(X_train_scaled, y_train)
        cv_lm_reg_r2s.append(lm_reg.score(X_val_scaled, y_val))

        poly = PolynomialFeatures(degree=2)
        X_train_poly = poly.fit_transform(X_train)
        X_val_poly = poly.fit_transform(X_val)
        lm_poly.fit(X_train_poly, y_train)
        cv_lm_poly_r2s.append(lm_poly.score(X_val_poly, y_val))
        
        #Lasso
        std = StandardScaler()
        std.fit(X_train)
        
        X_tr = std.transform(X_train)
        X_te = std.transform(X_test)
        
        X_val_lasso = std.transform(X_val)
        
        alphavec = 10**np.linspace(-10,10,1000)

        lasso_model = LassoCV(alphas = alphavec, cv=5)
        lasso_model.fit(X_tr, y_train)
        cv_lasso_r2s.append(lasso_model.score(X_val_lasso, y_val))
        
        test_set_pred = lasso_model.predict(X_te)
        
        column = df.drop(col,axis=1)
        to_print = list(zip(column.columns, lasso_model.coef_))
        pp = pprint.PrettyPrinter(indent = 1)
    
        rms = sqrt(mean_squared_error(y_test, test_set_pred))
        
    print('Simple regression scores: ', cv_lm_r2s, '\n')
    print('Ridge scores: ', cv_lm_reg_r2s, '\n')
    print('Poly scores: ', cv_lm_poly_r2s, '\n')
    print('Lasso scores: ', cv_lasso_r2s, '\n')

    print(f'Simple mean cv r^2: {np.mean(cv_lm_r2s):.3f} +- {np.std(cv_lm_r2s):.3f}')
    print(f'Ridge mean cv r^2: {np.mean(cv_lm_reg_r2s):.3f} +- {np.std(cv_lm_reg_r2s):.3f}')
    print(f'Poly mean cv r^2: {np.mean(cv_lm_poly_r2s):.3f} +- {np.std(cv_lm_poly_r2s):.3f}', '\n')
    
    print('lasso_model.alpha_:', lasso_model.alpha_)
    print(f'Lasso cv r^2: {r2_score(y_test, test_set_pred):.3f} +- {np.std(cv_lasso_r2s):.3f}', '\n')
    
    print(f'MAE: {np.mean(np.abs(y_pred - y_true)) }', '\n')
    print('RMSE:', rms, '\n')
    
    print('Lasso Coef:')
    pp.pprint (to_print)

# Setting a floor limit of 30
df1 = df1[df1.Reviews > 30]

Best Model: Lasso
Score: 0.419 +- 0.073

df2.Reviews = np.log(df2.Reviews)
df2.OriginalPrice = df2.OriginalPrice.astype(float)
df2.OriginalPrice = np.log(df2.OriginalPrice)

Best Model: Lasso
Score: 0.437 +- 0.104

# Checking to make sure the dummies are separated correctly
pd.get_dummies(df3.Main_Tag).head(5)

# Adding dummy categories into the dataframe
df3 = pd.concat([df3, pd.get_dummies(df3.Main_Tag).astype(int)], axis = 1)

# Drop original string based column to avoid conflict in linear regression
df3.drop('Main_Tag', axis = 1, inplace=True)

Best Model: Lasso
Score: 0.330 +- 0.073

# we can get dummies for each tag listed separated by comma
split_tag = df4.All_Tags.astype(str).str.strip('[]').str.get_dummies(', ')

# Now merge the dummies into the data frame to start EDA
df4= pd.concat([df4, split_tag], axis=1)

# Remove any column that only has value of 0 as precaution
df4 = df4.loc[:, (df4 != 0).any(axis=0)]

Best Model: Lasso
Score: 0.359 +- 0.080

# Dummy all top 5 tags
split_tag = df.All_Tags.astype(str).str.strip('[]').str.get_dummies(', ')
df5= pd.concat([df5, split_tag], axis=1)

# Log transform Review due to skewed pairplot graphs
df5['Log_Review'] = np.log(df5['Reviews'])

Best Model: Lasso
Score: 0.359 +- 0.080

# Binning reviews (which is highly correlated with popularity) based on the above 75 percentile and 25 percentile
df6.loc[df6['Reviews'] < 33, 'low_pop'] = 1
df6.loc[(df6.Reviews >= 33) & (df6.Reviews < 381), 'mid_pop'] = 1
df6.loc[df6['Reviews'] >= 381, 'high_pop'] = 1

# Binning Days_Since_Release based on the above 75 percentile and 25 percentile
df6.loc[df6['Days_Since_Release'] < 418, 'new_game'] = 1
df6.loc[(df6.Days_Since_Release >= 418) & (df6.Days_Since_Release < 1716), 'established_game'] = 1
df6.loc[df6['Days_Since_Release'] >= 1716, 'old_game'] = 1

# Fill all the NaN's
df6.fillna(0, inplace = True)

# Drop the old columns to avoid multicolinearity
df6.drop(['Reviews', 'Days_Since_Release'], axis=1, inplace = True)

Best Model: Ridge
Score: 0.273 +- 0.044

# Setting a floor threshold of 30 reivews for the data frame to remove some outliers
df7 = df7[df7.Reviews > 30]

# Binning based on 50%
df7.loc[df7['Reviews'] < 271, 'low_pop'] = 1
df7.loc[df7['Reviews'] >= 271, 'high_pop'] = 1

df7.loc[df7['Days_Since_Release'] < 1167, 'new_game'] = 1
df7.loc[df7['Days_Since_Release'] >= 1167, 'old_game'] = 1

# Fill all NaN's
df7.fillna(0, inplace= True)

# Drop old columns to avoid multicolinearity
df7.drop(['Reviews', 'Days_Since_Release'], axis=1, inplace = True)

Best Model: Lasso
Score: 0.313 +- 0.098