J'ai joué avec le back-end et le front-end, mais je n'ai pas encore essayé l'apprentissage automatique. C'est ma première tentative, donc je l'enregistrerai comme un mémorial. J'utilise python, numpy, tf.keras.

Mes spécifications

Voir cette Qiita.
Système de communication par c et go ~ développement backend, développement frontend par flutter / dart est possible
Je touche aussi un peu à python.
J'ai touché à l'apprentissage automatique avec des outils d'interface graphique.
L'apprentissage automatique avec python est mon premier défi. Un niveau que je n'ai jamais utilisé numpy.

Pour étudier collectivement la théorie de l'apprentissage automatique, "Deep Learning from scratch - the théorie and implementation of deep learning appris with Python J'ai lu "dp / 4873117585 /)". C'était un très bon livre.

L'environnement de développement est PyCharm Community 2019.3. J'utilise PyCharm en chargeant les bibliothèques nécessaires sans utiliser Anaconda.

1. Paramètre de tâche d'apprentissage automatique

Nous visons à apprendre automatiquement la logique correcte suivante.

C'est un problème de classification binaire avec un enseignant.
Définissez la quantité de caractéristique à saisir sous forme de deux valeurs aléatoires (0 ou plus et moins de 1), et définissez 0 ou 1 comme étiquette de réponse correcte en comparant les deux grandeurs.
Rarement, le bruit est mélangé dans la bonne étiquette. (Éliminez le bruit au début)

2. Code

J'ai créé un code typique pour le problème de classification binaire en regardant certains articles Web. J'ai trouvé que c'était assez compact et intuitif à écrire. Keras est incroyable.

#!/usr/bin/env python3

import tensorflow as tf
import numpy as np
from tensorflow_core.python.keras.metrics import binary_accuracy
import matplotlib.pyplot as plt

#Préparation du jeu de données
ds_features = np.random.rand(10000, 2)  #Données sur les fonctionnalités
NOISE_RATE = 0
ds_noise = (np.random.rand(10000) > NOISE_RATE).astype(np.int) * 2 - 1  #Pas de bruit: 1,Oui: -1
ds_labels = (np.sign(ds_features[:, 0] - ds_features[:, 1]) * ds_noise + 1) / 2  #Étiquette de réponse correcte

#Divisez l'ensemble de données pour la formation et la validation
SPLIT_RATE = 0.8   #Rapport de division
training_features, validation_features = np.split(ds_features, [int(len(ds_features) * SPLIT_RATE)])
training_labels, validation_labels = np.split(ds_labels, [int(len(ds_labels) * SPLIT_RATE)])

#Préparation du modèle
INPUT_FEATURES = ds_features.shape[1]   #Dimension caractéristique
LAYER1_NEURONS = int(INPUT_FEATURES * 1.2 + 1)   #Un peu plus large que la dimension d'entrée
LAYER2_NEURONS = LAYER1_NEURONS
LAYER3_NEURONS = LAYER1_NEURONS  #3 couches cachées
OUTPUT_RESULTS = 1  #La sortie est unidimensionnelle
ACTIVATION = 'tanh'
model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(input_shape=(INPUT_FEATURES,), units=LAYER1_NEURONS, activation=ACTIVATION),
    tf.keras.layers.Dense(units=LAYER2_NEURONS, activation=ACTIVATION),
    tf.keras.layers.Dense(units=LAYER3_NEURONS, activation=ACTIVATION),
    tf.keras.layers.Dense(units=OUTPUT_RESULTS, activation='sigmoid'),
])
LOSS = 'binary_crossentropy'
OPTIMIZER = tf.keras.optimizers.Adam   #Méthode d'optimisation typique
LEARNING_RATE = 0.03   #Valeurs initiales communes du coefficient d'apprentissage
model.compile(optimizer=OPTIMIZER(lr=LEARNING_RATE), loss=LOSS, metrics=[binary_accuracy])

#Apprentissage
BATCH_SIZE = 30
EPOCHS = 100
result = model.fit(x=training_features, y=training_labels,
                   validation_data=(validation_features, validation_labels),
                   batch_size=BATCH_SIZE, epochs=EPOCHS, verbose=1)

#afficher
plt.plot(range(1, EPOCHS+1), result.history['binary_accuracy'], label="training")
plt.plot(range(1, EPOCHS+1), result.history['val_binary_accuracy'], label="validation")
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.ylim(0.5, 1)
plt.legend()
plt.show()

3. Résultat

C'est le résultat de l'apprentissage. Il a rapidement atteint une précision d'environ 99%, et il semble qu'il n'ait pas surappris.

4. Examen

4.1. Comportement en cas d’ajout de bruit

J'ai essayé de définir NOISE_RATE = 0,2. La précision est réduite par la quantité de bruit, mais le résultat est approprié.

4.2. Comportement lorsque des fonctionnalités factices non pertinentes sont ajoutées

Retournons le bruit et augmentons la quantité de fonctionnalités à 5 types. Trouvez l'étiquette correcte avec la même logique en utilisant seulement 2 types sur 5. En d'autres termes, les 3 types restants de quantités d'entités sont des mannequins qui n'ont rien à voir avec la bonne réponse.

Le résultat est là, et bien que la largeur du flou soit légèrement plus grande, on peut dire que vous pouvez apprendre sans être trompé par le mannequin.

4.3. Comportement lorsque la normalisation de la quantité d'entités est interrompue

Je vais renvoyer le montant de la fonctionnalité à 2 types, mais j'ai essayé de multiplier la valeur aléatoire de 0 ou plus et de moins de 1 par 1000. Les résultats ne semblent pas converger uniformément et sont moins précis à l'approche de l'époque finale.

J'ai augmenté l'époque et vérifié. Après tout, l'apprentissage ne semble pas stable.

D'un autre côté, j'ai décalé la moyenne des quantités de caractéristiques et essayé d'augmenter la valeur aléatoire de 0 ou plus et de moins de 1 de +1000. Les résultats montrent que la précision est de presque 0,5, c'est-à-dire qu'elle n'est pas du tout formée en tant que classification binaire.

Dans l'ensemble, nous pouvons voir que la normalisation des quantités de caractéristiques est importante.

[PYTHON] Bilan du premier défi du machine learning avec Keras