La idea, es resolver el problema de crear un validador de emociones negativas o positivas a la hora de valorar una pelicula de forma textual, mediante el uso de los clasificadores binarios en Machine Learning. Este ejemplo, podría ser usado para filtrar criticas positivas y criticas negativas a la hora de hacer valoraciones sobre peliculas.
Para entrenar el modelo usaremos un Dataset etiquetado de valoraciones de cine de IMDB.

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np

filmsdb = pd.read_csv("IMDBDataset.csv")
filmsdb.head()

#Limpiamos la columna "rewiev" quitando todas las etiquetas HTML que contenga, así como caracteres raros, y espacios innecesarios.

import re
from html import unescape

def limpiar_html(texto):
    if isinstance(texto, str):
        texto = unescape(texto)					# Convierte entidades HTML ( , ", etc.)
        texto = re.sub(r'<.*?>', ' ', texto) 	# Expresión regular que elimina etiquetas HTML como saltos de linea, enlaces, etc.
        texto = re.sub(r'\s+', ' ', texto)      # Expresión regular que elimina espacios múltiples
        return texto.strip() 					# Quita espacios al inicio y al final del texto.
    return texto  # Devuelve tal cual si no es texto

# Aplica la limpieza a la columna
filmsdb['review'] = filmsdb['review'].apply(limpiar_html)

filmsdb.head()

filmsdb.info()

X = filmsdb.drop(columns=['sentiment'])
Y = filmsdb['sentiment']

# Transformarmos a categorica las etiquetas
from sklearn.preprocessing import LabelEncoder

label_encoder = LabelEncoder()
films_prepared_y = label_encoder.fit_transform(Y)

films_prepared_y.shape  				# Visualizamos las dimensiones del target categorizado

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, films_prepared_y, test_size=0.2)

from sklearn.pipeline import make_pipeline
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import SGDClassifier

pipeline = make_pipeline(TfidfVectorizer(max_features=5000, stop_words='english'), SGDClassifier(random_state=42))

pipeline.fit(X_train.squeeze(), y_train) 

from sklearn.model_selection import cross_val_predict

# Aquí usamos el pipeline directamente
y_train_pred = cross_val_predict(pipeline, X_train.squeeze(), y_train, cv=3)

from sklearn.metrics import confusion_matrix

cm = confusion_matrix(y_train, y_train_pred)
cm

from sklearn.metrics import classification_report

print(classification_report(y_train, y_train_pred))

y_scores = cross_val_predict(sgd_clf, X_train, y_train, cv=3,
                             method="decision_function")

from sklearn.metrics import precision_recall_curve

precisions, recalls, thresholds = precision_recall_curve(y_train, y_scores)

import matplotlib.pyplot as plt

plt.figure(figsize=(8, 5))

plt.plot(thresholds, precisions[:-1], label='Precisión')
plt.plot(thresholds, recalls[:-1], label='Recall (Sensibilidad)')

plt.xlabel('Umbral de decisión')
plt.ylabel('Valor')
plt.title('Precisión vs. Recall según el umbral')
plt.legend()
plt.grid(True)
plt.show()

final_predictions = pipeline.predict(X_test.squeeze())

from sklearn.metrics import classification_report

print(classification_report(final_predictions, y_test))

Vemos que se obtienen buenos resultados para el conjunto de test, así que nuestro modelo esta generalizando correctamente. Una vez hecho esto, ya podemos pasarlo a producción, teniendo un modelo funcional.

Podemos comprobar el funcionamiento del modelo con el siguiente formulario: