Comment profiter de Coursera / Machine Learning (semaine 10)

(Concernant le test de référence, [Addition](http://qiita.com/TomokIshii/items/b5708a02895847e3588c#%E8%BF%BD%E8%A8%98-theano-gpu%E8%A8%88%E7%AE% 97% E3% 81% A7 mini-lot% E3% 82% B5% E3% 82% A4% E3% 82% BA% E3% 81% AB% E7% 9D% 80% E7% 9B% AE% E3% 81% 97% E3% 81% A6% E3% 83% 99% E3% 83% B3% E3% 83% 81% E3% 83% 9E% E3% 83% BC% E3% 82% AF).

L'autre jour, j'ai posté sur Qiita comment profiter de la tâche de programmation (Matlab) du cours Coursera, Machine Learning (par l'Université de Stanford, Prof. Andrew Ng) tout en le portant sur Python. Après cela, j'ai suivi le cours, mais j'ai appris qu'il n'y avait pas de tâches de programmation que j'attendais avec impatience depuis la semaine 10. (Sur les 11 semaines au total, l'attribution de programme est disponible de la semaine 1 à la semaine 9. À propos, le quiz est également la semaine 10 et 11.)

La semaine 10 a été intéressante pour les conférences sur la descente de gradient stochastique (SGD) et l'apprentissage en ligne parce que c'était un "apprentissage automatique à grande échelle", mais s'il n'y a pas de tâches de programmation, j'étudierai par moi-même. Par conséquent, nous avons implémenté SGD par Python. (Ceci est une tentative pour étudier le Deep Learning Framework, "Theano" avec l'implémentation de SGD.) Aussi, je présenterai quelques résultats intéressants (astuces) dans le test de référence réalisé après l'implémentation de SGD. ..

Aperçu de la conférence vidéo (semaine 10)

Dans la vidéo, la méthode Stochastic Gradient Descent est expliquée contrairement à la méthode Batch Gradient Descent normale.

Batch Gradient Descent Fonction de coût:

J_{train}(\theta) = \frac{1}{2m} \sum_{i=1}^{m} (h_{\theta} (x^{(i)}) 
- y^{(i)} ) ^2

Le calcul itératif suivant est effectué pour minimiser cette fonction de coût. Repeat {

{\theta}_j := {\theta}_j - \alpha \frac{1}{m} \sum_{i=1}^{m}(h_{\theta} (x^{(i)}
-y^{(i)} ) x_j^{(i)}
\\ \ \ \ \ \ \ \ \ \ (\textbf{for every } j=0, ..., n)

}

Stochastic Gradient Descent 1. Randomly shuffle (reorder) training examples Mélangez les données d'entraînement de manière aléatoire.

** 2. ** Ci-dessous, mettez à jour $ \ theta $ en vous référant aux données d'entraînement une par une. Repeat {

for\ i:= 1,...,m {\ \ \ \ \ \ \{\\

{\theta}_j := {\theta}_j - \alpha (h_{\theta} (x^{(i)}) - y^{(i)}) x_j^{(i)}
\\\ \ \ (\textbf{for every } j=0, ...,n)
\\\ \ \ \}

\ \ }

}

Dans la conférence, j'ai expliqué comment mettre à jour les paramètres en faisant référence aux données d'entraînement une par une, puis il y a eu une descente de dégradé en mini-lot (en tant que méthode entre la descente de gradient par lots et la GD stochastique). C'était.

Mise en œuvre de la méthode de descente de gradient normale (régression logistique)

En ce qui concerne les données utilisées pour vérifier le code, j'ai sélectionné le jeu de données "Adult" dans le référentiel UCI Machine Learning. Ceci est extrait de la base de données du recensement américain et semble être des données populaires dans l'apprentissage automatique.

39, State-gov, 77516, Bachelors, 13, Never-married, Adm-clerical, Not-in-family, White, Male, 2174, 0, 40, United-States, <=50K
50, Self-emp-not-inc, 83311, Bachelors, 13, Married-civ-spouse, Exec-managerial, Husband, White, Male, 0, 0, 13, United-States, <=50K
38, Private, 215646, HS-grad, 9, Divorced, Handlers-cleaners, Not-in-family, White, Male, 0, 0, 40, United-States, <=50K
53, Private, 234721, 11th, 7, Married-civ-spouse, Handlers-cleaners, Husband, Black, Male, 0, 0, 40, United-States, <=50K
28, Private, 338409, Bachelors, 13, Married-civ-spouse, Prof-specialty, Wife, Black, Female, 0, 0, 40, Cuba, <=50K

L'âge, les antécédents scolaires, le type de profession, les antécédents de mariage, etc. sont alignés, mais à la fin de chaque ligne se trouve l'étiquette de la classe de revenu «<= 50K» ou «> 50K». C'est la variable expliquée utilisée pour la classification. Je ne sais pas quoi choisir comme variable explicative (caractéristique) à utiliser pour la régression, mais cette fois, je n'ai choisi qu'une seule année d'inscription à l'école. On pense que la formation universitaire a une résolution légèrement plus élevée, mais il semble que cela soit lié au revenu dans le monde.

Nous commençons par définir une fonction de coût et une fonction pour calculer son gradient, en suivant la méthode des tâches précédentes de Coursera Machine Learning.

import numpy as np
import pandas as pd
import timeit

import theano
import theano.tensor as T

def load_data():
(Omis)
    return xtr, ytr, xte, yte

def compute_cost(w, b, x, y):
    p_1 = 1 / (1 + T.exp(-T.dot(x, w) -b))  # same as sigmoid(T.dot(x,w)+b)
    income_class = lambda predictor: T.gt(predictor, 0.5)  # 0.5 is threshold
    prediction = income_class(p_1)
    
    xent = -y * T.log(p_1) - (1-y) * T.log(1- p_1)
    cost = xent.mean() + 0.01 * (w ** 2).sum()  # regularization
    
    return cost, prediction

def compute_grad(cost, w, b):
    gw, gb = T.grad(cost, [w, b])
    
    return gw, gb

Une caractéristique du framework "Theano" est qu'une fois que vous vous y êtes habitué (c'est difficile à comprendre si vous n'y êtes pas habitué), vous pouvez rédiger une déclaration de manière très concise. (En particulier, le calcul du gradient peut être fait en une seule ligne.)

Le traitement principal est effectué à l'aide de ces fonctions.

    xtr, ytr, xte, yte = load_data()
   
    # Declare Theano symbolic variables
    xtr_shape = xtr.shape
    if len(xtr_shape) == 2:
        w_len = xtr_shape[1]
    else:
        w_len = 1
    
    x = T.matrix('x')    # for xmat
    y = T.vector('y')    # for ymat, labels
    w = theano.shared(np.zeros(w_len), name='w')    # w, b <- all zero
    b = theano.shared(0., name='b')

    print ' Initial model: '
    wi = w.get_value()
    bi = w.get_value()
    print 'w : [%12.4f], b : [%12.4f]' % (wi[0], bi)

    cost, prediction = compute_cost(w, b, x, y)  # ... Cost-J
    gw, gb = compute_grad(cost, w, b)            # ... Gradients
    
    # Compile
    train = theano.function(
          inputs=[x,y],
          outputs=[cost, prediction],
          updates=((w, w - 0.1 * gw), (b, b - 0.1 * gb)),
          allow_input_downcast=True)
    predict = theano.function(inputs=[x], outputs=prediction,
          allow_input_downcast=True)
    
    # Train (Optimization)
    start_time = timeit.default_timer()
    training_steps = 10000
    xtr= xtr.reshape(len(xtr), 1)  # shape: (m,) to (m,1)
    for i in range(training_steps):
        cost_j, pred = train(xtr, ytr)

Comme décrit ci-dessus, les paramètres (w, b) qui minimisent la fonction de coût ont été obtenus par la méthode de descente de gradient (Batch Gradient Descent). Le jugement de convergence n'est pas effectué et la solution est obtenue en mettant à jour les paramètres un nombre prédéterminé de fois.

Implémentation de la descente de gradient stochastique

Maintenant, c'est l'implémentation du sujet principal, Stochastic Gradient Descent (méthode de descente de gradient probabiliste). Dans la conférence de Cousera, il y avait une explication de la descente de gradient stochastique, qui scanne les données utilisées pour l'entraînement un ensemble à la fois, et de la descente de gradient stochastique mini-lot, qui scanne les données de 2 à 100 ensembles de petite taille un par un. Choisissez le mini-lot.

Dans SGD, les données d'entraînement sont mélangées de manière aléatoire en tant que prétraitement. De plus, afin d'accélérer le traitement, nous avons décidé de placer les données dans la variable partagée de Theano.

def setup_data(xmat, ymat):
    # store the data into 'shared' variables to be accessible by Theano
    def shared_dataset(xm, ym, borrow=True):
        shared_x = theano.shared(np.asarray(xm, dtype=theano.config.floatX),
                                        borrow=borrow)
        shared_y = theano.shared(np.asarray(ym, dtype=theano.config.floatX),
                                        borrow=borrow)
        #
        return shared_x, shared_y
    
    def data_shuffle(xm, ym, siz):
        idv = np.arange(siz)
        idv0 = np.array(idv)    # copy numbers
        np.random.shuffle(idv)
        xm[idv0] = xm[idv]
        ym[idv0] = ym[idv]
        
        return xm, ym
     
    total_len = ymat.shape[0]
    n_features = np.size(xmat) / total_len
    # Random Shuffle
    xmat, ymat = data_shuffle(xmat, ymat, total_len)
    train_len = int(total_len * 0.7)
    test_len = total_len - train_len
    
    xtr, ytr = shared_dataset((xmat[:train_len]).reshape(train_len, n_features), 
                               ymat[:train_len])
    xte, yte = shared_dataset((xmat[train_len:]).reshape(test_len, n_features), 
                               ymat[train_len:])
    
    rval = [(xtr, ytr), (xte, yte)]
    return rval

La description de la fonction ano.est modifiée car la destination de stockage de l'ensemble de données est déplacée vers la variable partagée. L'argument doit être donné indirectement avec le mot-clé ** givens **, pas directement avec ** inputs **.

Données d'entrée (réimpression) avec la variable Theano (variable non partagée)

    # Compile
    train = theano.function(
          inputs=[x,y],
          outputs=[cost, prediction],
          updates=((w, w - 0.1 * gw), (b, b - 0.1 * gb)),
          allow_input_downcast=True)
    predict = theano.function(inputs=[x], outputs=prediction,
          allow_input_downcast=True)

Données d'entrée à partir de variables partagées (version SGD)

    # Compile
    batch_size = 10
    train_model = theano.function(
          inputs=[index, learning_rate],
          outputs=[cost, prediction],
          updates=((w, w - learning_rate * gw), (b, b - learning_rate * gb)),
          givens=[(x, xtr[index * batch_size:(index + 1) * batch_size]), 
                  (y, ytr[index * batch_size:(index + 1) * batch_size])],
          allow_input_downcast=True
    )
    predict = theano.function(
          inputs=[],
          outputs=prediction,
          givens=[(x, xte)],
          allow_input_downcast=True
    )

Le calcul itératif est effectué à l'aide de la fonction Theano définie ci-dessus.

    # Train (Optimization)
    start_time = timeit.default_timer()
    n_epochs = 20
    epoch = 0
    lrate_base = 0.03
    lrate_coef = 20
    n_train_batches = int(ytr.get_value().shape[0] / batch_size)
    
    while (epoch < n_epochs):
        epoch += 1
        for mini_batch_index in range(n_train_batches):
            l_rate = lrate_base * lrate_coef / (epoch + lrate_coef)
            cost_j, pred = train_model(mini_batch_index, l_rate)
        
        print 'epoch[%3d] : cost =%f ' % (epoch, cost_j)
  

Résultat de l'exécution.

 Initial model: 
w : [      0.0000], b : [      0.0000]
epoch[  1] : cost =0.503755 
epoch[  2] : cost =0.510341 
epoch[  3] : cost =0.518218 
epoch[  4] : cost =0.524344 
epoch[  5] : cost =0.528745 
epoch[  6] : cost =0.531842 
epoch[  7] : cost =0.534014 
epoch[  8] : cost =0.535539 
epoch[  9] : cost =0.536614 
epoch[ 10] : cost =0.537375 
epoch[ 11] : cost =0.537913 
epoch[ 12] : cost =0.538294 
epoch[ 13] : cost =0.538563 
epoch[ 14] : cost =0.538751 
epoch[ 15] : cost =0.538880 
epoch[ 16] : cost =0.538966 
epoch[ 17] : cost =0.539021 
epoch[ 18] : cost =0.539053 
epoch[ 19] : cost =0.539067 
epoch[ 20] : cost =0.539069 

 Final model: 
w : [      0.3680], b : [     -4.9370]
Elapsed time:     26.565 [s]
accuracy =       0.7868 

J'ai tracé les changements des paramètres dans le calcul.

** Fig. Tracé pour chaque époque **

** Fig. Tracé pour chaque mini-lot **

Lorsque la résolution est augmentée, la caractéristique de mouvement de la méthode de descente de gradient stochastique (SGD) peut être observée.

Augmenter la variable indépendante (caractéristique) de la régression logistique

Étant donné que l'ensemble de données «Adulte» comporte de nombreuses variables indépendantes (caractéristiques), nous avons décidé d'augmenter les caractéristiques de calcul. Le code ne modifie que le traitement d'entrée des données d'entraînement x. Les fonctionnalités utilisées sont les suivantes.

• Année d'études (éducation, 12 ans si vous avez fait des études secondaires au Japon) (également utilisé dans le premier modèle de régression)
• Rôle dans le ménage (mari, femme, enfant, célibataire, etc.) (Ajouté dans ce modèle de régression.) --Heures de travail par semaine (ajoutées dans ce modèle de régression.)

Je m'attendais à ce que la précision de la classification s'améliore dans une certaine mesure, mais malheureusement, la précision ne s'est pas améliorée par rapport au premier modèle de régression. (Cette fois, le but est de mettre en œuvre le programme, nous n'avons donc pas pris en compte les résultats de l'analyse des données.)

Les résultats du benchmark concernant le temps de calcul sont les suivants.

** Comparaison du temps de calcul **

! Aucun jugement de convergence n'est effectué dans aucun des calculs. Calculez le nombre de boucles spécifié. ! La descente de gradient par lots a nécessité environ 10 000 calculs pour obtenir une solution convergente. (Taux d'apprentissage du taux d'apprentissage = 0,1)

Si vous ne regardez pas le calcul GPU, Batch G.D. vs SGD vous fera gagner beaucoup de temps de calcul. Nous avons pu confirmer la grande efficacité de calcul de SGD.

Effet de la taille du mini-lot sur le calcul GPU

Maintenant, le problème est "la mauvaise efficacité de calcul du GPU". Etant donné que le temps de calcul est réglé en réglant la minuterie avant l'apprentissage et en acquérant la valeur de la minuterie après l'achèvement, il ne fait aucun doute que cette partie d'apprentissage en est la cause. Habituellement, on soupçonne que le calcul du processeur (en particulier le traitement numpy) est mélangé dans la partie calcul du GPU. Dans cet esprit, j'ai regardé le code en détail, mais je n'ai pas trouvé la cause. (En fait, je fais référence au code dans Theano Tutorial, documentation Deep Learning 0.1, qui est un modèle, donc je ne pense pas que je puisse faire une simple erreur.)

Après cela, je suis venu avec la surcharge d'appeler Theano Function. J'ai changé (augmenté) la taille du mini-lot et mesuré le temps de calcul.

L'axe horizontal correspond à la taille du mini-lot et l'axe vertical correspond au temps d'entraînement. L'échelle de gauche est Linéaire-Linéaire et l'échelle de droite est Log-Linéaire. Il faut considérer que le nombre de boucles diminue proportionnellement à la taille du Mini-Batch, mais le résultat ci-dessus montre que le temps de calcul est réduit "exponentiellement", et on considère que l'influence de l'appel de fonction d'apprentissage est grande.

Dans la conférence du coursera, il a été expliqué que "la taille du mini-lot doit être déterminée en tenant compte du calcul parallèle (vectorisation) du processeur, environ 2 à 100 est pratique." En outre, il semble y avoir une proposition selon laquelle "dans le cas de la classification, il convient de décider en fonction du nombre de classes de la destination de tri (2 parce que cette fois est 2 classifications, 10 pour la classification des numéros manuscrits MNIST). Cependant, cette fois D'après le résultat de, "Il est préférable de définir la taille du Mini-Batch dans une certaine mesure dans le calcul GPU".

Cette fois, puisqu'il s'agit d'une régression logistique, la quantité de calcul par lot est considérablement inférieure à celle d'un réseau neuronal. Je voudrais étudier l'effet de la taille du mini-lot sur un calcul à une échelle légèrement plus grande, comme un réseau neuronal, à une date ultérieure. De plus, la surcharge de l'appel de fonction est due au transfert de données entre les mémoires, la situation peut donc différer selon le matériel. (Est-ce impossible avec un ordinateur portable?)

(L'environnement de programmation de cet article est le suivant, python 2.7.8, theano 0.7.0, CUDA Driver / Runtime 7.5 / 7.0)

Références (site Web)

--Coursera, Machine Learning (en particulier la semaine 10)

• Theano Tutorial http://deeplearning.net/software/theano/tutorial/
• Theano, Deep Learning Tutorials http://deeplearning.net/tutorial/
• UCI Machine Learning Repository, Adult http://archive.ics.uci.edu/ml/datasets/Adult
• [Qiita] Apprenez à nouveau les bases de Theano http://qiita.com/TomokIshii/items/1f483e9d4bfeb05ae231 (Depuis que j'ai fait des recherches sur Theano cette fois, j'aimerais également mettre à jour cet article lié.)

(Ajout) Le calcul du GPU Theano se concentre sur la taille des mini-lots et les benchmarks

Dans l'article ci-dessus, j'ai écrit que "lors de l'exécution de la méthode de descente de gradient probabiliste avec Mini-Batch, il semble être affecté par la taille du Mini-Batch", mais depuis que j'ai reçu un commentaire à ce sujet, j'ai augmenté les conditions et évalué J'ai essayé.

Problèmes utilisés dans le benchmark - Ensemble de données pour adultes

Comme dans cet article, j'ai sélectionné et utilisé "Adult" dans le référentiel UCI Machine Learning. Les données «adultes» posent un problème pour classer le revenu annuel de «50 000 $ US» ou moins et de «50 000 $ US» ou plus en fonction de la «structure familiale» et du «bagage scolaire» des résidents américains. Cette fois, nous avons utilisé deux codes de classification.

1. Classification par régression logistique Créez un modèle de régression en sélectionnant 3 des 14 entités incluses dans le jeu de données «Adulte». De plus, les données du fichier «adulte.data» sont divisées en 70% / 30% et utilisées respectivement pour les données de train et les données de test. (La dernière fois, j'ai effectué l'opération ci-dessus sans remarquer l'existence du fichier de test'adult.test 'inclus dans l'ensemble de données.)

2. Classification par modèle de Perceptron multicouche (MLP). Sélectionnez 11 des 14 entités incluses dans le jeu de données «Adulte» et entrez-les dans le modèle de réseau MLP. Le MLP se compose de la couche cachée 1 (22 unités) + couche cachée 2 (20 unités) + couche de sortie (1 unité). Le fichier'adult.data 'a été utilisé comme données de train et' adulte.test 'a été utilisé comme données de test. Le nombre d'instances est le Train-32561, Test-16281.

L'optimiseur a utilisé la méthode Stochastic Gradient Descent, qui ajuste les paramètres tout en fournissant des données avec un mini-lot.

Processus de calcul

Les données d'apprentissage sont définies comme un ensemble, divisées en tailles de mini-lots prédéterminées, puis entrées dans le classificateur. L'étape de calcul de l'entrée de l'ensemble complet est appelée époque, et le nombre fixe d'époques (époque = 50 cette fois) a été calculé sans effectuer de jugement de convergence. Vous trouverez ci-dessous le code de cette partie.

    #############################################
    batch_size = 100
    #############################################

    # Compile
    train_model = theano.function(
        inputs=[index],
        outputs=[cost, accur],
        updates=one_update,
        givens=[(x, trXs[index * batch_size:(index + 1) * batch_size]), 
                (y_, trYs[index * batch_size:(index + 1) * batch_size])],
        allow_input_downcast=True
    )
    accuracy = theano.function(
        inputs=[],
        outputs=accur,
        givens=[(x, teXs), (y_, teYs)],
        allow_input_downcast=True
    )

    # Train (Optimization)
    start_time = timeit.default_timer()

    n_epochs = 50
    epoch = 0

    n_train_batches = int(trY.shape[0] / batch_size)
    
    while (epoch < n_epochs):
        epoch += 1
        for mini_batch_index in range(n_train_batches):
            cost_j, accur = train_model(mini_batch_index)
        
        print('epoch[%3d] : cost =%8.4f' % (epoch, cost_j))
    
    elapsed_time = timeit.default_timer() - start_time
    print('Elapsed time: %10.3f [s]' % elapsed_time)
    
    last_accur = accuracy()
    print('Accuracy = %10.3f ' % last_accur)

Une mise en garde est le nombre de mini-lots à une époque.

#   Mini-Nombre de lots=Nombre d'instances de données de train/ Mini-Taille du lot
    n_train_batches = int(trY.shape[0] / batch_size)

Dans certains cas, le surplus est tronqué. Cela a un effet relativement important à mesure que la taille du mini-lot augmente. Par exemple, dans le cas de 32 561 mini-lots de 10 000, 30 000 instances sont référencées mais 2561 est ignoré.

Résultats des tests sur banc

L'environnement informatique est le suivant.

1. PC portable (avec GPU), OS: Windows 10, Python 2.7.11, Theano 0.7.0
2. PC de bureau (avec GPU), OS: Linux, Ubuntu 14.04LTS, Python 2.7.11, Theano 0.7.0

** Résultat du test (données brutes) ** (L'unité est en secondes [s])

Description de chaque colonne: --batch_siz: taille du mini-lot --Laptop_LR_fastc: régression logistique sur ordinateur portable, theano.config.Mode = fast_compile --Laptop_MLP_fastc: classification de modèle MLP sur ordinateur portable, theano.config.Mode = fast_compile --Laptop_LR_fastr: régression logistique sur ordinateur portable, theano.config.Mode = fast_run --Laptop_MLP_fastr: classification du modèle MLP sur PC de bureau, theano.config.Mode = fast_run --Desktop_LR_fastr: régression logistique sur PC de bureau, theano.config.Mode = fast_run --Desktop_MLP_fastr: classification du modèle MLP sur PC de bureau, theano.config.Mode = fast_run

'theano.config.Mode' est une option pour'fast_run 'pour augmenter le niveau d'optimisation et augmenter la vitesse d'exécution, et'fast_compile' est une option pour l'optimisation partielle (raccourcissant le temps de compilation).

Ensuite, nous examinerons les détails tout en faisant référence à l'intrigue.

Fig. Logistic Regression vs. MLP model (Laptop_LR_fastr vs. Laptop_MLP_fastr)

L'axe horizontal correspond à la taille du mini-lot et l'axe vertical correspond au temps nécessaire à la partie d'apprentissage. Premièrement, la différence de code de classification et la comparaison entre la régression logistique et la classification par modèle MLP. Comme prévu, le temps de calcul est environ 3 à 4 fois plus long en raison de l'augmentation de la quantité de calcul dans le modèle MLP. De plus, l'influence de la taille du mini-lot est la même pour les deux, et on peut voir que le temps de calcul diminue à mesure que la taille du mini-lot augmente.

Fig. Theano mode FAST_COMPILE vs. FAST_RUN (Logistic Regression)

Il s'agit d'une comparaison entre le mode FAST_COMPILE, qui n'effectue pas beaucoup d'optimisation liée à CUDA, et le mode FAST_RUN, qui effectue plus d'optimisation, mais comme le montre la figure ci-dessus, il n'y a pas beaucoup de différence entre les régressions logistiques.

Fig. Theano mode FAST_COMPILE vs. FAST_RUN (MLP classification)

En revanche, dans la classification des modèles MLP avec une grande quantité de calcul, l'effet de «FAST_RUN», qui a été optimisé, est ressorti, conduisant à une réduction du temps de calcul.

FIG. Laptop PC vs. Desktop PC (MLP classification)

On pense que cela est le résultat d'une simple différence de performances matérielles. (Dans les deux cas, le mode Theano est FAST_RUN. De plus, je n'ai pas examiné la différence de système d'exploitation en détail, mais l'effet sera faible.)

Considération

Comme mentionné ci-dessus, il a été observé que le temps de calcul d'apprentissage a tendance à diminuer de manière significative lorsque la taille du mini-lot augmente dans toutes les conditions. La cause est que lorsque la taille du mini-lot est gravée petite, le nombre d'appels à la fonction train_model () dans la boucle d'apprentissage while augmente, et l'influence de la surcharge sur cet appel de fonction est considérée comme importante. (Si vous voulez enquêter plus en détail, je pense qu'il est nécessaire d'utiliser un profileur. Pour le moment, j'ai regardé la situation avec le profil C du profileur standard, mais j'ai pu saisir la partie qui a pris du temps dans la partie à l'intérieur du code Theano. Cependant, faute de compétences, j'ai abandonné les détails.)

Dans ce test (comme mentionné ci-dessus, il y a un problème de "troncature" des données qui se produisent pendant l'alimentation des données), le contour et la quantité de données à alimenter sont les mêmes conditions. À l'origine, il s'agit de la rapidité avec laquelle la précision du classificateur peut être améliorée lors de l'apprentissage, il est donc possible de prendre une stratégie pour ajuster les paramètres de calcul (taux d'apprentissage, paramètres de l'optimiseur, etc.) pour chaque mini-lot. Il y a beaucoup de. Il est important de définir la taille du mini-lot de manière appropriée en tenant compte de cette question et de la surcharge générée lorsque la fonction de calcul GPU appelée cette fois est observée, afin de réaliser un apprentissage efficace.