Préparation du code du module de couche

Commencez par créer un conteneur de base.

import numpy as np


class BaseLayer():
    """
Toutes les classes de couches sous-jacentes
Décrivez le traitement commun à la couche intermédiaire et à la couche de sortie.
    """
    
    def __init__(self):
        pass
    
    
    def forward(self):
        """
Mise en œuvre de la propagation directe
        """
        pass
    
    
    def backward(self):
        """
Mise en œuvre de la rétropropagation
        """
        pass
    
    
    def update(self):
        """
Mise en œuvre de l'apprentissage des paramètres
        """
        pass

import numpy as np


#import .baselayer import BaseLayer


class MiddleLayer(BaseLayer):
    """
Classe moyenne
La couche d'entrée est également traitée comme l'une des couches intermédiaires en termes de montage.
    """
    pass

import numpy as np


#from .baselayer import BaseLayer


class OutputLayer(BaseLayer):
    """
Classe de couche de sortie
    """
    pass

Préparation du code du gestionnaire de couches

Ici, nous allons préparer un gestionnaire pour gérer les modules de couche. ** Enfin, rassemblez le code. Veuillez noter que vous avez peut-être oublié de changer le code au milieu. ** ** Fondamentalement, nous le ferons en gardant à l'esprit le type List et le type Dictionary de Python.

import numpy as np


#from .layer import *


class _TypeManager():
    """
Classe de gestionnaire pour les types de couches
    """
    N_TYPE = 2  #Nombre de types de couches
    
    MIDDLE = 0  #Numérotation des couches intermédiaires
    OUTPUT = 1  #Numérotation des couches de sortie


class LayerManager(_TypeManager):
    """
Classe Manager pour la gestion des couches
    """
    def __init__(self):
        pass

La classe LayerManager connaît le type Dictionary et vous permet de conserver une liste de couches et de les ajouter / supprimer. Aussi, héritons de _TypeManager.

Au fait, le module «layer» est un module pour importer tous les modules liés à «Layer».

from .middlelayer import *
from .outputlayer import *
from ._layererror import *

Le module _layererror sera décrit plus tard, mais nous prévoyons d'en faire un module qui résume les erreurs qui se produisent dans la couche.

Mise en œuvre de méthodes spéciales

Tout d'abord, implémentez une méthode spéciale de la classe LayerManager. Voir Documentation officielle pour une liste de méthodes spéciales.

Implémentation de la méthode __init __

Maintenant, implémentez la méthode __init__ de la classe LayerManager. En premier lieu, la méthode __init__ est l'une des méthodes spéciales de Python et l'une des méthodes appelées lors de la création d'une instance d'une classe. En d'autres termes, décrivez l'action que vous souhaitez effectuer lorsque la classe LayerManager est générée. ici

• Gardez une liste de couches
• Gardez une liste de noms de couches
• Gardez le nombre de couches par type

Je veux que vous le fassiez, alors mettez-le en œuvre de cette façon.

    def __init__(self):
        self.__layer_list = []  #Liste des couches
        self.__name_list = []   #Liste de noms pour chaque couche
        self.__ntype = np.zeros(self.N_TYPE)  #Nombre de couches par type

Implémentation des méthodes __repr__ et __str__

La méthode __repr__ est une représentation sous forme de chaîne" officielle "appelée depuis la fonction repr, une des fonctions intégrées de Python. Cela s'appelle "officiel", mais le fait est que ce sont des informations détaillées. La méthode __str__ est une représentation sous forme de chaîne" non officielle "qui est appelée depuis l'une des fonctions intégrées de Python, la fonction str et les fonctions intégrées format et print. Le sens du terme «informel» est qu'il est facile à lire.

    def __repr__(self):
        layerRepr= "layer_list: " + repr(self.__layer_list)
        nameRepr = "name_list: " + repr(self.__name_list)
        ntypeRepr = "ntype: " + repr(self.__ntype)
        return (layerRepr + "\n"
                + nameRepr + "\n"
                + ntypeRepr)
    
    
    def __str__(self):
        layerStr = "layer_list: " + str(self.__layer_list)
        nameStr = "name_list: " + str(self.__name_list)
        ntypeStr = "ntype: " + str(self.__ntype)
        return (layerStr + "\n"
                + nameStr + "\n"
                + ntypeStr)

Implémentation de la méthode __len__

La méthode __len__ décrit le comportement lorsqu'elle est appelée à partir de la fonction len, qui est l'une des fonctions intégrées de Python. Retournons le nombre de couches que possède la classe LayerManager.

    def __len__(self):
        """
Fonctions intégrées Python`len`Décrit l'opération lorsqu'elle est appelée depuis.
Renvoie la somme du nombre de couches par type.
        """
        return np.sum(self.__ntype)

    def __getitem__(self, key):
        """
Par exemple
        lm = LayerManager()
        
        +----------------+
        | (Ajouter un élément à lm) |
        +----------------+
        
        x = lm[3].~~
Est appelé lors de l'accès à un élément d'une liste ou d'un tableau, comme
Décrivez l'opération à ce moment-là.
tranche et str,Autoriser uniquement l'accès int.
        """
        if isinstance(key, slice):
            #Si la clé est une tranche, reportez-vous à la liste des calques avec tranche.
#Valeur inhabituelle(Index hors de portée, etc.)Quand est entré
            #Python me donne une erreur.
            return self.__layer_list[key]
        elif isinstance(key, str):
            #Si key est une chaîne, récupérez l'index dans la liste des noms de chaque couche et
            #Renvoie les éléments de la liste des couches applicables.
            if key in self.__name_list:
                index = self.__name_list.index(key)
                return self.__layer_list[index]
            else:
                #Si la clé n'existe pas, une KeyError est émise.
                raise KeyError("{}: No such item".format(key))
        elif isinstance(key, int):
            #Si key est un entier, renvoie l'élément correspondant dans la liste des couches.
            #Valeur inhabituelle(Index hors de portée, etc.)Quand est entré
            #Python me donne une erreur.
            return self.__layer_list[key]
        else:
            raise KeyError("{}: Not defined such key type.".format(key))

    def __setitem__(self, key, value):
        """
Par exemple
        lm = LayerManager()
        
        +----------------+
        | (Ajouter un élément à lm) |
        +----------------+
        
        lm[1] = x
Est appelé lors de l'accès à un élément d'une liste ou d'un tableau, comme
Décrivez l'opération à ce moment-là.
Seul l'écrasement des éléments est autorisé et l'ajout de nouveaux éléments est interdit.
        """
        value_type = ""
        if isinstance(value, list):
            #Spécifié sur le côté droit'value'Mais'list'Si
            #Tous les éléments'BaseLayer'Erreur si classe ou ne l'hérite pas.
            if not np.all(
                np.where(isinstance(value, BaseLayer), True, False)):
                self.AssignError()
            value_type = "list"
        elif isinstance(value, BaseLayer):
            #Spécifié sur le côté droit'value'Mais'BaseLayer'Est-ce une classe?
            #Erreur s'il n'est pas hérité.
            self.AssignError(type(value))
        if value_type == "":
            value_type = "BaseLayer"
            
        if isinstance(key, slice):
            #Si la clé est une tranche, écrasez l'élément dans la liste des calques.
            #pourtant'value_type'Mais'list'Sinon, une erreur.
            #Valeur inhabituelle(Index hors de portée, etc.)Quand est entré
            #Python me donne une erreur.
            if value_type != "list":
                self.AssignError(value_type)
            self.__layer_list[key] = value
        elif isinstance(key, str):
            #Si key est une chaîne, récupérez l'index dans la liste des noms de chaque couche et
            #Remplacez les éléments dans la liste des calques applicables.
            #pourtant'value_type'Mais'BaseLayer'Sinon, une erreur.
            if value_type != "BaseLayer":
                raise AssignError(value_type)
            if key in self.__name_list:
                index = self.__name_list.index(key)
                self.__layer_list[index] = value
            else:
                #Si la clé n'existe pas, une KeyError est émise.
                raise KeyError("{}: No such item".format(key))
        elif isinstance(key, int):
            #Si la clé est un entier, écrasez l'élément correspondant dans la liste des couches.
            #pourtant'value_type'Mais'BaseLayer'Sinon, une erreur.
            #Aussi, une valeur anormale(Index hors de portée, etc.)Quand est entré
            #Python me donne une erreur.
            if value_type != "BaseLayer":
                raise AssignError(value_type)
            self.__layer_list[key] = value
        else:
            raise KeyError(key, ": Undefined such key type.")

    def __delitem__(self, key):
        """
Par exemple
        lm = LayerManager()
        
        +----------------+
        | (Ajouter un élément à lm) |
        +----------------+
        
        del lm[2]
Parce qu'il est appelé lorsque l'élément de la liste ou du tableau est accédé par l'instruction del comme
Décrivez l'opération à ce moment-là.
Si l'élément spécifié existe, il sera supprimé et renommé.
        """
        if isinstance(key, slice):
            #Si la clé est une tranche, supprimez l'élément spécifié tel quel
            #Valeur inhabituelle(Index hors de portée, etc.)Quand est entré
            #Python me donne une erreur.
            del self.__layer_list[slice]
            del self.__name_list[slice]
        elif isinstance(key, str):
            #Si key est une chaîne, récupérez l'index dans la liste des noms de chaque couche et
            #Supprimez l'élément concerné.
            if key in self.__name_list:
                del self.__layer_list[index]
                del self.__name_list[index]
            else:
                #Si la clé n'existe pas, une KeyError est émise.
                raise KeyError("{}: No such item".format(key))
        elif isinstance(key, int):
            #Si la clé est un entier, supprimez l'élément correspondant dans la liste des couches.
            #Valeur inhabituelle(Index hors de portée, etc.)Quand est entré
            #Python me donne une erreur.
            del self.__layer_list[key]
        else:
            raise KeyError(key, ": Undefined such key type.")
        
        #Renommer
        self._rename()

    def _rename(self):
        """
Lorsque la dénomination de la liste de noms enfreint les règles en raison de l'opération de liste
Renommez la liste de dénomination et chaque couche pour respecter à nouveau les règles.
        
La règle de dénomination est[Type de calque][Quel nombre]ça ira.
Si le type de calque est Couche intermédiaire, Milieu
Sortie pour la couche de sortie
Il est abrégé en.
Le nombre est compté par type.
        
Aussi, ici encore__Compte ntypes.
        """
        #Initialiser le nombre de couches par type
        self.__ntype = np.zeros(self.N_TYPE)
        
        #Recompter et renommer chaque couche
        for i in range(len(self)):
            if "Middle" in self.__name_list[i]:
                self.__ntype[self.MIDDLE] += 1
                self.__name_list[i] = "Middle{}".format(
                        self.__ntype[self.MIDDLE])
                self.__layer_list[i].name = "Middle{}".format(
                        self.__ntype[self.MIDDLE])
            elif "Output" in self.__name_list[i]:
                self.__ntype[self.OUTPUT] += 1
                self.__name_list[i] = "Output{}".format(
                        self.__ntype[self.OUTPUT])
                self.__layer_list[i].name = "Output{}".format(
                        self.__ntype[self.OUTPUT])
            else:
                raise UndefinedLayerType(self.__name_list[i])

Implémentation de la méthode ʻAppend`

Implémentez la méthode familière ʻappend` dans la méthode d'ajout d'éléments à la liste. Puisqu'il est ajouté à la fin, il n'y a pas de traitement compliqué.

    def append(self, *, name="Middle", **kwds):
        """
Implémentation de la méthode append familière, qui est une méthode pour ajouter des éléments à une liste.
        """
        if "prev" in kwds:
            # 'prev'Est inclus dans le mot-clé
            #Cela signifie que le nombre d'éléments de la couche précédente est spécifié.
            #Fondamentalement, il est censé être le moment d'insérer la première couche, donc
            #En dehors de cela, il est essentiellement déterminé automatiquement et n'est pas spécifié.
            if len(self) != 0:
                if kwds["prev"] != self.__layer_list[-1].n:
                    #Erreur s'il ne correspond pas au nombre d'unités à la fin.
                    raise UnmatchUnitError(self.__layer_list[-1].n,
                                           kwds["prev"])
            else:
                if len(self) == 0:
                    #La première couche doit toujours spécifier le nombre d'unités d'entrée.
                    raise UnmatchUnitError("Input units", "Unspecified")
                else:
                    #Le nombre d'unités dans la dernière couche'kwds'Ajouter à
                    kwds["prev"] = self.__layer_list[-1].n
            
            #Lisez le type de couche et modifiez le nom selon la règle de dénomination
            if name == "mid" or "m":
                name = "Middle"
            elif name == "out" or "o":
                name = "Output"
            else:
                raise UndefinedLayerError(name)
            
            #Ajoutez un calque.
            if name == "Middle":
                #Incrémenter la couche par type
                self.__ntype[self.MIDDLE] += 1
                #Ajouter au nom
                name += str(self.__ntype[self.MIDDLE])
                #Ajouter à la liste de noms
                self.__name_list.append(name)
                #Enfin, créez un calque et ajoutez-le à la liste.
                self.__layer_list.append(
                        MiddleLayer(name=name, **kwds))
            elif name == "Output":
                #C'est également la même chose.
                self.__ntype[self.OUTPUT] += 1
                name += str(self.__ntype[self.OUTPUT])
                self.__name_list.append(name)
                self.__layer_list.append(
                        OutputLayer(name=name, **kwds))
            #Si vous ne dessinez pas d'instruction else ici, modifiez le nom selon la règle de dénomination
            #Déjà anormal au stade'name'Est omis.

Implémentation de la méthode ʻExend`

Ce n'est peut-être pas très familier? Implémentez la méthode ʻextend de List. <détails> <summary> Description de la méthode ʻextend </ summary>

x = [1, 2, 3]
y = [4, 5, 6]
x.append(y)
print(x)

[1, 2, 3, [4, 5, 6]]

x = [1, 2, 3]
y = [4, 5, 6]
x.extend(y)
print(x)

[1, 2, 3, 4, 5, 6]