Build applications that make decisions (chatbots, agents, simulations, etc...). Monitor, trace, persist, and execute on your own infrastructure.
Python aiburrchatbot-frameworkdagsgenerative-aigraphshacktoberfestllmopsllmsmlopspersistent-data-structurestate-machinestate-managementvisibility
Adds ML training placeholder
elijahbenizzy60be8751f0cb
diff --git a/docs/examples/ml_training.rst b/docs/examples/ml_training.rstindex d6621f66..186ac531 100644--- a/docs/examples/ml_training.rst+++ b/docs/examples/ml_training.rst@@ -7,4 +7,4 @@ to gaussian processes, `burr` is a simple way to implement robust, failure-resistrack of hyperparameters and metrics and feeding these into a decision function to determine where to look next.``burr``'s state machine can help you write and manage that process.-This is still a WIP -- come back soon, or `contribute your own example <https://github.com/DAGWorks-Inc/burr/issues/new>`_!+Read more/contribute at `the placeholder issue on the repository <https://github.com/DAGWorks-Inc/burr/tree/main/examples/ml-training>`_diff --git a/examples/ml-training/README.md b/examples/ml-training/README.mdnew file mode 100644index 00000000..7cfd49ee--- /dev/null+++ b/examples/ml-training/README.md@@ -0,0 +1,45 @@+# ML Training++This is a WIP! Please contribute back if you have ideas. You can track the associated issue [here](https://github.com/DAGWorks-Inc/burr/issues/138).++A machine learning training system can easily be modeled as a state machine.++While often, this is more of a DAG (E.G. `query_data` -> `feature_engineer` -> `train_model` -> `evaluate_model`), there+are some interesting reasons this as a state machine.++## More granular training routines++If, rather than treating `train` as a action, you treat `train_epoch` as an action, you can utilize the abstractions+burr represents to get the following benefits:++#### Checkpointing++You can store the current params + best model (or pointers to them). Then go back to the failure point. This allows you+to recover from failure in a generic way.++#### Decoupling training logic from termination condition++You can have a condition that checks training completeness based on metric history, which is different from the training logic itself.+This allows you to easily swap in and out termination conditions (testing them against each other or running different ones in different scenarios),+as well as easy reuse.++#### Visibility into lower-level training++Similar to [hooks](https://lightning.ai/docs/pytorch/stable//extensions/callbacks.html) in pytorch lightning,+you can use Burr hooks to log metrics, visualize, etc... at each step. This allows you to have a more granular view of training that updates live+(obviuosly depending on the UI/model-monitoring you're using.)++## Human in the loop++While some models are trained in a single-shot and shipped to production, many require human input.+Burr can be used to express training, then checkpoint/pause the state while a human is evaluating it,+and have their input (e.g. go/no-go) passed in as an [input parameter](https://burr.dagworks.io/concepts/actions/#runtime-inputs).++Note that this still requires a scheduling tool (say a task executor that runs until the next human input is needed),+but that task executor does not need to be complicated (all it needs to do is run a job when prompted, and possibly on a chron schedule).++## Hyperparameter training++Similar to epoch training, hyperparameter training can be modeled as a state machine. The system makes a decision about what+to look for next based on the prior results. Furthermore, one can model a step that handles multiple jobs, keeping them alive/+launching new ones as they compleete (based on state).diff --git a/examples/ml-training/application.py b/examples/ml-training/application.pydeleted file mode 100644index 845edec3..00000000--- a/examples/ml-training/application.py+++ /dev/null@@ -1,110 +0,0 @@-import burr.core.application-from burr.core import Action, Condition, State, default---class ProcessDataAction(Action):- @property- def reads(self) -> list[str]:- return ["data_path"]-- def run(self, state: State) -> dict:- pass-- @property- def writes(self) -> list[str]:- return ["training_data", "evaluation_data"]-- def update(self, result: dict, state: State) -> State:- return state.update(training_data=result["training_data"])---class TrainModel(Action):- @property- def reads(self) -> list[str]:- return ["training_data", "epochs"]-- def run(self, state: State) -> dict:- pass-- @property- def writes(self) -> list[str]:- return ["models", "training_metrics", "epochs"]-- def update(self, result: dict, state: State) -> State:- return state.update(- epochs=result["epochs"], # overwrite each epoch- ).append(- models=result["model"], # append -- note this can get big if your model is big- # so you'll want to overwrite but store the conditions, or log somewhere- metrics=result["metrics"], # append the metrics- )---class ValidateModel(Action):- @property- def reads(self) -> list[str]:- return ["models", "evaluation_data"]-- def run(self, state: State) -> dict:- pass-- @property- def writes(self) -> list[str]:- return ["validation_metrics"]-- def update(self, result: dict, state: State) -> State:- return state.append(validation_metrics=result["validation_metrics"])---class BestModel(Action):- @property- def reads(self) -> list[str]:- return ["validation_metrics", "models"]-- def run(self, state: State) -> dict:- pass-- @property- def writes(self) -> list[str]:- return ["best_model"]-- def update(self, result: dict, state: State) -> State:- return state.update(best_model=result["best_model"])---def application(epochs: int) -> burr.core.application.Application:- return (- burr.core.ApplicationBuilder()- .with_state(- data_path="data.csv",- epochs=10,- training_data=None,- evaluation_data=None,- models=[],- training_metrics=[],- validation_metrics=[],- best_model=None,- )- .with_actions(- process_data=ProcessDataAction(),- train_model=TrainModel(),- validate_model=ValidateModel(),- best_model=BestModel(),- )- .with_transitions(- ("process_data", "train_model", default),- ("train_model", "validate_model", default),- ("validate_model", "best_model", Condition.expr(f"epochs>{epochs}")),- ("validate_model", "train_model", default),- )- .with_entrypoint("process_data")- .build()- )---if __name__ == "__main__":- app = application(100) # doing good data science is up to you...- # action, state, result = app.run(halt_after=["result"])- app.visualize(output_file_path="ml_training.png", include_conditions=True, view=True)- # assert state["counter"] == 10- # print(state["counter"])