Wie erhöhe ich die Richtigkeit meiner Linearen Regressionsmodell?(maschinelles lernen mit python)

Werde ich erarbeiten ein wenig auf @GeorgiKaradjov Antwort mit einigen Beispielen. Ihre Frage ist sehr breit, und es gibt mehrere Möglichkeiten, um Verbesserungen. Am Ende, mit domain-wissen (Kontext) geben Ihnen die bestmögliche chance auf Verbesserungen.

1. Normalisieren Sie Ihre Daten, dh, verschieben Sie auf einen Mittelwert von null und eine Streuung von 1 Standardabweichung
2. Drehen kategorische Daten werden in den Variablen über, z.B., OneHotEncoding
3. Tun Funktion engineering:
   • Sind meine Eigenschaften kollinearer?
   • Nicht alle meine Funktionen cross terms/höherer Ordnung Begriffen?
4. Regularisierung der features zu reduzieren, mögliche überanpassung
5. Blick auf alternative Modelle gegeben, die zugrunde liegenden Funktionen und dem Ziel, das Projekt

1) Normalisierung der Daten

from sklearn.preprocessing import StandardScaler
std = StandardScaler()
afp = np.append(X_train['AFP'].values, X_test['AFP'].values)
std.fit(afp)

X_train[['AFP']] = std.transform(X_train['AFP'])
X_test[['AFP']] = std.transform(X_test['AFP'])

Gibt

0    0.752395
1    0.008489
2   -0.381637
3   -0.020588
4    0.171446
Name: AFP, dtype: float64

2) Kategorische Feature Codierung

def feature_engineering(df):

    dev_plat = pd.get_dummies(df['Development_platform'], prefix='dev_plat')
    df[dev_plat.columns] = dev_plat
    df = df.drop('Development_platform', axis=1)

    lang_type = pd.get_dummies(df['Language_Type'], prefix='lang_type')
    df[lang_type.columns] = lang_type
    df = df.drop('Language_Type', axis=1)

    resource_level = pd.get_dummies(df['Resource_Level'], prefix='resource_level')
    df[resource_level.columns] = resource_level
    df = df.drop('Resource_Level', axis=1)

    return df

X_train = feature_engineering(X_train)
X_train.head(5)

Gibt

AFP dev_plat_077070 dev_plat_077082 dev_plat_077117108116105    dev_plat_080067 lang_type_051071076 lang_type_052071076 lang_type_065112071 resource_level_1    resource_level_2    resource_level_4
0   0.752395    1   0   0   0   1   0   0   1   0   0
1   0.008489    0   0   1   0   0   1   0   1   0   0
2   -0.381637   0   0   1   0   0   1   0   1   0   0
3   -0.020588   0   0   1   0   1   0   0   1   0   0

3) Feature Engineering; Kollinearität

import seaborn as sns
corr = X_train.corr()
sns.heatmap(corr, mask=np.zeros_like(corr, dtype=np.bool), cmap=sns.diverging_palette(220, 10, as_cmap=True), square=True)

Du willst die rote Linie für y=x da die Werte sollten korreliert sein mit sich. Aber keine roten oder blauen Säulen zeigen eine starke Korrelation/anti-Korrelation, erfordert eine genauere Untersuchung. Zum Beispiel, Ressource=1, Resource=4, könnte eine hohe Korrelation in dem Sinne, wenn Menschen 1 es gibt eine geringere chance zu haben, 4 usw. Regression wird davon ausgegangen, dass die verwendeten Parameter sind von einander unabhängig.

3) Feature engineering, höhere Reihenfolge Begriffe

Vielleicht ist dein Modell ist zu einfach, Sie könnte prüfen, indem höhere Bestell-und cross-Bedingungen:

from sklearn.preprocessing import PolynomialFeatures
poly = PolynomialFeatures(2, interaction_only=True)
output_nparray = poly.fit_transform(df)
target_feature_names = ['x'.join(['{}^{}'.format(pair[0],pair[1]) for pair in tuple if pair[1]!=0]) for tuple in [zip(df.columns, p) for p in poly.powers_]]
output_df = pd.DataFrame(output_nparray, columns=target_feature_names)

Hatte ich einen schnellen Versuch an, ich glaube nicht, dass die höhere Reihenfolge Begriffe helfen viel. Es ist auch möglich Ihre Daten nicht-lineare, eine schnelle logarithm oder die Y-Ausgang gibt ein schlechter fit, was darauf hindeutet, es ist linear. Sie könnten auch einen Blick auf den aktuellen Werten, aber ich war zu faul....

4) Regularisierung

Versuchen Sie es mit sklearn ist RidgeRegressor und spielen mit alpha:

lr = RidgeCV(alphas=np.arange(70,100,0.1), fit_intercept=True)

5) Alternative Modelle

Manchmal die lineare regression ist nicht immer geeignet. Zum Beispiel, Random Forest Regressoren kann ausführen sehr gut, und sind in der Regel unempfindlich gegen die Daten werden vereinheitlicht und als kategorischen/permanent. Andere Modelle verfügen über XGBoost, und Lasso (der Linearen regression mit L1-Regularisierung).

lr = RandomForestRegressor(n_estimators=100)

Setzen Sie alle zusammen

Ich wurde mitgerissen und begann, mich an Ihrem problem, konnte es aber nicht verbessern, ist es zu viel, ohne zu wissen, alle die Kontext-Funktionen:

import numpy as np
import pandas as pd
import scipy
import matplotlib.pyplot as plt
from pylab import rcParams
import urllib
import sklearn
from sklearn.linear_model import RidgeCV, LinearRegression, Lasso
from sklearn.ensemble import RandomForestRegressor
from sklearn.preprocessing import StandardScaler, PolynomialFeatures
from sklearn.model_selection import GridSearchCV

def feature_engineering(df):

    dev_plat = pd.get_dummies(df['Development_platform'], prefix='dev_plat')
    df[dev_plat.columns] = dev_plat
    df = df.drop('Development_platform', axis=1)

    lang_type = pd.get_dummies(df['Language_Type'], prefix='lang_type')
    df[lang_type.columns] = lang_type
    df = df.drop('Language_Type', axis=1)

    resource_level = pd.get_dummies(df['Resource_Level'], prefix='resource_level')
    df[resource_level.columns] = resource_level
    df = df.drop('Resource_Level', axis=1)

    return df

df = pd.read_csv("TrainingData.csv")
df2 = pd.read_csv("TestingData.csv")

df['Development_platform']= ["".join("%03d" % ord(c) for c in s) for s in df['Development_platform']]
df['Language_Type']= ["".join("%03d" % ord(c) for c in s) for s in df['Language_Type']]

df2['Development_platform']= ["".join("%03d" % ord(c) for c in s) for s in df2['Development_platform']]
df2['Language_Type']= ["".join("%03d" % ord(c) for c in s) for s in df2['Language_Type']]

X_train = df[['AFP','Development_platform','Language_Type','Resource_Level']]
Y_train = df['Effort']

X_test = df2[['AFP','Development_platform','Language_Type','Resource_Level']]
Y_test = df2['Effort']

std = StandardScaler()
afp = np.append(X_train['AFP'].values, X_test['AFP'].values)
std.fit(afp)

X_train[['AFP']] = std.transform(X_train['AFP'])
X_test[['AFP']] = std.transform(X_test['AFP'])

X_train = feature_engineering(X_train)
X_test = feature_engineering(X_test)

lr = RandomForestRegressor(n_estimators=50)
lr.fit(X_train, Y_train)

print("Training set score: {:.2f}".format(lr.score(X_train, Y_train)))
print("Test set score: {:.2f}".format(lr.score(X_test, Y_test)))

fig = plt.figure()
ax = fig.add_subplot(111)

ax.errorbar(Y_test, y_pred, fmt='o')
ax.errorbar([1, Y_test.max()], [1, Y_test.max()])

Ergibt:

Training set score: 0.90
Test set score: 0.61

Kann man sich die Bedeutung der Variablen (je höher der Wert, desto wichtiger).

Importance
AFP                         0.882295
dev_plat_077070             0.020817
dev_plat_077082             0.001162
dev_plat_077117108116105    0.016334
dev_plat_080067             0.004077
lang_type_051071076         0.012458
lang_type_052071076         0.021195
lang_type_065112071         0.001118
resource_level_1            0.012644
resource_level_2            0.006673
resource_level_4            0.021227

Könnten Sie beginnen, die hyperparameters um Verbesserungen auf diesem auch: http://scikit-learn.org/stable/modules/generated/sklearn.model_selection.GridSearchCV.html#sklearn.model_selection.GridSearchCV

1. normalisieren Sie Ihre Daten
2. Je nach Art der Eingabe-features, die Sie extrahieren können verschiedene Funktionen von Ihnen (feature-Kombinationen sind auch möglich)
3. Wenn Ihre Daten nicht Linear trennbar, Sie werden nicht in der Lage, vorherzusagen, ist es gut. Möglicherweise müssen Sie verwenden ein anderes Modell, Logistische regression, SVR, NN /was auch immer