Quatre règles de fonctionnement avec l'apprentissage automatique 6 [Commercial]
# 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.\\
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é.
# 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)
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