¿Cuál es el código de aprendizaje automático más pequeño que se podría escribir en Java?

Este es un ejemplo de ” Hola mundo ” de aprendizaje automático en Java. Simplemente le da una idea del aprendizaje automático en Java.

Ambiente

• ¿Cuáles son las instituciones en India que ofrecen cursos de aprendizaje automático y minería de datos y cuáles son las áreas posteriores?
• ¿Debo memorizar las matemáticas y los algoritmos al aprender el aprendizaje automático y el aprendizaje profundo?
• ¿Los humanos son actualizadores bayesianos?
• ¿Qué hay de nuevo con Wasserstein GAN?
• ¿Hay alguna desventaja de usar GPU en el aprendizaje profundo?

Java 1.6+ y Eclipse

Paso 1: descargue la biblioteca Weka

Página de descarga: http://www.cs.waikato.ac.nz/ml/w…

Descargue stable.XX.zip , descomprima el archivo, agregue weka.jar a su ruta de biblioteca del proyecto Java en Eclipse.

Paso 2: preparar los datos

Cree un archivo txt ” weather.txt ” siguiendo el siguiente formato:

@relation weather

@attribute outlook {soleado, nublado, lluvioso}
@ temperatura de atributo numérico
@ atributo de humedad numérico
@ atributo ventoso {VERDADERO, FALSO}
@attribute play {yes, no}

@datos
soleado, 85,85, FALSO, no
soleado, 80,90, VERDADERO, no
nublado, 83,86, FALSO, sí
lluvioso, 70,96, FALSO, sí
lluvioso, 68,80, FALSO, sí
lluvioso, 65,70, VERDADERO, no
nublado, 64,65, VERDADERO, sí
soleado, 72,95, FALSO, no
soleado, 69,70, FALSO, sí
lluvioso, 75,80, FALSO, sí
soleado, 75,70, VERDADERO, si
nublado, 72,90, VERDADERO, sí
nublado, 81,75, FALSO, sí
lluvioso, 71,91, VERDADERO, no

Este conjunto de datos es del paquete de descarga weka. Se encuentra en ” /data/weather.numeric.arff “. El nombre de la extensión del archivo es ” arff “, pero simplemente podemos usar ” txt “.

Paso 3: Entrenamiento y prueba usando Weka

• Este ejemplo de código utiliza un conjunto de clasificadores proporcionados por Weka. Entrena el modelo en el conjunto de datos dado y prueba usando validación cruzada dividida en 10. Explicaré cada clasificador más tarde, ya que es un tema más complicado.

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import weka.classifiers.Classifier;
import weka.classifiers.Evaluation;
import weka.classifiers.evaluation.NominalPrediction;
import weka.classifiers.rules.DecisionTable;
import weka.classifiers.rules.PART;
import weka.classifiers.trees.DecisionStump;
importar weka.classifiers.trees.J48;
importar weka.core.FastVector;
importar weka.core.Instances;

clase pública WekaTest {
public static BufferedReader readDataFile (String filename) {
BufferedReader inputReader = nulo;

tratar {
inputReader = nuevo BufferedReader (nuevo FileReader (nombre de archivo));
} catch (FileNotFoundException ex) {
System.err.println (“Archivo no encontrado:” + nombre de archivo);
}

return inputReader;
}

Clasificación de evaluación estática pública (modelo clasificador,
Instancias trainingSet, Instances testingSet) lanza Exception {
Evaluación de evaluación = nueva evaluación (trainingSet);

model.buildClassifier (trainingSet);
Evaluation.evaluateModel (modelo, testingSet);

evaluación de retorno;
}

public static double CalculateAccuracy (predicciones de FastVector) {
doble correcto = 0;

for (int i = 0; i <predictions.size (); i ++) {
NominalPrediction np = (NominalPrediction) predictions.elementAt (i);
if (np.predicted () == np.actual ()) {
correcto ++;
}
}

return 100 * correct / predictions.size ();
}

Instancias públicas estáticas [] [] crossValidationSplit (Datos de instancias, int numberOfFolds) {
Instancias [] [] split = instancias nuevas [2] [numberOfFolds];

for (int i = 0; i <numberOfFolds; i ++) {
split [0] [i] = data.trainCV (numberOfFolds, i);
split [1] [i] = data.testCV (numberOfFolds, i);
}

retorno dividido;
}

public static void main (String [] args) lanza Exception {
Archivo de datos BufferedReader = readDataFile (“weather.txt”);

Datos de instancias = nuevas instancias (archivo de datos);
data.setClassIndex (data.numAttributes () – 1);

// Hacer validación cruzada dividida en 10
Instancias [] [] split = crossValidationSplit (datos, 10);

// División separada en matrices de entrenamiento y prueba
Instancias [] trainingSplits = split [0];
Instancias [] testingSplits = split [1];

// Usa un conjunto de clasificadores
Clasificador [] modelos = {
nuevo J48 (), // un árbol de decisión
parte nueva(),
nuevo DecisionTable (), // clasificador mayoritario de tabla de decisiones
nuevo DecisionStump () // árbol de decisión de un nivel
};

// Ejecutar para cada modelo
for (int j = 0; j <models.length; j ++) {

// Recopila cada grupo de predicciones para el modelo actual en un FastVector
Predicciones FastVector = nuevo FastVector ();

// Para cada par dividido de prueba de entrenamiento, entrene y pruebe el clasificador
for (int i = 0; i <trainingSplits.length; i ++) {
Validación de evaluación = clasificar (modelos [j], trainingSplits [i], testingSplits [i]);

predictions.appendElements (validation.predictions ());

// Descomente para ver el resumen de cada par de entrenamiento-prueba.
//System.out.println (modelos [j] .toString ());
}

// Calcular la precisión general del clasificador actual en todas las divisiones
precisión doble = calcular precisión (predicciones);

// Imprime el nombre y la precisión del clasificador actual de forma complicada,
// pero de una manera bonita.
System.out.println (“Precisión de” + modelos [j] .getClass (). GetSimpleName () + “:”
+ String.format (“%. 2f %%”, precisión)
+ “\ n ———————————”);
}

}
}

La vista del paquete de su proyecto debería ser similar a la siguiente:

Referencias
1. http://www.cs.umb.edu/~ding/hist…
2. http://www.cs.ru.nl/P.Lucas/teac…