EXERCICE

#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 10pas)
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);



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

#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
Remp=rep(0,tmax)

####################################################
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;
      Remp[t]=Remp[t]-val*uk
    };
  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 10pas)
#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);

#x11()
plot(Remp)
lines(Remp, col='red')



Remp





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

#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.001;                  #gain d'apprentissage
tracew=matrix(rep(0,N*tmax*p),N*tmax,p); #tracabilite de l'evolution des poids
Remp=rep(0,tmax*N)

####################################################
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;
    Remp[t]=Remp[t]-val*uk
  };
 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 10pas)
#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);

#x11()
plot(Remp)
lines(Remp, col='red')

rm(list=ls());

N=50;
p=2;
x=matrix(runif(N*p,-2,2),N,2);
u=rep(0,N);
droite=matrix(c(2,1),p,1);
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,0);
    if((valxi+c)>0)
      {indicpos=c(indicpos,i);}
    else
      {indicneg=c(indicneg,i);}
  };

w=matrix(runif(2,-1,1),2,1);
w0=w;
tmax=20;
alpha=0.1;
tracew=matrix(rep(0,N*tmax*p),N*tmax,p);
Eq=matrix(rep(NA,tmax),tmax,1);




y=c(rep(0,50));
for(i in 1:50)
{y[i]=ifelse((x[i,]%*%w)[1,1]>0,1,0)};

res=c(rep(0,50));
for(j in 1:50)
{res[j]=((u[j]-y[j])^2)/2}


#1ere iteration de t
Eqk=0;
for (k in 1:N)
 {
  xk=x[k,];
  aux=xk%*%w;
  val=aux[1,1];
  yk=ifelse(val>0,1,0);
  uk=u[k];
  if(!(yk==uk))
    {deltaw=alpha*(uk-yk)*xk;
      w=w+deltaw;
    };
  Eqk=Eqk+((uk-yk)^2)/2
 };
 Eq[1]=Eqk



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



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');

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



x11()
plot(Eq);
lines(Eq,col=2);



;