-
Edité par LucBertrand 25 octobre 2017 à 9:26:33

-
Edité par Christophe Lebrun 29 mai 2019 à 16:30:51

Idem ici... Je ne comprends pas la correction.

Des explications de la part des créateurs du cours seraient les bienvenues.

Bonjour

-
Edité par moustaphadieng 31 août 2019 à 1:25:57

Bonjour 

J'ai un soucis au niveau du TP de la partie "Classifiez vos données avec une SVM à noyau". En effet quand j’exécute le code permettant de visualiser la matrice de Gram avec "plt.pcolor" j'obtiens un graphique vide (voir Capture d'écran). Une idée ?!

Zachee54 a écrit:

Donne le code de création de kmatrix100.

Le code de création de kmatrix100 est le même que celui utilisé dans le cours:

from sklearn import metrics

kmatrix = metrics.pairwise.rbf_kernel(X_train_std, gamma=0.01)

kmatrix100 = kmatrix[:100, :100]

-
Edité par FreeSisyphe 29 octobre 2019 à 20:25:02

Oui, d'accord, mais on ne sait pas comment tu as défini X_train_std.

Le fond de ma question est de savoir si tu es sûr qu'il y a un contenu dans ta matrice, et lequel.

Zachee54 a écrit:

Oui, d'accord, mais on ne sait pas comment tu as défini X_train_std.

Le fond de ma question est de savoir si tu es sûr qu'il y a un contenu dans ta matrice, et lequel.

Oui sur d'avoir un contenu dans ma matrice, je n'ai fait qu'appliquer exactement à la lettre le code du cours et voici le contenu de ma matrice:

Trouvé : l'échelle du graphique est définie à partir des dimensions de X, alors que kmatrix100 est beaucoup plus petite. Du coup on ne voit rien.

Ecris les deux lignes suivantes à la place de celles du cours :

plt.xlim([0, kmatrix100.shape[0]])
plt.ylim([0, kmatrix100.shape[0]])

Zachee54 a écrit:

Trouvé : l'échelle du graphique est définie à partir des dimensions de X, alors que kmatrix100 est beaucoup plus petite. Du coup on ne voit rien.

Ecris les deux lignes suivantes à la place de celles du cours :

plt.xlim([0, kmatrix100.shape[0]])
plt.ylim([0, kmatrix100.shape[0]])

Christophe Lebrun du Puytison a écrit:

Bonjour,

Dans le quiz 1, je ne comprends pas pourquoi la figure 2 représente un modèle linéaire.

Que signifie : "La linéarité est entre les paramètres à estimer, pas entre les variables indépendantes observées." ?

Merci d'avance.

-
Edité par Christophe Lebrun du Puytison 29 mai 2019 à 16:30:51

Pour moi dans un modèle linéaire, on a les données (x) et les paramètres à estimer (w) qui interviennent uniquement au travers d'une combinaison linéaire (somme w_i * x_i ...). Apres, dans un pb de classification, tu peux avoir a décider de la classification via  f(cette combinaison linéaire) où f n'est pas linéaire (par exemple dans la régression logisitique ca se passe comme ca). Je ne comprends pas trop le terme de 'variables indépendantes observées', surtout le 'indépendantes', mais ca fait référence à la sortie du modèle (aux observations/prédictions donc). Ceci dit je ne suis pas sûr de bien voir quand même pourquoi le deuxième graphe correspond à  un pb non linéaire ... hehe

Sinon aussi pour la derniere question du quizz 2. On a ca : 

Les réseaux de neurones sont populaires car ils ont la particularité de 

La bonne réponse était la deuxième, mais j'ai bien l'impression que dans le commentaire on dit que la bonne solution est plutôt la première, non ? 

-
Edité par charox 1 novembre 2019 à 12:45:54

L'explication donnée à cette question "La linéarité est entre les paramètres à estimer, pas entre les variables indépendantes observées."est encore plus ambigu que la réponse !

J'ai du mal à comprendre la logique derrière cette réponse et encore moins l'explication fourni !!!

-
Edité par FreeSisyphe 1 novembre 2019 à 17:58:24

Comme déjà signalé par certains, il semble bien y avoir une erreur dans la correction de la question 7 du premier Quiz.

En effet, comme signalé dans le premier chapitre de la partie 1, dans un espace à 2 dimensions la fonction de décision d'un modèle linéaire est nécessairement une droite. En fait, la spécificité d'un modèle linéaire est d'être incapable de modéliser des objets courbes, on a donc du mal à voir comment un modèle linéaire pourrait modéliser la courbe rouge dans le graphique du milieu.

C'est d'autant plus étrange que la correction nous dit que le graphique de droite, comporte lui un modèle non linéaire. Or, d'un point de vu mathématique, les modèle du milieu et de droite sont fortement similaires. Pour celui du milieu c'est une parabole, et pour celui de droite une ellipse (bon c'est plus un patatoïde, mais une ellipse fonctionnerait tout aussi bien et serait plus facile à modéliser), ie. des coniques. Les coniques sont définies par des équations de degré 2 (fonction quadratique) et ne sont donc pas linéaires.

Bonjour,

dans le noyau gaussien le paramètre gamma est-il lié au paramètre sigma ? Comment ?

Merci

Jean-Baptiste

-
Edité par Zachee54 15 janvier 2021 à 14:03:39

Bonjour à tous,

je suis également assez perplexe de l'explication donnée. En effet, je ne comprends pas ce que "linéarité des paramètres à estimer" veut dire.

Petite spéculation : peut-être l'auteur du quizz voulait dire que les données peuvent être séparées par deux droites ??

Je voulais aussi rebondir sur cette question du quizz :

=> Cela ne me parait pas correct; j'ai justement pu créer un perceptron une-couche qui a appris cette fonction. (en utilisant une fonction d'activation en sigmoide - le seuil marche aussi et converge hyper vite)

Je mets le code ici :

import numpy as np
import matplotlib.pyplot as plt

ETA = 0.1
TEST_DATA_SIZE = 30000

# Construction des données d'entrainement pour un LOGICAL AND 
# Construire TEST_DATA_SIZE x 4 données d'entrainement
input  = []
output = []
for i in range(0,TEST_DATA_SIZE):
    input.insert(0, [[0, 0], [0, 1], [1, 0], [1, 1]])
    output.insert(0, [0, 0, 0, 1])

X = np.concatenate(input)
y = np.concatenate(output)    

# Valeurs initiales des poids
w_0 = np.random.randint(0,10)
w_1 = np.random.randint(0,10)
w_2 = np.random.randint(0,10)

# Fonction d'activation 1 : seuil
def seuil(x):
    return 1 if x > 0 else 0

# Fonction d'activation 1 : sigmoide
def sigmoid(x):
    return 1 / ( 1 + np.exp(-x) )

# x doit être le vecteur à p composantes
# on cacule ici le nouveau w_j (pour la jième composante)
def compute_new_w_j( j, old_w_j, x,  expected, predicted, eta ):
    """ Calculer la nouvelle valeur de w_j (poids/coefficient à appliquer à la composante j du vecteur x dans la combinaison linéaire)
    Paramètre : 
    j : le numéro de la composante (compris entre 0 et p=nb de composante d'un vecteur)
    old_w_j : ancienne valeur de w_j
    x : le vecteur x actuellement en cours d'itération
    expected : la valeur attendue pour ce vecteur x
    predicted : la valeur calculée par le perceptron pour cette itération = l'image de x par la fonction d'activation 
    eta : le pas de vitesse d'apprentissage
    """    
    if j == 0 :
        return old_w_j - eta * (  predicted - expected   )* 1
    else:
        return old_w_j - eta * ( predicted - expected  )* x[j - 1]

def activation_function(w0, w1, w2, x1, x2):
    """ Calculer la fonction d'activation pour le vecteur x = (x1,x2) ayant les poids/coefficients w0, w1 et w2
    """    
    linear_combi = w0 + w1 * x1 + w2 * x2
    return sigmoid(linear_combi)
    #return seuil(linear_combi)
    #return linear_combi (identité)

# Etat initial
print("--- initial  -----------")
print( "Valeur de w_0 : {}".format(w_0))
print( "Valeur de w_1 : {}".format(w_1))
print( "Valeur de w_2 : {}".format(w_2))
print('\n')

# Gardons un oeil sur les résultats des fonctions d'activation, pour voir si elles convergent
arr_0_0 = []
arr_0_1 = []
arr_1_0 = []
arr_1_1 = []

# Itérations
for i in range(0,X.shape[0]):

    # Calcul des nouveaux poids
    new_w_0 = compute_new_w_j( 0, w_0, X[i], y[i], activation_function( w_0, w_1 , w_2, X[i][0], X[i][1]), eta=ETA )
    new_w_1 = compute_new_w_j( 1, w_1, X[i], y[i], activation_function( w_0, w_1 , w_2, X[i][0], X[i][1]), eta=ETA )
    new_w_2 = compute_new_w_j( 2, w_2, X[i], y[i], activation_function( w_0, w_1 , w_2, X[i][0], X[i][1]), eta=ETA )

    # Mise à jour des poids
    w_0 = new_w_0
    w_1 = new_w_1
    w_2 = new_w_2

    # Stocker dans les tableaux arr_*_* les résultats actuels de la fonction d'activation
    arr_0_0.insert(len(arr_0_0), activation_function( w_0, w_1 , w_2, 0 , 0 ))
    arr_0_1.insert(len(arr_0_1), activation_function( w_0, w_1 , w_2, 0 , 1 ))
    arr_1_0.insert(len(arr_1_0), activation_function( w_0, w_1 , w_2, 1 , 0 ))
    arr_1_1.insert(len(arr_1_1), activation_function( w_0, w_1 , w_2, 1 , 1 ))    

# Etat final
print("--- final  -----------")
print( "Valeur de w_0 : {}".format(w_0))
print( "Valeur de w_1 : {}".format(w_1))
print( "Valeur de w_2 : {}".format(w_2))
print('\n')

print( "ET (0,0) vaut :",activation_function( w_0, w_1 , w_2, 0 , 0 ))
print( "ET (0,1) vaut :",activation_function( w_0, w_1 , w_2, 0 , 1 ))
print( "ET (1,0) vaut :",activation_function( w_0, w_1 , w_2, 1 , 0 ))
print( "ET (1,1) vaut :",activation_function( w_0, w_1 , w_2, 1 , 1 ))    

# Affichage de la convergence
plt.figure()
plt.plot( list(range(0,len(arr_0_0))), arr_0_0 ) 
plt.plot( list(range(0,len(arr_0_1))), arr_0_1 ) 
plt.plot( list(range(0,len(arr_1_0))), arr_1_0 ) 
plt.plot( list(range(0,len(arr_1_1))), arr_1_1 ) 
plt.legend(['0 ET 0', '0 ET 1', '1 ET 0', '1 ET 1' ])


fig = plt.figure()
ax = plt.axes()

ax.scatter(0,0,color='blue')
ax.scatter(0,1,color='blue')
ax.scatter(1,0,color='blue')
ax.scatter(1,1,color='red')


x = np.linspace(0,1)
y =( - w_1 * x - w_0 ) / w_2
ax.plot(x,y)

plt.show()

Et au passage, je pense qu'il y a une coquille dans la règle de mise à jour des poids :

Il faut échanger de place y(i) et f(x(i)) - car sinon vous vous éloignez du poids optimal pour expliquer x(i)...

Christophe

-
Edité par ChristopheNaciri 11 février 2022 à 13:21:50

Bonjour,

En effet certaines réponses du quizz peuvent interpeller.

- En essayant de donner du sens à la réponse pas très intuitive qui est donnée à la question 7, on pourrait se dire (à posteriori!) que:
si Y = a*X, Y est linéaire suivant la variable X et linéaire suivant le paramètre a
si Y = a*X², Y est non-linéaire suivant la variable X et linéaire suivant le paramètre a
si Y = a²*X, Y est linéaire suivant la variable X et non-linéaire suivant le paramètre a

Le 2e graphique montre une forme parabolique similaire à Y = a * X² donc linéaire suivant le(s) paramètre(s). Par exemple en posant Z=X² on obtient un modèle linéaire Y = a * Z

Le 3e graphique est du type Y² + X² = a (en simplifiant) et donc l'équation de la courbe de séparation est Y = +/-racine(a - X²) qui n'est pas linéaire en a.

- Pour la question sur la modélisation de "AND", apparemment il est possible de trouver des perceptrons qui modélisent la fonction. Contrairement à la fonction XOR on peut tracer une droite qui sépare les 2 classes, par exemple x1 + x2 -1.5 = 0
Si on considère un perceptron avec 2 unités en entrée et une unité en sortie avec les paramètres w1=1.0, w2=1.0 et b=-1.5 + une fonction d'activation de type seuil qui donne 1 si x>=0 et 0 si x<0:
1 + 1 -> 1.0*1 + 1.0*1 - 1.5 =  0.5 -> 1
1 + 0 -> 1.0*1 + 1.0*0 - 1.5 = -0.5 -> 0
0 + 1 -> 1.0*0 + 1.0*1 - 1.5 = -0.5 -> 0
0 + 0 -> 1.0*0 + 1.0*0 - 1.5 = -1.5 -> 0