Update app.py

app.py

@@ -1,73 +1,102 @@
-from transformers import pipeline, AutoModelForSequenceClassification, AutoTokenizer
-from sklearn.metrics.pairwise import cosine_similarity
-from sklearn.feature_extraction.text import TfidfVectorizer
+from huggingface_hub import from_pretrained_keras
 import numpy as np
 import gradio as gr
+import transformers
+import tensorflow as tf
 
-# Modelos para análisis de texto y similitud
-sentiment_analysis = pipeline("sentiment-analysis", model="distilbert-base-uncased-finetuned-sst-2-english")
-similarity_model = AutoModelForSequenceClassification.from_pretrained("bert-base-uncased")
-similarity_tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
+class BertSemanticDataGenerator(tf.keras.utils.Sequence):
+    """Generates batches of data."""
+    def __init__(
+        self,
+        sentence_pairs,
+        labels,
+        batch_size=32,
+        shuffle=True,
+        include_targets=True,
+    ):
+        self.sentence_pairs = sentence_pairs
+        self.labels = labels
+        self.shuffle = shuffle
+        self.batch_size = batch_size
+        self.include_targets = include_targets
+        # Load our BERT Tokenizer to encode the text.
+        # We will use base-base-uncased pretrained model.
+        self.tokenizer = transformers.BertTokenizer.from_pretrained(
+            "bert-base-uncased", do_lower_case=True
+        )
+        self.indexes = np.arange(len(self.sentence_pairs))
+        self.on_epoch_end()
 
-# Respuestas esperadas para las preguntas
-expected_responses = {
-    'question1': ['respuesta1a', 'respuesta1b', 'respuesta1c'],
-    'question2': ['respuesta2a', 'respuesta2b', 'respuesta2c'],
-    'question3': ['respuesta3a', 'respuesta3b', 'respuesta3c'],
-    'question4': ['respuesta4a', 'respuesta4b', 'respuesta4c'],
-}
+    def __len__(self):
+        # Denotes the number of batches per epoch.
+        return len(self.sentence_pairs) // self.batch_size
 
-# Función para calcular la similitud de respuestas usando TF-IDF y cosine similarity
-def calculate_similarity(response, expected_responses):
-    vectorizer = TfidfVectorizer().fit_transform([response] + expected_responses)
-    vectors = vectorizer.toarray()
-    cosine_similarities = cosine_similarity(vectors[0:1], vectors[1:])
-    return float(max(cosine_similarities[0]))
+    def __getitem__(self, idx):
+        # Retrieves the batch of index.
+        indexes = self.indexes[idx * self.batch_size : (idx + 1) * self.batch_size]
+        sentence_pairs = self.sentence_pairs[indexes]
 
-# Función para evaluar una sola respuesta
-def evaluate_response(response, expected_responses):
-    return calculate_similarity(response, expected_responses)
+        # With BERT tokenizer's batch_encode_plus batch of both the sentences are
+        # encoded together and separated by [SEP] token.
+        encoded = self.tokenizer.batch_encode_plus(
+            sentence_pairs.tolist(),
+            add_special_tokens=True,
+            max_length=128,
+            return_attention_mask=True,
+            return_token_type_ids=True,
+            pad_to_max_length=True,
+            return_tensors="tf",
+        )
 
-# Función para evaluar análisis de texto
-def analyze_text(response):
-    analysis = sentiment_analysis(response)
-    return analysis[0]
+        # Convert batch of encoded features to numpy array.
+        input_ids = np.array(encoded["input_ids"], dtype="int32")
+        attention_masks = np.array(encoded["attention_mask"], dtype="int32")
+        token_type_ids = np.array(encoded["token_type_ids"], dtype="int32")
 
-# Función para evaluar todas las respuestas
-def evaluate_all_responses(responses):
-    results = {}
-    for i, response in enumerate(responses[:4]):
-        question_key = f'question{i+1}'
-        results[question_key] = evaluate_response(response, expected_responses[question_key])
+        # Set to true if data generator is used for training/validation.
+        if self.include_targets:
+            labels = np.array(self.labels[indexes], dtype="int32")
+            return [input_ids, attention_masks, token_type_ids], labels
+        else:
+            return [input_ids, attention_masks, token_type_ids]
 
-    for i, response in enumerate(responses[4:]):
-        question_key = f'question{i+5}'
-        results[question_key] = analyze_text(response)
+model = from_pretrained_keras("keras-io/bert-semantic-similarity")
+labels = ["contradiction", "entailment", "neutral"]
 
-    return results
+def predict(*sentences):
+    if len(sentences) != 6:
+        return {'error': 'Se esperan 6 oraciones'}
 
-# Interfaz Gradio
-def evaluate(*responses):
-    if len(responses) != 6:
-        return {'error': 'Se esperan 6 respuestas'}
-    results = evaluate_all_responses(responses)
-    return results
+    sentence_pairs = np.array([[str(sentences[i]), str(expected_responses[i])] for i in range(6)])
+    test_data = BertSemanticDataGenerator(
+        sentence_pairs, labels=None, batch_size=1, shuffle=False, include_targets=False,
+    )
+    probs = model.predict(test_data[0])[0]
 
-# Definir los cuadros de texto para las respuestas de las preguntas
-input_texts = [gr.Textbox(label=f"Pregunta {i+1}") for i in range(6)]
+    labels_probs = {labels[i]: float(probs[i]) for i, _ in enumerate(labels)}
+    return labels_probs
 
-# Definir la salida como un JSON para mostrar los resultados
-output_text = gr.JSON(label="Resultados")
+expected_responses = [
+    'respuesta1a', 'respuesta2a', 'respuesta3a', 'respuesta4a', 'respuesta5a', 'respuesta6a'
+]
 
-# Crear la interfaz Gradio
-demo = gr.Interface(
-    fn=evaluate,
-    inputs=input_texts,
-    outputs=output_text,
-    title="Evaluación de Respuestas y Análisis de Texto",
-    description="Ingrese las respuestas para las 6 preguntas y obtenga evaluaciones de similitud y análisis de sentimientos.",
-)
+examples = [
+    ["Two women are observing something together.", "respuesta1a"],
+    ["A smiling costumed woman is holding an umbrella", "respuesta2a"],
+    ["A soccer game with multiple males playing", "respuesta3a"],
+    ["Some men are playing a sport", "respuesta4a"],
+    ["Another example sentence", "respuesta5a"],
+    ["One more example for the sixth input", "respuesta6a"]
+]
 
-# Lanzar la aplicación
-if __name__ == "__main__":
-    demo.launch()
+# Interfaz Gradio
+gr.Interface(
+    fn=predict,
+    title="Semantic Similarity with BERT",
+    description="Natural Language Inference by fine-tuning BERT model on SNLI Corpus 📰",
+    inputs=[gr.Textbox(label=f"Input {i+1}") for i in range(6)],
+    examples=examples,
+    outputs=gr.outputs.Label(num_top_classes=3, label='Semantic similarity'),
+    cache_examples=False,
+    article="Author: <a href=\"https://huggingface.co/vumichien\">Vu Minh Chien</a>. Based on the keras example from <a href=\"https://keras.io/examples/nlp/semantic_similarity_with_bert/\">Mohamad Merchant</a>",
+).launch(debug=True, enable_queue=True)