eval_svm.c

linux下的源码分类器SVM

        {
        y_j = y_app[j];
	partiel = 0.0;

        if(y_j == y_i)
          for(l=1; l<=Q; l++)
            partiel += alpha[j][l];

        if(y_j == k)
          for(l=1; l<=Q; l++)
	    partiel -= alpha[j][l];

        partiel += alpha[j][k] - alpha[j][y_i];
          
	if(partiel != 0.0)
          H_alpha[i][k] += partiel * 
	ker(nature_kernel, X_app[i], X_app[j], dim_input);
        }
      }
    }
  }

for(i=1; i<=nb_data_app; i++)
  {
  y_i = y_app[i];
  for(k=1; k<=Q; k++)
    if(k != y_i)
      gradient[i][k] = H_alpha[i][k] - 1.0;
    else
      gradient[i][k] = 0.0;
  }

printf("\n\nEnd of the gradient computation...\n");

}

void check_sup_vect()

{

sup_vect = matrix(nb_data_app, Q);
nb_sup_vect = matrix(Q, Q);

for(i=1; i<=nb_data_app; i++)
  for(k=1; k<=Q; k++)
    sup_vect[i][k] = 0.0;

for(k=1; k<=Q; k++)
  for(l=1; l<=Q; l++)
    nb_sup_vect[k][l] = 0.0;

for(i=1; i<=nb_data_app; i++)
  for(k=1; k<=Q; k++)
    if(alpha[i][k] > negligeable)
      {
      sup_vect[i][k] = 1.0;
      nb_sup_vect[y_app[i]][k]++;
      }

printf("\nDistribution matrix of the support vectors\n");
display_mat(nb_sup_vect, Q, Q, 6, 0);

}

void check_margin_vect()

{

long over=false;
double average;

margin_vect = matrix(nb_data_app, Q);
nb_margin_vect = matrix(Q, Q);
radius = matrix(Q, Q);

for(i=1; i<=nb_data_app; i++)
  for(k=1; k<=Q; k++)
    margin_vect[i][k] = 0.0;

average = C / 2.0;

for(k=1; k<=Q; k++)
  for(l=1; l<=Q; l++)
    radius[k][l] = C / 10000.0;

while(over == false)
  {

  for(k=1; k<=Q; k++)
    for(l=1; l<=Q; l++)
      nb_margin_vect[k][l] = 0.0;

  for(i=1; i<=nb_data_app; i++)
    {
    y_i = y_app[i];
    for(k=1; k<=Q; k++)
      if(fabs(alpha[i][k] - average) <= radius[y_i][k])
        {
        margin_vect[i][k] = 1.0;
	nb_margin_vect[y_i][k]++;
        }
    }

  over = true;

  for(k=1; k<=Q-1; k++)
    for(l=k+1; l<=Q; l++)
      if((nb_margin_vect[k][l] == 0.0) && (nb_margin_vect[l][k] == 0.0))
        {
        over = false;
	if((average - radius[k][l]) > (average / 5000.0))
          radius[k][l] += average / 10000.0;
	else
          radius[k][l] = (radius[k][l] + average) / 2.0;
	radius[l][k] = radius[k][l];
	}

  }

if((fc=fopen(fichier_SV, "w"))==NULL)
  {
  printf("\nFile of support vectors: %s cannot be open...\n", fichier_SV);
  exit(0);
  }

for(i=1; i<=nb_data_app; i++)
  for(k=1; k<=Q; k++)
    if(margin_vect[i][k] == 1.0)
      fprintf(fc, "Example %5d, SV between %d and %d\n",
      i, y_app[i], k);

fclose(fc);

/*
printf("\nDistribution matrix of the points belonging to a margin\n");
display_mat(nb_margin_vect, Q, Q, 6, 0);
*/

}

double fonction(long categorie, double *vecteur)

{

long indice1, indice2;

double resultat = 0.0;

for(indice1=1; indice1<=nb_data_app; indice1++)
  {
  if(y_app[indice1] == categorie)
    {
    partiel = 0.0;
    for(indice2=1; indice2<=Q; indice2++)
      partiel += alpha[indice1][indice2];
    }
  else
    partiel = - alpha[indice1][categorie];

  if(partiel != 0.0)
    resultat += partiel * ker(nature_kernel, X_app[indice1], vecteur, dim_input);
  }

return resultat;

}

void eval_training()

{

long ind_min = 0;

double minimum = tres_grand, delta = 0.0;

for(k=1; k<=Q; k++)
  for(l=1; l<=Q; l++)
    mat_conf[k][l] = 0.0;

R_emp = 0.0;

for(i=1; i<=nb_data_app; i++)
  {
  minimum = tres_grand;
  ind_min = 0;
  y_i = y_app[i];

  for(k=1; k<=Q; k++)
    if(k != y_i)
      {
      delta = gradient[i][k] + b_SVM[y_i] - b_SVM[k];
      if(delta < 0.0)
         R_emp -= delta;
      if(delta < minimum)
        {
        minimum = delta;
        ind_min = k;
        }
      }
  if(minimum <= -1.0)
    mat_conf[y_i][ind_min] += 1.0;
  else
    mat_conf[y_i][y_i] += 1.0;
  }
  
/* display_stats(chaine_app, nb_data_app, nb_data_app, Q, mat_conf, cost); */

}

void compute_W()

{

W = matrix(dim_input, Q);

for(j=1; j<=dim_input; j++)
  for(k=1; k<=Q; k++)
    W[j][k] = 0.0;

for(k=1; k<=Q; k++)
  for(i=1; i<=nb_data_app; i++)
    {
    if((y_app[i]) == k)
      {
      partiel = 0.0;
      for(l=1; l<=Q; l++)
        partiel += alpha[i][l];
      for(j=1; j<=dim_input; j++)
        W[j][k] += partiel * X_app[i][j];
      }
    else
      for(j=1; j<=dim_input; j++)
        W[j][k] -= alpha[i][k] * X_app[i][j];
    }
        
printf("\nMatrix of the vectors defining the separating hyperplanes\n");

display_mat(W, dim_input, Q, 12, 6);
Pause("");

}

void estime_b()

{

double b_part;

delta_b_SVM = matrix(Q, Q);
b_SVM = (double *) calloc(Q+1, sizeof(double));
best_b_SVM = (double *) calloc(Q+1, sizeof(double));

for(k=1; k<=Q; k++)
  {
  b_SVM[k] = 0.0;
  best_b_SVM[k] = 0.0;
  }

for(k=1; k<=Q; k++)
  for(l=1; l<=Q; l++)
    delta_b_SVM[k][l] = 0.0;

for(i=1; i<=nb_data_app; i++)
  for(k=1; k<=Q; k++)
    if(margin_vect[i][k] == 1.0)
      delta_b_SVM[y_app[i]][k] -= gradient[i][k];

for(k=1; k<=Q; k++)
  for(l=1; l<=Q; l++)
    if(k != l)
      if(nb_margin_vect[k][l] != 0.0)
        delta_b_SVM[k][l] /= nb_margin_vect[k][l];

/*
printf("\nComponents of the delta_b_SVM matrix:\n");
display_mat(delta_b_SVM, Q, Q, 10, 6);
*/

for(k=2; k<=Q; k++)
  if(nb_margin_vect[k][1] + nb_margin_vect[1][k] > 0.0)
    {
    b_SVM[k] = (nb_margin_vect[k][1] * delta_b_SVM[k][1] 
                 - nb_margin_vect[1][k] * delta_b_SVM[1][k]) / 
                  (nb_margin_vect[k][1] + nb_margin_vect[1][k]);
    best_b_SVM[k] = b_SVM[k];
    }

standardize_b();

printf("\nComponents of the b vector:\n");
printf("\n");
for(k=1; k<=Q; k++)
  printf("%11.6f\n", b_SVM[k]);

}

void compute_outputs(double **X, long *y, char *chaine, long nb_data)

{

long ind_max = 0;

double *output, maximum = - tres_grand;

output = (double *) calloc(Q+1, sizeof(double));

for(k=1; k<=Q; k++)
  for(l=1; l<=Q; l++)
    mat_conf[k][l] = 0.0;

if((fc=fopen(fichier_resultat, "w"))==NULL)
  {
  printf("\nFile of outputs: %s cannot be open...\n", fichier_resultat);
  exit(0);
  }

for(i=1; i<=nb_data; i++)
  {
  for(k=1; k<=Q; k++)
    output[k] = fonction(k, X[i]) + b_SVM[k];

  ind_max = 0;
  maximum = - tres_grand;

  for(k=1; k<=Q; k++)
    if(output[k] > maximum)
      {
      maximum = output[k];
      ind_max = k;
      }

  mat_conf[(int)y[i]][(int)ind_max]++;

  for(k=1; k<=Q; k++) 
    fprintf(fc, "%12.6f%c", output[k], (k==Q) ? '\n' : ' ');

  if((i % pas) == 0)
    {
    printf("\nExample: %5d", i);
    display_stats(chaine, i, nb_data, Q, mat_conf, cost);
    }
  }

fclose(fc);

printf("\n*** Test performance\n");
display_stats(chaine, nb_data, nb_data, Q, mat_conf, cost);

}

void compute_obj_dual()

{

Q_form_dual = 0.0;

for(i=1; i<=nb_data_app; i++)
  for(k=1; k<=Q; k++)
    Q_form_dual += H_alpha[i][k] * alpha[i][k];

Q_form_dual *= -0.5;

dual = Q_form_dual;

for(i=1; i<=nb_data_app; i++)
  for(k=1; k<=Q; k++)
    dual += alpha[i][k];

/* printf("\nDual Q : %lf -> %lf\n", Q_form_dual, dual); */

}

void compute_obj_primal()

{

long class;

primal = - Q_form_dual + C * R_emp;

if(primal < dual)
  {
  printf("\nInconsistency in the values of the objective functions...\n\n");
/*  exit(0); */
  }

if(R_emp < R_emp_min)
  {
  R_emp_min = R_emp;
  for(class=1; class<=Q; class++)
    best_b_SVM[class] = b_SVM[class];     
  }

}

void compute_boundaries()

{

double slope, y_at_origin;

/* printf("\nEntering the compute_boundaries function...\n"); */

slope = (W[1][1] - W[1][2]) / (W[2][2] - W[2][1]);
y_at_origin = (b_SVM[1] -  b_SVM[2]) / (W[2][2] - W[2][1]);

printf("\nSlope : %lf", slope);
printf("\nOrdinate at the origin : %lf\n", y_at_origin);

Pause("");

slope = (W[1][1] - W[1][3]) / (W[2][3] - W[2][1]);
y_at_origin = (b_SVM[1] -  b_SVM[3]) / (W[2][3] - W[2][1]);

printf("\nSlope : %lf", slope);
printf("\nOrdinate at the origin : %lf\n", y_at_origin);

Pause("");

slope = (W[1][2] - W[1][3]) / (W[2][3] - W[2][2]);
y_at_origin = (b_SVM[2] -  b_SVM[3]) / (W[2][3] - W[2][2]);

printf("\nSlope : %lf", slope);
printf("\nOrdinate at the origin : %lf\n", y_at_origin);

Pause("");
/* exit(0); */

}

void compute_significance()

{

long former_true = 0;

double recognition_rate=0.0, former_recognition_rate=0.0, score=0.0, p_hat=0.0,
       denominator=0.0;

printf("\nConfusion matrix:");

display_mat( mat_conf, Q, Q, 5, 0);

for(k=1; k<=Q; k++)
  recognition_rate += mat_conf[k][k];

recognition_rate /= nb_data_test;

printf("\nFormer number of true positives and true negatives: ");
scanf("%d", &former_true);

former_recognition_rate = (double) former_true / (double) nb_data_test;

printf("\n%5.3f -> %5.3f\n\n", former_recognition_rate, recognition_rate);

p_hat = (recognition_rate + former_recognition_rate) / 2.0;

/* printf("\nEstimate of the recognition rate: %5.3f\n", p_hat); */

denominator = 2.0 / nb_data_test;
denominator *= p_hat * (1.0 - p_hat);
denominator = sqrt(denominator);

score = fabs(recognition_rate - former_recognition_rate) / denominator;
printf("\nScore: %6.3f\n", score);

printf("\nThe confidence in the significance of the %s is: %lf\n\n",
(recognition_rate >= former_recognition_rate)?"increase":"decrease", 
erf((score / sqrt(2.0))));

}