trinity.explorer package

Subpackages

• trinity.explorer.api package
  • Submodules
    • trinity.explorer.api.api module
    • trinity.explorer.api.service module
  • Module contents

Submodules

• trinity.explorer.explorer module
  • Explorer
    • Explorer.__init__()
    • Explorer.setup_weight_sync_group()
    • Explorer.setup_model_level_weight_sync_group()
    • Explorer.prepare()
    • Explorer.get_weight()
    • Explorer.explore()
    • Explorer.explore_step()
    • Explorer.need_sync()
    • Explorer.need_eval()
    • Explorer.eval()
    • Explorer.benchmark()
    • Explorer.save_checkpoint()
    • Explorer.sync_weight()
    • Explorer.shutdown()
    • Explorer.is_alive()
    • Explorer.serve()
    • Explorer.get_actor()
• trinity.explorer.explorer_client module
• trinity.explorer.scheduler module
  • TaskWrapper
    • TaskWrapper.task
    • TaskWrapper.batch_id
    • TaskWrapper.sub_task_num
    • TaskWrapper.results
    • TaskWrapper.__init__()
  • calculate_task_level_metrics()
  • RunnerWrapper
    • RunnerWrapper.__init__()
    • RunnerWrapper.prepare()
    • RunnerWrapper.update_state()
    • RunnerWrapper.run_with_retry()
    • RunnerWrapper.restart_runner()
  • sort_batch_id()
  • Scheduler
    • Scheduler.__init__()
    • Scheduler.task_done_callback()
    • Scheduler.start()
    • Scheduler.stop()
    • Scheduler.schedule()
    • Scheduler.dynamic_timeout()
    • Scheduler.get_results()
    • Scheduler.has_step()
    • Scheduler.wait_all()
    • Scheduler.get_key_state()
    • Scheduler.get_runner_state()
    • Scheduler.get_all_state()
    • Scheduler.print_all_state()
• trinity.explorer.workflow_runner module
  • Status
    • Status.ok
    • Status.metrics
    • Status.message
    • Status.__init__()
  • calculate_run_level_metrics()
  • WorkflowRunner
    • WorkflowRunner.__init__()
    • WorkflowRunner.prepare()
    • WorkflowRunner.is_alive()
    • WorkflowRunner.get_runner_state()
    • WorkflowRunner.run_task()
  • DebugWorkflowRunner
    • DebugWorkflowRunner.__init__()
    • DebugWorkflowRunner.prepare()
    • DebugWorkflowRunner.debug()

Module contents

class trinity.explorer.Explorer(config: Config)

Bases: object

Responsible for exploring the taskset.

__init__(config: Config)

async benchmark() → bool

Benchmark the model checkpoints.

async eval()

Evaluation on all evaluation data samples.

async explore() → str

The timeline of the exploration process:

<——————————— one period ————————————-> |

explorer | <—————- step_1 ————–> | |

| <—————- step_2 ————–> | |

… |

| <—————- step_n —————> | |

| <———————- eval ——————–> | <– sync –> |

|--------------------------------------------------------------------------------------|

trainer | <– idle –> | <– step_1 –> | <– step_2 –> | … | <– step_n –> | <– sync –> |

async explore_step() → bool

classmethod get_actor(config: Config)

Get a Ray actor for the explorer.

async get_weight(name: str) → Tensor

Get the weight of the loaded model (For checkpoint weights update).

async is_alive() → bool

Check if the explorer is alive.

need_eval() → bool

async need_sync() → bool

async prepare() → None

Preparation before running.

async save_checkpoint(sync_weight: bool = False) → None

async serve() → None

Run the explorer in serving mode.

In serving mode, the explorer starts an OpenAI compatible server to handle requests. Agent applications can be deployed separately and interact with the explorer via the API.

import openai


client = openai.OpenAI(
    base_url=f"{explorer_server_url}/v1",
    api_key="EMPTY",
)
response = client.chat.completions.create(
    model=config.model.model_path,
    messages=[{"role": "user", "content": "Hello!"}]
)

async setup_model_level_weight_sync_group()

Setup process group for each model, only used in serve mode.

async setup_weight_sync_group(master_address: str, master_port: int, state_dict_meta: List = None)

async shutdown() → None

async sync_weight() → None

Synchronize model weights.