Esercitazione con codice per l’ammissione all’esame scritto di Data mining - Classificazione semi-supervisionata

Calcolo delle metriche di valutazione

double TP, FP, FN, TN;

double totalePrecisione, totaleTP0, totaleTP1, totaleTP2, totaleFP0, totaleFP1, totaleFP2;

totalePrecisione = totaleTP0 = totaleTP1 = totaleTP2 = totaleFP0 = totaleFP1 = totaleFP2 = TP = FP = FN = TN = 0;

double MediaPrecisione, MediaTP0, MediaTP1, MediaTP2, MediaFP0, MediaFP1, MediaFP2;

MediaPrecisione = MediaTP0 = MediaTP1 = MediaTP2 = MediaFP0 = MediaFP1 = MediaFP2 = 0;

Nel processo di 10-fold cross-validation, il set di dati viene suddiviso in 10 parti (folds). Il modello viene addestrato su 9 di queste parti e testato sulla restante. Questo processo viene ripetuto 10 volte, ogni volta con un diverso fold come set di test.

// Inizializzo l'oggetto trainingSet. Questo oggetto verrà popolato con i dati di addestramento

// Inizializzo l'oggetto testSet. Questo verrà utilizzato per i dati di test.

Instances trainingSet = null;

Instances testSet = null;

for (int i = 0; i < NUMBER_FOLDS; i++) {

01/12/2023 …. - Matricola: …..

Inizializzo

una matrice di confusione (confusionMatrix) utilizzata per valutare le prestazioni del modello di classificazione.

confusionMatrix = new double[Calcoli.NumClusters][Calcoli.NumClusters];
int rows = confusionMatrix.length;
int columns = confusionMatrix[0].length;
String str = ""\t"";

/*Inizializzo tre variabili (Centroide0, Centroide1, Centroide2) utilizzate per contare quanti elementi di ciascuna classe sono associati a un certo centroide con indice 0, per il processo di clustering o classificazione in cui i dati sono assegnati a centroidi monitorandone la distribuzione delle classi nei vari centroidi.*/
int Centroide00 = 0;
int Centroide01 = 0;
int Centroide02 = 0;
int Centroide10 = 0;
int Centroide11 = 0;
int Centroide12 = 0;
int Centroide20 = 0;
int Centroide21 = 0;
int Centroide22 = 0;

/* trainingSet - Restituisce il sottoinsieme del set di dati da utilizzare come set di addestramento durante l'iterazione (fold) della cross-validation. Calcoli.numberOfFolds indica il numero totale di fold */

trainLabel2.instance(j);
EuclideanDistance e = new EuclideanDistance(centroid);
double[] vettDist1 = new double[3];
vettDist1[0] = e.distance(instance, centroid.get(0));
vettDist1[1] = e.distance(instance, centroid.get(1));
vettDist1[2] = e.distance(instance, centroid.get(2));
int MinimoCentroide = Calcoli.MinimoIndice(vettDist1);
/*identifico l'etichetta di ciascun cluster basandomi sul numero di istanze etichettate
del set di addestramento assegnate ad esso*/
if (MinimoCentroide == 0) {
    if (InstanceEtic.classValue() == 0.0) {
        Centroide00++;
    } else if (InstanceEtic.classValue() == 1.0) {
        Centroide01++;
    } else {
        Centroide02++;
    }
} else if (MinimoCentroide == 1) {
    if (InstanceEtic.classValue() == 0.0) {
        Centroide10++;
    } else if (InstanceEtic.classValue() == 1.0) {
        Centroide11++;
    } else {
        Centroide12++;
    }
} else {
    if (InstanceEtic.classValue() == 0.0) {
        Centroide20++;
    } else if (InstanceEtic.classValue() == 1.0) {
        Centroide21++;
    } else {
        Centroide22++;
    }
}
01/12/2023 …. - Matricola: …..
}}
System.out.println(

"CENTROIDI CONTEGGI"

0: Centroide00 Centroide01 Centroide02

1: Centroide10 Centroide11 Centroide12

2: Centroide20 Centroide21 Centroide22

double[] alfa1 = new double[3];

alfa1[0] = Centroide00;

alfa1[1] = Centroide01;

alfa1[2] = Centroide02;

double[] alfa2 = new double[3];

alfa2[0] = Centroide10;

alfa2[1] = Centroide11;

alfa2[2] = Centroide12;

double[] alfa3 = new double[3];

alfa3[0] = Centroide20;

alfa3[1] = Centroide21;

alfa3[2] = Centroide22;

double[] Centroide = new double[3];

Centroide[0] = (double) (Calcoli.MaggioreIndice(alfa1));

Centroide[1] = (double) (Calcoli.MaggioreIndice(alfa2));

Centroide[2] = (double) (Calcoli.MaggioreIndice(alfa3));

Remove filter3 = new Remove();

filter3.setAttributeIndices("" + (testSet.classIndex() + 1));

filter3.setInputFormat(testSet);

Instances testSet2 = Filter.useFilter(testSet,

filter3);
for (int x = 0; x < testSet2.size(); x++) {
    int count = 1;
    Instance instance = testSet2.get(x);
    Instance InstanceEtic = testSet.get(x);
    EuclideanDistance e = new EuclideanDistance(centroid);
    double[] vettDist2 = new double[3];
    vettDist2[0] = e.distance(instance, centroid.get(0));
    vettDist2[1] = e.distance(instance, centroid.get(1));
    vettDist2[2] = e.distance(instance, centroid.get(2));
    int MinimoCentroide = Calcoli.MinimoIndice(vettDist2);
    double result = Centroide[MinimoCentroide];
    double classValue = InstanceEtic.classValue();
    confusionMatrix[(int) result][(int) classValue] = confusionMatrix[(int) result][(int) classValue] + count;
}
01/12/2023 …. - Matricola: …..
System.out.println("CONFUSION MATRIX: ");
System.out.println("\n");
for (int y = 0; y < rows; y++) {
    for (int z = 0; z < columns; z++) {
        str += confusionMatrix[y][z] + "\t";
    }
    System.out.println(str + "");
    str = "\t";
}
/** Stampo risultati ottenuti*/
double TP0 = Calcoli.numTruePositives(confusionMatrix,

0);
double TP1 = Calcoli.numTruePositives(confusionMatrix, 1);
double TP2 = Calcoli.numTruePositives(confusionMatrix, 2);
double TN0 = Calcoli.numTrueNegatives(confusionMatrix, 0);
double TN1 = Calcoli.numTrueNegatives(confusionMatrix, 1);
double TN2 = Calcoli.numTrueNegatives(confusionMatrix, 2);
double FP0 = Calcoli.numFalsePositives(confusionMatrix, 0);
double FP1 = Calcoli.numFalsePositives(confusionMatrix, 1);
double FP2 = Calcoli.numFalsePositives(confusionMatrix, 2);
double FN0 = Calcoli.numFalseNegatives(confusionMatrix, 0);
double FN1 = Calcoli.numFalseNegatives(confusionMatrix, 1);
double FN2 = Calcoli.numFalseNegatives(confusionMatrix, 2);

System.out.println("<br>");
System.out.println("TP(0): " + TP0);
System.out.println("FP(0): " + FP0);
System.out.println("FN(0): " + FN0);
System.out.println("TN(0): " + TN0);
System.out.println("TP(1): " + TP1);
System.out.println("FP(1): " + FP1);
System.out.println("FN(1): " + FN1);
System.out.println("TN(1): " + TN1);
System.out.println("TP(2): " + TP2);
System.out.println("FP(2): " + FP2);
System.out.println("FN(2): " + FN2);
System.out.println("TN(2): " + TN2);

TP1);
System.out.println("FP(1):" + " " + FP1);
System.out.println("FN(1):" + " " + FN1);
System.out.println("TN(1):" + " " + TN1);
System.out.println("TP(2):" + " " + TP2);
System.out.println("FP(2):" + " " + FP2);
System.out.println("FN(2):" + " " + FN2);
System.out.println("TN(2):" + " " + TN2);
System.out.println("\n");
TP = TP0 + TP1 + TP2;
TN = TN0 + TN1 + TN2;
FP = FP0 + FP1 + FP2;
FN = FN0 + FN1 + FN2;
if (TP + TN + FP + FN > 0){
    accuracy[i] = (TP + TN) / (TP + TN + FP + FN);
}
truePositiveRateA0[i] = Calcoli.truePositiveRate(TP0, FN0);
01/12/2023 …. - Matricola: …..
truePositiveRateA1[i] = Calcoli.truePositiveRate(TP1, FN1);
truePositiveRateA2[i] = Calcoli.truePositiveRate(TP2, FN2);
falsePositiveRateA0[i] = Calcoli.falsePositiveRate(FP0, TN0);
falsePositiveRateA1[i] = Calcoli.falsePositiveRate(FP1, TN1);
falsePositiveRateA2[i] = Calcoli.falsePositiveRate(FP2,

MediaFP1));
System.out.println("TPR - 2: " + String.format("%.2f%%", MediaTP2));
System.out.println("FPR - 2: " + String.format("%.2f%%", MediaFP2)+"\nFINE");
} catch (Exception e) {
    e.printStackTrace();
}
}
}
//Calcoli.java
//…..
package we