Introduction à la création d'IA avec Python! Partie 2 J'ai essayé de prédire le prix de l'immobilier dans la ville de Boston avec un réseau neuronal

À propos de cet article

En utilisant le "retour", qui est la base de l'apprentissage en profondeur, Je voudrais faire un programme pour prédire le prix de l'immobilier. J'écrirai autant que possible du point de vue d'un débutant. L'article précédent est ici .

Qu'est-ce qu'un retour?

La régression consiste à prédire des valeurs numériques basées sur des données caractéristiques. Cette fois, nous allons créer un programme pour prédire les prix des maisons, mais il est également possible de prédire les mouvements de prix des actions et des devises (opérations de change).

import

L'importation est ↓. Cette fois, importons des pandas pour vérifier les données.

Au fait, les pandas sont très faciles à manipuler, mais très lents. Il est courant d'utiliser numpy pour l'apprentissage et les pandas pour la confirmation visuelle et le prétraitement des données.

from tensorflow.keras.datasets import boston_housing
from tensorflow.keras.layers import Activation, Dense, Dropout
from tensorflow.keras.models import Sequential
from tensorflow.keras.callbacks import EarlyStopping
from tensorflow.keras.optimizers import Adam
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

Accueil Prix Télécharger

Cette fois, nous utiliserons une bibliothèque appelée boston_housing pour prédire les prix des maisons. boston_housing contient des informations caractéristiques et l'étiquette de réponse correcte lors du choix d'une maison à Boston, aux États-Unis. Les informations caractéristiques (ci-après dénommées variables explicatives) comprennent le taux de criminalité et l'accessibilité de la zone.

Évidemment, si cette variable explicative contient des informations bâclées, la prédiction sera inexacte. Par exemple, même si vous ajoutez le nombre de boutiques de pachinko à proximité aux variables explicatives Seul le pachinker ressent la valeur, donc cela interférera avec la prédiction. Nous devons ajouter quelque chose que tout le monde sent utile.

La partie la plus difficile de la prédiction de régression est la définition de cette variable explicative. Cette fois, c'est facile car il est inclus dans les données téléchargées.

Le téléchargement est le code ci-dessous. Les variables explicatives téléchargées séparent les étiquettes de réponse correctes pour l'apprentissage et la vérification. (train_data, train_labels) est pour la formation et (test_data, test_labels) est pour la vérification. Cette zone est la même que la classification de l'article précédent.

(train_data, train_labels), (test_data, test_labels) = boston_housing.load_data()

Vérifiez le nombre de formes. Il y a 404 données d'entraînement et 102 données de vérification. Par rapport au classement de l'article précédent, c'est beaucoup moins. C'est le nombre de cas qui me fait me demander si je peux vraiment le prédire.

Prétraitement des données

Vient ensuite la tâche la plus simple et la plus importante, le prétraitement des données. Ces prévisions de prix des logements ne sont pas des données chronologiques, il n'y a donc pas de continuité. Lors de la prédiction de telles données, il est plus sûr de mélanger les données.

• La lecture aléatoire est strictement interdite lors de la prédiction de données chronologiques telles que les actions et les devises.

Utilisez random.random () '' pour créer un nombre aléatoire et np.argsort () '' pour créer un index et trier.

order = np.argsort(np.random.random(train_labels.shape))
train_data = train_data[order]
train_labels = train_labels[order]

Ensuite, normalisez les variables explicatives qui déterminent le prix du logement. Cette fois, la normalisation est utilisée pour fixer la variable explicative à une valeur avec une variance de 1 avec une moyenne de 0.

Dans la prédiction de régression, la prédiction peut être tirée par un grand nombre de variables explicatives. On dit qu'il est bon de normaliser de cette manière.

La normalisation peut être calculée en soustrayant la moyenne des données que vous souhaitez normaliser et en la divisant par l'écart type. Le code est ↓.

mean = train_data.mean(axis=0)
std = train_data.std(axis=0)
train_data = (train_data - mean) / std
test_data = (test_data - mean) / std

Utilisez des pandas pour vous assurer que les variables explicatives sont normalisées.

#Confirmation des données après le prétraitement de l'ensemble de données
column_names = ['CRIM', 'ZN', 'INDUS', 'CHAS', 'NOX', 'RM', 'AGE',  'DIS', 'RAD', 'TAX', 'PTRATIO', 'B', 'LSTAT']
df = pd.DataFrame(train_data, columns=column_names)
df.head()

Créer un modèle

Créez un modèle du réseau neuronal. Cette fois, nous préparerons trois couches de connexion totale totale.

• Il n'y a pas d'abandon cette fois

model = Sequential()
model.add(Dense(64, activation='relu', input_shape=(13,)))
model.add(Dense(64, activation='relu'))
model.add(Dense(1))

model.compile(loss='mse', optimizer=Adam(lr=0.001), metrics=['mae']) #compiler

Je vais expliquer chacun d'eux. Tout d'abord, créez un modèle séquentiel avec `` model = Sequential () ''.

model.add (Dense (64, activation = 'relu', input_shape = (13,))) est la couche d'entrée. Dense: Liaison totale totale, Nombre d'unités: 64, Fonction d'activation: ReLU, Variables explicatives: 13

model.add (Dense (64, activation = 'relu')) est une couche cachée. Dense: Liaison totale totale, Nombre d'unités: 64, Fonction d'activation: ReLU

`` model.add (Dense (1)) '' est la couche de sortie. Cette fois, il s'agit d'une prédiction numérique, il n'y a donc qu'une seule unité (nombre de sorties).

Compiler le modèle

Compilez avec model.compile (loss = 'mse', optimizer = Adam (lr = 0.001), metrics = ['mae']). Avec loss = 'mse', définissez la fonction de perte __ pour trouver l'erreur __ entre la valeur prédite et la valeur réelle. Définissons mse qui convient à la régression.

Avec optimizer = Adam (lr = 0,001), définissez Adam sur la fonction d'optimisation __ pour réduire l'erreur et définissez le taux d'apprentissage sur 0,01.

Avec metrics = ['mae'], définissez le mae de la fonction d'évaluation __ pour évaluer les performances du modèle __.

Apprentissage

Cette fois, j'aimerais apprendre à utiliser l'arrêt anticipé. Avec EarlyStopping, si vous ne voyez aucune amélioration dans l'apprentissage avec le nombre d'époques spécifié, il s'arrêtera automatiquement. Cette fois, s'il n'y a pas d'amélioration depuis 20 époques, je voudrais m'arrêter.

Pour l'apprentissage, définissez le nombre maximal d'époques sur 500, définissez les données de vérification sur 20% et activez l'arrêt anticipé avec callbacks = [early_stop].

#Préparez-vous à un arrêt anticipé
early_stop = EarlyStopping(monitor='val_loss', patience=30)

#Exécution de l'apprentissage
history = model.fit(train_data, train_labels, epochs=500, 
    validation_split=0.2, callbacks=[early_stop])

Ceci est une explication de la situation d'apprentissage. __loss est l'erreur de données d'entraînement __. Plus il est proche de 0, meilleur est le résultat. __mae est l'erreur absolue moyenne des données d'entraînement __. Plus il est proche de 0, meilleur est le résultat. __val_loss est l'erreur de données de validation __. Plus il est proche de 0, meilleur est le résultat. __val_mae est l'erreur absolue moyenne __ des données de validation. Plus il est proche de 0, meilleur est le résultat.

J'ai fixé le nombre d'époques à 500, mais je pense qu'il a été interrompu car aucune amélioration n'est visible en cours de route.

Afficher les résultats d'apprentissage dans un graphique

Dessinez history.history où le résultat d'apprentissage est enregistré avec matplotlib.

plt.plot(history.history['mae'], label='train mae')
plt.plot(history.history['val_mae'], label='val mae')
plt.xlabel('epoch')
plt.ylabel('mae [1000$]')
plt.legend(loc='best')
plt.ylim([0,5])
plt.show()

Évaluation de l'apprentissage

Évaluez les données d'entraînement avec model.evalute.

test_loss, test_mae = model.evaluate(test_data, test_labels)
print('loss:{:.3f}\nmae: {:.3f}'.format(test_loss, test_mae))

Le résultat est pire que les données d'entraînement, mais le résultat est presque le même. Il est étonnant que même avec un petit nombre de cas, environ 400, nous pouvons en approcher un certain nombre. Peut-être que la définition des variables explicatives est excellente.

inférence

Enfin, sortons les données de prédiction et vérifions-les. Affichez d'abord l'étiquette de réponse correcte, puis déduisez. Puisque le résultat de l'inférence en sortie est bidimensionnel, convertissons-le en unidimensionnel avec `` flatten () ''.

#Afficher l'étiquette de réponse correcte
print(np.round(test_labels[0:10]))

#Affichage du prix déduit
test_predictions = model.predict(test_data[0:10]).flatten()
print(np.round(test_predictions))

Les propriétés qui sont inférieures à cette prévision peuvent être vendues moins cher que le prix du marché. Cependant, cela peut être moins cher pour des raisons qui ne peuvent être exprimées par des variables explicatives (comme l'apparition de fantômes). Il est dangereux d'acheter et de vendre uniquement avec ce résultat de prédiction, mais je pense que ce sera utile.