Perceptron multi-couches pour le Deep Learning (Deep Learning avec Python; Série MPS Yokohama Deep Learning)

Objectif

Créez MLP (Multi Layer Perceptron) dans Python3 en utilisant uniquement Numpy et Scipy. De plus, à titre d'exemple concret, nous allons construire un MLP qui classifie les images numériques manuscrites en utilisant la base de données des nombres manuscrits MNIST.

environnement

Mise en garde

Cet article est un événement de MPS (Morning Project Samurai) Yokohama qui se tiendra le 23 juillet 2016 Deep Learning (with Python) Vol. 10 Cet article a été écrit pour: //mpsamurai.doorkeeper.jp/events/49018). Je vous serais reconnaissant si vous pouviez poser des questions ou des suggestions.

MLP (Multi Layer Perceptron)

Tout d'abord, considérez un MLP simple comme indiqué dans la figure ci-dessous. En fait, tous les nœuds de la couche $ i + 1 $ et de la couche $ i $ sont entièrement connectés, mais par souci de clarté, seule une partie de la connexion est dessinée.

Ici, les symboles sont définis comme suit.

• $ s_ {ij} $: état du $ j $ ème nœud de la couche $ i $
• $ w_ {ikj} $: Poids sur la $ j $ ème sortie de la couche $ i-1 $ entrée dans le $ k $ ème nœud de la couche $ i $
• $ f_ {i} $: AF (fonction d'activation) de la couche $ i $
• $ y_ {ij} $: Sortie du $ j $ ème nœud de la couche $ i $
• E: EF (Error Function)

FP (Forward Propagation)

Le FP de la couche $ i-1 $ à la couche $ i $ ressemble à ceci:

y_{i} = f_{i}(W_{i}y_{i-1} + b_{i-1})

Ici, soit $ y_ {i} = (y_ {ij}) $, $ W_ {i} = (w_ {ikj}) $, $ b_ {i} = (b_ {ij}) $.

Le code Python pour un MLP FP à deux couches avec trois entrées et une sortie ressemble à ceci:

import numpy as np


# activation function
def sigmoid(s):
    return 1/(1 + np.exp(-s))


# x: Input vector, W: Weight matrix, b: Bias, y: Output vector
x = np.random.randn(3, 1)
W = np.random.randn(1, 3)
b = np.random.randn(1, 1)
y = sigmoid(W @ x + b)

Si vous définissez une classe Layer qui a l'opération ci-dessus comme méthode, vous pouvez facilement créer un MLP. Voici un exemple de réseau qui a une couche intermédiaire en plus de la couche d'entrée et de la couche de sortie.

from scipy import misc
import numpy as np


class Layer:
    def __init__(self, W, b, f):
        self._W = W
        self._b = b
        self._f = f

    def propagate_forward(self, x):
        return self._f(self._W @ x + self._b)


def sigmoid(s):
    return 1/(1 + np.exp(-s))


if __name__ == '__main__':
    # Input vector (Layer 0)
    x = np.random.randn(3, 1)

    # Middle layer (Layer 1)
    W1 = np.random.randn(3, 3)
    b1 = np.random.randn(3, 1)
    layer1 = Layer(W1, b1, sigmoid)

    # Output layer (Layer 2)
    W2 = np.random.randn(3, 3)
    b2 = np.random.randn(3 ,1)
    layer2 = Layer(W2, b2, sigmoid)

    # FP
    y1 = layer1.propagate_forward(x)
    y2 = layer2.propagate_forward(y1)

    print(y2)

À ce stade, vous avez la configuration du MLP et la sortie pour certaines entrées du MLP. Voici un exemple dans lequel le numéro manuscrit 9 comme indiqué dans la figure ci-dessous est donné comme entrée.

from scipy import misc
import numpy as np
from matplotlib import pyplot as plt


class Layer:
    def __init__(self, W, b, f):
        self._W = W
        self._b = b
        self._f = f

    def propagate_forward(self, x):
        return self._f(self._W @ x + self._b)


def sigmoid(s):
    return 1/(1 + np.exp(-s))


if __name__ == '__main__':
    # Input vector (Layer 0)
    x = misc.imread('img/9.png', flatten=True).flatten()
    x = x.reshape((len(x), 1))

    # Middle layer (Layer 1)
    n_output_1 = len(x)
    W1 = np.random.randn(n_output_1, len(x))
    b1 = np.random.randn(n_output_1, 1)
    layer1 = Layer(W1, b1, sigmoid)

    # Output layer (Layer 2)
    n_output_2 = 10
    W2 = np.random.randn(n_output_2, n_output_1)
    b2 = np.random.randn(n_output_2, 1)
    layer2 = Layer(W2, b2, sigmoid)

    # FP
    y1 = layer1.propagate_forward(x)
    y2 = layer2.propagate_forward(y1)

    hist_W1, bins_W1 = np.histogram(W1.flatten())
    hist_W2, bins_W2 = np.histogram(W2.flatten())

    # Draw bar chart
    index = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    plt.title('Prediction')
    plt.bar(index , y2.flatten(), align="center")
    plt.xticks(index, index)
    plt.show()

Puisque nous utilisons la fonction sigmoïde pour la fonction d'activation, la sortie des 10 nœuds de la couche de sortie sera comprise entre 0 et 1. En supposant que la sortie du nœud $ i $ ème de la couche de sortie représente la probabilité que l'image d'entrée soit le nombre $ i $, le résultat ci-dessus prédit que la probabilité d'être 2, 6 ou 7 est la plus élevée. , Inutile.

EF (Error Function)

EF est un indice pour mesurer la distance entre l'état de MLP et l'état idéal. Par exemple, dans le cas de la reconnaissance d'image manuscrite mentionnée ci-dessus, la réponse correcte est 9, et il est idéal d'obtenir ce qui suit en tant que sortie.

y_{2} = (0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0)^{T}

SE (Squared Error) est l'une des fonctions d'erreur couramment utilisées et s'exprime comme suit.

E = \frac{1}{2}\sum_{j} (t_{j} - y_{ij})^{2} = \frac{1}{2}(t-y_{i})^{T}(t-y_{i})

Le code permettant de trouver le SE lorsqu'un 9 manuscrit est saisi est indiqué ci-dessous.

from scipy import misc
import numpy as np


class Layer:
    def __init__(self, W, b, f):
        self._W = W
        self._b = b
        self._f = f

    def propagate_forward(self, x):
        return self._f(self._W @ x + self._b)


def sigmoid(s):
    return 1/(1 + np.exp(-s))


def se(t, y):
    return ((t - y).T @ (t-y)).flatten()[0]/2


if __name__ == '__main__':
    # Input vector (Layer 0)
    x = misc.imread('img/9.png', flatten=True).flatten()
    x = x.reshape((len(x), 1))

    # Middle layer (Layer 1)
    n_output_1 = len(x)
    W1 = np.random.randn(n_output_1, len(x))
    b1 = np.random.randn(n_output_1, 1)
    layer1 = Layer(W1, b1, sigmoid)

    # Output layer (Layer 2)
    n_output_2 = 10
    W2 = np.random.randn(n_output_2, n_output_1)
    b2 = np.random.randn(n_output_2, 1)
    layer2 = Layer(W2, b2, sigmoid)

    # FP
    y1 = layer1.propagate_forward(x)
    y2 = layer2.propagate_forward(y1)

    # Calculate SE
    t = np.zeros(shape=(10, 1))
    t[9, 0] = 1.0
    e = se(t, y2)
    print(e)

Apprendre avec BP (propagation en arrière)

BP doit propager les informations dans la direction opposée du réseau. L'apprentissage à l'aide de BP nécessite deux étapes: les informations nécessaires à l'apprentissage sont propagées dans la direction opposée à l'aide de BP, et l'apprentissage proprement dit est effectué à l'aide de ces informations.

L'entraînement MLP utilise le fait que le gradient EF se trouve dans l'espace où le paramètre souhaité est le domaine et que le déplacement du paramètre dans la direction opposée réduit le plus la valeur EF au voisinage du paramètre actuel. Faire. BP est utilisé pour propager les informations nécessaires pour calculer efficacement ce gradient.

Apprentissage de la couche de sortie

Tout d'abord, envisagez d'apprendre la couche de sortie d'un MLP à trois couches.

Le paramètre que vous souhaitez ajuster est le poids $ w_ {2ji} $, donc si vous effectuez un différentiel partiel de EF $ E $, vous obtenez l'équation suivante.

\frac{\partial{E}}{\partial{w_{2ji}}} = 
\frac{\partial{E}}{\partial{y_{2j}}}
\frac{\partial{y_{2j}}}{\partial{s_{2j}}}
\frac{\partial{s_{2j}}}{\partial{w_{2ji}}}

Il s'agit de découvrir comment $ E $ change lorsque vous modifiez $ w_ {2ji} $, comment $ s_ {2j} $ change lorsque vous modifiez $ w_ {2ji} $ Découvrez ensuite comment $ y_ {2j} $ change lorsque vous modifiez $ s_ {2j} $, et enfin $ lorsque vous modifiez $ y_ {2j} $. Il montre la relation que nous devrions étudier comment E $ change, ce qui est intuitif par rapport au diagramme MLP.

Ici, il est défini comme suit.

\frac{\partial{E}}{\partial{y_{2j}}}\frac{\partial{y_{2j}}}{\partial{s_{2j}}} = \delta_{2j}

De plus, l'équation suivante peut être obtenue à partir de $ s_ {2j} = \ sum_ {i} w_ {2ji} y_ {1i} $.

\frac{\partial{s_{2j}}}{\partial{w_{2ji}}} = y_{1i}

Les équations suivantes sont obtenues en combinant les équations précédentes.

\frac{\partial{E}}{\partial{w_{2ji}}} = \delta_{2j}y_{1i}

L'apprentissage peut être effectué avec la formule de mise à jour suivante. Ici, la flèche dans la formule signifie remplacer la variable du côté gauche par le côté droit. De plus, $ \ epsilon $ est un hyper paramètre appelé taux d'apprentissage. En ajustant cette valeur, la vitesse d'apprentissage peut être augmentée ou diminuée.

w_{2ji} \leftarrow w_{2ji} - \epsilon \delta_{2j}y_{1i}

Ici, mettez-le comme suit,

\delta_{2} = (\delta_{2j})

L'équation suivante est un résumé des discussions jusqu'à présent sous la forme d'une matrice.

\Delta W_{2} = (\frac{\partial{E}}{\partial{w_{2ji}}}) 
= \delta_{2}y_{1}^{T}

W_{2} \leftarrow W_{2} - \epsilon \Delta W_{2}

En considérant le terme Bias de la même manière, l'équation suivante peut être obtenue.

\frac{\partial{E}}{\partial{b_{2j}}} = \delta_{2j}

Par conséquent, la formule de mise à jour pour le terme de biais est la suivante.

b_{2} \leftarrow b_{2} - \epsilon \delta_{2}

Plus précisément, un exemple utilisant la fonction sigmoïde comme AF et SE comme EF est montré.

\frac{\partial{E}}{\partial{y_{2j}}} = -(t_{j}-y_{2j})

\frac{\partial{y_{2j}}}{\partial{s_{2j}}} = y_{2j}(1-y_{2j})

Par conséquent, l'équation suivante est obtenue.

\delta_{2j} = -(t_{j}-y_{2j})y_{2j}(1-y_{2j})

Ce $ \ delta_ {2} = (\ delta_ {2j}) $ peut être utilisé pour entraîner les paramètres de poids et de biais.

Vous trouverez ci-dessous le code qui permet au MLP à trois couches d'apprendre la reconnaissance du caractère manuscrit 9 uniquement dans la couche de sortie.

from scipy import misc
import numpy as np
from matplotlib import pyplot as plt


class Layer:
    def __init__(self, W, b, f):
        self._W = W
        self._b = b
        self._f = f

    def propagate_forward(self, x):
        return self._f(self._W @ x + self._b)


def sigmoid(s):
    return 1/(1 + np.exp(-s))


def d_sigmoid(y):
    return y * (1 - y)


def se(t, y):
    return ((t - y).T @ (t-y)).flatten()[0]/2


def d_se(t, y):
    return -(t - y)


if __name__ == '__main__':
    # Input vector (Layer 0)
    x = misc.imread('img/9.png', flatten=True).flatten()
    x = x.reshape((len(x), 1))

    # Middle layer (Layer 1)
    n_output_1 = len(x)
    W1 = np.random.randn(n_output_1, len(x))
    b1 = np.random.randn(n_output_1, 1)
    layer1 = Layer(W1, b1, sigmoid)

    # Output layer (Layer 2)
    n_output_2 = 10
    W2 = np.random.randn(n_output_2, n_output_1)
    b2 = np.random.randn(n_output_2, 1)
    layer2 = Layer(W2, b2, sigmoid)

    # Training datum
    t = np.zeros(shape=(10, 1))
    t[9, 0] = 1.0

    # FP, BP and learning
    epsilon = 0.1
    se_history = []
    delta2_history = []
    for i in range(0, 100):
        # FP
        y1 = layer1.propagate_forward(x)
        y2 = layer2.propagate_forward(y1)

        # Calculate and store SE
        se_history.append(se(t, y2))

        # BP and learning
        delta2 = d_se(t, y2) * d_sigmoid(y2)
        Delta_W2 = delta2 @ y1.T
        layer2._W -= epsilon * Delta_W2
        layer2._b -= epsilon * delta2

        # Store delta2 history
        delta2_history.append(np.linalg.norm(delta2))

    y1 = layer1.propagate_forward(x)
    y2 = layer2.propagate_forward(y1)

    # Draw SE history
    plt.figure()
    plt.title('SE History')
    plt.plot(range(len(se_history)), se_history)

    # Draw delta2 history
    plt.figure()
    plt.title('delta2 history')
    plt.plot(range(len(delta2_history)), delta2_history)

    # Draw bar chart
    index = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    plt.figure()
    plt.title('Prediction')
    plt.bar(index, y2.flatten(), align="center")
    plt.xticks(index, index)

    plt.show()

La figure ci-dessous montre la transition de SE lorsqu'il est entraîné 100 fois. On peut voir que l'ES a chuté de manière significative dans les premiers stades de l'apprentissage. On peut également voir que l'effet d'apprentissage n'est guère sorti après la 5ème fois.

Pour confirmer la cause, le graphique de la taille de $ \ delta_ {2} $ est présenté ci-dessous. À partir de la 5ème fois, vous pouvez voir que la taille est de presque 0 $.

La sortie MLP à ce moment est la suivante.

Apprentissage de la couche intermédiaire

Ensuite, considérons l'apprentissage de la couche intermédiaire du MLP à 3 couches. Vous trouverez ci-dessous un autre diagramme du MLP à 3 couches.

Similaire à l'entraînement de la couche de sortie, tout d'abord, l'EF est partiellement différencié par le poids $ w_ {1ih} $ que vous souhaitez entraîner. Ici, par exemple, si vous modifiez $ w_ {100} $, ce changement affecte $ s_ {10} $, puis $ y_ {10} $, ce qui affecte tous les nœuds de la couche de sortie. Cela affecte $ s_ {2j} $, affecte leur sortie $ y_ {2j} $, et finalement affecte la valeur d'EF à travers eux. En tenant compte de cela, nous développerons et organiserons les équations aux dérivées partielles.

\begin{eqnarray}
\frac{\partial{E}}{\partial{w_{1ih}}} 
&=& \sum_{j}\frac{\partial{E}}{\partial{y_{2j}}}
\frac{\partial{y_{2j}}}{\partial{s_{2j}}}
\frac{\partial{s_{2j}}}{\partial{y_{1i}}}
\frac{\partial{y_{1i}}}{\partial{s_{1i}}}
\frac{\partial{s_{1i}}}{\partial{w_{1ih}}}\\

&=& (\sum_{j}\frac{\partial{E}}{\partial{y_{2j}}}
\frac{\partial{y_{2j}}}{\partial{s_{2j}}}
\frac{\partial{s_{2j}}}{\partial{y_{1i}}})
\frac{\partial{y_{1i}}}{\partial{s_{1i}}}
\frac{\partial{s_{1i}}}{\partial{w_{1ih}}}\\

&=&(\sum_{j}\delta_{2j} w_{2ji})
\frac{\partial{y_{1i}}}{\partial{s_{1i}}}y_{0h}\\

&=&\delta_{1i}y_{0h}
\end{eqnarray}

Ici, $ \ delta_ {1i} $ est défini comme suit.

\delta_{1i} = (\sum_{j}\delta_{2j} w_{2ji})
\frac{\partial{y_{1i}}}{\partial{s_{1i}}}

Notez que l'équation obtenue à la fin de la transformation d'équation ci-dessus est exactement la même que l'équation dérivée en considérant l'apprentissage des poids de la couche de sortie. Réimprimez ces formules.

\begin{eqnarray}
\frac{\partial{E}}{\partial{w_{2ji}}} &=& \delta_{2j}y_{1i}\\
\frac{\partial{E}}{\partial{w_{1ih}}} &=& \delta_{1i}y_{0h}
\end{eqnarray}

La couche supérieure est utilisée pour apprendre la couche de sortie, et la couche inférieure est utilisée pour apprendre la couche intermédiaire cette fois.

Notez également que $ \ delta_ {1i} $ est basé sur le $ \ delta_ {2j} $ trouvé pour entraîner la couche de sortie. En d'autres termes, si vous connaissez le $ \ delta_ {2j} $ trouvé dans la couche de sortie (s'il est propagé à partir de la couche de sortie), vous pouvez trouver le $ \ delta_ {1i} $ dans la couche du milieu sans calculs compliqués. Vous pourrez apprendre la couche intermédiaire sur cette base. Dans l'apprentissage MLP, ce $ \ delta $ est appelé une erreur, et sa propagation s'appelle BP.

L'apprentissage des poids dans la couche intermédiaire est organisé à l'aide d'une représentation matricielle.

\delta_{1} = W_{2}^{T} \circ \frac{\partial{y_{1}}}{\partial{s_{1}}}

Où $ \ circ $ représente le produit Adamal. Le produit Adamar est une multiplication pour chaque élément de la matrice.

\Delta W_{1} = \delta_{1} y_{0}^T

Où $ y_ {0} $ est un vecteur constitué des sorties de chaque nœud de la couche d'entrée. La formule de mise à jour des pondérations par apprentissage est la suivante.

W_{1} \leftarrow W_{1} - \epsilon \Delta W_{1}

Veuillez essayer de dériver le terme de biais par vous-même.

Création d'un MLP pour classer les images numériques manuscrites

Sur la base de la discussion jusqu'à présent, le code qui permet au MLP à 3 couches d'apprendre la classification des nombres manuscrits à l'aide d'une base de données de nombres manuscrits appelée MNIST Il est montré ci-dessous. Comme auparavant, la couche de sortie a 10 nœuds et le $ i $ ème nœud représente la probabilité que le nombre écrit dans l'image donnée soit $ i $. Cette fois, le numéro de nœud affichant la probabilité la plus élevée est adopté comme résultat final de la reconnaissance.

MNIST fournit 600 millions d'images numérotées manuscrites avec des étiquettes comme données d'enseignant, cette fois en utilisant les 1000 premières de ces données pour la formation et les autres comme données de test. Le nombre d'apprentissage est fixé à 400 000 fois au total en utilisant les données ci-dessus 400 fois à plusieurs reprises.

import numpy as np
from matplotlib import pyplot as plt
from tqdm import tqdm


class Layer:
    def __init__(self, W, b, f):
        self._W = W
        self._b = b
        self._f = f

    def propagate_forward(self, x):
        return self._f(self._W @ x + self._b)


def sigmoid(s):
    return 1/(1 + np.exp(-s))


def d_sigmoid(y):
    return y * (1 - y)


def se(t, y):
    return ((t - y).T @ (t - y)).flatten()[0] / 2.0


def d_se(t, y):
    return -(t - y)


def ma(history, n):
    return np.array([0, ] * (n - 1) + [np.average(history[i - n: i]) for i in range(n, len(history) + 1)])


if __name__ == '__main__':
    from mnist import MNIST

    # Load MNIST dataset
    mndata = MNIST('./mnist')
    train_img, train_label = mndata.load_training()
    train_img = np.array(train_img, dtype=float)/255.0
    train_label = np.array(train_label, dtype=float)

    # Input vector (Layer 0)
    n_output_0 = len(train_img[0])

    # Middle layer (Layer 1)
    n_output_1 = 200
    W1 = np.random.randn(n_output_1, n_output_0)
    b1 = np.random.randn(n_output_1, 1)
    layer1 = Layer(W1, b1, sigmoid)

    # Output layer (Layer 2)
    n_output_2 = 10
    W2 = np.random.randn(n_output_2, n_output_1)
    b2 = np.random.randn(n_output_2, 1)
    layer2 = Layer(W2, b2, sigmoid)

    # FP, BP and learning
    epsilon = 0.15
    n_training_data = 1000
    se_history = []
    y1_history = []
    y2_history = []
    W1_history = []
    W2_history = []
    cpr_history = []
    for loop in range(400):
        for i in tqdm(range(n_training_data)):
            # Store W1 and W2 history
            W1_history.append(np.linalg.norm(layer1._W))
            W2_history.append(np.linalg.norm(layer2._W))

            # FP
            x = train_img[i].reshape(len(train_img[i]), 1)
            y1 = layer1.propagate_forward(x)
            y2 = layer2.propagate_forward(y1)

            # Store y1 and y2
            y1_history.append(y1)
            y2_history.append(y2)

            # Training datum
            t = np.zeros(shape=(10, 1))
            t[train_label[i], 0] = 1.0

            # Calculate and store SE
            se_history.append(se(t, y2))

            # BP
            delta2 = d_se(t, y2) * d_sigmoid(y2)
            delta1 = layer2._W.T @ delta2 * d_sigmoid(y1)

            # Learning
            Delta_W2 = delta2 @ y1.T
            layer2._W -= epsilon * Delta_W2
            layer2._b -= epsilon * delta2

            Delta_W1 = delta1 @ x.T
            layer1._W -= epsilon * Delta_W1
            layer1._b -= epsilon * delta1

        # FP to evaluate correct prediction rate
        n_correct_prediction = 0
        n_prediction = 0
        for _i in np.random.choice(np.arange(n_training_data, train_img.shape[0]), 100):
            _x = train_img[_i].reshape(len(train_img[_i]), 1)
            _y1 = layer1.propagate_forward(_x)
            _y2 = layer2.propagate_forward(_y1)

            n_prediction += 1
            if train_label[_i] == np.argmax(_y2):
                n_correct_prediction += 1
        cpr_history.append(n_correct_prediction/n_prediction)

    # Draw W1
    plt.figure()
    plt.title('W1 history')
    plt.plot(range(len(W1_history)), W1_history)

    # Draw W2
    plt.figure()
    plt.title('W2 history')
    plt.plot(range(len(W2_history)), W2_history)

    # Draw SE history and its moving average
    plt.figure()
    plt.title('SE History')
    plt.plot(range(len(se_history)), se_history, color='green')
    plt.plot(range(len(se_history)), ma(se_history, 100), color='red')

    # Draw CPR history
    plt.figure()
    plt.title('CPR')
    plt.plot(range(len(cpr_history)), cpr_history)

    plt.show()

La figure ci-dessous montre le changement de SE de MLP avec le nombre d'apprentissage sur l'axe horizontal. Le vert représente la valeur de SE lorsqu'une donnée est entraînée, puis une autre donnée est donnée. Le rouge est la moyenne mobile de la série verte. Puisque 100 données sont utilisées en moyenne, il s'agit d'une série de valeurs SE moyennes obtenues par 100 séances d'entraînement. En regardant cette figure, on peut voir que le SE obtenu par chaque apprentissage vibre beaucoup à chaque apprentissage, mais en moyenne il devient plus petit.

La figure ci-dessous montre l'évolution du taux de reconnaissance des nombres manuscrits avec le nombre d'apprentissage sur l'axe horizontal. Cependant, étant donné que la mesure de précision de prédiction est effectuée une fois tous les 1000 apprentissages, le nombre réel d'apprentissage est la valeur sur l'axe horizontal multipliée par 1000. Ici aussi, on peut voir que la précision de prédiction s'améliore à chaque apprentissage en regardant la moyenne mobile. À partir de là, on s'attend à ce qu'il soit préférable de faire des prédictions en combinant plusieurs MLP, plutôt que de faire des prédictions en utilisant un seul MLP.

finalement

Ce que nous avons implémenté dans cet article est le MLP de base et son apprentissage. Dans MPS Yokohama Deep Learning from Mathematical Basics (avec Python), faites-le pour pouvoir faire du Deep Learning la prochaine fois. Je vais le remodeler.

Les bénévoles ont créé de merveilleux matériaux pour ce projet, veuillez donc vous y référer également (sans ordre particulier).

Nous avons également téléchargé des diapositives et des vidéos d'événements utilisées lors d'événements précédents sur SlideShare et YouTube, donc si vous êtes intéressé, veuillez jeter un coup d'œil.

Merci

Ce projet est composé de la grande coopération de nombreuses personnes. Chaque fois, nous louons des équipements tels que salle, projecteur, WiFi, tournons des vidéos et les téléchargeons. Information Science College, Professeur Muto, Sakura Internet qui fournit un environnement cloud, Résumé de chaque fois Saito-san, qui nous donne des conseils précis sur la gestion de la session d'étude, Ueno-san, qui dirige cette session d'étude en tant que leader du MPS Yokohama, et Wataru-san, qui nous aide à gérer la session d'étude tous les matins. Merci beaucoup à M. Terasaki, M. Hirara et M. n-ken d'avoir créé les documents et posé des questions et souligné à chaque fois. Je voudrais également remercier M. Masaki, qui soutient les activités du MPS depuis deux ans depuis que je l'ai rencontré. Je voudrais profiter de ce moment pour vous remercier. Ravi de vous rencontrer.

2016/07/22 Junya Kaneko