[PYTHON] Spécialisation en apprentissage profond (Coursera) Dossier d'auto-apprentissage (C1W2)

introduction

Voici le contenu du cours 1, semaine 2 (C1W2) de Spécialisation en apprentissage profond.

(C1W2L01) Binary Classification

Contenu

• Explication de la classification binaire dans le cas de juger "s'il s'agit ou non d'un chat" à partir de données d'image --Explication de la notation (signification du symbole)
• $ X ; 1 fonction de données ( n_x ) dans le sens de la ligne, exemple d'apprentissage ( m $ pièces) dans le sens de la colonne ($ X \ in \ mathbb {R} ^ {n_x \ times m} $)
• Y ; Y \in \mathbb{R}^{1\times m}

Impressions

• La signification des lignes et des colonnes de $ X $ a changé par rapport au cas de la conférence Machine Learning.

(C1W2L02) Logistic Regression

Contenu

--Valeur prédite $ \ hat {y} = P (y = 1 | x) $ (probabilité de $ y = 1 $) --Définissez le paramètre $ w \ in \ mathbb {R} ^ {n_x} $, $ b \ in \ mathbb {R} $

• $ \ hat {y} = \ sigma (w ^ T x + b) $; fonction sigmoïde
• \sigma(z) = \frac{1}{1+e^{-z}}

Impressions

――Le symbole est différent ici ainsi que dans le Machine Learning. N'utilisez pas $ x_0 ^ {(i)} = 1 $. N'incluez pas le terme constant $ b $ dans $ w $.

(C1W2L03) Logistic Regression Cost Function

Contenu

• cost function ; J(w, b) = -\frac{1}{m} \Sigma^m_{i=1}\[y^{(i)}\log\hat{y}^{(i)} + \(1-y^{(i)}\)\log\(1-\hat{y}^{(i)}\) \]

(C1W2L04) Gradient Descent

Contenu

• Explication intuitive de la descente de gradient
• $ \ frac {\ partial J (w, b)} {\ partial w} $ est souvent écrit comme dw dans les programmes
• $ \ frac {\ partial J (w, b)} {\ partial b} $ est souvent écrit comme db dans les programmes

(C1W2L05) Derivatives

Contenu

• Une brève explication de la différenciation

Impressions

―― Comme il s'agit d'un contenu de base, vous pouvez regarder la vidéo à 1,75 fois.

(C1W2L06) More Derivatives Example

Contenu

• Une brève explication de la différenciation

Impressions

―― Comme il s'agit d'un contenu de base, vous pouvez regarder la vidéo à 1,75 fois.

(C1W2L07) Computation Graph

Contenu

-Lorsque $ J (a, b, c) = 3 \ (a + bc ) $, décomposer en $ u = bc $, $ v = a + u $, $ J = 3v $ Illustrer comment calculer

(C1W2L08) Derivatives With Computation Graph

Contenu

--Explication de la différenciation ($ \ frac {dJ} {da} = \ frac {dJ} {dv} \ frac {dv} {da} $) en utilisant le graphe de calcul

(C1W2L09) Logistic Regression Gradient Descent

Contenu

--Explication de la différenciation de la perte $ L \ (a, y ) $ de régression logistique

(C1W2L10) Gradient Descent on m Example

Contenu

--Explication de la façon de différencier la fonction de coût $ J \ (w, b ) $ et de l'appliquer à la méthode de descente la plus raide lorsque le nombre d'échantillons est $ m $

• Comme expliqué dans la boucle for, la vectorisation est importante car la boucle for est inefficace.

(C1W2L11) Vectorization

Contenu

-Explication du concept de vectorisation en utilisant $ w ^ T x $ de $ z = w ^ T x + b $ comme exemple

• Démontrez le temps de calcul de la boucle for et du calcul vectoriel (z = np.dot (w, x) + b) sur le notebook Jupyter. 300 fois différent
• SIMD ; Single Instruction Multiple Data --Python Numpy parallélise les calculs

J'ai également comparé le temps avec la boucle for et le calcul vectoriel.

vectorization.py

import numpy as np
import time

a = np.random.rand(1000000)
b = np.random.rand(1000000)

tic = time.time()
c = np.dot(a, b)
toc = time.time()

print(c)
print("Vectorization version:" + str(1000*(toc-tic)) + "ms")

c = 0
tic = time.time()
for i in range(1000000):
    c += a[i]*b[i]
toc = time.time()

print(c)
print("for loop:" + str(1000*(toc-tic)) + "ms")

Le résultat. Il y avait une différence de moins de 700 fois, 12 ms pour la vectorisation et 821 ms pour la boucle for.

249840.57440415953
Vectorization version:12.021541595458984ms
249840.57440415237
for loop:821.0625648498535ms

(C1W2L12) More Vectorization Examples

Contenu

• Guide de programmation de réseau neural; ** Dans la mesure du possible, évitez la boucle for explicite / Évitez la boucle for autant que possible **

example.py

import numpy as np

u = np.dot(A, v) #Produit de matrice et de vecteur

u = np.exp(v) #Laisser exp agir sur chaque élément
u = np.log(v) #Faire en sorte que le journal fonctionne élément par élément
u = np.abs(v) #Abs pour chaque élément(Valeur absolue)Agir
u = np.maximum(v, 0) #Les éléments inférieurs à 0 doivent être 0
u = v ** 2 #Carré pour chaque élément
u = 1/v #Inverse pour chaque élément

(C1W2L13) Vectorizing Logistics Regression

Contenu

• Vectoriser le calcul de régression logistique

X = \left[x^{(1)} \ x^{(2)} \cdots \ x^{(m)}\right] \ (X \in \mathbb{R}^{n_x \times m}) \\
Z = \left[z^{(1)} \ z^{(2)} \cdots \ z^{(m)}\right] \ (Z \in \mathbb{R}^m ) \\
A = \left[a^{(1)} \ a^{(2)} \cdots \ a^{(m)}\right] \ (A \in \mathbb{R}^m ) \\
Z = w^T X + \left[b \ b \ \cdots b \right] \\
A = \mathrm{sigmoid}\left( Z \right) \ (\mathrm{sigmoid} \Mettre en œuvre la fonction correctement)

--En Python, `Z = np.dot (w.T, X) + b ''` ( `` b``` est automatiquement converti en un vecteur colonne de [1, m])

(C1W2L14) Vectorizing Logistics Regression's Gradient Computation

Contenu

--Explication de la vectorisation du calcul différentiel de la régression logistique

db = \frac{1}{m} \cdot \mathrm{np.sum}(Z) \\
dw = \frac{1}{m} \cdot X\ dZ^T

Impressions

• Un mélange d'expressions mathématiques ordinaires et de code Python. Vous pouvez le comprendre en écoutant la classe, mais cela peut être difficile à comprendre si vous y repensez plus tard.

(C1W2L15) Broadcasting in Python

Contenu

--Explication de la diffusion Python -Lorsque la matrice (m, n) et la matrice (1, n) sont ajoutées, la matrice (1, n) devient automatiquement la matrice (m, n). -Lorsque la matrice (m, n) et la matrice (m, 1) sont ajoutées, la matrice (m, 1) devient automatiquement la matrice (m, n).

• Voir la documentation de diffusion NumPy pour plus de détails
• La fonction bsxfun de Matlab / Octave est un peu différente (?)

example.py

>>> import numpy as np
>>> a = np.array([[1, 2, 3, 4], [5, 6, 7, 8]])
>>> b = np.array([100, 200, 300, 400])
>>> a + b
array([[101, 202, 303, 404],
       [105, 206, 307, 408]])

(C1W2L16) A Note on Python/numpy vectors

Contenu

• La flexibilité de Python / NumPy est à la fois un avantage et un inconvénient
• Même si vous ajoutez le vecteur de ligne et le vecteur de colonne, aucune erreur ne se produira et un résultat de calcul sera obtenu, il est donc difficile de trouver l'erreur.
• ** N'utilisez pas de tableaux de taille (n,) (n'utilisez pas de tableaux de rang 1) **

example.py

>>> import numpy as np
>>> a = np.random.rand(5) #Tableau de rang 1
>>> print(a)
[0.4721318  0.73582028 0.78261299 0.25030022 0.69326545]
>>> print(a.T)
[0.4721318  0.73582028 0.78261299 0.25030022 0.69326545] #L'affichage ne change pas même si vous changez de place
>>> print(np.dot(a, a.T)) #Je calcule le produit intérieur, mais je ne sais pas s'il faut calculer le produit intérieur ou le produit extérieur.
1.9200902050946715
>>>
>>> a = np.random.rand(5, 1) # (5, 1)Matrice
>>> print(a) #Vecteur de ligne
[[0.78323543]
 [0.18639053]
 [0.45103025]
 [0.48060903]
 [0.93265189]]
>>> print(a.T)
[[0.78323543 0.18639053 0.45103025 0.48060903 0.93265189]] #Vecteur de colonne après l'atterrissage
>>> print(np.dot(a, a.T)) #Calculez correctement le produit du vecteur de ligne et du vecteur de colonne
[[0.61345774 0.14598767 0.35326287 0.37643002 0.73048601]
 [0.14598767 0.03474143 0.08406777 0.08958097 0.17383748]
 [0.35326287 0.08406777 0.20342829 0.21676921 0.42065422]
 [0.37643002 0.08958097 0.21676921 0.23098504 0.44824092]
 [0.73048601 0.17383748 0.42065422 0.44824092 0.86983955]]

--Si vous ne connaissez pas la dimension, entrez assert (a.shape == (5, 1)) etc. --Un tableau de rang 1 est explicitement remodelé comme ```a = a.reshape ((5,1)) `` `

Impressions

«C'est important ici car j'ai souvent perdu la trace de la taille de la matrice lorsque j'ai suivi le Machine Learning.

(C1W2L17) Quick tour of Jupyter/ipython notebooks

Contenu

• Explication de l'utilisation du notebook Jupyter / ipython lors de la prise de cours à Coursera

(C1W2L18) Explanation of Logistics Regression Cost Function (Optional)

Contenu

• (Re) description de la fonction coût de la régression logistique
• \hat{y} = \sigma(w^T x + b) {y}when \sigma(z) = \frac{1}{1 + e^{-z}}
• \hat{y} = P(y=1 | x) ; y=1Probabilité, doncy=1Sip(y|x) = \hat{y}，y=0Sip(y|x) = 1 - \hat{y}
• Pour résumer cela, vous pouvez également écrire $ p (y | x) = \ hat {y} ^ y (1- \ hat {y}) ^ {(1-y)} $
• Puisque la fonction logarithmique est également une fonction croissante, il en est de même pour maximiser le logarithme de la formule ci-dessus.
• \log p(y|x) = y\log\hat{y} + (1-y)\log(1-\hat{y}) = -L(\hat{y}, y)
• Compte tenu des probabilités dans plusieurs ensembles d'apprentissage, $ \ Pi ^ {m} _ {i = 1} p (y ^ {(i)} | x ^ {(i)}) $
• Compte tenu du logarithme de ceci, $ \ Sigma ^ {m} _ {i = 1} \ log p (y ^ {(i)} | x ^ {(i)}) = - \ Sigma L (\ hat { y} ^ {(i)}, y ^ {(i)}) $. Cela sera maximisé. La fonction --cost est $ \ frac {1} {m} $ et minimisée, donc prenez un signe négatif et $ J (w, b) = \ frac {1} {m} \ Sigma ^ {m} _ {i = 1} L (\ hat {y} ^ {(i)}, y ^ {(i)}) $

Impressions

• Honnêtement, je ne comprends pas grand-chose: -p
• $ L (\ hat {y}, y) = --y \ log \ hat {y} - (1-y) \ log (1- \ hat {y}) Il est plus intuitif pour moi de parler de $ C'était facile à comprendre

référence

• Fiche d'auto-apprentissage de la spécialisation en apprentissage profond (Coursera) (table des matières)