Écrivez votre propre fonction d'activation avec Pytorch (sigmoïde dur)

Portage de Chainer à Pytorch

Je fais du Deep Learning dans mes recherches, mais l'autre jour, j'ai appris que la mise à jour de Chainer touchait à sa fin, j'ai donc décidé de changer le framework en Pytorch ainsi que le développeur. Comme point de départ, j'ai décidé de porter le programme Chainer existant vers Pytorch.

En gros, tout ce que j'avais à faire était de changer le nom de la fonction, mais en chemin, j'ai remarqué que Pytorch n'avait pas HardSigmoid. Alors faisons-le nous-mêmes.

Je l'ai vraiment écrit

... mais c'est écrit dans la référence officielle, donc je l'ai fait presque exactement. --> https://pytorch.org/docs/master/autograd.html

python


class MyHardSigmoid(torch.autograd.Function):
    @staticmethod
     def forward(ctx, i):
         ctx.save_for_backward(i)
         result = (0.2 * i + 0.5).clamp(min=0.0, max=1.0)
         return result

     @staticmethod
     def backward(ctx, grad_output):
         grad_input = grad_output.clone()
         result, = ctx.saved_tensors
         grad_input *= 0.2
         grad_input[result < -2.5] = 0
         grad_input[result > -2.5] = 0
         return grad_input

Si vous n'écrivez pas @staticmethod, un avertissement apparaîtra. La fonction officielle est une fonction exponentielle, mais nous la changerons en sigmoïde dur.

Premièrement, forward () est propagé vers l'avant. hard sigmoid () a la formule suivante, donc je l'ai écrit pour qu'il le soit.

h(x) = \left\{
\begin{array}{ll}
0 & (x \lt -2.5) \\
0.2x + 0.5 & (-2.5 \leq x \leq 2.5)  \\
1 & (2.5 \lt x)
\end{array}
\right.

Ensuite, avec backward (), cela écrit la rétropropagation. Le coefficient différentiel est le suivant.

\frac{\partial h(x)}{\partial x} = \left\{
\begin{array}{ll}
0 & (x \lt -2.5) \\
0.2 & (-2.5 \leq x \leq 2.5)  \\
0 & (2.5 \lt x)
\end{array}
\right.

Et enfin, appliquez cela au modèle. (Le contenu du modèle est approprié.)

model.py


import torch.nn as nn
import torch.nn.functional as F

class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.conv1 = nn.Conv2d(1, 20, 5)
        self.conv2 = nn.Conv2d(20, 20, 5)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        hard_sigmoid = MyHardSigmoid.apply
        return hard_sigmoid(self.conv2(x))

C'est parfait! !! ... devrait être

Recommended Posts

Écrivez votre propre fonction d'activation avec Pytorch (sigmoïde dur)
Définissez votre propre fonction de distance avec k-means de scikit-learn
Résolvez votre propre labyrinthe avec Q Learning
Entraînez UGATIT avec votre propre jeu de données
Résolvez votre propre labyrinthe avec DQN
Votre propre client Twitter réalisé avec Django
[Renforcer l'apprentissage] DQN avec votre propre bibliothèque
Créez votre propre serveur DNS avec Twisted
Créez votre propre valeur composite avec SQLAlchemy
Pour importer votre propre module avec jupyter
Publiez votre propre bibliothèque Python sur Homebrew
Reproduisez le changement de couleur semblable à la thermographie avec la fonction sigmoïde
Essayez de créer votre propre AWS-SDK avec bash
Créez rapidement votre propre module avec setuptools (python)
Entraînez Stanford NER Tagger avec vos propres données
Créez votre propre lecteur de musique avec Bottle0.13 + jPlayer2.5!
Étapes pour installer votre propre bibliothèque avec pip