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

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.

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.

¡Mi Discord!

¡Únete a mi comunidad para estar al tanto de todas las novedades!. Unirse al canal de Discord

Alexis Galán

por Alexis Galán

SEO, Prompts & Python...

Deja una respuesta