En este artículo les explicaré cómo convertir un modelo de Machine Learning entrenado en un código ejecutable en Python. Para demostrarlo, entrenaré un clasificador Random Forest con Sklearn y luego lo convertiré en un archivo de texto plano que se puede ejecutar como código en Python. El código resultante incluirá todo lo necesario para llevar a cabo tareas de clasificación sin necesidad de utilizar Sklearn.
Esta técnica resulta especialmente útil cuando necesitamos utilizar modelos de Machine Learning en entornos en los que no es posible instalar recursos de Machine Learning. Veamos de qué se trata.
Modelos de Machine Learning en Sklearn
Sklearn es una biblioteca de Python muy popular para la implementación de modelos de Machine Learning. En Panama Hitek, hemos cubierto este tema en profundidad en varios artículos, incluyendo uno en el que probamos 16 modelos diferentes de Machine Learning disponibles en Sklearn. En general, las librerías de aprendizaje automático, como Sklearn, Tensorflow y Pytorch, hacen que la utilización de estos modelos sea bastante fácil.
Sin embargo, a menudo nos preguntamos qué hay detrás de cada modelo de aprendizaje automático que utilizamos en la implementación práctica. En general, detrás de cada modelo hay una serie de cálculos matemáticos que hacen posible que estos algoritmos sean funcionales. Estos cálculos pueden ser complejos y requieren un conocimiento profundo de las matemáticas.
En este post vamos a utilizar una librería disponible en Github que nos permite convertir los modelos entrenados en código. Esta librería generará automáticamente el código necesario para realizar estas operaciones aritméticas y matriciales. La librería en cuestión se llama m2cgen y se encuentra disponible en este enlace.
¿Qué podemos hacer con m2cgen?
M2cgen (Model 2 Code Generator) es una biblioteca ligera que proporciona una manera fácil de transpilar modelos estadísticos entrenados a un código nativo en varios lenguajes de programación, incluyendo Python, C, Java, Go, JavaScript, Visual Basic, C#, PowerShell, R, PHP, Dart, Haskell, Ruby, F#, Rust, Elixir.
Su implementación es muy sencilla y el resultado es un equivalente perfecto al uso de Sklearn en Python. Yo ya lo he probado y estoy muy complacido con el resultado.
El código resultante será muy extenso, pero podrá ser ejecutado fácilmente en un entorno de Python en el que no se pueda o no se haya instalado Sklearn. Digamos que esta librería nos permite crear códigos «standalone».
Prueba de funcionamiento
Para probar el funcionamiento de M2cgen vamos a entrenar un Clasificador Random Forest con el MNIST dataset. Nos basaremos en este código que publicamos en el post sobre el Clasificador Random Forest.
El código es el siguiente:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
import pandas as pd import numpy as np from sklearn.ensemble import RandomForestClassifier import m2cgen as m2c import time trainingSamples = 50000 def loadDataset(fileName, samples): # Load a dataset from a CSV file, and return the features and labels as NumPy arrays train_data = pd.read_csv(fileName) y = np.array(train_data.iloc[0:samples, 0]) # Extract the labels from the first column x = np.array(train_data.iloc[0:samples, 1:]) / 255 # Extract the features, and normalize them by dividing by 255 return x, y def main(): # Load the MNIST training dataset and the number of samples to use for training train_x, train_y = loadDataset("../../../datasets/mnist/mnist_train.csv", trainingSamples) # Train the random forest classifier and time the training process startTrainingTime = time.time() clf = RandomForestClassifier() clf.fit(train_x, train_y) endTrainingTime = time.time() trainingTime = endTrainingTime - startTrainingTime # Export the trained model to Java code and time the process startExportTime = time.time() java_code = m2c.export_to_python(clf) endExportTime = time.time() exportTime = endExportTime - startExportTime # Save the Java code to a text file, and print the training time and export time with open('trained_model.txt', 'w') as f: f.write(java_code) print("Trained model saved to trained_model.txt.") print("Training time: ", round(trainingTime, 2), " seconds") print("Export time: ", round(exportTime, 2), " seconds") if __name__ == "__main__": main() |
Este código está disponible en nuestro repositorio de Github. El resultado en la consola será algo como esto:
El código se demoró alrededor de 40 segundos en completar el entrenamiento. Luego de eso fueron 160 segundos construyendo el código en Python. El resultado fue un fichero absurdamente grande, con más 150 MB y 1.3 millones de líneas de código. Este fichero, sin embargo, cuenta con todo lo necesario para hacer la clasificación de datos:
El contenido de este archivo es una serie de instrucciones, pruebas lógicas y operaciones aritméticas como las que se muestran en esta imagen:
Se supone que ese código debe poder reproducir los resultados que obtuvimos en la prueba de concepto de Random Forest. Para comprobar esto, usaremos el siguiente código:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 |
import trained_model # Import the trained_model module containing the trained model import pandas as pd # Import the Pandas library for working with data import numpy as np # Import the NumPy library for working with arrays import time # Import the time library for measuring the testing time trainingSamples = 50000 # The number of training samples used for training the model testingSamples = 10000 # The number of testing samples to evaluate the model def loadDataset(fileName, samples): """ Load a dataset from a CSV file. Args: fileName: The path to the CSV file. samples: The number of samples to load. Returns: A tuple of two NumPy arrays: one containing the input data (x) and the other containing the output labels (y). """ x = [] y = [] train_data = pd.read_csv(fileName) # Load the data from the CSV file using Pandas y = np.array(train_data.iloc[0:samples, 0]) # Get the labels (first column) for the specified number of samples x = np.array(train_data.iloc[0:samples, 1:]) / 255 # Get the input data (remaining columns) and normalize it return x, y # Load the testing dataset test_x, test_y = loadDataset("../../../datasets/mnist/mnist_test.csv", testingSamples) validResults = 0 # The number of correctly classified samples startTestingTime = time.time() # Get the current time to measure the testing time # Iterate over the testing data and classify each sample for i in range(len(test_y)): # Get the expected result from the dataset expectedResult = int(test_y[int(i)]) # Use the trained model to get a confidence score for each possible class score = trained_model.score(test_x[int(i)]) # Find the class with the highest confidence score and use it as the predicted result result = score.index(max(score)) # Check if the predicted result matches the expected result outcome = "" # Initialize the outcome to an empty string if result == expectedResult: validResults += 1 outcome = " OK " # Print the classification results for each sample print("Nº ", i + 1, " | Expected result: ", expectedResult, " | Obtained result: ", result, " | ", outcome, " | Accuracy: ", round((validResults / (i + 1)) * 100, 2), "%") endTestingTime = time.time() testingTime = endTestingTime - startTestingTime # Print the final testing results print("-------------------------------") print("Results") print("-------------------------------") print("Testing samples: ", testingSamples) print("Testing time: ", round(testingTime, 2), " s") print("Testing accuracy: ", round((validResults / testingSamples) * 100, 2), "%") |
Este código realizará una prueba estadística sobre cada fila del dataset de pruebas y nos producirá una matriz con 10 columnas, de las cuales la mayor será representativa del dígito que clasificamos. Este código también está disponible en Github.
El resultado de ejecutar este código luce así:
96.75% de eficiencia y 5.43 segundos de tiempo de prueba. Tanto la eficiencia como el tiempo de entrenamiento es similar a los resultados que ya habíamos obtenido antes, pero el tiempo de pruebas es sustancialmente menor. Veamos como luce la salida del clasificado Random Forest con Sklearn:
Precisión similar, pero con 20 veces más tiempo de testeo. Esto se debe a que el archivo que generamos previamente es mucho más fácil de ejecutar para el compilador de Python.
Conclusiones
En este post se explica cómo podemos utilizar la biblioteca M2cgen para convertir modelos de aprendizaje automático entrenados en código ejecutable en varios lenguajes de programación. En particular, se utiliza un clasificador Random Forest entrenado con Sklearn y se muestra cómo M2cgen puede ser utilizado para convertir este modelo en un archivo de texto plano que se puede ejecutar como código en Python. Este archivo contiene una serie de instrucciones, pruebas lógicas y operaciones aritméticas que se pueden utilizar para clasificar nuevos datos.
El post destaca que el archivo generado por M2cgen es mucho más fácil de ejecutar para el compilador de Python, lo que reduce significativamente el tiempo de prueba. Este archivo es extremadamente pesado (más de 150 MB), pero se trata de código fácilmente ejecutable para el compilador de Python.
También se muestra cómo se puede utilizar el archivo generado por M2cgen para clasificar nuevos datos utilizando el mismo modelo de aprendizaje automático que se ha entrenado previamente. En resumen, M2cgen es una herramienta valiosa para los desarrolladores de aprendizaje automático que buscan convertir modelos entrenados en diferentes frameworks en código ejecutable en varios lenguajes de programación.
Es importante destacar que M2cgen es una biblioteca ligera que proporciona una manera fácil de transpilar modelos estadísticos entrenados a un código nativo en varios lenguajes de programación, incluyendo Python, C, Java, Go, JavaScript, Visual Basic, C#, PowerShell, R, PHP, Dart, Haskell, Ruby, F#, Rust, Elixir.
Agradecemos al lector por haber leído este artículo y esperamos que haya encontrado información útil sobre la conversión de modelos de aprendizaje automático en código ejecutable. Si tiene algún comentario o pregunta, no dude en dejarlo en la sección de comentarios a continuación. Su opinión es valiosa para nosotros y nos ayuda a mejorar nuestros contenidos.
