Deep Learning from scratch 4.3.3 Dessinez un vecteur de gradient de votre propre fonction en vous basant sur l'exemple de code de différenciation partielle.

introduction

4.3.3 Différenciation partielle fournit un exemple de dessin d'un vecteur de gradient de f = x0 ^ 2 + x1 ^ 2 avec du code. Sur cette base, lorsque j'ai essayé de dessiner le résultat de f = x0 * x1, je suis resté bloqué, je vais donc décrire la solution. L'exemple de code d'origine est deep-learning-from-scratch / ch04 / gradient_2d.py )est. Le résultat de l'exécution est le suivant. f1.png

Vérification

Tout d'abord, le code de résultat de vérification de cette heure est affiché.

# coding: utf-8
# cf.http://d.hatena.ne.jp/white_wheels/20100327/p3
import numpy as np
import matplotlib.pylab as plt
from mpl_toolkits.mplot3d import Axes3D

def _numerical_gradient_no_batch(f, x):
    h = 1e-4 # 0.0001
    grad = np.zeros_like(x)
    
    for idx in range(x.size):
        tmp_val = x[idx]
        x[idx] = float(tmp_val) + h
        fxh1 = f(x) # f(x+h)
        
        x[idx] = tmp_val - h 
        fxh2 = f(x) # f(x-h)
        grad[idx] = (fxh1 - fxh2) / (2*h)
        
        x[idx] = tmp_val #Restaurer la valeur
        
    return grad


def numerical_gradient(f, X):
    if X.ndim == 1:
        return _numerical_gradient_no_batch(f, X)
    else:
        grad = np.zeros_like(X)
        
        for idx, x in enumerate(X):
            grad[idx] = _numerical_gradient_no_batch(f, x)
        
        return grad

def function_2(x):
    if x.ndim == 1:
        return np.sum(x**2)
    else:
        return np.sum(x**2, axis=1)

# f = x0*x1, df/dx0 = x1, df/dx1 = x0
# can110
def function_xy(x):
    if x.ndim == 1:
        return x[0]*x[1]
    else:
        return x[:,0]*x[:,1]

# f = sin(x0*x1), df/dx0 = x1*cos(x0*x1), df/dx1 = x0*cos(x0*x1)
# can110
def function_sin_xy(x):
    if x.ndim == 1:
        return np.sin(x[0]*x[1])
    else:
        return np.sin(x[:,0]*x[:,1])

def tangent_line(f, x):
    d = numerical_gradient(f, x)
    print(d)
    y = f(x) - d*x
    return lambda t: d*t + y
     
if __name__ == '__main__':
    x0 = np.arange(-2, 2.5, 0.25)
    x1 = np.arange(-2, 2.5, 0.25)
    X, Y = np.meshgrid(x0, x1)
    
    X = X.flatten()
    Y = Y.flatten()
    a = np.array([X, Y])
    a = a.T #Translocation. 1 ligne=1 vecteur (colonne=x0,x1) devrait être can110

    #Vérification
    #func = function_2      # df/dx0(=2*x0), df/dx1(=2*x1)Sont x0 respectivement,Puisqu'il n'est calculé qu'à partir de x1, cela fonctionne-t-il?
    func = function_xy
    #func = function_sin_xy
    
    #grad = numerical_gradient(function_2, np.array([X, Y]) )
    grad = numerical_gradient(func, a)
    grad = grad.T #Transposé pour carquois (x0 par ligne,Placer les valeurs de coordonnées x1) can110
    
    plt.figure()
    plt.quiver(X, Y, -grad[0], -grad[1],  angles="xy",color="#666666")#,headwidth=10,scale=40,color="#444444")
    plt.xlim([-2, 2])
    plt.ylim([-2, 2])
    plt.xlabel('x0')
    plt.ylabel('x1')
    plt.grid()
    plt.legend()
    plt.draw()
    plt.show()

Cette fois, j'ai défini la fonction f = x0 * x1 comme suit. Au fait, dans ce calcul de gradient, seule la partie de x.ndim == 1 est appelée.

def function_xy(x):
    if x.ndim == 1:
        return x[0]*x[1]
    else:
        return x[:,0]*x[:,1]

Je l'ai remplacé par l'original function_2 et l'ai exécuté, mais avec des résultats étranges. xy_ng.png

J'ai donc suivi le code de calcul du gradient. La fonction numerical_gradient est utilisée pour plusieurs vecteurs → La fonction _numerical_gradient_no_batch est utilisée pour calculer le gradient pour un vecteur. Donc, si vous regardez x.shape dans _numerical_gradient_no_batch, c'est (324,). Le nombre de vecteurs (points à dessiner). Cela devrait être ** (2,) **. Donc, si vous vérifiez l'appelant

    grad = numerical_gradient(function_2, np.array([X, Y]) )

Nous passons une paire de coordonnées X (x0) et Y (x1). Telle est la cause. En traduisant «np.array ([X, Y]» sous la forme «1 ligne = 1 vecteur (point)», il est maintenant dessiné correctement. xy_ok.png

Résumé

--Passez le résultat transposé (1 ligne = 1 vecteur) à la fonction numerical_gradient.

Tableau correct / erroné de "Deep Learning from scratch", mais cela ressemble à un bogue ??

Recommended Posts

Deep Learning from scratch 4.3.3 Dessinez un vecteur de gradient de votre propre fonction en vous basant sur l'exemple de code de différenciation partielle.
Un mémo lors de l'exécution de l'exemple de code de Deep Learning créé à partir de zéro avec Google Colaboratory
Deep Learning from scratch 4.4.2 Gradient pour les réseaux de neurones La question sur la fonction numerical_gradient a été résolue.
Créez un environnement d'apprentissage pour le «Deep learning from scratch» avec Cloud9 (jupyter miniconda python3)
Python vs Ruby "Deep Learning from scratch" Chapitre 4 Implémentation de la fonction de perte
Enregistrement d'apprentissage de la lecture "Deep Learning from scratch"
Deep Learning from scratch La théorie et la mise en œuvre de l'apprentissage profond appris avec Python Chapitre 3
[Deep Learning from scratch] Valeur initiale du poids du réseau neuronal utilisant la fonction sigmoïde
GitHub du bon livre "Deep Learning from scratch"
[Mémo d'apprentissage] Apprentissage profond à partir de zéro ~ Mise en œuvre de l'abandon ~
Python vs Ruby "Deep Learning from scratch" Chapitre 3 Graphique de la fonction step, fonction sigmoid, fonction ReLU
[Deep Learning from scratch] Poids initial du réseau neuronal lors de l'utilisation de la fonction Relu
[Deep Learning from scratch] J'ai implémenté la couche Affine
#Une fonction qui renvoie le code de caractère d'une chaîne de caractères
Application de Deep Learning 2 à partir de zéro Filtre anti-spam
Othello ~ De la troisième ligne de "Implementation Deep Learning" (4) [Fin]
Chapitre 3 Réseau de neurones Ne découpez que les bons points de Deeplearning à partir de zéro
[Deep Learning from scratch] J'ai essayé d'expliquer la confirmation du gradient d'une manière facile à comprendre.
"Deep Learning from scratch" Mémo d'auto-apprentissage (n ° 14) Exécutez le programme du chapitre 4 sur Google Colaboratory
Chapitre 2 Implémentation de Perceptron Ne découpez que les bons points de Deeplearning à partir de zéro
Apprentissage profond à partir de zéro
[Deep Learning from scratch] Implémentation de la méthode Momentum et de la méthode AdaGrad
Chapitre 1 Introduction à Python Découpez uniquement les bons points de Deeplearning à partir de zéro