Aprendizaje de ingles con IA & Python

 

Aprendizaje de Inglés: Combinando Python, OpenAI, y Visión

1 de abril de 2024 #GPT-3, #Herramientas Gratuitas, #OpenAI

En este post, exploraremos un proyecto de Python que combina diversas tecnologías, incluyendo OpenAI para la traducción, la biblioteca de reconocimiento de voz speech_recognition para convertir la voz a texto, y mediapipe para la detección de manos, ofreciendo así una herramienta educativa interactiva.

Esta aplicación es particularmente útil para estudiantes de inglés, permitiéndoles interactuar a través de la voz y gestos manuales para mejorar su aprendizaje.

  

Preparación del Entorno

Antes de sumergirnos en el código, necesitamos preparar nuestro entorno de desarrollo instalando las dependencias necesarias. Asegúrate de tener Python instalado en tu sistema y luego instala los siguientes paquetes usando pip:

bashCopy codepip install opencv-python mediapipe tkinter speechrecognition openai

• opencv-python (OpenCV) se utiliza para la manipulación y el procesamiento de imágenes y vídeos.
• mediapipe ofrece soluciones preconstruidas para la detección de manos.
• tkinter es un paquete para la creación de interfaces gráficas de usuario (GUI).
• speechrecognition permite la conversión de voz a texto.
• openai se usa para acceder a las capacidades de traducción de GPT-3.

Exploración del Código

El código se organiza en una clase llamada EnglishLearningAssistant, que encapsula toda la funcionalidad de la aplicación.

 

Inicialización y GUI

La aplicación comienza inicializando la interfaz gráfica de usuario (GUI) con tkinter, creando un botón para iniciar la detección de manos y un área de texto para mostrar traducciones y mensajes al usuario.

pythonCopy codeclass EnglishLearningAssistant:
    def __init__(self, master):
        ...

Detección de Manos y Escucha Activa

Utilizando mediapipe, el método detect_hand inicia la cámara y procesa las imágenes capturadas para detectar la presencia de manos. Si se detectan manos y el sistema no está “escuchando”, se activa la escucha a través de start_listening.

pythonCopy codedef detect_hand(self):
    ...

Conversión de Voz a Texto y Traducción

La escucha activa se maneja en listen_and_translate, donde el audio capturado por el micrófono se convierte a texto usando el paquete speech_recognition. Luego, este texto se envía a la API de OpenAI para obtener una traducción o interpretación, que se muestra al usuario.

pythonCopy codedef listen_and_translate(self):
    ...

Personalización y Expansión

Este código es altamente personalizable. Puedes ajustar la confianza en la detección de manos en mediapipe o modificar el modelo de OpenAI utilizado para la traducción. También es posible expandir la aplicación para incluir más idiomas o agregar funcionalidades como juegos educativos que utilicen gestos manuales.

• Mira mi post sobre como mejorar tus promtps para aprender idiomas.

Codigo Completo

>>import cv2
>>import mediapipe as mp
>>import threading
>>import tkinter as tk
>>from tkinter import ttk, scrolledtext
>>import speech_recognition as sr
>>import openai
>>import time
>>import traceback

>>openai.api_key = "TU API DE OPENAI"

>>class EnglishLearningAssistant:
>>    def __init__(self, master):
>>        self.master = master
>>        master.title("Asistente de Aprendizaje de Inglés")

>>        self.listen_button = ttk.Button(master, text="Iniciar Detección de Mano", command=self.start_hand_detection)
>>        self.listen_button.pack(pady=10)

>>        self.translation_area = scrolledtext.ScrolledText(master, height=10)
>>        self.translation_area.pack(padx=10, pady=5, fill='both', expand=True)

>>        self.is_listening = False
>>        self.last_call_time = None

>>    def start_listening(self):
>>        current_time = time.time()
>>        if self.last_call_time and current_time - self.last_call_time < 10:
>>            time_to_wait = 10 - (current_time - self.last_call_time)
>>            print(f"Esperando {time_to_wait} segundos para evitar solapamiento...")
>>            time.sleep(time_to_wait)
>>        if not self.is_listening:
>>            self.is_listening = True
>>            threading.Thread(target=self.listen_and_translate, daemon=True).start()

>>    def listen_and_translate(self):
>>        self.last_call_time = time.time()
>>        try:
>>            recognizer = sr.Recognizer()
>>            with sr.Microphone() as source:
>>                self.update_translation_area_safe("Escuchando...")
>>                audio_data = recognizer.listen(source)
>>                text = recognizer.recognize_google(audio_data)
>>                self.update_translation_area_safe(f"Texto detectado: {text}\nTraduciendo...")
>>                translation = self.translate_text(text)
>>                self.update_translation_area_safe(f"Traducción al inglés:\n{translation}")
>>        except Exception as e:
>>            self.update_translation_area_safe(f"Error: {traceback.format_exc()}")
>>        finally:
>>            self.is_listening = False
>>            self.last_call_time = time.time()

>>    def translate_text(self, text):
>>        try:
>>            response = openai.Completion.create(
>>                model="gpt-3.5-turbo-instruct",
>>                prompt=f"Actua como un profesor de ingles dando ejemplos en español de la consulta:\n\n'{text}'",
>>                max_tokens=70,
>>                temperature=0.7
>>            )
>>            return response.choices[0].text.strip()
>>        except Exception as e:
>>            return f"Translation error: {traceback.format_exc()}"

>>    def update_translation_area_safe(self, message):
>>        if self.master.winfo_exists():
>>            self.translation_area.delete('1.0', tk.END)
>>            self.translation_area.insert(tk.INSERT, message)

>>    def start_hand_detection(self):
>>        threading.Thread(target=self.detect_hand, daemon=True).start()

>>    def detect_hand(self):
>>        mp_hands = mp.solutions.hands
>>        hands = mp_hands.Hands(min_detection_confidence=0.5, min_tracking_confidence=0.5)
>>        cap = cv2.VideoCapture(0)

>>        while cap.isOpened():
>>            success, image = cap.read()
>>            if not success:
>>                continue

>>            image = cv2.cvtColor(cv2.flip(image, 1), cv2.COLOR_BGR2RGB)
>>            results = hands.process(image)
>>
>>            if results.multi_hand_landmarks and not self.is_listening:
>>                self.start_listening()

>>            if cv2.waitKey(5) & 0xFF == 27:
>>                break

>>        cap.release()

>>root = tk.Tk()
>>app = EnglishLearningAssistant(root)
>>root.mainloop()

Conclusiones

El proyecto presentado es un ejemplo fascinante de cómo combinar varias tecnologías para crear herramientas educativas interactivas. Al integrar visión por computadora, procesamiento de lenguaje natural, y una interfaz gráfica, se abre un mundo de posibilidades para el aprendizaje de idiomas y otras áreas educativas. Este código no solo sirve como una herramienta útil sino también como un excelente punto de partida para proyectos más complejos y personalizados.