Profesor: generar exercices

#¿Por qué preparar los ejercicios con un modelo local?

El marco de uso de la IA en educación publicado por el ministerio en junio de 2025, tal como lo resumen las administraciones educativas regionales francesas, permite su uso para preparar clases, evaluar y corregir, con dos obligaciones para el docente: verificar sistemáticamente los contenidos generados por la IA y ser transparente sobre su utilización. Prohíbe expresamente utilizar datos personales o confidenciales en las IA destinadas al público general e invita a dar prioridad a las soluciones libres. Un modelo local cumple estos tres puntos: nada sale del ordenador, no es necesario registrarse y los modelos de pesos abiertos son soluciones libres en el sentido habitual del término.

Hay que matizar un argumento que se suele esgrimir: sigue estando permitido preparar un ejercicio de matemáticas con un servicio dirigido al público general siempre que no se introduzca ningún dato personal. Las ventajas de ejecutar modelos en local están en otros aspectos. Permite trabajar con documentos que contienen nombres, como trabajos de alumnos o comentarios de evaluación, sin exponer a los alumnos. Funciona sin conexión. Y ofrece un comportamiento estable: una instrucción guardada y un modelo que no cambia de un mes a otro.

Alumnos y trabajos escolares

No introducir nunca nombres, trabajos de alumnos identificables ni valoraciones en un servicio en línea. En local, el riesgo de transferencia desaparece, pero la regla de minimización sigue siendo una buena práctica.

Coste

Sin suscripción. Ya dispones del hardware si tu ordenador reciente tiene 16 GB de memoria; de lo contrario, un modelo pequeño basta para los ejercicios sencillos.

Sin conexión

Útil en la sala de profesores o en un centro educativo cuya red filtra los servicios de IA.

Estabilidad

Una instrucción guardada en un modelo personalizado da fichas homogéneas de una semana a otra.

#Pila mínima

Puedes elegir entre dos programas para servir el modelo: Ollama, mediante la línea de comandos, o LM Studio, con una interfaz gráfica más accesible si el terminal te echa para atrás. En cuanto al modelo, Qwen 3.5 con 9 mil millones de parámetros ocupa 6,6 GB en la biblioteca de Ollama y anuncia 256.000 tokens de contexto: cabe en una tarjeta de 8 GB o en la memoria de un ordenador reciente. Mistral Small 24B ocupa 14 GB y requiere más memoria. Un modelo más grande no garantiza la exactitud; tu revisión sí.

Para no tener que volver a escribir tu consigna, crea un modelo personalizado con un archivo Modelfile: la instrucción SYSTEM define el mensaje de sistema aplicado a cada conversación. El archivo a continuación fija el rol, el nivel y el estilo de tus fichas.

FROM qwen3.5:9b
PARAMETER temperature 0.4
PARAMETER num_ctx 8192
SYSTEM """Tu aides un professeur de collège à préparer des exercices conformes aux programmes
français du cycle 4. Vocabulaire adapté à l'âge des élèves. Tu ne donnes que des
corrigés dont tu es sûr ; sinon tu écris : à vérifier. Tu n'inventes jamais de citation,
de date ou de source."""

ollama create prof-exos -f Modelfile
ollama run prof-exos

#Generar cuestionarios de opción múltiple utilizables, no solo legibles

Un cuestionario de opción múltiple solicitado en texto libre es difícil de reutilizar: hay que volver a escribirlo en la herramienta de la clase. Es mejor pedir un formato estructurado, que luego comprueba el código. Ollama puede restringir la respuesta a un esquema JSON: según su documentación, este se pasa en el campo format. El modelo redacta las preguntas; el script verifica que haya cuatro opciones distintas y una única respuesta correcta, y luego escribe un archivo que se puede importar.

import json, requests, re

SCHEMA = {'type': 'object', 'properties': {'questions': {'type': 'array', 'items': {
  'type': 'object', 'properties': {
    'enonce': {'type': 'string'},
    'choix': {'type': 'array', 'items': {'type': 'string'}},
    'bonne_reponse': {'type': 'integer'},
    'explication': {'type': 'string'}},
  'required': ['enonce', 'choix', 'bonne_reponse', 'explication']}}},
  'required': ['questions']}

def generer(sujet, niveau, n=10, modele='prof-exos'):
    consigne = (f'Rédige {n} questions à choix multiple sur : {sujet}. Niveau : {niveau}. '
      'Quatre choix par question, dont un seul correct ; bonne_reponse est l\'indice (0 à 3). '
      'Les mauvais choix doivent être plausibles. Une phrase d\'explication. '
      'Réponds par un JSON conforme à : ' + json.dumps(SCHEMA))
    r = requests.post('http://localhost:11434/api/chat', json={
        'model': modele, 'stream': False, 'format': SCHEMA,
        'messages': [{'role': 'user', 'content': consigne}]})
    return json.loads(r.json()['message']['content'])['questions']

def valides(questions):
    ok, rejets, vus = [], [], set()
    for q in questions:
        c = q.get('choix', [])
        if (len(c) != 4 or len({x.strip().lower() for x in c}) != 4
                or q.get('bonne_reponse') not in (0, 1, 2, 3) or q['enonce'].strip().lower() in vus):
            rejets.append(q); continue
        vus.add(q['enonce'].strip().lower()); ok.append(q)
    return ok, rejets

def esc(s):
    return re.sub(r'([~=#{}:])', r'\\\1', s)

def vers_gift(questions):
    blocs = []
    for i, q in enumerate(questions, 1):
        lignes = [('=' if j == q['bonne_reponse'] else '~') + esc(c) for j, c in enumerate(q['choix'])]
        blocs.append(f"::Q{i}::{esc(q['enonce'])} {{\n" + '\n'.join(lignes) + '\n}\n')
    return '\n'.join(blocs)

El formato GIFT, utilizado por Moodle, es un archivo de texto simple que se importa a un banco de preguntas. Si tu institución utiliza otra herramienta, adapta la última función: el principio sigue siendo generar un archivo a partir de datos verificados, no copiar y pegar el texto del modelo. Lo que el script no comprueba es la veracidad de las preguntas: de ahí la sección sobre verificación.

#Anclar cada pregunta en un pasaje de tu curso

El método más seguro para evitar hechos inventados consiste en exigir, para cada pregunta, el pasaje del curso que la justifica. Pegas tu texto, añades al esquema un campo passage y el script verifica que ese pasaje aparezca palabra por palabra en el texto proporcionado. Una pregunta cuyo pasaje no se encuentra se descarta: o el modelo ha inventado información o ha parafraseado sin fuente. Esta verificación no demuestra que la pregunta sea buena, pero garantiza que esté basada en tu curso y no en la memoria aproximada del modelo.

def normaliser(t):
    return ' '.join(t.split()).lower()

def ancrees(questions, cours):
    base = normaliser(cours)
    bonnes, douteuses = [], []
    for q in questions:
        (bonnes if normaliser(q.get('passage', '')) in base else douteuses).append(q)
    return bonnes, douteuses

El esquema y la instrucción se completan en consecuencia: añade passage a las propiedades y a los campos obligatorios, y escribe en la instrucción «copia palabra por palabra el pasaje del texto que justifica la respuesta correcta». Las preguntas sobre hechos que no aparecen en el curso, por ejemplo fechas nunca mencionadas, no pasarán el filtro, que es precisamente el objetivo.

#Ejercicios de matemáticas: Python calcula, el modelo da forma al texto

Un modelo de 9 mil millones de parámetros se equivoca en operaciones simples, especialmente con decimales y llevadas. Para ejercicios de cálculo, es mejor invertir los roles: el código elige los números al azar, calcula el resultado exacto y genera la solución; el modelo sirve para redactar enunciados de problemas a partir de esos números, algo que hace bien. Así, las respuestas de tus fichas nunca dependen de la aritmética del modelo.

import random
from decimal import Decimal

def fr(d):
    return str(d.normalize() if d == d.to_integral() else d).replace('.', ',')

def exercices_decimaux(n=8, graine=None):
    hasard = random.Random(graine)
    sortie = []
    for i in range(n):
        nb = 2 if i < 2 else hasard.choice([3, 3, 4])
        vals = [Decimal(hasard.randint(10, 9999)) / hasard.choice([10, 100]) for _ in range(nb)]
        signes = ['+'] + [hasard.choice(['+', '-']) for _ in vals[1:]]
        total = sum(v if s == '+' else -v for v, s in zip(vals, signes))
        if total < 0:
            continue
        enonce = ' '.join((s + ' ' if k else '') + fr(v) for k, (v, s) in enumerate(zip(vals, signes)))
        sortie.append((enonce, fr(total)))
    return sortie

for e, r in exercices_decimaux(graine=42):
    print(e, '=', r)

La semilla fija permite regenerar exactamente la misma ficha, por ejemplo para producir la versión corregida al día siguiente. El mismo principio se aplica a las conversiones de unidades, a los porcentajes, a las ecuaciones de primer grado, a todo lo que se calcula: el código produce y verifica, el modelo da formato. Para los idiomas, en cambio, el modelo está en su campo: produce frases para completar, diálogos con huecos e instrucciones, que hay que revisar.

Prépare pour des élèves de 5e (niveau A2 du CECRL) une fiche sur le present simple
et le present continuous : 5 phrases à conjuguer, 3 phrases à transformer, un court
dialogue à trous. Vocabulaire courant uniquement. Donne le corrigé à la fin, séparé
par une ligne « CORRIGÉ », et signale entre crochets toute phrase où les deux temps
sont possibles.

#Soluciones: pedir, luego contrastar

El solucionario se pide en un segundo mensaje para que el modelo mantenga el enunciado en contexto, especificando lo que esperas: la respuesta final, el razonamiento paso a paso, la regla aplicada y el error típico que hay que evitar. El solucionario es la parte más arriesgada de la ficha: un alumno aprende una respuesta incorrecta con confianza. Dos prácticas reducen el riesgo.

Calcular en lugar de encargar el cálculo

Cuando la respuesta se pueda calcular, obténla del código, no del modelo.

Generar dos veces y comparar

En los ejercicios de razonamiento, pide la solución dos veces con instrucciones ligeramente diferentes. Si las respuestas finales divergen, el ejercicio debe revisarse a mano.

Hacer que otro modelo lo resuelva

Un segundo modelo, de tamaño o familia diferente, resuelve el enunciado sin ver la solución. El desacuerdo señala errores probables. No es una prueba, solo un filtro.

Releer todo lo que se distribuirá

Ninguna verificación automática reemplaza la lectura del docente, quien sigue siendo responsable del contenido.

#Ajustar una ficha al nivel de los alumnos

La diferenciación es el uso en el que el modelo más aporta, porque reformular es su punto fuerte. Basta con partir de una ficha validada y pedir variantes, manteniendo los mismos números y las mismas respuestas para que el solucionario siga siendo válido. Pide a un colega que revise la variante antes de difundirla: una reformulación más sencilla puede modificar el sentido de un enunciado, un defecto habitual de estas reescrituras.

#Verificar la precisión, disciplina por disciplina

Lo que tienen en común es que el modelo escribe con la misma seguridad cuando tiene razón y cuando se equivoca. Además, el marco ministerial exige una verificación sistemática de los contenidos producidos por la IA. En concreto, reserva cinco minutos de revisión por ficha y lleva un pequeño registro de los errores encontrados: al cabo de un mes, sabrás en qué disciplinas el modelo es fiable para ti.

#Un ritmo de producción realista

1. 01
   Listar los conceptos de la semana

   Tres a cinco conceptos, con los extractos de clase como fuente.
2. 02
   Generar a partir de tus fuentes

   Pega el extracto del curso en la instrucción: las preguntas se mantienen vinculadas a lo que has enseñado.
3. 03
   Hacer que el código calcule las soluciones

   Para todo lo que implique cifras, utiliza un script como el anterior.
4. 04
   Releer y corregir

   Lee la ficha como lo haría un estudiante: un error en el solucionario cuesta caro.
5. 05
   Maquetar y declarar el uso

   Exporta en PDF o a tu herramienta de clase, y indica a los alumnos que una IA ayudó a preparar la ficha, conforme a la exigencia de transparencia.

• Fundamentos del prompting
• Dominar los system prompts
• Ollama Modelfile: crear y personalizar tu modelo
• LM Studio para principiantes
• Limitar las alucinaciones de un LLM local
• Salidas JSON estructuradas con Ollama

• Fuente: síntesis del marco de uso de la IA en educación (academia de Normandie)
• Fuente: marco de uso de la IA en educación (ministerio)
• Fuente: el archivo Modelfile de Ollama
• Fuente: salidas estructuradas de Ollama
• Fuente: Qwen 3.5 en la biblioteca de Ollama