Nous allons nous intéresser à l'algorithme du perceptron (Rosenblatt, 58) dont le pseudo-code est le suivant:
`input: Train, eta, m, MaxEp
init : w
epoque=0
err=1
while epoque<=MaxEp and err!=0
err=0
for i in 1:m
prendre le i-ième exemple (x,y) de Train
dp <- produit_scalaire(x,w)
if (dp <= 0)
w <- w + eta*y*x
err <- err+1
epoque <- epoque+1
output: w`
Le but étant de l'appliquer à quelques bases de la collection UCI (http://archive.ics.uci.edu/ml/index.php). En commençant par la base sonar qui constient 208 exemples en dimension 60 séparés par `,` et la dernière élément correspond à la classe de l'exemple.
Pour cela nous allons nous appuyer sur les fonctions suivantes:
* La fonction `ConstTrainTest` qui va télécharger la collection avec la fonction read_table de la librairie pandas (https://pandas.pydata.org/pandas-docs/stable/generated/pandas.read_table.html), et crée une liste de listes qui contient chacune le vecteur représentatif d'un exemple en ajoutant sa classe en fin de la liste. En sortie, cette fonction retourne deux bases d'apprentissage et de test avec des proportions données:
* La fonction `dotproduct` qui calcule le produit scalaire entre un exemple $\mathbf{x}=(x_1,\ldots,x_d)$ et le vecteur poids $\mathbf{w}=(w_0,w_1,\ldots,w_d)$: $\langle \mathbf{w},\mathbf{x} \rangle=w_0+\sum_{j=1}^d w_j x_j$
%% Cell type:code id: tags:
``` python
defdotproduct(x,w):
res=w[0]
foriinrange(len(x)-1):
res+=w[i+1]*x[i]
returnres
```
%% Cell type:markdown id: tags:
1. Appelez la fonction la fonction `ConstTrainTest` pour créer les bases d'apprentissage (Train) et de test (Test) avec une proportion 75% et 25%.
%% Cell type:code id: tags:
``` python
```
%%Celltype:markdownid:tags:
*L'algorithtme du perceptron prend en entrée la base Train, le nombre maximum d'époquesetunpasd'apprentissage eta et donne en sortie le vecteur poids et l'erreurcommiseàladernièreépoque:
%%Celltype:codeid:tags:
``` python
def perceptron(Train,MaxEpoch,eta):
W=[0.0 for i in range(len(Train[0]))]
epoch=0
err=1
d=len(Train[0])-1
E=[]
while (epoch<MaxEpoch and err!=0):
err=0
for x in Train:
dp=dotproduct(x,W)
if(x[d]*dp<=0):
err+=1
W[0]+=eta*x[d]
for i in range(d):
W[i+1]+=eta*x[d]*x[i]
E.append(err)
epoch+=1
return W,E
return W,err
```
%% Cell type:markdown id: tags:
2. Tournez l'algorithme sur la base Train avec 1000 époques et un pas de eta=0.1
%% Cell type:code id: tags:
``` python
```
%% Cell type:markdown id: tags:
3. Modifiez le code pour avoir la liste des erreurs commises à chaque époque. On appelera cette liste E. Le but étant d'afficher les erreurs en s'aidant de la fonction suivante:
%% Cell type:code id: tags:
``` python
import matplotlib.pyplot as plt
def plotting(X,Y,strtitle,strxlabel,strylabel):
plt.plot(X, Y)
plt.yscale('linear')
plt.title(strtitle)
plt.xlabel(strxlabel)
plt.ylabel(strylabel)
plt.grid(True)
```
%% Cell type:code id: tags:
``` python
```
%% Cell type:markdown id: tags:
4. Téléchargez les bases https://archive.ics.uci.edu/ml/datasets/spambase, https://archive.ics.uci.edu/ml/datasets/heart+Disease, https://archive.ics.uci.edu/ml/datasets/Breast+Cancer+Wisconsin+%28Original%29, https://archive.ics.uci.edu/ml/datasets/Ionosphere et reportez dans le tableau ci-dessous les erreurs du modèles sur les bases tests (on gardera les mêmes paramètres qu'avant)
