Phi 4 Multimodal: Una guía con proyecto de demostración

Phi-4-multimodal es un multimodal ligero multimodal ligero desarrollado por Microsoft. Forma parte de la familia Phi de Microsoft de pequeños modelos lingüísticos (SLM).

En este tutorial, te explicaré paso a paso cómo utilizar Phi-4-multimodal para construir un tutor lingüístico multimodal que pueda trabajar con texto, imágenes y audio. Las principales características de esta aplicación son

• Aprendizaje basado en textos: Proporciona corrección gramatical en tiempo real, traducción de idiomas, reestructuración de frases y sugerencias de vocabulario según el contexto.
• Aprendizaje basado en imágenes: Extrae y traduce el texto de las imágenes y resume el contenido visual para una mejor comprensión.
• Aprendizaje basado en audio: Convierte el habla en texto, evalúa la precisión de la pronunciación y permite la traducción del habla en tiempo real a varios idiomas. 

Hagamos primero una presentación muy rápida del modelo multimodal Phi-4, y luego empezaremos a construir la aplicación.

¿Qué es Phi-4-Multimodal?

Phi-4-multimodal es un modelo avanzado de IA diseñado para el procesamiento de texto, visión y habla. Permite la integración perfecta de múltiples modalidades, lo que lo hace ideal para aplicaciones de aprendizaje de idiomas. Algunas de sus capacidades clave son:

• Tratamiento de textos: Esto incluye corrección gramatical, traducción y construcción de frases.
• Procesamiento de la visión: Phi 4 puede realizar reconocimiento óptico de caracteres (OCR), resumen de imágenes e interacciones multimodales.
• Procesamiento del habla: También puede realizar el reconocimiento automático del habla (ASR), junto con la respuesta de pronunciación y la traducción de voz a texto.

Con una longitud de contexto de 128K tokens, el modelo multimodal Phi-4 está optimizado para un razonamiento eficiente y entornos con limitaciones de memoria, lo que lo hace perfecto para el aprendizaje del lenguaje impulsado por IA en tiempo real.

Paso 1: Requisitos previos

La aplicación de tutor lingüístico multimodal que vamos a construir es una herramienta interactiva potenciada por IA diseñada para ayudar a los usuarios a aprender nuevos idiomas mediante una combinación de interacciones basadas en texto, imágenes y audio.

Antes de empezar, asegurémonos de que tenemos instaladas las siguientes herramientas y bibliotecas:

• Python 3.8+
• antorcha
• Transformers
• PIL
• Archivo de sonido
• Gradio

Ejecuta los siguientes comandos para instalar las dependencias necesarias:

pip install gradio transformers torch soundfile pillow

También debemos asegurarnos de que FlashAttention2 está instalado para mejorar el rendimiento:

pip install flash-attn --no-build-isolation

Nota: Este proyecto utiliza una GPU A100 en un portátil Google Colab. Si utilizas una GPU antigua (por ejemplo, NVIDIA V100), puede que tengas que desactivar FlashAttention2 configurando _attn_implementation="eager" en el paso de inicialización del modelo.

Una vez instaladas las dependencias anteriores, ejecuta los siguientes comandos de importación:

import gradio as gr
import torch
import requests
import io
import os
import soundfile as sf
from PIL import Image
from transformers import AutoModelForCausalLM, AutoProcessor, GenerationConfig

Paso 2: Carga Phi-4-Multimodal

Para aprovechar las capacidades multimodales de Phi-4, primero cargamos tanto el modelo como su procesador. La ruta del modelo se establece desde Cara Abrazadamientras que el procesador se encarga de tokenizar el texto, redimensionar y normalizar las imágenes, y convertir las formas de onda de audio a un formato compatible con el modelo para un procesamiento multimodal sin fisuras.

# Load model and processor
model_path = "microsoft/Phi-4-multimodal-instruct"
processor = AutoProcessor.from_pretrained(model_path, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_path, 
    device_map="cuda", 
    torch_dtype="auto", 
    trust_remote_code=True,
    _attn_implementation='flash_attention_2',
).cuda()
generation_config = GenerationConfig.from_pretrained(model_path)

El paso de inicialización del modelo utiliza el 'AutoModelForCausalLM.from_pretrained() function to load the pretrained Phi-4 model for causal language modeling (CLM) and loads the model on GPU using device_map="cuda".

Un parámetro clave en este paso es _attn_implementation='flash_attention_2'`, que utiliza FlashAttention2 para un mecanismo de atención más rápido y eficiente en memoria, especialmente para el procesamiento de contextos largos.

Paso 3: Construir funcionalidades clave

Ahora que hemos cargado el modelo, vamos a construir las funcionalidades clave.

1. Limpiar la respuesta

Un aspecto importante de cualquier proyecto basado en LLM o VLM es garantizar que el modelo genere respuestas precisas y pertinentes. Esto también implica eliminar cualquier texto de aviso de la salida, garantizando que los usuarios reciban una respuesta limpia y directa sin que la instrucción inicial aparezca al principio.

def clean_response(response, instruction_keywords):
    """Removes the prompt text dynamically based on instruction keywords."""
    for keyword in instruction_keywords:
        if response.lower().startswith(keyword.lower()):
            response = response[len(keyword):].strip()
    return response

Simplemente utilizamos la función strip() para eliminar el texto de la instrucción basándonos en las palabras clave de la instrucción.

2. Tratamiento de entradas

Ahora, vamos a procesar nuestras entradas, que pueden ser texto, imagen o audio, según la entrada del usuario o el escenario.

def process_input(file, input_type, question):
    user_prompt = "<|user|>"
    assistant_prompt = "<|assistant|>"
    prompt_suffix = "<|end|>"
    
    if input_type == "Image":
	prompt= f'{user_prompt}<|image_1|>{question}{prompt_suffix}{assistant_prompt}'
        image = Image.open(file)
	inputs = processor(text=prompt, images=image, return_tensors='pt').to(model.device)
    elif input_type == "Audio":
 	prompt= f'{user_prompt}<|audio_1|>{question}{prompt_suffix}{assistant_prompt}'
        audio, samplerate = sf.read(file)
        inputs = processor(text=prompt, audios=[(audio, samplerate)], return_tensors='pt').to(model.device)
    elif input_type == "Text":
        prompt = f'{user_prompt}{question} "{file}"{prompt_suffix}{assistant_prompt}'
        inputs = processor(text=prompt, return_tensors='pt').to(model.device)
    else:
        return "Invalid input type"    
    
    generate_ids = model.generate(**inputs, max_new_tokens=1000, generation_config=generation_config)
    response = processor.batch_decode(generate_ids, skip_special_tokens=True)[0]
    return clean_response(response, [question])

La función anterior se encarga de manejar las entradas de texto, imagen y audio y de generar una respuesta utilizando el modelo multimodal Phi-4. Aquí tienes un desglose técnico de este flujo de trabajo:

1. Procesamiento de entrada de imágenes: Si el tipo de entrada es "Image", la consulta se formatea con un marcador de posición de imagen (<|image_1|>). A continuación se carga la imagen, y el procesador tokeniza el texto que la acompaña mientras extrae las características visuales. Las entradas procesadas se transfieren a la GPU para un cálculo optimizado.
2. Procesamiento de entrada de audio: Si el tipo de entrada es "Audio", el indicador se estructura con un marcador de posición de audio (<|audio_1|>). El archivo de audio se lee con la función sf.read(), extrayendo la forma de onda en bruto y la frecuencia de muestreo. A continuación, el procesador codifica tanto el audio como el texto, garantizando una integración perfecta para la comprensión multimodal.
3. Procesamiento de entrada de texto: Si el tipo de entrada es "Text", el texto se incrusta directamente en el prompt. El procesador tokeniza y codifica la entrada, preparándola para su posterior procesamiento por el modelo.

3. Traducción y correcciones gramaticales

A continuación, procesamos el texto para su traducción y corrección gramatical mediante el modelo multimodal Phi-4. 

def process_text_translate(text, target_language):
    prompt = f'Translate the following text to {target_language}: "{text}"'
    return process_input(text, "Text", prompt)
def process_text_grammar(text):
    prompt = f'Check the grammar and provide corrections if needed for the following text: "{text}"'
    return process_input(text, "Text", prompt)

La función process_text_translate() construye dinámicamente un aviso de traducción especificando la lengua de destino y pasa el texto de entrada y el aviso estructurado a la función process_input(), devolviendo el texto traducido. 

Del mismo modo, la función process_text_grammar() construye un aviso de corrección gramatical, llama a la función process_input() con el texto de entrada y el tipo, y devuelve una versión gramaticalmente corregida del texto. Ambas funciones agilizan el procesamiento lingüístico utilizando las capacidades del modelo para la traducción y la corrección gramatical.

Paso 4: Construir la demostración multimodal con Gradio

Ahora ya tenemos todas las funciones lógicas clave. A continuación, trabajaremos en la creación de una interfaz de usuario interactiva con Gradio.

def gradio_interface():
    with gr.Blocks() as demo:
        gr.Markdown("# Phi 4 Powered - Multimodal Language Tutor")        
        with gr.Tab("Text-Based Learning"):
            text_input = gr.Textbox(label="Enter Text")
            language_input = gr.Textbox(label="Target Language", value="French")
            text_output = gr.Textbox(label="Response")
            text_translate_btn = gr.Button("Translate")
            text_grammar_btn = gr.Button("Check Grammar")
            text_clear_btn = gr.Button("Clear")
            text_translate_btn.click(process_text_translate, inputs=[text_input, language_input], outputs=text_output)
            text_grammar_btn.click(process_text_grammar, inputs=[text_input], outputs=text_output)
            text_clear_btn.click(lambda: ("", "", ""), outputs=[text_input, language_input, text_output])        
        with gr.Tab("Image-Based Learning"):
            image_input = gr.Image(type="filepath", label="Upload Image")
            language_input_image = gr.Textbox(label="Target Language for Translation", value="English")
            image_output = gr.Textbox(label="Response")
            image_clear_btn = gr.Button("Clear")
            image_translate_btn = gr.Button("Translate Text in Image")
            image_summarize_btn = gr.Button("Summarize Image")
            image_translate_btn.click(process_input, inputs=[image_input, gr.Textbox(value="Image", visible=False), gr.Textbox(value="Extract and translate text", visible=False)], outputs=image_output)
            image_summarize_btn.click(process_input, inputs=[image_input, gr.Textbox(value="Image", visible=False), gr.Textbox(value="Summarize this image", visible=False)], outputs=image_output)
            image_clear_btn.click(lambda: (None, "", ""), outputs=[image_input, language_input_image, image_output])
        with gr.Tab("Audio-Based Learning"):
            audio_input = gr.Audio(type="filepath", label="Upload Audio")
            language_input_audio = gr.Textbox(label="Target Language for Translation", value="English")
            transcript_output = gr.Textbox(label="Transcribed Text")
            translated_output = gr.Textbox(label="Translated Text")
            audio_clear_btn = gr.Button("Clear")
            audio_transcribe_btn = gr.Button("Transcribe & Translate")
            audio_transcribe_btn.click(process_input, inputs=[audio_input, gr.Textbox(value="Audio", visible=False), gr.Textbox(value="Transcribe this audio", visible=False)], outputs=transcript_output)
            audio_transcribe_btn.click(process_input, inputs=[audio_input, gr.Textbox(value="Audio", visible=False), language_input_audio], outputs=translated_output)
            audio_clear_btn.click(lambda: (None, "", "", ""), outputs=[audio_input, language_input_audio, transcript_output, translated_output])        
        demo.launch(debug=True)

if __name__ == "__main__":
    gradio_interface()

El código anterior organiza la interfaz de Gradio en tres pestañas interactivas, a saber: aprendizaje basado en texto, aprendizaje basado en imágenes y aprendizaje basado en audio, cada una de ellas diseñada para diferentes funcionalidades de aprendizaje de idiomas.

Los usuarios pueden introducir texto para traducción o corrección gramatical, subir imágenes para extracción y resumen de texto, o proporcionar audio para transcripción y traducción de voz. 

Cada función se activa mediante el método click() de Gradio, que llama a funciones de procesamiento como process_text_translate(), process_text_grammar() y process_input(), como ya se ha comentado, pasando las entradas necesarias y actualizando las salidas dinámicamente.

Se incluye un botónClear en cada pestaña para restablecer las entradas y salidas, garantizando una experiencia de usuario sin problemas. Por último, la interfaz se lanza con demo.launch(debug=True), lo que permite a los desarrolladores depurar fácilmente cualquier error de la aplicación.

Paso 5: Probar la aplicación

Aquí tienes algunos de mis experimentos con esta aplicación.

Traducción y revisión gramatical

Para las tareas de traducción y comprobación gramatical, proporcioné el texto "Hola mundo" e indiqué al modelo que lo tradujera al francés y comprobara su gramática (fíjate en los diferentes botones para traducción y comprobación gramatical).

Traducir el texto de una imagen

En este ejemplo, he proporcionado una imagen de una señal de stop española que indica a los peatones que no deben circular por un camino concreto. El modelo interpretó con precisión el significado del signo y generó la respuesta: "No camines por la pista".

Transcripción y traducción de audio

Para la transcripción del audio, proporcioné un archivo de audio en inglés e indiqué a la modelo que transcribiera el discurso y tradujera la transcripción al francés.

Conclusión

En este tutorial, construimos un tutor de idiomas multimodal utilizando el modelo multimodal Phi-4, que permite el aprendizaje de idiomas basado en texto, imágenes y audio. Utilizamos las capacidades avanzadas de visión, voz y texto de Phi-4 para proporcionar traducciones en tiempo real, correcciones gramaticales, transcripción de voz y conocimientos de aprendizaje basados en imágenes. Este proyecto demuestra cómo la IA multimodal puede mejorar la educación lingüística y la accesibilidad.