[PYTHON] J'ai essayé de prédire l'année prochaine avec l'IA

Introduction 2019 n'est qu'à quelques heures et l'intérêt pour l'année prochaine grandit. J'ai fait une prédiction par AI sur l'année prochaine.

Method

Données d'entraînement

J'ai appris des données de 2019 de cette année à 2019.

Apprentissage

Je l'ai appris avec Kernel Ridge du noyau rbf.

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_

Les données d'entraînement ont été divisées au hasard en données d'entraînement et données de test, et entraînées à l'aide des données d'entraînement. Kernel Ridge a des hyper paramètres ʻalpha et gamma`, donc je l'ai optimisé par la recherche de grille.

Result

Vérification croisée

GridSearchCV divise davantage les données données et recherche les paramètres qui maximisent les performances de généralisation. Déterminez les performances du prédicteur aux paramètres optimaux.

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

Le score de performance de généralisation était suffisamment élevé.

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()

Un yyplot a été dessiné pour visualiser si oui ou non une prédiction valide a été faite pour les données de formation / test.

On peut voir que des prédictions correctes ont été faites pour de nombreuses données existantes.

Courbe d'apprentissage

Une courbe d'apprentissage a été dessinée et vérifiée pour déterminer si elle était surentraînée.

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()

Étant donné que les performances d'apprentissage et les performances de généralisation ont convergé vers des valeurs élevées, on peut estimer que la possibilité de surapprentissage est faible.

Prévisions de l'année prochaine

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

J'ai entré les paramètres pour l'année prochaine de cette année et j'ai prédit l'année prochaine.

[2019.99488853]

Le résultat était de 2 020 $ \ fois 10 ^ 3 $ ans. En conséquence, l'année prochaine devrait être 2020.

Discussion

La méthode Kernel Ridge du noyau rbf est une méthode pour trouver une fonction qui minimise la fonction de perte à partir de l'espace des fonctions gaussiennes de dimension infinie, et présente des performances de généralisation élevées pour les problèmes dans lesquels une forme fonctionnelle explicite est supposée. Il est fort probable que l'année prochaine soit 2020.