Skip to content

armgit / burr

Public Imported from GitHub
0

Build applications that make decisions (chatbots, agents, simulations, etc...). Monitor, trace, persist, and execute on your own infrastructure.

Adds ML training placeholder

elijahbenizzy60be8751f0cb
diff --git a/docs/examples/ml_training.rst b/docs/examples/ml_training.rst
index 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-resis
track 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.md
new file mode 100644
index 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.py
deleted file mode 100644
index 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"])