Quatre règles de fonctionnement avec l'apprentissage automatique 6 [Commercial]

商.png

# coding=utf-8
import numpy as np
import matplotlib.pyplot as plt

#valeur initiale
#Nombre d'apprentissage
N = 1000
#couche
layer = [2, 2, 1]
#biais
#bias = [0.0, 0.0]
#Taux d'apprentissage
η = [0.001, 0.001]
#η = [0.000001, 0.000001]
#Nombre de couches intermédiaires
H = len(η) - 1
#Valeur de l'enseignant
t = [None for _ in range(N)]
#Valeur de sortie de fonction
f_out = [[None for _ in range(H + 1)] for _ in range(N)]
#Valeur d'entrée de fonction
f_in = [[None for _ in range(H + 1)] for _ in range(N)]
#poids
w = [[None for _ in range(H + 1)] for _ in range(N + 1)]
for h in range(H + 1):   
    w[0][h] = np.random.uniform(-1.0, 1.0, (layer[h + 1], layer[h]))

for h in range(H + 1):
    print(w[0][h])
    
#Erreur carrée
dE = [None for _ in range(N)]
#∂E/∂IN
δ = [[None for _ in range(H + 1)] for _ in range(N)]

#Apprentissage
for n in range(N):

    #Valeur d'entrée
    f_out[n][0] = np.random.uniform(-10.0, 10.0, (layer[0]))
    
    #Valeur de l'enseignant
    t[n] = f_out[n][0][0] / f_out[n][0][1]
    
    #Propagation vers l'avant
    f_in[n][0] = np.dot(w[n][0], f_out[n][0])
    f_out[n][1] = np.log(f_in[n][0]*f_in[n][0])
    f_in[n][1] = np.dot(w[n][1], f_out[n][1])

    #Valeur de sortie
    div = np.exp(f_in[n][1])

    #Erreur carrée
    dE[n] = div - t[n]#Valeur après différenciation de l'erreur quadratique due à une omission de calcul

    #δ
    δ[n][1] = div * dE[n]
    δ[n][0] = (2.0 / f_in[n][0]) * np.dot(w[n][1].T, δ[n][1])
    
    #Rétropropagation
    for h in range(H + 1):
        w[n + 1][h] = w[n][h] - η[h] * np.real(δ[n][h].reshape(len(δ[n][h]), 1) * f_out[n][h])
        

#production
#valeur
for h in range(H + 1):
    print(w[N][h])
#Figure
#Zone verticale
py = np.amax(layer)
#À côté de la zone
px = (H + 1) * 2
#Dimensions de la zone
plt.figure(figsize = (16, 9))
#Axe horizontal sur la figure
x = np.arange(0, N + 1, 1) #0 à N+Jusqu'à 1 incréments sur 1
#dessin
for h in range(H + 1):
    for l in range(layer[h + 1]):
        #Coordonnées de la zone
        plt.subplot(py, px, px * l + h * 2 + 1)
        for m in range(layer[h]):                       
            #ligne
            plt.plot(x, np.array([w[n][h][l, m] for n in range(N + 1)]), label = "w[" + str(h) + "][" + str(l) + "," + str(m) + "]")        
        #Ligne de treillis
        plt.grid(True)
        #Guide d'utilisation
        plt.legend(bbox_to_anchor = (1, 1), loc = 'upper left', borderaxespad = 0, fontsize = 10)

#sauvegarder
plt.savefig('graph_div.png') 
#Illustré
plt.show()
J'ai pensé au circuit de division sous forme d'apprentissage profond.\\
 \\
Poids\\
w[0]=
\begin{pmatrix}
△ & □\\
▲ & ■
\end{pmatrix},
w[1]=
\begin{pmatrix}
〇 & ●
\end{pmatrix}\\
\\
Et\\
 \\
Valeur d'entrée et w[0]Produit de\\
\begin{pmatrix}
△ & □\\
▲ & ■
\end{pmatrix}
\begin{pmatrix}
a\\
b
\end{pmatrix}\\
=
\begin{pmatrix}
△a+□b\\
▲a+■b
\end{pmatrix}\\
 \\
Entrée 1ère couche\\
\begin{pmatrix}
log(△a+□b)^2\\
log(▲a+■b)^2
\end{pmatrix}\\
 \\
Le vrai nombre est au carré pour correspondre au nombre négatif.\\
 \\
Sortie 1ère couche et w[1]Produit de\\
\begin{align}
\begin{pmatrix}
〇 & ●
\end{pmatrix}
\begin{pmatrix}
log(△a+□b)^2\\
log(▲a+■b)^2
\end{pmatrix}
=&〇log(△a+□b)^2+●log(▲a+■b)^2\\
=&log(△a+□b)^{2〇}-log(▲a+■b)^{-2●}\\
=&log\frac{(△a+□b)^{2〇}}{(▲a+■b)^{-2●}}\\
\end{align}\\
 \\
Entrée de la couche de sortie\\
e^{log\frac{(△a+□b)^{2〇}}{(▲a+■b)^{-2●}}}=\frac{(△a+□b)^{2〇}}{(▲a+■b)^{-2●}}\\
 \\
\left\{
\begin{array}{l}
△=1,□=0,〇=0.5 \\
▲=0,■=1,●=-0.5
\end{array}
\right.\\
 \\
\frac{a}{b}\\
 \\
Dans le cas le plus simple, si les conditions ci-dessus sont remplies, le quotient a/Vous pouvez sortir b.\\
Cependant, c'est en fait plus compliqué car le théorème binomial généralisé est pertinent.

[Exposition] Théorème binomial de généralisation et approximation des routes, etc.


La valeur initiale est aléatoire(-1.0~1.0)Après avoir décidé, j'ai essayé de voir si cela convergerait vers la valeur cible si l'apprentissage était répété.\\
 \\
Valeur cible\\
w[0]=
\begin{pmatrix}
△ & □\\
▲ & ■
\end{pmatrix}
,w[1]=
\begin{pmatrix}
○ & ●
\end{pmatrix}\\
\left\{
\begin{array}{l}
△=1,□=0,〇=0.5 \\
▲=0,■=1,●=-0.5
\end{array}
\right.\\
 \\
valeur initiale\\
w[0]=
\begin{pmatrix}
-0.18845444 & -0.56031414\\
-0.48188658 & 0.6470921
\end{pmatrix}
,w[1]=
\begin{pmatrix}
0.80395641 & 0.80365676
\end{pmatrix}\\
\left\{
\begin{array}{l}
△=-0.18845444,□=-0.56031414,〇=0.80395641 \\
▲=-0.48188658,■=0.6470921,●=0.80365676
\end{array}
\right.\\
 \\
Valeur calculée\\
w[0]=
\begin{pmatrix}
14601870.60282903 & -14866110.02378938\\
13556781.27758209 & -13802110.45958244
\end{pmatrix}
,w[1]=
\begin{pmatrix}
-1522732.53915774 & -6080851.59710287
\end{pmatrix}\\
\left\{
\begin{array}{l}
△=14601870.60282903,□=-14866110.02378938,〇=-1522732.53915774 \\
▲=13556781.27758209,■=-13802110.45958244,●=-6080851.59710287
\end{array}
\right.\\

graph_div.png


C'est un échec. Peu importe combien de fois vous le faites, le poids divergera à une valeur ridicule.\\
J'ai cherché la cause.\\
Avec la règle de la chaîne de propagation des erreurs\\
(log(x^2))'=\frac{2}{x}\\
\lim_{x \to ±∞} \frac{2}{x}=0\\
 \\
(e^x)'=e^x\\
\lim_{x \to -∞} e^x=0\\
Il s'est avéré que prendre une valeur extrêmement grande comme celle-ci fait disparaître le dégradé.\\
 \\
J'ai reconsidéré.

商ver2.png

# coding=utf-8
import numpy as np
import matplotlib.pyplot as plt

#valeur initiale
#Nombre d'apprentissage
N = 200000
#couche
layer = [2, 2, 1]
#biais
#bias = [0.0, 0.0]
#Taux d'apprentissage
η = [0.1, 0.1]
#η = [0.000001, 0.000001]
#Prix de coupe
#clip = 709
clip = 700
#Nombre de couches intermédiaires
H = len(η) - 1
#Valeur de l'enseignant
t = [None for _ in range(N)]
#Valeur de sortie de fonction
f_out = [[None for _ in range(H + 1)] for _ in range(N)]
#Valeur d'entrée de fonction
f_in = [[None for _ in range(H + 1)] for _ in range(N)]
#poids
w = [[None for _ in range(H + 1)] for _ in range(N + 1)]
for h in range(H):   
    w[0][h] = np.random.uniform(-1.0, 1.0, (layer[h + 1], layer[h]))
w[0][H] = np.zeros((layer[H + 1], layer[H]))

for h in range(H + 1):
    print(w[0][h])
    
#Erreur carrée
dE = [None for _ in range(N)]
#∂E/∂IN
δ = [[None for _ in range(H + 1)] for _ in range(N)]

#Apprentissage
for n in range(N):

    #Valeur d'entrée
    t[n] = clip
    while np.abs(t[n]) > np.log(np.log(clip)):#Mesures contre le problème de disparition du gradient
        f_out[n][0] = np.random.uniform(0.0, 10.0, (layer[0]))
        f_out[n][0] = np.array(f_out[n][0], dtype=np.complex)
    
        #Valeur de l'enseignant
        t[n] = f_out[n][0][0] / f_out[n][0][1]
    
    #Propagation vers l'avant
    f_in[n][0] = np.dot(w[n][0], f_out[n][0])    
    f_out[n][1] = np.log(f_in[n][0])    
    f_in[n][1] = np.dot(w[n][1], f_out[n][1])
    
    #Valeur de sortie
    div = np.exp(f_in[n][1])
    
    #Erreur carrée
    dE[n] = np.real(div - t[n])#Valeur après différenciation de l'erreur quadratique due à une omission de calcul
    dE[n] = np.clip(dE[n], -clip, clip)
    dE[n] = np.nan_to_num(dE[n])

    #δ
    δ[n][1] = np.real(div * dE[n])
    δ[n][1] = np.clip(δ[n][1], -clip, clip)
    δ[n][1] = np.nan_to_num(δ[n][1])
    
    
    δ[n][0] = np.real((1.0 / f_in[n][0]) * np.dot(w[n][1].T, δ[n][1]))
    δ[n][0] = np.clip(δ[n][0], -clip, clip)  
    δ[n][0] = np.nan_to_num(δ[n][0]) 
    
    #Rétropropagation
    for h in range(H + 1):
        #Mesures contre le problème de disparition du gradient
        # a*10^Seule la partie a de b
        w10_u = np.real(δ[n][h].reshape(len(δ[n][h]), 1) * f_out[n][h])
        w10_u = np.clip(w10_u, -clip, clip)  
        w10_u = np.nan_to_num(w10_u)        
        w10_d = np.where(
            w10_u != 0.0,
            np.modf(np.log10(np.abs(w10_u)))[1],
            0.0
        )
        #Non pris en charge pour les petits nombres
        w10_d = np.clip(w10_d, 0.0, clip)
        
        w[n + 1][h] = w[n][h] - η[h] * (w10_u / np.power(10.0, w10_d))

#production
#valeur
for h in range(H + 1):
    print(w[N][h])
#Figure
#Zone verticale
py = np.amax(layer)
#À côté de la zone
px = (H + 1) * 2
#Dimensions de la zone
plt.figure(figsize = (16, 9))
#Axe horizontal sur la figure
x = np.arange(0, N + 1, 1) #0 à N+Jusqu'à 1 incréments sur 1
#dessin
for h in range(H + 1):
    for l in range(layer[h + 1]):
        #Coordonnées de la zone
        plt.subplot(py, px, px * l + h * 2 + 1)
        for m in range(layer[h]):                       
            #ligne
            plt.plot(x, np.array([w[n][h][l, m] for n in range(N + 1)]), label = "w[" + str(h) + "][" + str(l) + "," + str(m) + "]")        
        #Ligne de treillis
        plt.grid(True)
        #Guide d'utilisation
        plt.legend(bbox_to_anchor = (1, 1), loc = 'upper left', borderaxespad = 0, fontsize = 10)

#sauvegarder
plt.savefig('graph_div.png') 
#Illustré
plt.show()

Comme contre-mesure -Définissez la valeur d'entrée sur un nombre complexe. -Seules les données qui ne débordent pas facilement avec la valeur de l'enseignant. ・ Ne définissez pas δ sur une valeur supérieure à une certaine valeur. ・ Réglez le gradient uniquement sur la partie a de a * 10 ^ b afin que le poids ne diverge pas. (Uniquement lorsque b est un nombre positif)

graph_div.png


Valeur cible\\
w[0]=
\begin{pmatrix}
△ & □\\
▲ & ■
\end{pmatrix}
,w[1]=
\begin{pmatrix}
○ & ●
\end{pmatrix}\\
\left\{
\begin{array}{l}
△=1,□=0,〇=1 \\
▲=0,■=1,●=-1
\end{array}
\right.\\
 \\
valeur initiale\\
w[0]=
\begin{pmatrix}
-0.12716087 & 0.34977234\\
0.85436489 & 0.65970844
\end{pmatrix}
,w[1]=
\begin{pmatrix}
0.0 & 0.0
\end{pmatrix}\\
\left\{
\begin{array}{l}
△=-0.12716087,□=0.34977234,〇=0.0 \\
▲=0.85436489,■=0.65970844,●=0.0
\end{array}
\right.\\
 \\
Valeur calculée\\
w[0]=
\begin{pmatrix}
-1.71228449e-08 & 1.00525062e+00\\
1.00525061e+00 & -4.72288257e-09
\end{pmatrix}
,w[1]=
\begin{pmatrix}
-0.99999998 & 0.99999998
\end{pmatrix}\\
\left\{
\begin{array}{l}
△=-1.71228449e-08,□=1.00525062e+00,〇=-0.99999998\\
▲=1.00525061e+00,■=-4.72288257e-09,●=0.99999998
\end{array}
\right.\\
 \\
Réussi. Les valeurs de △ □ et ▲ ■ sont inversées.\\
Je n'aime pas ça d'une manière qui a la bonne réponse et qui s'en rapproche.\\
Même ainsi, connectez-vous tout au plus en essayant d'enseigner la division,exp,Avec des nombres complexes\\
J'avais des ennuis parce que je devais m'étendre aux mathématiques au lycée.\\

Recommended Posts

Quatre règles de fonctionnement avec l'apprentissage automatique 6 [Commercial]
4 [/] Quatre arithmétiques par apprentissage automatique
Quatre règles de python
Résumé de l'apprentissage automatique par les débutants de Python
Apprentissage automatique
Faire le contrôle d'un homme sandwich par l'apprentissage automatique ver4
[Échec] Trouvez Maki Horikita par apprentissage automatique
[Note] Opérateurs liés aux quatre règles de fonctionnement
Mémo d'étude Python & Machine Learning ④: Machine Learning par rétro-propagation
Classification des images de guitare par apprentissage automatique Partie 1
[Revue statistique] Quatre règles de variables stochastiques
Mayungo's Python Learning Episode 5: J'ai essayé de faire quatre règles avec des nombres
Classer les informations liées à l'apprentissage automatique par modèle de sujet
Analyse de l'utilisation de l'espace partagé par l'apprentissage automatique
Prévision du cours de l'action par machine learning Numerai Signals
[Français] scikit-learn 0.18 Introduction de l'apprentissage automatique par le didacticiel scikit-learn
Estimation raisonnable du prix de Mercari par apprentissage automatique
[Memo] Apprentissage automatique
Classification des images de guitare par apprentissage automatique, partie 2
Classification de l'apprentissage automatique
Histoire de l'analyse de données par apprentissage automatique
Exemple d'apprentissage automatique
Mémo d'apprentissage Python pour l'apprentissage automatique par Chainer du chapitre 2
Mémo d'apprentissage Python pour l'apprentissage automatique par Chainer chapitres 1 et 2
Prédiction de données chronologiques par AutoML (apprentissage automatique automatique)
Résumé du didacticiel d'apprentissage automatique
Apprentissage automatique ⑤ Résumé AdaBoost
Apprentissage automatique: supervisé - AdaBoost
Machine de vecteur de support d'apprentissage automatique
Machine Sommelier par Keras-
Étudier l'apprentissage automatique ~ matplotlib ~
Régression linéaire d'apprentissage automatique
Mémo du cours d'apprentissage automatique
Bibliothèque d'apprentissage automatique dlib
Apprentissage automatique (TensorFlow) + Lotto 6
Apprenez en quelque sorte le machine learning
Bibliothèque d'apprentissage automatique Shogun
Défi de lapin d'apprentissage automatique
Introduction à l'apprentissage automatique
Apprentissage automatique: k-voisins les plus proches
Qu'est-ce que l'apprentissage automatique?
Prédire la présence ou l'absence d'infidélité par l'apprentissage automatique
Mémo d'apprentissage Python pour l'apprentissage automatique par Chainer Chapitre 7 Analyse de régression
Discriminer les chansons t + pazolite par apprentissage automatique (développement du défi NNC)
Prévisions du cours des actions par apprentissage automatique Commençons Numerai