layermanager.py

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
import tqdm


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, x, y):
        self.x_train, self.x_test = x
        self.y_train, self.y_test = y
        
        self.__layer_list = []  #Liste des couches
        self.__name_list = []   #Liste de noms pour chaque couche
        self.__ntype = np.zeros(self.N_TYPE, dtype=int)  #Nombre de couches par type


    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)


    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 int(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 via 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(key, ": Undefined such key type.")


    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])

    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 == "Middle" or name == "mid" or name == "m":
            name = "Middle"
        elif name == "Output" or name == "out" or name == "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.


    def extend(self, lm):
        """
Un autre gestionnaire de couches qui existe déjà dans la méthode d'extension'lm'Des éléments de
Tout ajouter.
        """
        if not isinstance(lm, LayerManager):
            # 'lm'Erreur si l'instance de n'est pas LayerManager.
            raise TypeError(type(lm), ": Unexpected type.")
        if len(self) != 0:
            if self.__layer_list[-1].n != lm[0].prev:
                #Avec le nombre d'unités dans votre dernière couche
                # 'lm'Erreur si le nombre d'entrées dans la première couche de n'est pas le même.
                raise UnmatchUnitError(self.__layer_list[-1].n,
                                       lm[0].prev)

        #Chaque'extend'Ajouter par méthode
        self.__layer_list.extend(lm.layer_list)
        self.__name_list.extend(lm.name_list)

        #Renommer
        self._rename()


    def insert(self, prev_name, name="Middle", **kwds):
        """
Dans la méthode d'insertion, spécifiez le nom du calque précédent et combinez-le avec ce calque.
Ajoutez un élément.
        """
        # 'prev_name'Erreur si n'existe pas.
        if not prev_name in self.__name_list:
            raise KeyError(prev_name, ": No such key.")
        # 'prev'Est inclus dans le mot-clé
        # 'prev_name'Erreur s'il ne correspond pas au nombre d'unités du calque spécifié dans.
        if "prev" in kwds:
            if kwds["prev"] \
                != self.__layer_list[self.index(prev_name)].n:
                raise UnmatchUnitError(
                    kwds["prev"],
                    self.__layer_list[self.index(prev_name)].n)
        # 'n'Est inclus dans le mot-clé
        if "n" in kwds:
            # 'prev_name'Si ce n'est pas le dernier
            if prev_name != self.__name_list[-1]:
                #Erreur s'il ne correspond pas au nombre d'unités dans la couche suivante.
                if kwds["n"] != self.__layer_list[
                        self.index(prev_name)+1].prev:
                    raise UnmatchUnitError(
                        kwds["n"],
                        self.__layer_list[self.index(prev_name)].prev)
        #S'il n'y a pas encore d'éléments'append'Donnez une erreur pour utiliser la méthode.
        if len(self) == 0:
            raise RuntimeError(
                "You have to use 'append' method instead.")

        #Obtenir l'index de l'emplacement d'insertion
        index = self.index(prev_name) + 1

        #Lisez le type de couche et modifiez le nom selon la règle de dénomination
        if name == "Middle" or name == "mid" or name == "m":
            name = "Middle"
        elif name == "Output" or name == "out" or name == "o":
            name = "Output"
        else:
            raise UndefinedLayerError(name)

        #Insérer un élément
        #En ce moment,'name'Ne respecte pas encore les règles de dénomination,
        #Je le renommerai plus tard alors ne vous inquiétez pas.
        if "Middle" in name:
            self.__layer_list.insert(index,
                                     MiddleLayer(name=name, **kwds))
            self.__name_list.insert(index, name)
        elif "Output" in name:
            self.__layer_list.insert(index,
                                     OutputLayer(name=name, **kwds))
            self.__name_list.insert(index, name)

        #Renommer
        self._rename()


    def extend_insert(self, prev_name, lm):
        """
C'est la fonction d'origine.
Il se comporte comme une combinaison de la méthode extend et de la méthode insert.
En termes simples, c'est comme insérer un autre gestionnaire de calques.
        """
        if not isinstance(lm, LayerManager):
            # 'lm'Erreur si l'instance de n'est pas LayerManager.
            raise TypeError(type(lm), ": Unexpected type.")
        # 'prev_name'Erreur si n'existe pas.
        if not prev_name in self.__name_list:
            raise KeyError(prev_name, ": No such key.")
        #Le nombre d'unités des couches avant et après l'emplacement spécifié et les première et dernière couches de lm
        #S'ils ne correspondent pas, une erreur se produit.
        if len(self) != 0:
            if self.__layer_list[self.index(prev_name)].n \
                    != lm.layer_list[0].prev:
                #Avec le nombre d'unités dans votre emplacement désigné'lm'Le premier nombre d'unités dans
                #S'ils ne correspondent pas, une erreur se produit.
                raise UnmatchUnitError(
                    self.__layer_list[self.index(prev_name)].n,
                    lm.layer_list[0].prev)
            if prev_name != self.__name_list[-1]:
                # 'prev_name'N'est-ce pas ma dernière couche
                if lm.layer_list[-1].n \
                    != self.__layer_list[self.index(prev_name)+1].prev:
                    # 'lm'Le nombre d'unités à la fin et au niveau suivant de votre emplacement désigné
                    # 'prev'Erreur s'il ne correspond pas au nombre d'unités.
                    raise UnmatchUnitError(
                        lm.layer_list[-1].n,
                        self.__layer_list[self.index(prev_name)+1].prev)
        else:
            #Si vous n'avez aucun élément'extend'J'obtiens une erreur lors de l'utilisation de la méthode.
            raise RuntimeError(
                "You have to use 'extend' method instead.")

        #Obtenir l'index de l'emplacement d'insertion
        index = self.index(prev_name) + 1

        #Éléments après l'emplacement d'insertion'buf'Après avoir évacué vers, retirez-le une fois
        #Ajouter un élément à l'aide de la méthode extend
        layer_buf = self.__layer_list[index:]
        name_buf = self.__name_list[index:]
        del self.__layer_list[index:]
        del self.__name_list[index:]
        self.extend(lm)

        #Ajouter l'élément qui a été évacué
        self.__layer_list.extend(layer_buf)
        self.__name_list.extend(name_buf)

        #Renommer
        self._rename()


    def remove(self, key):
        """
La méthode remove supprime l'élément avec le nom spécifié.
Il est également autorisé à être spécifié par index.
        """
        #Déjà implémenté'del'La phrase est OK.
        del self[key]


    def index(self, target):
        return self.__name_list.index(target)


    def name(self, indices):
        return self.__name_list[indices]


    @property
    def layer_list(self):
        return self.__layer_list


    @property
    def name_list(self):
        return self.__name_list


    @property
    def ntype(self):
        return self.__ntype
    
    
    def training(self, epoch, n_batch=16, threshold=1e-8,
                         show_error=True, **kwds):
        if show_error:
            self.error_list = []
        if self.make_anim:
            self.images = []
        
        n_in = self.__layer_list[0].prev
        n_out = self.__layer_list[-1].n
        n_train = self.x_train.size//n_batch
        n_test = self.x_test.size
        
        #Commencer à apprendre
        error = 0
        error_prev = 0
        rand_index = np.arange(self.x_train.size)
        for t in tqdm.tqdm(range(1, epoch+1)):
            #Création de scène
            if self.make_anim:
                self.make_scene(t, epoch)
            
            #Calcul d'erreur
            x_in = self.x_test.reshape(n_test, n_in)
            for ll in self.__layer_list:
                x_in = ll.forward(x_in)
            error = lm[-1].get_error(self.y_test.reshape(n_test, n_out))
            if show_error:
                self.error_list.append(error)

            #Jugement de convergence
            if abs(error - error_prev) < threshold:
                print("end learning...")
                break
            else:
                error_prev = error

            np.random.shuffle(rand_index)
            for i in range(n_train):
                rand = rand_index[i*n_in : (i+n_batch)*n_in]

                x_in = self.x_train[rand].reshape(-1, n_in)
                for ll in self.__layer_list:
                    x_in = ll.forward(x_in)

                y_in = self.y_train[rand].reshape(-1, n_out)
                for ll in self.__layer_list[::-1]:
                    y_in = ll.backward(y_in)

                for ll in self.__layer_list:
                    ll.update()
        
        if show_error:
            #Affichage de transition d'erreur
            self.show_errors(**kwds)
    
    
    def show_errors(self, title="error transition",
                                  xlabel="epoch", ylabel="error", fname="error_transition.png ",
                                  **kwds):
        fig, ax = plt.subplots(1)
        fig.suptitle(title)
        ax.set_yscale("log")
        ax.set_xlabel(xlabel)
        ax.set_ylabel(ylabel)
        ax.grid()
        ax.plot(self.error_list)
        fig.show()
        if len(fname) != 0:
            fig.savefig(fname)
    
    
    def ready_anim(self, n_image, x, y, title="animation",
                                xlabel="x", ylabel="y", ex_color="r", color="b",
                                x_left=0, x_right=0, y_down = 1, y_up = 1):
        self.n_image = n_image
        self.x = x
        self.color = color
        self.make_anim = True
        
        self.anim_fig, self.anim_ax = plt.subplots(1)
        self.anim_fig.suptitle(title)
        self.anim_ax.set_xlabel(xlabel)
        self.anim_ax.set_ylabel(ylabel)
        self.anim_ax.set_xlim(np.min(x) - x_left, np.max(x) + x_right)
        self.anim_ax.set_ylim(np.min(y) - y_down, np.max(y) + y_up)
        self.anim_ax.grid()
        self.anim_ax.plot(x, y, color=ex_color)
        
        return self.anim_fig, self.anim_ax
    
    
    def make_scene(self, t, epoch):
        #Création de scène
        if t % (epoch/self.n_image) == 1:
            x_in = self.x.reshape(-1, 1)
            for ll in self.__layer_list:
                x_in = ll.forward(x_in)
            im, = self.anim_ax.plot(self.x, ll.y, color=self.color)
            self.images.append([im])