De su primera pregunta
a su propio sistema de IA.

Empiece sin código: distinga reglas, aprendizaje y generación.

1. IA, ML y deep learning
2. Predicción frente a generación
3. Una línea base medible

Práctica: Con etiquetas [0,0,0,1,0], cree exactitud_base como proporción de ceros y positivos_detectados=0 para el predictor siempre negativo.

Reto: Describa una tarea cotidiana que podría beneficiarse de IA y compárela con una regla simple.

Relacione los datos disponibles con el tipo de aprendizaje.

1. Supervisado y no supervisado
2. Autosupervisión y transferencia
3. Recompensas y decisiones

Práctica: Cree enfoques con las claves spam, agrupar y juego y los valores supervisado, no supervisado y refuerzo, respectivamente.

Reto: Proponga tres problemas y justifique su forma de aprendizaje según las etiquetas o recompensas disponibles.

Diseñe un proyecto antes de elegir el modelo.

1. Formular la decisión
2. Separar desarrollo y prueba
3. Reproducir y documentar

Práctica: Con ids=range(10), cree train con 0 a 5, valid con 6 y 7, y test con 8 y 9; compruebe que no se solapan.

Reto: Redacte un protocolo de experimento con decisión, datos, partición, línea base y criterio de aceptación.

Reconozca riesgos concretos desde el primer módulo.

1. El dato representa decisiones
2. Privacidad y minimización
3. Supervisión y abstención

Práctica: Desde registros con nombre y valor, cree datos_minimos conservando solo valor: [{"valor":2},{"valor":3}].

Reto: Prepare un registro de riesgos para su proyecto: sesgo de selección, datos personales y una salida insegura.

Aprenda a escribir, ejecutar y leer una respuesta.

1. Objetos y nombres
2. Texto, números y tipos
3. Leer la consola

Práctica: Cree muestras=12, replicas=3 y total=muestras*replicas. Muestre total con print.

Reto: Cambie el ejemplo para calcular el coste de procesar varias muestras y explique cada línea.

Transforme observaciones de forma explícita.

1. Secuencias y diccionarios
2. Condiciones y sangría
3. Recorridos y comprensión

Práctica: Desde valores=[-2,0,3,5], cree positivos con valores mayores que cero y cuadrados con sus cuadrados.

Reto: Filtre una lista de registros incompletos y explique qué valores decidió excluir.

Convierta un cálculo en una pieza reutilizable.

1. Entradas y devolución
2. Errores como contratos
3. Pruebas de comportamiento

Práctica: Defina media(valores): devuelva sum(valores)/len(valores) y lance ValueError si la lista está vacía.

Reto: Cree una función de normalización y escriba tres casos que comprueben su contrato.

Pase de listas a matrices y tablas.

1. Arrays y dimensiones
2. Tablas con significado
3. Limpieza sin fuga

Práctica: Cree un DataFrame con grupo=["A","A","B"] y valor=[2,4,8]; obtenga medias por grupo en resumen.

Reto: Audite una tabla sintética: tipos, faltantes y duplicados; proponga decisiones de limpieza.

Entienda el lenguaje de las representaciones.

1. Vectores como características
2. Matrices y transformaciones
3. Coseno y geometría

Práctica: Con a=[1,2] y b=[2,1], calcule producto=4 y coseno=0.8 usando NumPy.

Reto: Diseñe tres vectores de dos dimensiones e interprete sus semejanzas y diferencias.

Combine evidencia con la frecuencia de partida.

1. Probabilidad condicional
2. Teorema de Bayes
3. Incertidumbre de los supuestos

Práctica: Calcule posterior con prevalencia=0.01, sensibilidad=0.9 y fpr=0.05 mediante Bayes.

Reto: Explique el resultado con una población de 10 000 objetos sin usar terminología clínica.

Describa variación y evite prometer precisión injustificada.

1. Centro y dispersión
2. Muestreo y bootstrap
3. Leer evidencia

Práctica: Para valores=[1,2,3,4,100], calcule media y mediana con NumPy.

Reto: Compare la exactitud de dos modelos con un intervalo y explique qué no permite concluir.

Vea cómo aprende un parámetro.

1. Una pérdida cuantifica error
2. Derivada como pendiente
3. Tasa de aprendizaje

Práctica: Empiece con w=0 y haga 40 actualizaciones w -= 0.1*2*(w-3). Guarde perdida=(w-3)**2.

Reto: Compare tres tasas y documente velocidad, oscilación y error final.

Resuelva un problema sin entrenar una red.

1. Estados y transiciones
2. BFS, Dijkstra y A estrella
3. Memoria y estados repetidos

Práctica: Implemente BFS sobre grafo={"A":["B","C"],"B":["D"],"C":["D"],"D":[]}; guarde ruta desde A hasta D.

Reto: Modele un recorrido como grafo y compare una ruta corta con una barata.

Separe lo que se deduce de lo que se predice.

1. Proposiciones y reglas
2. Satisfacer restricciones
3. Sistemas híbridos

Práctica: Enumere con itertools.product los pares de colores rojo y azul para A y B; guarde soluciones donde A y B difieran.

Reto: Defina un horario con tres variables y dos restricciones e identifique una contradicción.

Construya su primer predictor de cantidades.

1. Una combinación de variables
2. MAE y MSE
3. Residuos y extrapolación

Práctica: Ajuste LinearRegression con X=[[0],[1],[2],[3]] e y=[1,3,5,7]; guarde prediccion para [[4]].

Reto: Compare una recta y una constante en un conjunto reservado, incluyendo los residuos.

Transforme probabilidades en decisiones justificadas.

1. Regresión logística
2. Matriz de confusión
3. Umbral y calibración

Práctica: Con y=[0,1,1,0], probabilidades=[0.1,0.4,0.8,0.7] y umbral=0.5, calcule tp, fp, fn y recall.

Reto: Elija un umbral para un filtro de revisión humana y justifique el coste de ambos errores.

Haga que cada transformación respete la evaluación.

1. Particiones según dependencia
2. Transformaciones aprendidas
3. Pipeline reproducible

Práctica: Ajuste StandardScaler sobre [[0],[2]]; transforme [[4]] y guarde escalado como número.

Reto: Diseñe un pipeline con faltantes y variables categóricas para una partición por grupos.

Modele relaciones no lineales en tablas.

1. Divisiones de un árbol
2. Bagging y bosques
3. Boosting secuencial

Práctica: Entrene DecisionTreeClassifier(max_depth=1,random_state=7) con X=[[0],[1],[2],[3]], y=[0,0,1,1]; guarde clases para [[0.2],[2.8]].

Reto: Compare árbol y bosque con una partición fija y describa errores por subgrupo.

Elija modelos sin engañarse con el ajuste.

1. Sesgo y varianza
2. Búsqueda de hiperparámetros
3. Elegir con varias restricciones

Práctica: Calcule media_cv y desviacion_cv de scores=[0.7,0.8,0.9] con NumPy (desviación poblacional).

Reto: Seleccione un modelo usando rendimiento, variabilidad y tiempo de inferencia con una regla escrita de antemano.

Descubra estructura sin convertirla en una certeza.

1. Agrupar por proximidad
2. PCA y proyección
3. Anomalías y contexto

Práctica: Ajuste PCA(n_components=1) a X=[[0,0],[1,1],[2,2],[3,3]]; cree proyeccion y varianza_explicada.

Reto: Agrupe objetos sintéticos y pruebe cómo cambia el resultado si cambia la escala de una variable.

Construya la unidad de una red y siga sus derivadas.

1. De una neurona a una red
2. Propagación hacia delante
3. Derivar hacia atrás

Práctica: Con X=[[1,2],[3,4]], W=[[1,-1],[0.5,1]] y b=[0,1], calcule z=X@W+b y activacion=max(0,z) con NumPy.

Reto: Dibuje una red con dimensiones de entrada, dos capas y salida, y explique por dónde viaja el gradiente.

Entrene una red pequeña con controles claros.

1. Lotes y optimizadores
2. Regularización y parada
3. Diagnosticar el aprendizaje

Práctica: Entrene una neurona sigmoide para AND con NumPy durante 1500 pasos a tasa 0.5; produzca pred para [[0,0],[0,1],[1,0],[1,1]].

Reto: Entrene una red en un notebook y compare curvas con y sin regularización.

Reconozca patrones espaciales sin olvidar la procedencia.

1. Imagen como tensor
2. Convoluciones y filtros
3. Transferencia y aumentos

Práctica: Calcule la correlación válida sin invertir el filtro: señal=[1,2,4,7], kernel=[-1,1]; guarde bordes.

Reto: Diseñe una clasificación de imágenes con partición por fuente y aumentos justificados.

Transforme texto en representaciones comparables.

1. Tokenizar y representar
2. Embeddings aprendidos
3. Secuencias y memoria

Práctica: Use TfidfVectorizer sobre ["gato duerme","perro corre","gato corre"]; calcule matriz y vocabulario.

Reto: Compare coincidencia léxica y embeddings con sinónimos, negaciones y términos del dominio.

Calcule cómo una posición combina información de otras.

1. Queries, keys y values
2. Cabezas y posición
3. Máscaras y coste

Práctica: Con scores=[1,2,3] y valores=[10,20,30], calcule pesos softmax estable y contexto como suma ponderada.

Reto: Construya una atención de dos tokens y explique qué cambia al aplicar una máscara.

Entienda qué hace realmente un modelo de lenguaje.

1. Preentrenar y condicionar
2. Muestreo y temperatura
3. Contexto y recursos

Práctica: Con logits=[2,1,0], cree p_frio con temperatura 0.5 y p_calido con 2.0 usando softmax; ambas deben sumar 1.

Reto: Diseñe una comparación de decodificación que mida diversidad y exactitud por separado.

Convierta una petición vaga en una tarea comprobable.

1. Especificar el contrato
2. Estructura y validación
3. Iterar con una evaluación

Práctica: Analice respuesta JSON {"categoria":"soporte","prioridad":2}; cree valido=True solo si categoria está en soporte/ventas y prioridad es un entero entre 1 y 3.

Reto: Escriba un prompt de extracción y un esquema con tres casos que deban rechazarse.

Conecte texto, imagen y audio con sus límites.

1. Representaciones entre modalidades
2. Difusión y eliminación de ruido
3. Audio y evaluación

Práctica: En el modelo simplificado x_t=sqrt(alpha)*x0+sqrt(1-alpha)*ruido, recupere x0 con alpha=0.64, x_t=[1.4,2.2], ruido=[1,1].

Reto: Diseñe una evaluación multimodal y enumere casos donde la salida requiere verificación humana.

Encuentre evidencia antes de redactar una respuesta.

1. Indexar documentos
2. Recuperación híbrida
3. Medir la búsqueda

Práctica: Con documentos=["cultivo bacteriano","red neuronal","cultivo celular"], vectorice TF-IDF y recupere el índice de mayor similitud para "neuronal" en mejor.

Reto: Diseñe fragmentos de un manual y prepare diez consultas con referencias relevantes.

Conecte recuperación y generación sin prometer ausencia de errores.

1. El flujo RAG
2. Citas verificables
3. Defensas del sistema

Práctica: Dadas evidencias={"D1":"La incubación es de 24 horas","D2":"Conservar a 4 grados"}, cree respuesta con texto="La incubación es de 24 horas" y citas=["D1"].

Reto: Prepare un flujo de RAG con respuesta respaldada, consulta sin evidencia y documento con una instrucción maliciosa.

Mida el sistema completo y sus modos de fallo.

1. Conjunto de evaluación
2. Evaluaciones automáticas y humanas
3. Pruebas de ataque

Práctica: Con resultados=[True,False,True,True] y latencias=[100,200,150,550], calcule tasa_exito y latencia_media.

Reto: Construya diez casos de evaluación con rúbrica, incluyendo ausencia de evidencia e inyección.

Diseñe autonomía acotada y observable.

1. Workflow frente a agente
2. Herramientas como contratos
3. Memoria, presupuesto y trazas

Práctica: Implemente ejecutar(nombre,a,b) que solo acepte nombre="sumar", devuelva a+b y lance ValueError para cualquier otro nombre.

Reto: Diseñe un agente de consulta con dos herramientas de lectura, límite de pasos y escalamiento.

Elija cuándo modificar pesos y qué datos necesita.

1. Prompt, RAG o ajuste
2. Datos y objetivo supervisado
3. LoRA y adaptación eficiente

Práctica: Con W=identidad 2x2, B=[[1],[2]] y A=[[0.1,0.2]], cree W_adaptada=W+B@A.

Reto: Elabore una decisión entre prompt, RAG y LoRA con criterios de calidad, actualización y recursos.

Entienda cómo se ajusta el comportamiento de un modelo.

1. De demostraciones a preferencias
2. RLHF y modelo de recompensa
3. Optimización directa de preferencias

Práctica: Calcule perdida_dpo=log(1+exp(-beta*margen)) para beta=0.5 y margen=2.0 usando math.

Reto: Diseñe una rúbrica de preferencia con desacuerdos posibles y una evaluación independiente.

Reduzca recursos sin ocultar pérdida de calidad.

1. Cuantización de pesos
2. Distilación
3. Servir con presupuesto

Práctica: Cuantice simétricamente w=[-1,-0.25,0.5,1] con escala=1/127 usando round y límites -127,127; reconstruya recuperado.

Reto: Compare modelo base y comprimido en calidad, memoria pico y latencia p95.

Compare compresión, generación y reconstrucción.

1. Autoencoder
2. Variacional y adversarial
3. Evaluación y cobertura

Práctica: Con original=[1,2,3] y reconstruido=[1.1,1.8,3.1], calcule error_reconstruccion como media de errores cuadrados.

Reto: Diseñe una auditoría de un generador con calidad, diversidad y riesgo de memorización.

Aprenda a decidir cuando actuar cambia la experiencia.

1. Explorar o explotar
2. Estados y retorno
3. Q-learning y su extensión

Práctica: Actualice q=1 con tasa=0.5, recompensa=2, gamma=0.9 y max_siguiente=4 para una transición no terminal; guarde q_nuevo.

Reto: Diseñe una recompensa y muestre una conducta indeseada que podría maximizarla.

Ordene candidatos y evite confundir clics con valor.

1. Candidatos y puntuación
2. Evaluar rankings
3. Retroalimentación y objetivos

Práctica: Con usuario=[1,2] e items=[[1,0],[0,2],[1,1]], calcule puntuaciones por producto punto y mejor_item (índice).

Reto: Diseñe una evaluación temporal que incluya usuarios nuevos y una métrica de diversidad.

Separe predecir lo que ocurre de cambiar lo que ocurrirá.

1. Asociación e intervención
2. Predicción temporal
3. Estimaciones y cambio

Práctica: Con serie=[10,12,11,15,14], cree pred=[10,12,11,15] como pronóstico de último valor para los cuatro siguientes y calcule mae.

Reto: Formule por separado una pregunta predictiva y una causal sobre el mismo proceso.

Investigue por qué falla y para quién.

1. Explicar predicciones
2. Equidad y calibración
3. Robustez y distribución

Práctica: Con grupo_A=(8 aciertos,10 casos) y grupo_B=(12 aciertos,20 casos), calcule tasa_A, tasa_B y brecha absoluta.

Reto: Prepare una ficha de auditoría con dos grupos, errores por tipo y pruebas de cambio de fuente.

Convierta un experimento en una interfaz con contrato.

1. Empaquetar el predictor
2. Contenedores y recursos
3. Pruebas de contrato

Práctica: Defina validar(registro) que devuelva True solo si contiene edad numérica entre 0 y 120, rechazando bool y campos ausentes.

Reto: Prepare el contrato de una API con versión, validación, errores y una predicción de referencia.

Controle lo que sucede después del lanzamiento.

1. Versionar y registrar
2. Drift y calidad
3. Despliegue gradual

Práctica: Con referencia=[0.5,0.5] y actual=[0.8,0.2], calcule distancia_tv=0.5*sum(abs(a-b)) y alerta si supera 0.2.

Reto: Diseñe un lanzamiento gradual con métricas, tamaño mínimo y condición de rollback.

Optimice con medidas que representen al usuario.

1. Percentiles y colas
2. Coste por tarea resuelta
3. Trazas útiles y privadas

Práctica: En un ejemplo hipotético, 100 llamadas cuestan 2 unidades y resuelven 80 tareas; calcule coste_por_exito y exito_porcentaje.

Reto: Diseñe un tablero con calidad, p95, coste por éxito y fallos por herramienta.

Haga revisable el uso previsto y sus límites.

1. Modelo de amenazas
2. Datos y acceso
3. Model cards y decisiones

Práctica: Cree ficha con claves proposito, datos, metrica y limitaciones; limitaciones debe ser una lista con al menos dos entradas no vacías.

Reto: Escriba una model card y un procedimiento para retirar una versión ante un incidente.

Integre datos, pipeline y evaluación sobre un problema tabular.

1. Definir la tarea
2. Comparar modelos
3. Entregar evidencia

Práctica: Cargue iris, divida 25% prueba con random_state=7 y stratify=y; ajuste make_pipeline(StandardScaler(),LogisticRegression(max_iter=500)); guarde exactitud en prueba y predicciones.

Reto: Entregue un experimento tabular completo con línea base, matriz de confusión y model card.

Evalúe imágenes pequeñas y prepare una extensión con una red real.

1. Problema de imágenes
2. Una línea base fuerte
3. Transferencia revisable

Práctica: Cargue digits, divida 25% prueba con random_state=7 y stratify=y; entrene pipeline StandardScaler y SVC(C=3); guarde exactitud.

Reto: Compare la línea base con una red en el notebook, mostrando errores visuales y coste.

Una recuperación comprobable con citas, abstención y permisos.

1. Corpus y casos
2. Componer un sistema
3. Auditar respuestas

Práctica: Con corpus D1="incubar muestra durante 24 horas", D2="conservar reactivo a cuatro grados", recupere por TF-IDF "incubar muestra" y cree salida con cita="D1" y texto del documento seleccionado.

Reto: Entregue un asistente con corpus versionado, diez consultas, citas y pruebas de abstención e inyección.

Conecte los fundamentos con problemas abiertos.

1. Escalado y distribución
2. Razonamiento y cómputo en inferencia
3. Reproducir un hallazgo

Práctica: Un MoE de ejemplo tiene 8 expertos de 1000 parámetros y activa 2 por token. Calcule parametros_totales y parametros_activos_expertos (sin incluir capas compartidas).

Reto: Prepare una propuesta de reproducción con hipótesis, ablación, recursos y criterio para aceptar o rechazar la conclusión.