.
Preparación y Descarga de Recursos
Python
import nltk
nltk.download('punkt_tab')
corpus = {
"Hola": "Hola, ¿cómo estás?",
"¿Cuál es tu nombre?": "Me llamo Responsibile Bias.",
"¿Qué puedes hacer?": "Puedo responder preguntas simples y mantener una
conversación básica.",
"Adiós": "¡Hasta luego!"
}
import nltk
from nltk.tokenize import word_tokenize
from nltk.corpus import stopwords
import string
from nltk.chat.util import Chat, reflections
nltk.download('punkt')
nltk.download('stopwords')
import nltk: Importa la biblioteca nltk (Natural Language Toolkit), esencial para
el procesamiento de lenguaje natural.
nltk.download('punkt_tab'): Descarga un modelo específico de NLTK (punkt_tab), que
ayuda a la tokenización de texto (dividirlo en palabras u oraciones).
corpus = {...}: Define el conocimiento base del chatbot. Es un diccionario donde
las claves son las preguntas que el bot "conoce" (las que puede reconocer) y los
valores son las respuestas asociadas.
Las siguientes líneas (import nltk, from nltk.tokenize..., nltk.download('punkt'),
nltk.download('stopwords')) son importaciones y descargas duplicadas. Las librerías
y modelos se pueden importar/descargar solo una vez.
word_tokenize: Se usará para dividir texto en palabras.
stopwords: Contiene listas de palabras comunes (como "el", "la") que a menudo se
ignoran.
string: Proporciona acceso a constantes de cadenas, como la puntuación.
Chat, reflections: Son partes de NLTK para crear chatbots más tradicionales basados
en reglas, pero en este código no se usan realmente estas clases de nltk.chat.util.
2. Función de Preprocesamiento de Texto
Python
def preprocesar_texto(texto):
tokens = word_tokenize(texto.lower())
tokens = [t for t in tokens if t not in string.punctuation]
tokens = [t for t in tokens if t not in stopwords.words('spanish')]
return tokens
def preprocesar_texto(texto):: Define una función para limpiar el texto (tanto las
preguntas del corpus como las entradas del usuario).
tokens = word_tokenize(texto.lower()): Convierte el texto a minúsculas y lo divide
en palabras individuales (tokens).
tokens = [t for t in tokens if t not in string.punctuation]: Elimina los signos de
puntuación de la lista de tokens.
tokens = [t for t in tokens if t not in stopwords.words('spanish')]: Elimina las
"stop words" en español (palabras muy comunes que no suelen aportar mucho
significado) de la lista de tokens.
return tokens: Devuelve la lista de palabras limpias.
3. Función para Evaluar Similitud
Python
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
def evaluar_similitud(entrada, corpus):
corpus_keys = list(corpus.keys())
vectorizer = TfidfVectorizer(tokenizer=preprocesar_texto)
tfidf_matrix = vectorizer.fit_transform(corpus_keys + [entrada])
similitudes = cosine_similarity(tfidf_matrix[-1], tfidf_matrix[:-1])
indice_max_similitud = similitudes.argmax()
return corpus_keys[indice_max_similitud], similitudes[0, indice_max_similitud]
from sklearn.feature_extraction.text import TfidfVectorizer: Importa
TfidfVectorizer de scikit-learn. Esta herramienta convierte texto en vectores
numéricos basándose en la importancia de las palabras (TF-IDF).
from sklearn.metrics.pairwise import cosine_similarity: Importa cosine_similarity,
que calcula la similitud del coseno entre dos vectores. Una similitud de coseno
alta (cercana a 1) indica que los vectores son muy parecidos.
def evaluar_similitud(entrada, corpus):: Define una función que compara la entrada
del usuario con las preguntas del corpus.
corpus_keys = list(corpus.keys()): Obtiene una lista de todas las preguntas
conocidas del chatbot.
vectorizer = TfidfVectorizer(tokenizer=preprocesar_texto): Crea una instancia de
TfidfVectorizer. Le indica que use la función preprocesar_texto para procesar el
texto antes de crear los vectores TF-IDF.
tfidf_matrix = vectorizer.fit_transform(corpus_keys + [entrada]):
Crea una lista que contiene todas las preguntas del corpus más la entrada del
usuario.
fit_transform: Aprende el vocabulario de estos textos y luego los convierte a su
representación numérica TF-IDF. El resultado es una matriz donde cada fila es el
vector TF-IDF de una pregunta o la entrada del usuario.
similitudes = cosine_similarity(tfidf_matrix[-1], tfidf_matrix[:-1]):
tfidf_matrix[-1]: Es el vector TF-IDF de la entrada del usuario.
tfidf_matrix[:-1]: Son los vectores TF-IDF de todas las preguntas del corpus.
Esta línea calcula la similitud del coseno entre la entrada del usuario y cada una
de las preguntas del corpus.
indice_max_similitud = similitudes.argmax(): Encuentra el índice de la pregunta del
corpus que tiene la mayor similitud con la entrada del usuario.
return corpus_keys[indice_max_similitud], similitudes[0, indice_max_similitud]:
Devuelve la pregunta del corpus más similar y el valor de esa similitud.
4. Función para Obtener Respuesta
Python
def obtener_respuesta(entrada, corpus, umbral=0.5):
pregunta, similitud = evaluar_similitud(entrada, corpus)
if similitud >= umbral:
return corpus[pregunta]
else:
return "Lo siento, no entendí eso. ¿Puedes repetirlo?"
def obtener_respuesta(entrada, corpus, umbral=0.5):: Define la función principal
para obtener una respuesta del chatbot.
pregunta, similitud = evaluar_similitud(entrada, corpus): Llama a la función
anterior para obtener la pregunta más similar y su puntuación de similitud.
if similitud >= umbral:: Comprueba si la similitud encontrada es mayor o igual a un
umbral (por defecto 0.5). Este umbral determina qué tan parecida debe ser una
pregunta para que el bot la considere "conocida".
return corpus[pregunta]: Si la similitud supera el umbral, el bot devuelve la
respuesta asociada a esa pregunta conocida desde el corpus.
else: return "Lo siento, no entendí eso. ¿Puedes repetirlo?": Si la similitud es
menor que el umbral, el bot indica que no entendió la pregunta.
5. Bucle de Interacción y Ejemplo de Uso
Python
while True:
entrada_usuario = input()
respuesta = obtener_respuesta(entrada_usuario, corpus)
print(f"respuesta: {respuesta}")
def obtener_respuesta(entrada, corpus, umbral=0.5):
pregunta, similitud = evaluar_similitud(entrada, corpus)
if similitud >= umbral:
return corpus[pregunta]
else:
return "Lo siento, no entendí eso. ¿Puedes repetirlo?"
# Ejemplo de uso
entrada_usuario = "Hola"
respuesta = obtener_respuesta(entrada_usuario, corpus)
print(respuesta)
while True:: Inicia un bucle infinito, lo que permite que el chatbot interactúe
continuamente con el usuario.
entrada_usuario = input(): Le pide al usuario que escriba su pregunta.
respuesta = obtener_respuesta(entrada_usuario, corpus): Llama a la función para
obtener la respuesta del bot.
print(f"respuesta: {respuesta}"): Imprime la respuesta del chatbot.
La segunda definición de obtener_respuesta y el "Ejemplo de uso" al final del
código son duplicados e innecesarios. La función ya se definió y se usa en el bucle
while.
En resumen, el código crea un chatbot que usa el modelo TF-IDF para medir la
similitud semántica entre lo que el usuario escribe y un conjunto de preguntas
predefinidas. Si encuentra una pregunta suficientemente parecida, da la respuesta
asociada; de lo contrario, dice que no entendió.
