En este tutorial, implementamos una versión lista para Colab del marco AutoResearch propuesto originalmente por Andrej Karpathy. Creamos un proceso de experimentación automatizado que clona el repositorio de AutoResearch, prepara un entorno de capacitación liviano y ejecuta un experimento de referencia para establecer métricas de rendimiento iniciales. Luego creamos un ciclo de investigación automatizado que edita mediante programación los hiperparámetros en train.py, ejecuta nuevas iteraciones de entrenamiento, evalúa el modelo resultante utilizando la métrica de bits por byte de validación y registra cada experimento en una tabla de resultados estructurada. Al ejecutar este flujo de trabajo en Google Colab, demostramos cómo podemos reproducir la idea central de la investigación sobre aprendizaje automático autónomo: modificar de forma iterativa las configuraciones de entrenamiento, evaluar el rendimiento y preservar las mejores configuraciones, sin requerir hardware especializado ni una infraestructura compleja.
“numpy”,”pandas”,”pyarrow”,”requests”,
“rustbpe”,”tiktoken”,”openai”
]: intente: __import__(pkg) excepto: pip_install(pkg) importe pandas como pd si no es Path(“autoresearch”).exists(): subprocess.run([“git”,”clone”,”https://github.com/karpathy/autoresearch.git”]) os.chdir(“autoresearch”) OPENAI_API_KEY=Ninguno intente: desde google.colab importar datos de usuario OPENAI_API_KEY = userdata.get(“OPENAI_API_KEY”) excepto: OPENAI_API_KEY=os.environ.get(“OPENAI_API_KEY”) si OPENAI_API_KEY: os.environ[“OPENAI_API_KEY”]=OPENAI_API_KEY
Comenzamos importando las bibliotecas principales de Python necesarias para el flujo de trabajo de investigación automatizado. Instalamos todas las dependencias necesarias y clonamos el repositorio de investigación automática directamente desde GitHub, asegurando que el entorno incluya el marco de capacitación original. También configuramos el acceso a la clave API de OpenAI, si está disponible, lo que permite que el sistema admita opcionalmente la experimentación asistida por LLM más adelante en el proceso.
Modificamos parámetros de configuración clave dentro del repositorio para que el flujo de trabajo de capacitación sea compatible con el hardware de Google Colab. Reducimos la duración del contexto, el presupuesto de tiempo de capacitación y el recuento de tokens de evaluación para que los experimentos se ejecuten con recursos limitados de GPU. Después de aplicar estos parches, preparamos los fragmentos del conjunto de datos necesarios para el entrenamiento para que el modelo pueda comenzar los experimentos de inmediato.
“commit”:”baseline”,
“val_bpb”:baseline[“val_bpb”] si es de referencia[“val_bpb”] else 0, “memory_gb”: round((línea base[“peak_vram_mb”] o 0)/1024,1), “status”:”keep”, “description”:”baseline” }]pd.DataFrame(rows).to_csv(results_path,sep=”\t”,index=False) print(“Baseline:”,baseline)
Ejecutamos la ejecución de entrenamiento de referencia para establecer una referencia de rendimiento inicial para el modelo. Implementamos una función de análisis de registros que extrae métricas de entrenamiento clave, incluidos bits de validación por byte, tiempo de entrenamiento, uso de memoria de GPU y pasos de optimización. Luego almacenamos estos resultados de referencia en una tabla de experimentos estructurada para que todos los experimentos futuros puedan compararse con esta configuración inicial.
“WINDOW_PATTERN”,
“TOTAL_BATCH_SIZE”,
“EMBEDDING_LR”,
“UNEMBEDDING_LR”,
“MATRIX_LR”,
“SCALAR_LR”,
“WEIGHT_DECAY”,
“ADAM_BETAS”,
“WARMUP_RATIO”,
“WARMDOWN_RATIO”,
“FINAL_LR_FRAC”,
“DEPTH”,
“DEVICE_BATCH_SIZE”
]
def read_text(ruta): return Ruta(ruta).read_text() def write_text(ruta,texto): Ruta(ruta).write_text(texto) def extract_hparams(texto): vals={} for k en HP_KEYS: m=re.search(rf”^{k}\s*=\s*(.+?)$”,text,re.MULTILINE) if m: vals[k]=m.group(1).strip() devuelve vals def set_hparam(texto,clave,valor): devuelve re.sub(rf”^{clave}\s*=.*$”,f”{clave} = {valor}”,texto,flags=re.MULTILINE) base_text=read_text(BACKUP_FILE) base_hparams=extract_hparams(base_text) SEARCH_SPACE={ “VENTANA_PATRÓN”:[‘”L”‘,'”SSSL”‘]”TOTAL_BATCH_SIZE”:[“2**16″,”2**17″,”2**18″]”EMBEDDING_LR”:[“0.2″,”0.4″,”0.6″]”MATRIX_LR”:[“0.01″,”0.02″,”0.04″]”ESCALAR_LR”:[“0.3″,”0.5″,”0.7″]”WEIGHT_DECAY”:[“0.05″,”0.1″,”0.2″]”ADAM_BETAS”:[“(0.8,0.95)”,”(0.9,0.95)”]”RELACIÓN_CALENTAMIENTO”:[“0.0″,”0.05″,”0.1″]”WARMDOWN_RATIO”:[“0.3″,”0.5″,”0.7″]”FINAL_LR_FRAC”:[“0.0″,”0.05″]”PROFUNDIDAD”:[“3″,”4″,”5″,”6″]”DEVICE_BATCH_SIZE”:[“8″,”12″,”16″,”24″]
} def sample_candidate(): claves=random.sample(lista(SEARCH_SPACE.keys()),random.choice([2,3,4])) cand=dict(base_hparams) cambios={} para k en claves: cand[k]=elección.aleatoria(SEARCH_SPACE[k]) cambios[k]=cand[k]
devolver cand,cambios def apply_hparams(candidato): text=read_text(BACKUP_FILE) para k,v en candidato.items(): text=set_hparam(text,k,v) write_text(TRAIN_FILE,text) def run_experiment(tag): log=f”{tag}.log” subprocess.run(f”python train.py > {log} 2>&1″,shell=True) métricas=parse_run_log(log) métricas[“log”]= registrar métricas de retorno
Desarrollamos las utilidades principales que permiten la experimentación automatizada de hiperparámetros. Extraemos los hiperparámetros de train.py, definimos el espacio de parámetros de búsqueda e implementamos funciones que pueden editar estos valores mediante programación. También creamos mecanismos para generar configuraciones candidatas, aplicarlas al script de capacitación y ejecutar experimentos mientras registramos sus resultados.
Ejecutamos el ciclo de investigación automatizado que propone repetidamente nuevas configuraciones de hiperparámetros y evalúa su desempeño. Para cada experimento, modificamos el script de entrenamiento, ejecutamos el proceso de entrenamiento y comparamos la puntuación de validación resultante con la mejor configuración descubierta hasta el momento. Registramos todos los resultados de los experimentos, conservamos las configuraciones mejoradas y exportamos el mejor script de entrenamiento junto con el historial del experimento para su posterior análisis.
En conclusión, construimos un flujo de trabajo de investigación automatizado completo que demuestra cómo las máquinas pueden explorar de forma iterativa las configuraciones del modelo y mejorar el rendimiento del entrenamiento con una mínima intervención manual. A lo largo del tutorial, preparamos el conjunto de datos, establecimos un experimento de referencia e implementamos un bucle de búsqueda que propone nuevas configuraciones de hiperparámetros, ejecuta experimentos y realiza un seguimiento de los resultados en múltiples pruebas. Al mantener registros de experimentos y preservar automáticamente las configuraciones mejoradas, creamos un proceso de investigación reproducible y extensible que refleja el flujo de trabajo utilizado en la experimentación moderna con aprendizaje automático. Este enfoque ilustra cómo podemos combinar la automatización, el seguimiento de la experimentación y una infraestructura liviana para acelerar el desarrollo de modelos y permitir una investigación escalable directamente desde un entorno portátil en la nube.
Consulte los códigos completos aquí. Además, no dude en seguirnos en Twitter y no olvide unirse a nuestro SubReddit de más de 120.000 ML y suscribirse a nuestro boletín. ¡Esperar! estas en telegrama? Ahora también puedes unirte a nosotros en Telegram.