Phi-4 de Microsoft: Tutorial paso a paso con proyecto de demostración

Microsoft presentó recientemente Phi-4, la última incorporación a la familia Phi de pequeños modelos lingüísticos. Como destaca en matemáticas, decidí utilizar Phi-4 para construir un corrector de deberes integrado con Gradio.

En este tutorial, te guiaré paso a paso en la construcción de una aplicación web funcional capaz de validar soluciones, corregir errores y proporcionar enfoques alternativos, ¡como si fuera un profesor virtual!

¿Qué es el modelo Phi-4 de Microsoft?

Phi-4 destaca en tareas de razonamiento complejo, sobre todo en matemáticas, al tiempo que mantiene su competencia en el procesamiento convencional del lenguaje. Sus características principales son:

• Capacidades avanzadas de razonamiento: Phi-4 se entrena con conjuntos de datos conjuntos de datos sintéticos y utiliza técnicas innovadoras de post-entrenamiento para superar a modelos mayores en tareas de razonamiento matemático.
• Eficacia y accesibilidad: Con 14.000 millones de parámetros, Phi-4 ofrece resultados de alta calidad sin grandes recursos computacionales, lo que lo hace accesible para una gama más amplia de aplicaciones.
• Disponibilidad: Actualmente se puede acceder a Phi-4 a través de Azure AI Foundry en virtud de un Acuerdo de Licencia de Investigación de Microsoft (MSRLA) y Cara de Abrazo.

Phi-4 ha demostrado un gran rendimiento en tareas de razonamiento matemático, superando incluso a modelos mayores como Gemini Pro 1.5 en problemas de competición matemática. Esto lo convierte en una buena opción para aplicaciones que requieren capacidades avanzadas de resolución de problemas matemáticos.

Fuente: Microsoft

Comprobador de deberes Phi-4: Resumen de la implementación

La aplicación que vamos a crear con Phi-4 es un corrector de deberes con IA. Este es el flujo de trabajo por el que pasará el usuario:

1. El usuario envía su tarea terminada (tanto las instrucciones del ejercicio como la solución del usuario).
2. Si la solución es incorrectael modelo te explicará la solución correcta con pasos detallados, como un profesor.
3. Si la solución es correctael modelo confirmará la solución o sugerirá una alternativa más limpia y eficaz si la respuesta es confusa.

Para proporcionar una interfaz web en la que los usuarios puedan interactuar con el corrector de tareas, utilizaremos Gradio.

Paso 1: Requisitos previos

Antes de empezar, asegúrate de que tienes instalado lo siguiente:

• Python 3.8+
• PyTorch: Para ejecutar modelos de aprendizaje profundo.
• Biblioteca Transformers HuggingFace: Para cargar el modelo Phi-4 de HuggingFace.
• Gradio: Crear una interfaz web fácil de usar.

Instala estas dependencias ejecutando

!pip install torch transformers gradio -qCon la tecnología de

Ahora ya tenemos todas las dependencias instaladas. A continuación, configuramos el modelo Phi-4.

Paso 2: Configuración del modelo

Cargamos el modelo Phi-4 de la biblioteca Transformers de HuggingFace. A continuación, el tokenizador preprocesa la entrada (el ejercicio y la solución) y la prepara para la inferencia.

# Imports
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch
import gradio as gr

# Load the Phi-4 model and tokenizer
model_name = "NyxKrage/Microsoft_Phi-4"
model=AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch.float16, device_map="auto")
tokenizer = AutoTokenizer.from_pretrained(model_name)

# Set tokenizer padding token if not set
if tokenizer.pad_token_id is None:
    tokenizer.pad_token_id = tokenizer.eos_token_idCon la tecnología de

El fragmento de código anterior configura el modelo Phi-4 y el tokenizador y los integra con PyTorch para los cálculos. Vamos a desglosar el código anterior con más detalle:

• Las clases AutoModelForCausalLM y AutoTokenizer se importan para trabajar con el modelo y la tokenización.
• El modelo se carga desde el repositorio Cara Abrazada utilizando el método from_pretrained() y se configura para utilizar precisión FP16 para optimizar el uso de memoria y la velocidad de cálculo.
• El parámetro device_map="auto" garantiza que el modelo se asigne automáticamente al hardware disponible.
• También se carga el tokenizador, que procesa el texto de entrada en tokens adecuados para el modelo.
• Una comprobación asegura que el tokenizador tiene un token de relleno definido; si no, asigna el eos_token_id (token de fin de secuencia) como token de relleno.

Paso 3: Diseñar funciones básicas 

Una vez establecido el modelo, definimos tres funciones clave para la aplicación:

1. Validación de la solución: El modelo evalúa la solución del usuario y proporciona correcciones si es incorrecta.
2. Sugerencias alternativas: Sugiere soluciones más limpias si la solución del usuario es desordenada.
3. Respuesta clara: El modelo también estructura el resultado con secciones claras.

La siguiente función, check_homework(), construye un aviso que contiene el ejercicio, la solución del usuario e instrucciones específicas para que el modelo confirme la corrección, identifique problemas o proporcione una guía paso a paso si la solución es incorrecta.

# Function to validate the solution and provide feedback
def check_homework(exercise, solution):
    prompt = f"""
    Exercise: {exercise}
    Solution: {solution}
Task: Validate the solution to the math problem, provided by the user. If the user's solution is correct, confirm else provide an alternative if the solution is messy. If it is incorrect, provide the correct solution with step-by-step reasoning.
    """
    # Tokenize and generate response
    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
    print(f"Tokenized input length: {len(inputs['input_ids'][0])}")
    outputs = model.generate(**inputs, max_new_tokens=1024)
    print(f"Generated output length: {len(outputs[0])}")
    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
    # response = response.replace(prompt, "").strip()
    prompt_len = len(prompt)
    response = response[prompt_len:].strip()
    print(f"Raw Response: {response}")
    return responseCon la tecnología de

La función check_homework() tokeniza la consulta utilizando el tokenizador del modelo. Lo prepara para el procesamiento convirtiendo la entrada en tensores PyTorch, que se asignan al dispositivo donde se ejecuta el modelo.

A continuación, genera una respuesta del modelo con un límite de max_new_tokens=1024 para controlar la longitud de salida. Esta longitud de ficha puede variar según las necesidades.

Por último, se devuelve la respuesta procesada, que proporciona información o una solución corregida. 

Paso 4: Crear una interfaz fácil de usar con Gradio

Gradio simplifica el despliegue del corrector de deberes permitiendo a los usuarios introducir sus ejercicios y soluciones de forma interactiva. El siguiente fragmento de código crea una interfaz web de Gradio fácil de usar para la función check_homework(). La interfaz de Gradio toma las entradas del usuario (el ejercicio y la solución) y las pasa al modelo para su validación. 

# Define the function that integrates with the Gradio app
def homework_checker_ui(exercise, solution):
    return check_homework(exercise, solution)

# Create the Gradio interface using the new syntax
interface = gr.Interface(
    fn=homework_checker_ui,
    inputs=[
        gr.Textbox(lines=2, label="Exercise (e.g., Solve for x in 2x + 3 = 7)"),
        gr.Textbox(lines=1, label="Your Solution (e.g., x = 1)")
    ],
    outputs=gr.Textbox(label="Feedback"),
    title="AI Homework Checker",
    description="Validate your homework solutions, get corrections, and receive cleaner alternatives.",
)

# Launch the app
interface.launch(debug=True)Con la tecnología de

Creamos dos campos de entrada utilizando gr.Textbox: uno para el problema matemático (ejercicio) y otro para la solución del usuario. El resultado se muestra en un único gr.Textbox etiquetado "Feedback". El comando interface.launch() inicia la aplicación Gradio en un navegador, y la bandera debug=True habilita registros detallados para ayudar a solucionar errores. 

Paso 5: Probar y validar

Es hora de probar nuestra aplicación AI Homework Checker. Aquí tienes algunas pruebas que he realizado:

1. Un simple problema matemático: Intenté resolver problemas básicos de probabilidad, y la aplicación me devolvió una solución bien estructurada y clara del problema.

2. Problema de la derivada compleja: Resolver las derivadas puede ser un reto para algunos modelos. Aquí, intenté hallar la primera derivada de una función logarítmica natural con el corrector de tareas y produjo un razonamiento paso a paso correcto para la solución.

Conclusión

En este tutorial, creamos un corrector de tareas potenciado por IA utilizando el modelo Phi-4. Esta app valida las soluciones, proporciona correcciones detalladas y sugiere alternativas elegantes, lo que la convierte en un profesor virtual ideal para los estudiantes.

¿Listo para ampliar la aplicación? Experimenta con problemas más complejos, ¡o intégralo en plataformas educativas para un uso más amplio!