algorithme du perceptron

#Génération artificielle de deux classes linéairement séparables sur nuage de points aléatoire

N=50; #Nb de points au total;
p=2; #dimension de l'espace, ici 2D pour visualisation

x=matrix(runif(N*p,-2,2),N,2); #matrice échantillon, position des points
u=rep(0,N); #matrice des classes

#création d'un échantillon de taille N, 2 classes, linéairement séparable
droite=matrix(c(2,1),p,1); #droite de séparabilité
c=0
indicpos=NULL;
indicneg=NULL;
for(i in 1:N)
{
aux=x[i,]%*%droite;
valxi=aux[1,1];
u[i]=ifelse((valxi+c)>0,1,-1);
if((valxi+c)>0)
{indicpos=c(indicpos,i);}
else
{indicneg=c(indicneg,i);}
};


####################################################
####################################################
#Methodologie : perceptron

####################################################
#initialisation des points du perceptron
w=matrix(runif(2,-1,1),2,1); #matrice de poids
w0=w; #sauvegarde des conditions initiales (poids)
tmax=20; #nb d'iterations de l'algorithme d'apprentissage:tmax*N
alpha=0.1; #gain d'apprentissage
tracew=matrix(rep(0,N*tmax*p),N*tmax,p); #tracabilite de l'evolution des poids


####################################################
for(t in 1:(tmax*N))
{
k=1+trunc(N*runif(1)); #indice entre 1 et N
xk=x[k,];
aux=xk%*%w;
val=aux[1,1];
yk=ifelse(val>0,1,-1);
uk=u[k];
if(!(yk==uk))
{ s=ifelse(uk==1,1,-1);
deltaw=alpha*s*xk;
w=w+deltaw;
};
tracew[t,]=w;
};


####################################################
#visualisation/conditions initiales
plot(x[,1],x[,2], pch=19, col='cyan');
points(x[indicneg,1],x[indicneg,2], pch=19, col='blue');
a0=-w0[1,1]/w0[2,1];
b0=0;
abline(b0,a0, col='red');


####################################################
#visualisation/ apres convergence (5pas puis 10 puis 15 pas)
aw=-tracew[5,1]/tracew[5,2]; bw=0;
abline(bw,aw, col='blue', 'lty'=2);

aw=-tracew[10,1]/tracew[10,2]; bw=0;
abline(bw,aw,col='purple', 'lty'=4);

aw=-tracew[15,1]/tracew[15,2]; bw=0;
abline(bw,aw,col='yellow', 'lty'=4);
####################################################
#visualisation/ apres convergence
aw=-w[1,1]/w[2,1]; bw=0;
abline(bw,aw, col='green', 'lwd'=2);



##############################################################################

Perceptron - 2e partie

#Génération artificielle de deux classes linéairement séparables sur nuage de points aléatoire

N=50; #Nb de points au total;
p=2; #dimension de l'espace, ici 2D pour visualisation

x=matrix(runif(N*p,-2,2),N,2); #matrice échantillon, position des points
u=rep(0,N); #matrice des classes

#création d'un échantillon de taille N, 2 classes, linéairement séparable
droite=matrix(c(2,1),p,1); #droite de séparabilité
c=0
indicpos=NULL;
indicneg=NULL;
for(i in 1:N)
{
aux=x[i,]%*%droite;
valxi=aux[1,1];
u[i]=ifelse((valxi+c)>0,1,-1);
if((valxi+c)>0)
{indicpos=c(indicpos,i);}
else
{indicneg=c(indicneg,i);}
};

###############################################################################
###############################################################################
#Methodologie : perceptron

###############################################################################
#initialisation des points du perceptron
w=matrix(runif(2,-1,1),2,1); #matrice de points
w0=w; #sauvegarde des conditions initiales (poids)
tmax=20; #nb d'iterations de l'algorithme d'apprentissage:tmax*N
alpha=0.1; #gain d'apprentissage
tracew=matrix(rep(0,N*tmax*p),N*tmax,p); #tracabilite de l'evolution des poids

####################################################
for(t in 1:(tmax*N))
{
k=1+trunc(N*runif(1)); #indice entre 1 et N
xk=x[k,];
aux=xk%*%w;
val=aux[1,1];
yk=ifelse(val>0,1,-1);
uk=u[k];
if(!(yk==uk))
{ s=ifelse(uk==1,1,-1);
deltaw=alpha*s*xk;
w=w+deltaw;
};
tracew[t,]=w;
};

####################################################
#visualisation/conditions initiales
plot(x[,1],x[,2], pch=19, col='cyan');
points(x[indicneg,1],x[indicneg,2], pch=19, col='blue');
a0=-w0[1,1]/w0[2,1];
b0=0;
abline(b0,a0, col='red');

####################################################
#visualisation/ apres convergence (5pas)
aw=-tracew[5,1]/tracew[5,2]; bw=0;
abline(bw,aw, col='blue', 'Ity'=2);

aw=-tracew[10,1]/tracew[10,2]; bw=0;
abline(bw,aw,col='blue', 'Ity'=4);

####################################################
#visualisation/ apres convergence
aw=-w[1,1]/w[2,1]; bw=0;
abline(bw,aw, col='green', 'lwd'=2);



x11()

plot(1:1000,tracew[,1], pch=20)
lines(1:1000,tracew[,1], pch=20)

####################################################
for(t in 1:tmax)
{
for(k in 1:N)
{
xk=x[k,];
aux=xk%*%w;
val=aux[1,1];
yk=ifelse(val>0,1,-1);
uk=u[k];
if(!(yk==uk))
{ s=ifelse(uk==1,1,-1);
deltaw=alpha*s*xk;
w=w+deltaw;
};
tracew[t,]=w;
};
};

####################################################
#visualisation/conditions initiales
plot(x[,1],x[,2], pch=19, col='cyan');
points(x[indicneg,1],x[indicneg,2], pch=19, col='blue');
a0=-w0[1,1]/w0[2,1];
b0=0;
abline(b0,a0, col='red');

####################################################
#visualisation/ apres convergence (5pas)
aw=-tracew[5,1]/tracew[5,2]; bw=0;
abline(bw,aw, col='blue', 'lty'=2);

aw=-tracew[10,1]/tracew[10,2]; bw=0;
abline(bw,aw,col='blue', 'lty'=4);

####################################################
#visualisation/ apres convergence
aw=-w[1,1]/w[2,1]; bw=0;
abline(bw,aw, col='green', 'lwd'=2);



x11()

plot(1:1000,tracew[,1], pch=20)
lines(1:1000,tracew[,1], pch=20)

???????

rm(list=ls());

#Génération artificielle de deux classes linéairement séparables sur nuage de points aléatoire

N=50; #Nb de points au total;
p=2; #dimension de l'espace, ici 2D pour visualisation

x=matrix(runif(N*p,-2,2),N,2); #matrice échantillon, position des points
u=rep(0,N); #matrice des classes

#création d'un échantillon de taille N, 2 classes, linéairement séparable
droite=matrix(c(2,1),p,1); #droite de séparabilité
c=0
indicpos=NULL;
indicneg=NULL;
for(i in 1:N)
{
aux=x[i,]%*%droite;
valxi=aux[1,1];
u[i]=ifelse((valxi+c)>0,1,-1);
if((valxi+c)>0)
{indicpos=c(indicpos,i);}
else
{indicneg=c(indicneg,i);}
};

###############################################################################
###############################################################################
#Methodologie : perceptron

###############################################################################
#initialisation des points du perceptron
w=matrix(runif(2,-1,1),2,1); #matrice de points
w0=w; #sauvegarde des conditions initiales (poids)
tmax=20; #nb d'iterations de l'algorithme d'apprentissage:tmax*N
alpha=0.1; #gain d'apprentissage
tracew=matrix(rep(0,N*tmax*p),N*tmax,p); #tracabilite de l'evolution des poids
dessin=matrix(rep(0,tmax*p),tmax,p);

####################################################
for(t in 1:(tmax*N))
{
k=1+trunc(N*runif(1)); #indice entre 1 et N
xk=x[k,];
aux=xk%*%w;
val=aux[1,1];
yk=ifelse(val>0,1,-1);
uk=u[k];
if(!(yk==uk))
{ s=ifelse(uk==1,1,-1);
deltaw=alpha*s*xk;
w=w+deltaw;
};
tracew[t,]=w;
};


####################################################
RempG=0
for(t in 1:tmax)
{
for (k in 1:N) #indice entre 1 et N
{
xk=x[k,];
aux=xk%*%w;
val=aux[1,1];
yk=ifelse(val>0,1,-1);
uk=u[k];
Rempk=-aux%*%uk
if(!(yk==uk))
{ s=ifelse(uk==1,1,-1);
deltaw=alpha*s*xk;
w=w+deltaw;
RempG=RempG+Rempk
};
dessin[t,]=RempG;
};
};

####################################################
#visualisation/conditions initiales
plot(x[,1],x[,2], pch=19, col='cyan');
points(x[indicneg,1],x[indicneg,2], pch=19, col='blue');
a0=-w0[1,1]/w0[2,1];
b0=0;
abline(b0,a0, col='red');

####################################################
#visualisation/ apres convergence (5pas)
aw=-tracew[5,1]/tracew[5,2]; bw=0;
abline(bw,aw, col='blue', 'lty'=2);

aw=-tracew[10,1]/tracew[10,2]; bw=0;
abline(bw,aw,col='blue', 'lty'=4);

####################################################
#visualisation/ apres convergence
aw=-w[1,1]/w[2,1]; bw=0;
abline(bw,aw, col='green', 'lwd'=2);



x11()

plot(1:1000,tracew[,1], pch=20)
lines(1:1000,tracew[,1], pch=20)


x11()

plot(1:20,dessin[,1], pch=20)
lines(1:20,dessin[,1], pch=20)