restructure

Summary:
This diff is a preparation for bundled program documentation, including:
1. move bundled program documentation from tutorial/ to sdk/
2. remove the bento notebook, make its content directly in the .md file
3. elementary update to in line with new api

Differential Revision: D49550056

Author: Songhao Jia

docs/website/docs/tutorials/bundled_program.md renamed to docs/website/docs/sdk/07_bundled_program.md

@@ -9,7 +9,192 @@ Overall procedure can be broken into two stages, and in each stage we are suppor
 
 ## Emit stage
 
- This stage mainly focuses on the creation of a BundledProgram, and dump it out to the disk as a flatbuffer file. Please refer to Bento notebook [N2744997](https://www.internalfb.com/intern/anp/view/?id=2744997) for details on how to create a bundled program.
+ This stage mainly focuses on the creation of a BundledProgram, and dump it out to the disk as a flatbuffer file. The main procedure is as follow:
+1. Create a model and emit its executorch program.
+2. Construct a BundledConfig to record all info need to be bundled.
+3. Generate BundledProgram using the emited model and BundledProgram
+4. Serialize the BundledProgram and dump it out to the disk.
+
+### Step 1: Create a model and emit its executorch program.
+
+This is not the part BunledProgram focusing on, so we just give left an example here without detailed APIs usage. Most of the example is borrowed from bundled_program/tests/common.py:
+
+```python
+
+import torch
+from executorch import exir
+from executorch.exir import ExecutorchBackendConfig
+from executorch.exir.passes import MemoryPlanningPass, ToOutVarPass
+
+
+class SampleModel(torch.nn.Module):
+    """An example model with multi-methods. Each method has multiple input and single output"""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.a: torch.Tensor = 3 * torch.ones(2, 2, dtype=torch.int32)
+        self.b: torch.Tensor = 2 * torch.ones(2, 2, dtype=torch.int32)
+
+    def encode(
+        self, x: torch.Tensor, q: torch.Tensor
+    ) -> torch.Tensor:
+        z = x.clone()
+        torch.mul(self.a, x, out=z)
+        y = x.clone()
+        torch.add(z, self.b, out=y)
+        torch.add(y, q, out=y)
+        return y
+
+    def decode(
+        self, x: torch.Tensor, q: torch.Tensor
+    ) -> torch.Tensor:
+        y = x * q
+        torch.add(y, self.b, out=y)
+        return y
+
+
+method_names = ["encode", "decode"]
+model = SampleModel()
+
+capture_inputs = {
+    m_name: (
+        (torch.rand(2, 2) - 0.5).to(dtype=torch.int32),
+        (torch.rand(2, 2) - 0.5).to(dtype=torch.int32),
+    )
+    for m_name in method_names
+}
+
+# Trace to FX Graph and emit the program
+program = (
+    exir.capture_multiple(model, capture_inputs)
+    .to_edge()
+    .to_executorch()
+    .program
+)
+
+```
+
+### Step 2: Construct BundledConfig
+
+BundledConfig is a class under `executorch/bundled_program/config.py` that contains all information needs to be bundled for model verification. Here's the constructor api to create BundledConfig:
+
+```python
+class BundledConfig:
+    def __init__(
+        self,
+        method_names: List[str],
+        inputs: List[List[Any]],
+        expected_outputs: List[List[Any]],
+    ) -> None:
+        """Contruct the config given inputs and expected outputs
+
+        Args:
+            method_names: All method names need to be verified in program.
+            inputs: All sets of input need to be test on for all methods. Each list
+                    of `inputs` is all sets which will be run on the method in the
+                    program with corresponding method name. Each set of any `inputs` element should
+                    contain all inputs required by eager_model with the same inference function
+                    as corresponding execution plan for one-time execution.
+
+            expected_outputs: Expected outputs for inputs sharing same index. The size of
+                    expected_outputs should be the same as the size of inputs and provided method_names.
+        """
+
+```
+
+Here's an example of creating a bundled program for SampleModel above:
+
+```python
+
+from executorch.bundled_program.config import BundledConfig
+
+# number of input sets needed to be verified
+n_input = 10
+
+# All Input sets need to be verified for all execution plans.
+inputs = [
+    # The below list is all inputs for a single execution plan (inference method).
+    [
+        # Each list below is a individual input set.
+        # The number of inputs, dtype and size of each input follow Program's spec.
+        [
+            (torch.rand(2, 2) - 0.5).to(dtype=torch.int32),
+            (torch.rand(2, 2) - 0.5).to(dtype=torch.int32),
+        ]
+        for _ in range(n_input)
+    ]
+    for _ in range(len(program.execution_plan))
+]
+
+# Expected outputs align with inputs.
+expected_outputs = [
+    [[getattr(model, m_name)(*x)] for x in inputs[i]]
+    for i, m_name in enumerate(method_names)
+]
+
+
+bundled_config = BundledConfig(
+    method_names, inputs, expected_outputs
+)
+
+```
+
+### Step 3: Generate BundledProgram
+
+To create BundledProgram, we provice `create_bundled_program` under `executorch/bundled_program/core.py` to generate BundledProgram by bundling the emitted executorch program with the bundled_config:
+
+```python
+
+def create_bundled_program(
+    program: Program,
+    bundled_config: BundledConfig,
+) -> BundledProgram:
+    """
+    Args:
+        program: The program to be bundled.
+        bundled_config: The config to be bundled.
+    """
+```
+
+Example:
+
+```python
+from executorch.bundled_program.core import create_bundled_program
+
+bundled_program = create_bundled_program(program, bundled_config)
+```
+
+### Step 4: Serialize BundledProgram to Flatbuffer.
+
+To serialize BundledProgram to make runtime APIs use it, we provide two APIs, both under `executorch/bundled_program/serialize/__init__.py`.
+
+Serialize BundledProgram to flatbuffer:
+
+```python
+def serialize_from_bundled_program_to_flatbuffer(
+    bundled_program: BundledProgram,
+) -> bytes
+```
+
+Deserialize flatbuffer to BundledProgram:
+
+```python
+def deserialize_from_flatbuffer_to_bundled_program(
+    flatbuffer: bytes
+) -> BundledProgram
+```
+
+Example:
+```python
+from executorch.bundled_program.serialize import (
+    serialize_from_bundled_program_to_flatbuffer,
+    deserialize_from_flatbuffer_to_bundled_program,
+)
+
+serialized_bundled_program = serialize_from_bundled_program_to_flatbuffer(bundled_program)
+regenerate_bundled_program = deserialize_from_flatbuffer_to_bundled_program(serialized_bundled_program)
+
+```
 
 ## Runtime Stage
 This stage mainly focuses on executing the model with the bundled inputs and and comparing the model's output with the bundled expected output. We provide multiple APIs to handle the key parts of it.