Тот, который считывает ваши показатели, обнаруживает аномалии, применяет заранее определенные правила настройки, при необходимости перезапускает задания и регистрирует каждое решение — без необходимости смотреть на кривые потерь на 2 часа.
В этой статье я предоставлю мягкое средство. Предназначен для исследователей глубокого обучения и инженеров машинного обучения. Он может быть:
• Автоматическое обнаружение сбоев
• Визуально рассуждайте о показателях производительности.
• Примените предопределенные стратегии гиперпараметров.
• Перезапустить задания.
• Документируйте каждое действие и результат
Никаких архитектурных находок. Нет АвтоМЛ. Никакого агрессивного переписывания вашей кодовой базы.
Реализация намеренно минимальна: поместите свой сценарий обучения в контейнер, добавьте небольшой агент на основе Langchain, определите гиперпараметры в YAML и выразите априорные значения в Markdown. Вы, вероятно, уже делаете 50% этого.
Поместите этого агента в свое руководство train.py Рабочий процесс и пройдите от 0️⃣ до 💯 за один день.
Проблемы с текущими экспериментами
🤔Вы бесконечно рассматриваете гиперпараметры.
▶️ Вы запускаете train.py.
🐛 Исправьте ошибку в train.py.
🔁ты бежать снова поезд.py
👀 Вы смотрите на тензорную доску.
🫠Вы подвергаете сомнению реальность.
🔄Вы повторяете.
Перестаньте смотреть на цифры вашей модели, извергающие ее.
Вы не джедай. Никакое пристальное внимание не окажет на вас волшебного воздействия. [validation loss | classification accuracy | perplexity | any other metric you can name] Двигайтесь в том направлении, в котором хотите.
Уход за моделью посреди ночи из-за пропавшего/взорвавшегося щита. Нэн В глубокой трансформаторной сети, которую вы не можете отследить и, возможно, даже никогда не увидите? а также Не сложно.
Как вы решаете реальные исследовательские задачи, когда большая часть вашего времени тратится на работу, которая должна быть выполнена технически, но мало способствует реальному пониманию?
Если 70% вашего дня вы тратите на оперативную работу, когда происходит мышление?
Переход к экспериментам, управляемым агентами
Большинство инженеров и исследователей глубокого обучения, с которыми я работаю, до сих пор проводят эксперименты вручную. Значительная часть дня тратится на добавление весов и смещений для вчерашних запусков или сканирование тензорной доски, сравнение запусков, экспорт метрик, настройку гиперпараметров, регистрацию заметок, перезапуск заданий. Затем повторите цикл.
Это сухая, утомительная и повторяющаяся работа.
Мы собираемся удалить эти повторяющиеся задачи, чтобы вы могли сосредоточить свое внимание на более важных задачах.
Концепция AutoML, честно говоря, смешна.
Ваш [new] Агент не будет принимать решения об изменении топологии вашей сети или добавлении сложных функций — это ваша работа. Это заменит повторяющуюся работу по склеиванию, которая отнимает драгоценное время и не приносит никакой пользы.
Эксперимент, управляемый агентом (ADE)
Перейти от ручных экспериментов к рабочему процессу, управляемому агентами, проще, чем кажется на первый взгляд. Никакого переписывания вашего стека, никаких тяжелых систем, никакого технического долга.
По своей сути ADE требует трех шагов:
- Контейнеризируйте существующие сценарии обучения
- заверните свой подарок
train.pyВ контейнере Docker. Никакого рефакторинга логики модели. Никаких архитектурных изменений. Просто воспроизводимый предел производительности.
- заверните свой подарок
- добавить осветлитель
- Создайте небольшой скрипт на основе langchain, который считывает метрики с вашей панели управления, применяет ваши предпочтения, решает, когда и где перезапустить, приостановить или создать документ, и планирует его с помощью cron или любого планировщика заданий.
- Определите поведение и предпочтения с помощью естественного языка
- Используйте файл YAML для конфигурации и гиперпараметров.
- Используйте документы Markdown для связи с вашим агентом
Это целая система. Теперь давайте рассмотрим каждый шаг.
Контейнеризируйте свой сценарий обучения
Кто-то может возразить, что вам все равно следует это сделать. Это значительно упрощает перезапуск и планирование, а если вы перейдете в кластер Kubernetes для обучения, ваш существующий процесс будет гораздо меньше сбоев.
Если вы уже это делаете, перейдите к следующему разделу. Если нет, вот полезный код, который вы можете использовать, чтобы начать.
Сначала давайте определим структуру проекта, который будет работать с Docker.
your experiment/
├── scripts/
│ ├── train.py # Main training script
│ └── health_server.py # Health check server
├── requirements.txt # Python dependencies
├── Dockerfile # Container definition
└── run.sh # Script to start training + health check
Мы должны убедиться, что ваш train.py Скрипт может загружать файл конфигурации из облака, позволяя агенту редактировать его при необходимости.
Я рекомендую использовать для этого GitHub. Вот пример того, как читать файл удаленной конфигурации. У агента будет соответствующий инструмент для чтения и изменения этого файла конфигурации.
import os
import requests
import yaml
from box import Box
# add this to `train.py`
GITHUB_RAW = (
"https://raw.githubusercontent.com/"
"{owner}/{repo}/{ref}/{path}"
)
def load_config_from_github(owner, repo, path, ref="main", token=None):
url = GITHUB_RAW.format(owner=owner, repo=repo, ref=ref, path=path)
headers = {}
if token:
headers["Authorization"] = f"Bearer {token}"
r = requests.get(url, headers=headers, timeout=10)
r.raise_for_status()
return Box(yaml.safe_load(r.text))
config = load_yaml_from_github(...)
# use params throughout your `train.py` script
optimizer = Adam(lr=config.lr)
Мы также включаем сервер проверки работоспособности, который будет работать вместе с основным процессом. Это позволяет менеджерам контейнеров, таким как Kubernetes или вашему агенту, отслеживать состояние заданий. Без Проверка журналов.
Если состояние контейнера неожиданно изменится, его можно будет перезапустить автоматически. Это упрощает проверку агента, поскольку чтение и обобщение файлов журналов может потребовать больше токенов, чем проверка работоспособности контейнера.
# health_server.py
import time
from pathlib import Path
from fastapi import FastAPI, Response
app = FastAPI()
HEARTBEAT = Path("/tmp/heartbeat")
STATUS = Path("/tmp/status.json") # optional richer state
MAX_AGE = 300 # seconds
def last_heartbeat_age():
if not HEARTBEAT.exists():
return float("inf")
return time.time() - float(HEARTBEAT.read_text())
@app.get("/health")
def health():
age = last_heartbeat_age()
# stale -> training likely hung
if age > MAX_AGE:
return Response("stalled", status_code=500)
# optional: detect NaNs or failure flags written by trainer
if STATUS.exists() and "failed" in STATUS.read_text():
return Response("failed", status_code=500)
return {"status": "ok", "heartbeat_age": age}
Небольшой скрипт оболочки, run.shкоторый начинается health_server обрабатывать вместе train.py
#!/bin/bash
# Start health check server in the background
python scripts/health_server.py &
# Capture its PID if you want to terminate later
HEALTH_PID=$!
# Start the main training script
python scripts/train.py
И, конечно же, наш Dockerfile, созданный на основе базового образа NVIDIA, поэтому ваш контейнер может без проблем использовать ускорители хоста. Этот пример предназначен для Pytorch, но при необходимости вы можете легко расширить его до Jax или Tensorflow.
FROM nvidia/cuda:12.1.0-cudnn8-devel-ubuntu20.04
RUN apt-get update && apt-get install -y \
python3 python3-pip git
RUN python3 -m pip install --upgrade pip
# Install PyTorch with CUDA support
RUN pip3 install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/cu121
WORKDIR /app
COPY . /app
CMD ["sh", "run.sh"]
✅ Вы находитесь в контейнере. Простой и минимальный.
добавить осветлитель
Существует множество агентских фреймворков на выбор. Из этого агента мне нравится Лангчен.
Langchain — это платформа для создания систем на основе LLM, сочетающих в себе логику и исполнение. Эта модель упрощает объединение вызовов, управление памятью и интеграцию внешних возможностей, поэтому ваш LLM может делать гораздо больше, чем просто генерировать текст.
В Langchain инструменты — это явно определенные функции, привязанные к схеме, которые может вызывать модель. Каждый инструмент представляет собой пассивный навык или задачу (например, чтение файла, запрос API, изменение состояния).
Чтобы наш агент работал, нам сначала нужно определить инструменты, которые он может использовать для достижения нашей цели.
определения оборудования
- read_preferences
- Считывает пользовательские настройки и примечания по использованию из документа Markdown.
- check_tensorboard
- Chrome использует Selenium с WebDriver для показателей скриншотов
- анализ_метрика
- Мультимодальный LLM использует логику, чтобы понять, что происходит на скриншоте.
- check_container_health
- Проверяет наш контейнерный эксперимент с помощью проверки работоспособности.
- перезапуск_контейнер
- Перезапускает эксперимент, если необходимо изменить неработоспособные или гиперпараметры.
- изменить_конфигурацию
- Измените файл удаленной конфигурации и зафиксируйте его на Github.
- запись_память
- Непрерывно записывает серию действий в память (Markdown).
Этот набор инструментов определяет операционные границы нашего агента. Все взаимодействия с нашим экспериментом через эти устройства делают поведение управляемым и, будем надеяться, предсказуемым.
Вместо того, чтобы размещать эти инструменты в Интернете, вот краткий обзор Github, включающий все упомянутые выше инструменты. Вы можете подключить их к своему агенту или изменить по своему усмотрению.
агент
Честно говоря, когда я впервые попытался покопаться в официальной документации Langchain, эта идея меня сразу оттолкнула.
Это слишком многословно и сложнее, чем необходимо. Если вы новичок в работе с агентами или не хотите ориентироваться в лабиринтах документации Langchain, продолжайте читать ниже.
Вкратце, агенты Langchain работают следующим образом:
Наш агент использует готовый Решаем, что делать в каждом шаг.
шаг создаются динамически путем заполнения подсказки текущим контекстом и предыдущим выводом. каждый звонок в кино [+ optional tool invocation] является одним этапом, и его результаты передаются на следующий, образуя Цепь.
используют его концептуально рекурсивный циклАгент может рассуждать и предпринимать правильные желаемые действия, выполнив все необходимые шаги. Количество шагов зависит от способности агента рассуждать и от того, насколько четко определены условия завершения.
Это языковой сериал. взять его? 🤗
быстрый
Как уже упоминалось, подсказка — это рекурсивный связующий звено, поддерживающее контекст между LLM и вызовами инструментов. Вы увидите заполнители (определенные ниже), используемые при первом запуске агента.
Мы используем некоторые из встроенных абстракций памяти Langchain, включенных в каждый вызов инструмента. Кроме того, агент заполняет пробелы, решая как следующий шаг, так и какой инструмент вызвать.
Для удобства чтения основной знак расположен ниже. Вы можете либо подключить его непосредственно к сценарию агента, либо загрузить из файловой системы перед запуском.
"You are an experiment automation agent responsible for monitoring
and maintaining ML experiments.
Current context:
{chat_history}
Your workflow:
1. First, read preferences from preferences.md to understand thresholds and settings
2. Check TensorBoard at the specified URL and capture a screenshot
3. Analyze key metrics (validation loss, training loss, accuracy) from the screenshot
4. Check Docker container health for the training container
5. Take corrective actions based on analysis:
- Restart unhealthy containers
- Adjust hyperparameters according to user preferences
and anomalous patterns, restarting the experiment if necessary
6. Log all observations and actions to memory
Important guidelines:
- Always read preferences first to get current configuration
- Use visual analysis to understand metric trends
- Be conservative with config changes (only adjust if clearly needed)
- Write detailed memory entries for future reference
- Check container health before and after any restart
- When modifying config, use appropriate values from preferences
Available tools: {tool_names}
Tool descriptions: {tools}
Current task: {input}
Think step by step and use tools to complete the workflow.
"""Теперь, имея около 100 строк, у нас есть агент. Агент инициализируется, затем мы определяем серию шагов. Для каждого шага current_task Инструкция заполняет нашу подсказку, и каждый инструмент обновляет экземпляр общей памяти. ConverstationSummaryBufferMemory
Мы собираемся использовать OpenAI для этого агента, однако Langchain предлагает варианты, включая собственный хостинг. Если стоимость является проблемой, существуют модели с открытым исходным кодом, которые можно использовать здесь.
import os
from datetime import datetime
from pathlib import Path
from langchain.agents import AgentExecutor, create_react_agent
from langchain_openai import ChatOpenAI
from langchain.prompts import PromptTemplate
from langchain.memory import ConversationSummaryBufferMemory
# Import tools from tools.py
from tools import (
read_preferences,
check_tensorboard,
analyze_metric,
check_container_health,
restart_container,
modify_config,
write_memory
)
PROMPT=open("prompt.txt").read()
class ExperimentAutomation:
def __init__(self, openai_key=None):
"""Initialize the agent"""
self.llm = ChatOpenAI(
temperature=0.8,
model="gpt-4-turbo-preview",
api_key=openai_key or os.getenv('OPENAI_API_KEY')
)
# Initialize memory for conversation context
self.memory = ConversationSummaryBufferMemory(
llm=self.llm,
max_token_limit=32000,
memory_key="chat_history",
return_messages=True
)
def create_agent(self):
"""Create LangChain agent with imported tools"""
tools = [
lambda **kwargs: read_preferences(memory=self.memory, **kwargs),
lambda **kwargs: check_tensorboard(memory=self.memory, **kwargs),
lambda **kwargs: analyze_metric(memory=self.memory, **kwargs),
lambda **kwargs: check_container_health(memory=self.memory, **kwargs),
lambda **kwargs: restart_container(memory=self.memory, **kwargs),
lambda **kwargs: modify_config(memory=self.memory, **kwargs),
lambda **kwargs: write_memory(memory=self.memory, **kwargs)
]
# Create the prompt template
prompt = PromptTemplate.from_template(PROMPT)
agent = create_react_agent(
llm=self.llm,
tools=tools,
prompt=prompt
)
# Create agent executor with memory
return AgentExecutor(
agent=agent,
tools=tools,
memory=self.memory,
verbose=True,
max_iterations=15,
handle_parsing_errors=True,
return_intermediate_steps=True
)
def run_automation_cycle(self):
"""Execute the full automation cycle step by step"""
write_memory(
entry="Automation cycle started",
category="SYSTEM",
memory=self.memory
)
try:
agent = self.create_agent()
# Define the workflow as individual steps
workflow_steps = [
"Read preferences from preferences.md to capture thresholds and settings",
"Check TensorBoard at the specified URL and capture a screenshot",
"Analyze validation loss, training loss, and accuracy from the screenshot",
"Check Docker container health for the training container",
"Restart unhealthy containers if needed",
"Adjust hyperparameters according to preferences and restart container if necessary",
"Write all observations and actions to memory"
]
# Execute each step individually
for step in workflow_steps:
result = agent.invoke({"input": step})
# Write step output to memory
if result.get("output"):
memory_summary = f"Step: {step}\nOutput: {result['output']}"
write_memory(entry=memory_summary, category="STEP", memory=self.memory)
write_memory(
entry="Automation cycle completed successfully",
category="SYSTEM",
memory=self.memory
)
return result
except Exception as e:
error_msg = f"Automation cycle failed: {str(e)}"
write_memory(entry=error_msg, category="ERROR", memory=self.memory)
raise
def main():
try:
automation = ExperimentAutomation(openai_key=os.environ["OPENAI_API_KEY"])
result = automation.run_automation_cycle()
if result.get('output'):
print(f"\nFinal Output:\n{result['output']}")
if result.get('intermediate_steps'):
print(f"\nSteps Executed: {len(result['intermediate_steps'])}")
print("\n✓ Automation cycle completed successfully")
except Exception as e:
print(f"\n✗ Automation failed: {e}")
write_memory(entry=f"Critical failure: {str(e)}", category="ERROR")
import sys
sys.exit(1)
if __name__ == "__main__":
main()
Теперь, когда у нас есть агент и инструменты, давайте обсудим, как нам на самом деле донести свою точку зрения. Намерение как исследователь – Самая важная часть.
Определите поведение и предпочтения с помощью естественного языка
Как уже упоминалось, определение того, что мы ищем при запуске эксперимента, важно для получения правильного поведения от агента.
Хотя модели логики изображений прошли долгий путь и имеют достаточно контекста, им еще предстоит понять, как выглядит хорошая кривая потерь при иерархической оптимизации политики или как должна выглядеть запутанность кодовой книги в векторно-квантованном вариационном автокодировщике, чем я оптимизировал последнюю неделю.
Для этого мы запускаем любую автоматическую логику с помощью preferences.md.
Начнем с некоторых общих настроек
# Experiment Preferences
This file defines my preferences for this experiment.
The agent should always read this first before taking any action.
---
## General Settings
- experiment_name: vqvae
- container_name: vqvae-train
- tensorboard_url: http://localhost:6006
- memory_file: memory.md
- maximum_adjustments_per_run: 4
---
## More details
You can always add more sections here. The read_preferences task will parse
and reason over each section. Теперь давайте определим интересующие нас метрики. Это особенно важно в случае визуального мышления.
В документе Markdown определите yaml Блоки, которые будут анализироваться агентом read_preferences инструмент. Добавление этой части структуры полезно для использования приоритетов в качестве аргументов для других инструментов.
```yaml
metrics:
- name: perplexity
pattern: should remain high through the course of training
restart_condition: premature collapse to zero
hyperparameters: |
if collapse, increase `perplexity_weight` from current value to 0.2
- name: prediction_loss
pattern: should decrease over the course of training
restart_condition: increases or stalls
hyperparameters: |
if increases, increase the `prediction_weight` value from current to 0.4
- name: codebook_usage
pattern: should remain fixed at > 90%
restart_condition: drops below 90% for many epochs
hyperparameters: |
decrease the `codebook_size` param from 512 to 256.
```Основная идея заключается в том, что preferences.md должен предоставить Достаточно структурированное и описательное описание Таким образом, агент может:
Сравните его анализ с вашим намерениемНапример, если агент видит потерю проверки = 0,6, но в настройках указано val_loss_threshold should be 0.5Знает, какие корректирующие действия следует предпринять
Прочтите ограничения и ограничения (YAML или ключ-значение) для метрик, гиперпараметров и управления контейнерами.
Понять намерение или модели намерений Описано в удобочитаемых разделах, таких как «Корректируйте скорость обучения только в том случае, если потери при проверке превышают пороговое значение и точность стабилизируется».
соединить все это вместе
Теперь, когда у нас есть контейнерный эксперимент + агент, нам нужно запланировать работу агента. Это так же просто, как запустить процесс агента с помощью задания cron. При этом наш агент запускается один раз в час, обеспечивая компромисс между стоимостью (в токенах) и операционной эффективностью.
0 * * * * /usr/bin/python3 /path/to/agent.py >> /var/log/agent.log 2>&1Я обнаружил, что этот агент не требует новейших моделей рассуждения и хорошо работает с предыдущими поколениями Anthropic и OpenAI.
подведение итогов
Если время исследования ограничено, его следует потратить на исследования, а не на эксперименты по уходу за детьми.
Ваш агент должен выполнять мониторинг, перезапуски и настройку параметров без постоянного контроля. Когда атмосфера исчезает, остается настоящая работа: генерация гипотез, разработка лучших моделей и проверка важных идей.
Надеюсь, этот агент немного освободит вас для воплощения в жизнь следующей большой идеи. наслаждаться.
Ссылка
Мюллер Т., Смит Дж. и Ли К. (2023). Langchain: среда для разработки приложений с большими языковыми моделями.. Репозиторий GitHub. https://github.com/hwchase17/langchain
ОпенАИ. (2023). Документация OpenAI API. https://platform.openai.com/docs
![Вселенная данных Рёдзи Икеды [n°1] К 1 февраля расширено до 180 студий.](https://factmag-images.s3.amazonaws.com/wp-content/uploads/2025/12/ryoji-ikeda-data-cosm-1-1024x684.webp "Вселенная данных Рёдзи Икеды [n°1] К 1 февраля расширено до 180 студий.")
