diff --git a/4-Classification/4-Applied/translations/README.es.md b/4-Classification/4-Applied/translations/README.es.md
new file mode 100644
index 00000000..5d2d3a76
--- /dev/null
+++ b/4-Classification/4-Applied/translations/README.es.md
@@ -0,0 +1,316 @@
+# Construye una aplicación web de recomendación de cocina
+
+En esta lección, construirás un modelo de clasificación usando algunas de las técnicas que aprendiste en las lecciones anteriores y con el conjunto de datos de la cocina deliciosa usada a través de este serie de lecciones. Además, construirás una pequeña aplicación web para usar un modelo guardado, aprovechando el runtime web de Onnx.
+
+Uno de los usos prácticos más útiles del aprendizaje automático es construir sistemas de recomendación, y ¡hoy puedes tomar el primer en esa dirección!
+
+[![Presentando esta aplicación web](https://img.youtube.com/vi/17wdM9AHMfg/0.jpg)](https://youtu.be/17wdM9AHMfg "ML aplicado")
+
+> 🎥 Haz clic en la imagen de arriba para ver el video: Jen Looper construye una aplicación web usando los datos clasificados de cocina.
+
+## [Examen previo a la lección](https://white-water-09ec41f0f.azurestaticapps.net/quiz/25/)
+
+En esta lección aprenderás:
+
+- Cómo construir un modelo y guardarlo como un modelo Onnx
+- Cómo usar Netron para inspeccionar el modelo
+- Cómo usar tu modelo en una aplicación web por inferencia
+
+## Construye tu modelo
+
+Construir sistemas de aprendizaje automático aplicado es un parte importante de aprovechar estas tecnologías para tus sistemas de negocio. Puedes usar modelos dentro de tus aplicaciones web (y así usarlos de sin conexión en caso de ser necesario) al usar Onnx.
+
+En la [lección anterior](../../../3-Web-App/1-Web-App/translations/README.es.md), construiste un modelo de regresión acerca de los avistamientos OVNI, le hiciste "pickle", y los usaste en una aplicación Flask. Aunque esta arquitectura es muy útil conocerla, es una aplicación Python full-stack, y tus requerimientos pueden incluir el uso de una aplicación JavaScript.
+
+En esta lección, puedes construir un sistema JavaScript básico por inferencia. Pero primero, necesitas entrenar tu modelo y convertirlo para usarlo con Onnx.
+
+## Ejercicio - entrena tu modelo de clasificación
+
+Primero, entrena un modelo de clasificación usando el conjunto limpio de datos de cocina que ya usamos.
+
+1. Comienza importando bibliotecas útiles:
+
+ ```python
+ !pip install skl2onnx
+ import pandas as pd
+ ```
+
+ Necesitas '[skl2onnx](https://onnx.ai/sklearn-onnx/)' para ayudar a convertir tu modelo Scikit-learn al formato Onnx.
+
+1. Luego, trabaja con tus datos de la misma forma que lo hiciste en las lecciones anteriores, al leer el archivo CSV usando `read_csv()`:
+
+ ```python
+ data = pd.read_csv('../data/cleaned_cuisines.csv')
+ data.head()
+ ```
+
+1. Elimina las primeras dos columnas y guarda los datos restantes como 'X':
+
+ ```python
+ X = data.iloc[:,2:]
+ X.head()
+ ```
+
+1. Guarda las etiquetas como 'y':
+
+ ```python
+ y = data[['cuisine']]
+ y.head()
+
+ ```
+
+### Comienza la rutina de entrenamiento
+
+Usaremos la biblioteca 'SVC' la cual tiene buena precisión.
+
+1. Importa las bibliotecas correspondientes de Scikit-learn:
+
+ ```python
+ from sklearn.model_selection import train_test_split
+ from sklearn.svm import SVC
+ from sklearn.model_selection import cross_val_score
+ from sklearn.metrics import accuracy_score,precision_score,confusion_matrix,classification_report
+ ```
+
+1. Separa los conjuntos de entrenamiento y prueba:
+
+ ```python
+ X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.3)
+ ```
+
+1. Construye un model de clasificación SVC como lo hiciste en la lección anterior:
+
+ ```python
+ model = SVC(kernel='linear', C=10, probability=True,random_state=0)
+ model.fit(X_train,y_train.values.ravel())
+ ```
+
+1. Ahora, prueba tu modelo al llamar a `predict()`:
+
+ ```python
+ y_pred = model.predict(X_test)
+ ```
+
+1. Imprime un reporte de clasificación para revisar la calidad del modelo:
+
+ ```python
+ print(classification_report(y_test,y_pred))
+ ```
+
+ Como vimos anteriormente, la precisión es buena:
+
+ ```output
+ precision recall f1-score support
+
+ chinese 0.72 0.69 0.70 257
+ indian 0.91 0.87 0.89 243
+ japanese 0.79 0.77 0.78 239
+ korean 0.83 0.79 0.81 236
+ thai 0.72 0.84 0.78 224
+
+ accuracy 0.79 1199
+ macro avg 0.79 0.79 0.79 1199
+ weighted avg 0.79 0.79 0.79 1199
+ ```
+
+### Convierte tu modelo a Onnx
+
+Asegúrate que haces la conversión con el número adecuado de Tensor. Este conjunto de datos lista 380 ingredientes, por lo que necesitas anotar ese número en `FloatTensorType`:
+
+1. Conviértelo usando un número de tensor de 380.
+
+ ```python
+ from skl2onnx import convert_sklearn
+ from skl2onnx.common.data_types import FloatTensorType
+
+ initial_type = [('float_input', FloatTensorType([None, 380]))]
+ options = {id(model): {'nocl': True, 'zipmap': False}}
+ ```
+
+1. Crea el onx y guárdalo como un archivo **model.onnx**:
+
+ ```python
+ onx = convert_sklearn(model, initial_types=initial_type, options=options)
+ with open("./model.onnx", "wb") as f:
+ f.write(onx.SerializeToString())
+ ```
+
+ > Nota, puedes pasar [opciones](https://onnx.ai/sklearn-onnx/parameterized.html) a tu script de conversión. En este caso, pasamos 'nocl' como True y 'zipap' como False. Ya que este es un modelo de clasificación, tienes la opción de eliminar ZipMap el cual produce una lista de diccionarios (no necesarios). `nocl` se refiere a la información de clase que se incluye en el modelo. Reduce el tamaño de tu modelo al configurar `nocl` a 'True'.
+
+Al ejecutar todo el notebook construirás un modelo Onnx y lo guardará en su directorio.
+
+## Observa tu modelo
+
+Los modelos Onnx no se aprecian bien en Visual Studio Code, pero muchos investigadores usan buen software libre para visualizar el modelo y asegurar que se construyó de forma adecuada. Descarga [Netron](https://github.com/lutzroeder/Netron) y abre tu archivo `model.onnx`. Puedes visualizar de forma simple tu modelo, con sus 380 entradas y el clasificador listado:
+
+
+![Netron visual](../images/netron.png)
+
+Netron es una herramienta útil para ver tus modelos.
+
+Ahora estás listo para usar este modelo limpio en una aplicación web. Construyamos una aplicación que nos será útil cuando veas tu refrigerador e intentes descubrir qué combinación de tus ingredientes sobrantes puedes usar para realizar un platillo de cierta cocina, de acuerdo a lo que determina tu modelo.
+
+## Construye una aplicación web de recomendación
+
+Puedes usar tu modelo directamente en la aplicación web. Esta arquitectura también te permite ejecutarlo de forma local e incluso sin conexión en caso de ser necesario. Empieza creando un archivo `index.html` en el mismo directorio donde guardaste tu archivo `model.onnx`.
+
+1. En este archivo _index.html_, agrega el siguiente código:
+
+ ```html
+
+
+