[PYTHON] Ich habe versucht, nächstes Jahr mit AI vorherzusagen

Introduction 2019 ist nur noch wenige Stunden entfernt und das Interesse am nächsten Jahr wächst. Ich habe von AI vorausgesagt, welches Jahr nächstes Jahr sein wird.

Method

Trainingsdaten

Ich habe von 2019 Daten von diesem Jahr bis 2019 gelernt.

Lernen

Ich habe es mit Kernel Ridge vom rbf-Kernel gelernt.

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

df = pd.read_csv('years.csv',names=("years", "result"))
features = df.drop(["result"], axis=1)
target = df["result"]

from sklearn.model_selection import train_test_split
train_x, test_x, train_y, test_y = train_test_split(features, target, test_size=0.2, random_state=0)

from sklearn.model_selection import GridSearchCV
from sklearn.kernel_ridge import KernelRidge
param_grid = {'alpha': [i*10**j for i in [1,3] for j in [-9,-8,-7]],
              'gamma': [i*10**j for i in [1,2,4,7] for j in [-6,-5,-4]]}
gs = GridSearchCV(KernelRidge(kernel='rbf'), param_grid, cv=5, n_jobs=3)
gs.fit(train_x, train_y)
rgr = gs.best_estimator_

Die Trainingsdaten wurden zufällig in Trainingsdaten und Testdaten aufgeteilt und unter Verwendung der Trainingsdaten trainiert. Kernel Ridge hat die Hyperparameter "Alpha" und "Gamma", daher habe ich sie durch Rastersuche optimiert.

Result

Gegenüberstellung

GridSearchCV unterteilt die angegebenen Daten weiter und sucht nach Parametern, die die Generalisierungsleistung maximieren. Bestimmen Sie die Prädiktorleistung bei den optimalen Parametern.

print(gs.best_estimator_)
print(gs.best_score_)

KernelRidge(alpha=1e-09, coef0=1, degree=3, gamma=2e-05, kernel='rbf',
      kernel_params=None)
0.9999999999996596

Der Generalisierungsleistungswert war ausreichend hoch.

yyplot

plt.scatter(rgr.predict(train_x), train_y, marker='.', label='train')
plt.scatter(rgr.predict(test_x), test_y, marker='.', label='test')
plt.legend()
plt.show()

Ein Yyplot wurde gezeichnet, um zu visualisieren, ob eine gültige Vorhersage für die Trainings- / Testdaten gemacht wurde oder nicht.

Es ist ersichtlich, dass für viele vorhandene Daten korrekte Vorhersagen getroffen wurden.

Lernkurve

Eine Lernkurve wurde gezeichnet und verifiziert, um festzustellen, ob sie übertrainiert war.

from sklearn.model_selection import (learning_curve,ShuffleSplit)

def plot_learning_curve(estimator, title, X, y, ylim=None, cv=None,
                        n_jobs=None, train_sizes=np.linspace(.1, 1.0, 5), verbose=0):
    plt.figure()
    plt.title(title)
    if ylim is not None:
        plt.ylim(*ylim)
    plt.xlabel("Training examples")
    plt.ylabel("Score")
    train_sizes, train_scores, test_scores = learning_curve(
        estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes, verbose=verbose)
    train_scores_mean = np.mean(train_scores, axis=1)
    train_scores_std = np.std(train_scores, axis=1)
    test_scores_mean = np.mean(test_scores, axis=1)
    test_scores_std = np.std(test_scores, axis=1)
    plt.grid()

    plt.fill_between(train_sizes, train_scores_mean - train_scores_std,
                     train_scores_mean + train_scores_std, alpha=0.1,
                     color="r")
    plt.fill_between(train_sizes, test_scores_mean - test_scores_std,
                     test_scores_mean + test_scores_std, alpha=0.1, color="g")
    plt.plot(train_sizes, train_scores_mean, 'o-', color="r",
             label="Training score")
    plt.plot(train_sizes, test_scores_mean, 'o-', color="g",
             label="Cross-validation score")

    plt.legend(loc="best")
    return plt

cv = ShuffleSplit(n_splits=5, test_size=0.2, random_state=0)
t_size = np.linspace(0.01, 1.00, 20)
plot_learning_curve(RandomForestRegressor(n_estimators=50),
                    "Learning Curve", features, target, cv=cv, ylim=[0.98,1.005], train_sizes=t_size, verbose=10)
plt.show()

Da sowohl die Lernleistung als auch die Generalisierungsleistung zu hohen Werten konvergiert haben, kann beurteilt werden, dass die Möglichkeit eines Überlernens gering ist.

Prognose für das nächste Jahr

print(rgr.predict([[2019+1]]))

Ich habe die Parameter für das nächste Jahr dieses Jahres eingegeben und das Jahr des nächsten Jahres vorhergesagt.

[2019.99488853]

Das Ergebnis war $ 2.020 \ mal 10 ^ 3 $ Jahre. Infolgedessen wird für das nächste Jahr 2020 erwartet.

Discussion

Die Kernel Ridge-Methode des rbf-Kernels ist eine Methode zum Auffinden einer Funktion, die die Verlustfunktion aus dem unendlich dimensionalen Gaußschen Funktionsraum minimiert und eine hohe Generalisierungsleistung für Probleme aufweist, bei denen eine explizite funktionale Form angenommen wird. Es ist sehr wahrscheinlich, dass nächstes Jahr 2020 sein wird.