Voici une représentation Python d'un neurone de réseau neuronal que j'essaie de comprendre

class Network(object):

    def __init__(self, sizes):
        self.num_layers = len(sizes)
        self.sizes = sizes
        self.biases = [np.random.randn(y, 1) for y in sizes[1:]]
        self.weights = [np.random.randn(y, x) 
                        for x, y in zip(sizes[:-1], sizes[1:])]

Voici ma compréhension actuelle:

  • self.num_layers = len(sizes): Renvoyez le nombre d'articles dans les tailles
  • self.sizes = sizes: attribuer des tailles d'auto-instance aux tailles de paramètres de fonction
  • self.biases = sizes: générer un tableau d'éléments à partir de la distribution normale standard (indiquée par np.random.randn(y, 1))

Qu'est-ce que l'informatique en ligne suivante?

self.weights = [np.random.randn(y, x)
    for x, y in zip(sizes[:-1], sizes[1:])]

Je suis nouveau sur Python. Ce code peut-il être utilisé dans un shell Python afin que je puisse mieux comprendre en appelant chaque ligne séparément?

8
blue-sky 5 mars 2016 à 01:24

4 réponses

Meilleure réponse

La zip() fonction associe des éléments de chaque itérable; zip('foo', 'bar') par exemple, produirait [('f', 'b'), ('o', 'a'), ('o', 'r')]; chaque élément des deux chaînes a été couplé en trois nouveaux tuples.

zip(sizes[:-1], sizes[1:]) crée ensuite des paires d'éléments dans la séquence sizes avec l'élément suivant , car vous associez tous les éléments à l'exception du dernier (sizes[:-1]) avec tous les éléments sauf le premier (sizes[1:]). Ceci associe le premier et le deuxième élément ensemble, puis le deuxième et le troisième, etc. jusqu'aux deux derniers éléments.

Pour chaque paire de ce type, un échantillon aléatoire est produit, en utilisant une compréhension de liste . Ainsi, pour chaque paire x, y, une nouvelle matrice numpy bidimensionnelle est produite avec des valeurs aléatoires réparties sur y lignes et x colonnes.

Notez que la valeur biases utilise uniquement sizes[1:], toutes sauf la première, pour produire des matrices y - par 1 pour chacune de ces tailles.

Démonstration rapide de ces concepts:

>>> zip('foo', 'bar')
[('f', 'b'), ('o', 'a'), ('o', 'r')]
>>> zip('foo', 'bar', 'baz')  # you can add more sequences
[('f', 'b', 'b'), ('o', 'a', 'a'), ('o', 'r', 'z')]
>>> sizes = [5, 12, 18, 23, 42]
>>> zip(sizes[:-1], sizes[1:])  # a sliding window of pairs
[(5, 12), (12, 18), (18, 23), (23, 42)]
# 0, 1 ..  1,  2 ..  2,  3 ..  3,  4   element indices into sizes
>>> 
7
Martijn Pieters 4 mars 2016 à 22:35

C'est ce qu'on appelle la compréhension de liste. Vous pouvez créer le même effet si vous utilisez une boucle for normale:

self.weights = []
for x, y in zip(sizes[:-1], sizes[1:]):
    self.weights.append(np.random.randn(y, x))

Maintenant, avec cette boucle, vous pouvez voir que self.weights n'est vraiment qu'un groupe de np.random.randn(y, x)y et x sont définis pour chaque x et { {X5}} dans zip(sizes[:-1], sizes[1:]). Vous pouvez simplement vous le dire en lisant la liste de compréhension: self.weights = [np.random.randn(y, x)) for x, y in zip(sizes[:-1], sizes[1:])]. L'ordre des mots a finalement un sens. Si vous ne le saviez pas, zip est une fonction qui renvoie un liste de tuples de chaque élément correspondant dans ses arguments. Par exemple, zip([1, 2, 3, 4], [4, 3, 2, 1]) retournerait [(1, 4), (2, 3), (3, 2), (4, 1)]. (En Python3, en fait c'est un générateur de tuples)

1
zondo 4 mars 2016 à 22:32

Cela crée en fait deux variables aléatoires x et y. une pour les connexions de la 1ère couche à la 2ème couche de neurones. et d'autres pour la 2e couche de neurones à la couche de sortie de neurones. tailles (-1) signifie toutes les connexions dans le vecteur, sauf la dernière, qui correspond à la pondération de la 1ère couche aux couches cachées. et tailles (1) est toutes les connexions sauf le 1er élément du vecteur. Il s'agit des poids des connexions de caché à la couche de sortie.

Remarque: Les connexions ou tuples sont formées avec la fonction ZIP.

0
aditya sai 26 juil. 2016 à 11:47

self.weights = [np.random.randn(y, x) for x, y in zip(sizes[:-1], sizes[1:])] appellera la fonction randn avec les paramètres x, y qui sont les résultats de l'opération zip(sizes[:-1], sizes[1:])

Si nous considérons une liste l=[1, 2, 3, 4] l[:-1] renverra [1, 2, 3] et l[1] donnera [2, 3, 4] L'opération zip sur l[:-1], l[1] fera les paires [(1, 2), (2, 3), (3, 4)]. Ensuite, les paires seront transmises à la fonction randn

Bien sûr, vous pouvez toujours taper du code dans un shell python, cela vous donnera une meilleure compréhension;)

1
Alexis Clarembeau 4 mars 2016 à 22:30