Aprendizaje automático con JavaScript: Parte 1

El día de hoy aprenderemos acerca del Aprendizaje automático en JS, y sí, si estas leyendo bien.

Aprendizaje Automático en JS

¡¿JAVASCRIPT?! ¿No debería estar usando python? ¿Estoy loca por probar esos cálculos en JavaScript? ¿Estoy tratando de actuar con calma usando un lenguaje que no es python o R? scikit-learn ni siquiera funciona en JavaScript?

Respuesta corta: No. No estoy loca.

Respuesta larga: Es posible y me sorprende que los desarrolladores no le hayan prestado la atención que se merece. En lo que respecta a scikit-learn, la gente de JS ha creado su propio conjunto de bibliotecas para contrarrestarla, y yo también voy a usar una. Pero primero, un poco sobre el aprendizaje automático.

Según Arthur Samuel, el aprendizaje automático proporciona a los ordenadores la capacidad de aprender sin estar programados explícitamente. En otras palabras, le da a la computadora la habilidad de aprender por sí misma y ejecutar las instrucciones correctas, sin que tú le dé instrucciones.

Ha existido desde hace bastante tiempo, con Google pasando de la estrategia de móvil primero a la de IA primero.

¿Por qué no se menciona JavaScript con ML?

• Es muy lento. (Esto es un mito)
• La manipulación de matrices es difícil (hay bibliotecas, por ejemplo math.js).
• Sólo preocupado por el Desarrollo Web (En algún lugar, Node.js se está riendo de esto.)
• Las bibliotecas suelen estar hechas para python. (La gente de JS no está detrás)

Hay un puñado de librerías en JavaScript con algoritmos de Machine Learning pre-diseñados, tales como Regresión Lineal, SVMs, Naive-Bayes, etcétera. He aquí algunos de ellos,

• brain.js (Redes neuronales)
• Sináptico (Redes neuronales)
• Natural (Procesamiento del lenguaje natural)
• ConvNetJS (redes neuronales convolucionales)
• mljs (Un conjunto de subbibliotecas con una variedad de funciones)
• Neatáptico (Redes neuronales)
• Webdnn (Deep Learning)

Vamos a usar la biblioteca de regresión de mljs para realizar alguna brujería de regresión lineal jajaja.

Paso 1. Instalar las bibliotecas

$ yarn add ml-regression csvtojson

O si te gustan las npm

$ npm install ml-regression csvtojson

ml-regression hace lo que el nombre implica.

csvtojson es un rápido analizador de csv para node.js que permite cargar archivos de datos csv y convertirlos a JSON.

Descarga el archivo de datos (.csv) desde aquí y ponlo dentro de tu proyecto.

Asumiendo que ya has inicializado un proyecto npm vacío, abre el archivo index.js e introduzce lo siguiente. (Puedes copiar/pegar si lo deseas, pero yo prefiero que lo escribas tú mismo para una mejor comprensión.)

const ml = require('ml-regression');
const csv = require('csvtojson');
const SLR = ml.SLR; // Regresión lineal simple

const csvFilePath = 'advertising.csv'; // Datos
let csvData = [], //  Datos analizados
X = [], // entrada
y = []; // salida

let regressionModel;

Ahora vamos a usar el método fromFile de csvtojson para cargar nuestro archivo de datos.

csv()
.fromFile(csvFilePath)
.on('json', (jsonObj) => {
csvData.push(jsonObj);
})
.on('done', () => {
dressData(); // Para obtener puntos de datos de objetos JSON
performRegression();
});

Datos del apósito para prepararlo para su ejecución

Los objetos JSON que guardamos en csvData son bien, objetos, y necesitamos una serie de puntos de datos de entrada así como puntos de datos de salida. Vamos a ejecutar nuestros datos a través de una función dressData que rellenará nuestras variables X e y.

function dressData() {
/**
* Una línea del objeto de datos tiene el aspecto siguiente:
* {
* TV: "10",
* Radio: "100",
* Newspaper: "20",
* "Sales": "1000"
* }
*
* Por lo tanto, al agregar los puntos de datos, necesitamos analizar el valor

* de la cadena como un flotador.
*/
csvData.forEach((row) => {
X.push(f(row.Radio));
y.push(f(row.Sales));
});
}

function f(s) {
return parseFloat(s);
}

Entrena a tu modelo y empieza a predecir

Ahora que nuestros datos han sido vestidos exitosamente, es hora de entrenar a nuestro modelo.

Para ello, vamos a escribir una función performRegression:

función performRegression() {
regressionModel = nuevo SLR(X, y); // Capacitar al modelo en datos de formación
console.log(regressionModel.toString(3));
predictOutput();
}

El modelo de regresión tiene un método para String que toma un parámetro llamado precisión para las salidas en coma flotante.

La función predictOutput te permite introducir valores de entrada y envía la salida prevista a su consola.

Esto es lo que parece: (Ten en cuenta que estoy usando la utilidad de línea de lectura de Node.js)

function predictOutput() {
rl.question('Enter input X for prediction (Press CTRL+C to exit) : ', (answer) => {
console.log(`At X = ${answer}, y = ${regressionModel.predict(parseFloat(answer))}`);
predictOutput();
});
}

Y aquí está el código para agregar la entrada de lectura del usuario:

const readline = require('readline'); // Para que el usuario pida que se permitan las predicciones

const rl = readline.createInterface({
input: process.stdin,
output: process.stdout
});

¡Ya finalizamos!

Si seguiste los pasos, así es como debería verse tu index.js:

const ml = require('regresión ml-');
const csv = require('csvtojson');
const SLR = ml.SLR; // Regresión lineal simple

const csvFilePath = 'advertising.csv'; // Datos
let csvData = [], // Datos analizados
X = [], // Entrada
y = []; // Salida

dejemos que regressionModel;

const readline = require('readline'); // Para que el usuario pida que se permitan las predicciones

const rl = readline.createInterface({ {)
entrada: process.stdin,
salida: process.stdout
});

csv()
.desdeFile(csvFilePath)
.on('json', (jsonObj) => {
csvData.push(jsonObj);
})
.on('done', () => {
dressData(); // Para obtener puntos de datos de JSON Objects
performRegression();
});

función performRegression() {
regressionModel = nuevo SLR(X, y); // Capacitar al modelo en datos de formación
console.log(regressionModel.toString(3));
predictOutput();
}

función dressData() {
/**
Una fila del objeto de datos tiene el mismo aspecto:
* {
* TV: "10",
* Radio: "100",
Periódico: "20",
"Ventas": "1000"
* }
*
Por lo tanto, al añadir los puntos de datos,
necesitamos analizar el valor de la cadena como un flotador.
*/
csvData.forEach((row) => { {svData.forEach
X.push(f(row.Radio));
y.push(f(fila.Ventas));
});
}

función f(s)
devuelve parseFloat(s);
}

función predictOutput() {
rl.question('Enter input X for prediction (Presione CTRL+C para salir) : ', (respuesta) => {
console.log(`At X = ${respuesta}, y = ${regressionModel.predict(parseFloat(respuesta))}`);
predictOutput();
});
}

Ve a tu Terminal y ejecute el nodo index.js y se generará algo como esto:

nodo index.js

Introduce la entrada X para la predicción (Presione CTRL+C para salir) : 151.5

f(x) = 0.202 * x + 9.31

Introduzca la entrada X para la predicción (Presione CTRL+C para salir):

En X = 151,5, y = 39,989749279911285