Render schedule

app.py

@@ -1,7 +1,9 @@
 import gradio as gr
 import auto_schedule
 import v_schedule
-
+from PIL import Image
+from svg_event import render_manual_graph
+import pathlib
 def greet(name, is_morning, temperature):
     salutation = "Good morning" if is_morning else "Good evening"
     greeting = f"{salutation} {name}. It is {temperature} degrees today"
@@ -11,7 +13,7 @@ def greet(name, is_morning, temperature):
 def percentage(x):
   return f"{x*100:.2f}%"
 
-def get_schedule_time_and_image(result):
+def get_schedule_time(result):
   result = [
     list(filter(lambda x: x.type in {'F', 'B', 'W'}, r)) for r in result
   ]
@@ -20,13 +22,34 @@ def get_schedule_time_and_image(result):
       max([x.completion_time for x in stage]) - min([x.start_time for x in stage]) for stage in result
     ]
   )
-  return time, None
+  return time
+
+img_queue = []
+def get_schedule_image(result, max_time):
+  result = [
+    list(filter(lambda x: x.type in {'F', 'B', 'W'}, r)) for r in result
+  ]
+  svg = render_manual_graph(result, max_time, len(result[0]) <= 72)
+  img_queue.append(svg)
+  if len(img_queue) > 32:
+    poped = img_queue.pop(0)
+    pathlib.Path(poped).unlink()
+
+  return pathlib.Path(svg)
+
+  
 
 def calculate(p, m, f, b, w, c, mem):
-  baseline_time=(f+b+w)*m + (f+b+w+c)*(p-1)
-  baseline_bubble=percentage(baseline_time/(f+b+w)/m - 1)
-  baseline_acceleration=percentage(0)
-  baseline_image=None
+  if mem < p:
+    baseline_time=None
+    baseline_bubble=None
+    baseline_acceleration=None
+    baseline_image=None
+  else:
+    baseline_time=(f+b+w)*m + (f+b+w+c)*(p-1)
+    baseline_bubble=percentage(baseline_time/(f+b+w)/m - 1)
+    baseline_acceleration=percentage(0)
+    baseline_image=None
 
   
   zb_result = auto_schedule.auto_schedule(p, m, auto_schedule.GraphConfig(
@@ -37,29 +60,39 @@ def calculate(p, m, f, b, w, c, mem):
         max_mem=mem * 2,
         print_scaling=1000
   ))
-  zb_time,zb_image=get_schedule_time_and_image(zb_result)
+  
+  zb_time=get_schedule_time(zb_result)
 
   zb_bubble=percentage(zb_time/(f+b+w)/m - 1)
-  zb_acceleration=percentage(baseline_time/zb_time - 1)
+  zb_acceleration=percentage(baseline_time/zb_time - 1) if baseline_time is not None else None
 
-  zbv_graph = v_schedule.PipelineGraph(
-                n_stage=p,
-                n_micro=m,
-                f_cost=f/2,
-                b_cost=b/2,
-                w_cost=w/2,
-                c_cost=c,
-                f_mem=2,
-                b_mem=-1,
-                w_mem=-1,
-                max_mem=mem * 4,
-  )
-  zbv_result = zbv_graph.get_v_schedule()
+  if mem < p:
+    zbv_time=None
+    zbv_bubble=None
+    zbv_acceleration=None
+    zbv_image=None
+  else:
+    zbv_graph = v_schedule.PipelineGraph(
+                  n_stage=p,
+                  n_micro=m,
+                  f_cost=f/2,
+                  b_cost=b/2,
+                  w_cost=w/2,
+                  c_cost=c,
+                  f_mem=2,
+                  b_mem=-1,
+                  w_mem=-1,
+                  max_mem=mem * 4,
+    )
+    zbv_result = zbv_graph.get_v_schedule()
+
+    zbv_time = get_schedule_time(zbv_result)
+    zbv_bubble=percentage(zbv_time/(f+b+w)/m - 1)
+    zbv_acceleration=percentage(baseline_time/zbv_time - 1) if baseline_time is not None else None
 
-  zbv_time,zbv_image = get_schedule_time_and_image(zbv_result)
-  zbv_bubble=percentage(zbv_time/(f+b+w)/m - 1)
-  zbv_acceleration=percentage(baseline_time/zbv_time - 1)
-  zbv_image=None
+    max_time = max([baseline_time, zb_time, zbv_time])
+    zb_image = get_schedule_image(zb_result, max_time)
+    zbv_image = get_schedule_image(zbv_result, max_time)
 
   return [baseline_time, baseline_bubble, baseline_acceleration, baseline_image, zb_time, zb_bubble, zb_acceleration, zb_image, zbv_time, zbv_bubble, zbv_acceleration, zbv_image]
 
@@ -87,8 +120,8 @@ with gr.Blocks() as demo:
       print("update")
       if s=="custom":
         return mem
-      return p*int(s[:-1])
-    memsel=gr.Radio(choices=["1p", "2p", "3p", "custom"], value="1p")
+      return p*int(s[:1])
+    memsel=gr.Radio(choices=["1p (Same as 1F1B)", "2p", "3p", "custom"], value="1p (Same as 1F1B)")
     mem=gr.Number(label="Custom memory limit in terms of pending F on a stage. For ZBV schedules, this is relative to two virtual stages on a stage combined.", value=p.value, interactive=True, precision=0)
     memsel.change(update_mem, inputs=[p, memsel, mem], outputs=mem)
     p.change(update_mem, inputs=[p, memsel, mem], outputs=mem)
@@ -115,7 +148,7 @@ with gr.Blocks() as demo:
       with gr.Column(scale=4):
         zb_image=gr.Image(None, interactive=False, label="Schedule Image")
   with gr.Group():
-    gr.Markdown("Zero Bubble V Schedule")
+    gr.Markdown("Zero Bubble V Schedule (ZBV)")
     with gr.Row():
       with gr.Column(scale=1):
         zbv_time=gr.Textbox("", label="Longest Stage Time")

description1.md

@@ -6,29 +6,4 @@ Our paper is coming soon.
 
 Try out our implementation based on Megatron on [https://github.com/sail-sg/zero-bubble-pipeline-parallelism](https://github.com/sail-sg/zero-bubble-pipeline-parallelism)
 
-Experiments shows zero bubble pipeline parallelism can accelerate training up to 30% with a similar memory comsumption. A detailed table of experiments is coming soon.
-
-## Zero Bubble Schedules
-The key of achieving zero bubble is to breaking a backward pass into a B pass and W pass. B on one stage will only depend on the B on its next stage, compared to depending on both B and W of in 1F1B.
-
-![image](https://hackmd.io/_uploads/Bkc7CL7N6.png)
-
-### Comparision of Schedules
-* 1F1B
-![image](https://hackmd.io/_uploads/Hkq-gD7N6.png)
-* ZB1P
-![image](https://hackmd.io/_uploads/Hy2GxwmEa.png)
-* ZB2P
-![image](https://hackmd.io/_uploads/S10QgvmV6.png)
-* ZBV - Each device is assigned to exactly 2 chunks (virtual stages), where white text colors represent the first chunk and black text colors represent the second chunk. The sequence of dependencies among model chunks follows a ”V” shape pattern for both the forward and backward passes.
-![image](https://hackmd.io/_uploads/Sk9uyY4ra.png)
-
-
-    
-
-| Comparison assuming T_F=T_B=T_W                                                      | 1F1B    | ZB1P     | ZB2P | ZBV (Recommended) |
-| ----------------------------------------------------- | ------- | -------- | ---- | --- |
-| Bubble Rate                                           | (p-1)/m | (p-1)/3m | 0    | 0   |
-| Activation Memory <br> (Compared to 1F1B)             | 1x       | 1x        | 2x    | 1x   |
-| Pipeline Communication Volume <br> (Compared to 1F1B) | 1x       | 1x        | 1x    | 2x   |
-
+Experiments shows zero bubble pipeline parallelism can accelerate training up to 30% with a similar memory comsumption. A detailed table of experiments is coming soon.

description2.md

@@ -1,3 +1,27 @@
+## Zero Bubble Schedules
+The key of achieving zero bubble is to breaking a backward pass into a B pass and W pass. B on one stage will only depend on the B on its next stage, compared to depending on both B and W of in 1F1B.
+
+![image](https://hackmd.io/_uploads/Bkc7CL7N6.png)
+
+### Comparision of Schedules
+* 1F1B
+![image](https://hackmd.io/_uploads/Hkq-gD7N6.png)
+* ZB1P
+![image](https://hackmd.io/_uploads/Hy2GxwmEa.png)
+* ZB2P
+![image](https://hackmd.io/_uploads/S10QgvmV6.png)
+* ZBV - Each device is assigned to exactly 2 chunks (virtual stages), where white text colors represent the first chunk and black text colors represent the second chunk. The sequence of dependencies among model chunks follows a ”V” shape pattern for both the forward and backward passes.
+![image](https://hackmd.io/_uploads/rkfUVYNrp.png)
+
+
+    
+
+| Comparison assuming T_F=T_B=T_W                                                      | 1F1B    | ZB1P     | ZB2P | ZBV (Recommended) |
+| ----------------------------------------------------- | ------- | -------- | ---- | --- |
+| Bubble Rate                                           | (p-1)/m | (p-1)/3m | 0    | 0   |
+| Activation Memory <br> (Compared to 1F1B)             | 1x       | 1x        | 2x    | 1x   |
+| Pipeline Communication Volume <br> (Compared to 1F1B) | 1x       | 1x        | 1x    | 2x   |
+
 
 
 ## Optimizer Post Validation

svg_event.py

@@ -0,0 +1,367 @@
+import json
+
+import numpy as np
+import drawsvg as draw
+import colorsys
+import tempfile, os
+
+def filter_time(e, start, end):
+    # return e["start_time"] >= start and (end is None or e["completion_time"] <= end)
+    # Check completion_time here to include the last long W
+    return e.completion_time >= start and (end is None or e.completion_time <= end)
+
+
+def load_json_data(filename, start=0, end=None, time_scale=1):
+    with open(filename) as f:
+        data = json.loads(f.read())
+    fbw_types = {"F", "B", "W", "Optimizer"}
+    return [[{
+        "type": e["type"],
+        "start_time": int(max(e["start_time"] - start, 0)) * time_scale,
+        "completion_time": int(e["completion_time"] - start) * time_scale,
+        "minibatch": e.get("minibatch", None),
+    } for e in dev_evs
+        if e["type"] in fbw_types and filter_time(e, start, end)
+    ] for dev_evs in data]
+
+
+ENABLE_BORDER = True
+ENABLE_BATCH_ID = True
+ENABLE_EDGE_BLUR = False
+SCALE_FACTOR = 2
+S = SCALE_FACTOR
+
+# TIME_PER_UNIT = 300 // SCALE_FACTOR
+TIME_PER_UNIT = 4000 // SCALE_FACTOR
+
+
+def to_color_fmt(c):
+    # c = to_greyscale(c)
+    return f"#{hex(c[0])[2:]}{hex(c[1])[2:]}{hex(c[2])[2:]}"
+
+
+GREYSCALE_WEIGHTS = np.array([0.299, 0.587, 0.114])
+
+
+def to_greyscale(color):
+    c = np.dot(GREYSCALE_WEIGHTS, color[:3].astype(float)).astype(int)
+    return np.array([c, c, c, 255])
+
+
+COLOR_VALUE_MAP = {
+    "F": np.array([57, 122, 242]),
+    "B": np.array([62, 181, 191]),
+    # "B": np.array([68, 211, 218]),  # sea color
+    # "W": to_color_fmt(np.array([47, 158, 73, 255])),
+    "W": np.array([41, 137, 64]),
+    # "W": np.array([224, 240, 231]),  # sea color
+    # "Optimizer": to_color_fmt(np.array([255, 240, 197, 255])),
+    "Optimizer": np.array([255, 217, 102]),
+}
+
+
+COLOR_MAP = {k: to_color_fmt(v) for k, v in COLOR_VALUE_MAP.items()}
+
+
+# BORDER_SIZE = SCALE_FACTOR // 2
+BORDER_SIZE = 1
+SPAN_HEIGHT = SCALE_FACTOR * 10
+FONT_SIZE = SCALE_FACTOR * 10
+TITLE_WIDTH = SCALE_FACTOR * 60
+CENTER_TITLE_HEIGHT = SPAN_HEIGHT * 6
+
+WHITE = to_color_fmt(np.array([255, 255, 255, 255]))
+BLACK = to_color_fmt(np.array([0, 0, 0, 255]))
+
+
+class DrawCtx:
+    def __init__(self, d, oy, ox):
+        assert not isinstance(d, DrawCtx)
+        self.d = d
+        self.oy = oy
+        self.ox = ox
+
+    @classmethod
+    def from_base_ctx(cls, base_ctx, oy, ox):
+        assert isinstance(base_ctx, DrawCtx)
+        return cls(base_ctx.d, base_ctx.oy + oy, base_ctx.ox + ox)
+
+    def width(self):
+        return self.d.width
+
+    def height(self):
+        return self.d.height
+
+    def line(self, sy, sx, ey, ex, width=None):
+        self.d.append(draw.Line(
+            self.ox + sx,
+            self.oy + sy,
+            self.ox + ex,
+            self.oy + ey,
+            stroke='black',
+            stroke_width=width or BORDER_SIZE,
+        ))
+
+    def rect(self, sy, sx, h, w, color):
+        self.d.append(draw.Rectangle(
+            self.ox + sx,
+            self.oy + sy,
+            w, h,
+            fill=color,
+            shape_rendering="geometricPrecision",
+        ))
+
+    def rect_frame(self, sy, sx, h, w):
+        self.d.append(draw.Rectangle(
+            self.ox + sx,
+            self.oy + sy,
+            w, h,
+            fill="none",
+            stroke=BLACK,
+            stroke_width=BORDER_SIZE,
+        ))
+
+    def text(self, y, x, text, anchor="middle", font_scale=1, fill='black'):
+        font_size = FONT_SIZE * font_scale
+        tl = len(text) * font_size // 2
+        self.d.append(draw.Text(
+            text, font_size,
+            self.ox + x,
+            # Magic 3 to make it vertical center
+            self.oy + y + font_size - 3,
+            textLength=tl, lengthAdjust='spacing',
+            text_anchor=anchor,
+            font_family="Times New Roman",
+            fill=fill,
+            # font_style="oblique",
+            # font_family="Computer Modern Roman",
+        ))
+
+
+def change_color_sat(c, percentage):
+    c = c.astype(float) / 255.0
+    (h, s, v) = colorsys.rgb_to_hsv(c[0], c[1], c[2])
+    s *= percentage
+    r, g, b = colorsys.hsv_to_rgb(h, s, v)
+    c = np.array([r, g, b]) * 255
+    return c.astype(int)
+
+
+def draw_experiment_and_schedule(exp_events, sched_events, output_filename, tail=10):
+    exp_canvas_info = CanvasInfo(exp_events, tail, 0)
+    sched_canvas_info = CanvasInfo(sched_events, tail, 0, False)
+    width = max(exp_canvas_info.get_canvas_size()[1], sched_canvas_info.get_canvas_size()[1])
+    height = exp_canvas_info.get_canvas_size()[0] + sched_canvas_info.get_canvas_size()[0]
+
+    include_w = True
+
+    # d = draw.Drawing(width, sched_canvas_info.get_canvas_size()[0], origin="top-left")
+    d = draw.Drawing(width, height, origin="top-left")
+    ctx = DrawCtx(d, 0, 0)
+    plot_events(ctx, sched_events, "", sched_canvas_info, include_w, include_o=False, include_info=False)
+    # plot_events(ctx, sched_events, "", sched_canvas_info, include_w, include_o=False)
+    # d.save_svg("pics/schedule.svg")
+
+    # d = draw.Drawing(width, sched_canvas_info.get_canvas_size()[0], origin="top-left")
+    # exp_ctx = DrawCtx(d, 0, 0)
+    exp_ctx = DrawCtx.from_base_ctx(ctx, sched_canvas_info.get_canvas_size()[0], 0)
+    plot_events(exp_ctx, exp_events, "", exp_canvas_info, include_w, include_o=True)
+    # plot_events(exp_ctx, exp_events, "", exp_canvas_info, include_w, include_o=True)
+    d.save_svg(output_filename)
+
+
+def draw_events(events, output_filename, include_w=True, include_o=True, tail=50):
+    canvas_info = CanvasInfo(events, tail, center_title_height=0, enable_info=True)
+    max_len = canvas_info.max_len
+    # height = canvas_info.height
+    # info_height = canvas_info.info_height
+    height, width = canvas_info.get_canvas_size()
+
+    d = draw.Drawing(width, height, origin="top-left")
+    ctx = DrawCtx(d, 0, 0)
+
+    plot_events(ctx, events, "", canvas_info, include_w, include_o)
+    d.save_svg(output_filename)
+
+
+class CanvasInfo:
+    def __init__(self, events, tail, center_title_height=CENTER_TITLE_HEIGHT, enable_info=True):
+        last_time = max(max([e["completion_time"] for e in dev_evs]) for dev_evs in events)
+        self.max_len = (last_time + TIME_PER_UNIT - 1) // TIME_PER_UNIT + tail
+
+        self.height = SPAN_HEIGHT * len(events) + BORDER_SIZE * (len(events) + 1)
+        color_text_row_height = int(SPAN_HEIGHT * 1.6)
+        self.color_text_height = color_text_row_height + BORDER_SIZE
+        self.info_height = SPAN_HEIGHT + color_text_row_height + 3 * BORDER_SIZE
+        if not enable_info:
+            self.info_height /= 2
+        self.center_title_height = center_title_height
+        # self.center_title_height = 0
+
+    def get_canvas_size(self):
+        # height, width
+        return self.height + self.info_height + self.center_title_height, self.max_len + TITLE_WIDTH
+
+
+def plot_events(ctx, events, title_text: str, canvas_info: CanvasInfo, include_w=True, include_o=True, include_info=True):
+    max_len = canvas_info.max_len
+    height = canvas_info.height
+    color_text_height = canvas_info.color_text_height
+    info_height = canvas_info.info_height
+
+    data_ctx = DrawCtx.from_base_ctx(ctx, 0, TITLE_WIDTH)
+
+    for i, evs in enumerate(events):
+        h = i * SPAN_HEIGHT + (i + 1) * BORDER_SIZE
+        for e in evs:
+            start = BORDER_SIZE + e["start_time"] // TIME_PER_UNIT
+            end = BORDER_SIZE + e["completion_time"] // TIME_PER_UNIT
+            if start == end or not ENABLE_EDGE_BLUR:
+                plot_span(data_ctx, start, end, h, COLOR_MAP[e["type"]])
+            else:
+                plot_span(data_ctx, start + 1, end - 1, h, COLOR_MAP[e["type"]])
+                # plot_span(data_ctx, start, end - 1, h, COLOR_MAP[e["type"]])
+                c = change_color_sat(
+                    COLOR_VALUE_MAP[e["type"]],
+                    (e["start_time"] / TIME_PER_UNIT) % 1.0)
+                plot_span(data_ctx, start, start + 1, h, to_color_fmt(c))
+                c = change_color_sat(
+                    COLOR_VALUE_MAP[e["type"]],
+                    (e["completion_time"] / TIME_PER_UNIT) % 1.0)
+                plot_span(data_ctx, end - 1, end, h, to_color_fmt(c))
+
+            if ENABLE_BATCH_ID:
+                minibatch = str(e["minibatch"])
+                center = (start + end) // 2
+                data_ctx.text(h, center, minibatch, font_scale=0.7, fill='black' if e["chunk"] == 0 else 'white')
+        if ENABLE_BORDER:
+            data_ctx.line(h+SPAN_HEIGHT, 0, h+SPAN_HEIGHT+BORDER_SIZE, max_len - 1)
+
+    if ENABLE_BORDER:
+        data_ctx.line(0, 0, 0, max_len - 1)
+        data_ctx.line(0, 0, height, 0)
+        data_ctx.line(0, max_len - 1, height, max_len - 1)
+
+    dev_title_ctx = DrawCtx.from_base_ctx(ctx, 0, 0)
+    ndev = len(events)
+    add_devices(dev_title_ctx, ndev)
+
+    if not include_info:
+        return
+
+    info_height = ndev * SPAN_HEIGHT + (ndev + 1) * BORDER_SIZE
+    info_ctx = DrawCtx.from_base_ctx(ctx, info_height, 0)
+    add_info(info_ctx, color_text_height, include_w, include_o)
+
+    if title_text:
+        center_title_ctx = DrawCtx.from_base_ctx(info_ctx, canvas_info.info_height, 0)
+        add_center_title(center_title_ctx, title_text)
+
+
+def plot_span(ctx, start, end, h, color, ):
+    ctx.rect(h, start, SPAN_HEIGHT, end - start, color)
+    if ENABLE_BORDER:
+        ctx.rect_frame(h-BORDER_SIZE, start, SPAN_HEIGHT + BORDER_SIZE, end - start)
+
+
+def add_devices(ctx, devs):
+    for i in range(devs):
+        h = i * SPAN_HEIGHT + (i + 1) * BORDER_SIZE
+        ctx.text(h, 6 * SCALE_FACTOR, "Device {}".format(i), "left")
+
+
+def add_info(ctx, color_text_height, include_w=True, include_o=True):
+    div = 4 + int(include_w) + int(include_o)
+    f_start = ctx.width() // div
+    b_start = ctx.width() // div * 2
+    w_start = ctx.width() // div * 3
+    o_start = ctx.width() // div * 4
+
+    block_w = 25 * SCALE_FACTOR
+    plot_span(ctx, f_start, f_start+block_w, color_text_height + BORDER_SIZE, COLOR_MAP["F"])
+    plot_span(ctx, b_start, b_start+block_w, color_text_height + BORDER_SIZE, COLOR_MAP["B"])
+    if include_w:
+        plot_span(ctx, w_start, w_start+block_w, color_text_height + BORDER_SIZE, COLOR_MAP["W"])
+    if include_o:
+        plot_span(ctx, o_start, o_start+block_w, color_text_height + BORDER_SIZE, COLOR_MAP["Optimizer"])
+
+    ctx.text(0, 6 * SCALE_FACTOR, "Time", "left")
+    draw_arrow(ctx, SPAN_HEIGHT // 2 + BORDER_SIZE + 1, 65 * SCALE_FACTOR, 50 * SCALE_FACTOR)
+
+    block_w = 30 * SCALE_FACTOR
+    ctx.text(color_text_height, f_start + block_w, "F", "left")
+    ctx.text(color_text_height, b_start + block_w,
+             "B", "left")
+    if include_w:
+        ctx.text(color_text_height, w_start + block_w, "W", "left")
+    if include_o:
+        ctx.text(color_text_height, o_start + block_w, "Optimizer Step", "left")
+
+
+def add_center_title(ctx: DrawCtx, text):
+    ctx.text(CENTER_TITLE_HEIGHT / 4, ctx.width() / 2,
+             text, "middle", 2)
+
+
+def draw_arrow(ctx: DrawCtx, start_y, start_x, width, thickness=2):
+    b = thickness * (SCALE_FACTOR // 2)
+    ctx.line(start_y, start_x, start_y, start_x + width, b)
+    ctx.line(start_y, start_x + width, start_y - 3*b, start_x + width - 3*b)
+    ctx.line(start_y, start_x + width, start_y + 3*b, start_x + width - 3*b)
+
+
+def render_manual_graph(data, longest_time, enable_batch_id = False):
+    global ENABLE_BORDER
+    global ENABLE_BATCH_ID
+    ENABLE_BORDER = True
+    ENABLE_BATCH_ID = enable_batch_id
+    fbw_types = {"F", "B", "W", "Optimizer"}
+    start = 0
+    end = None
+    time_scale= 1024 / longest_time * TIME_PER_UNIT
+    events = [[{
+        "type": e.type,
+        "start_time": int(max(e.start_time - start, 0)) * time_scale,
+        "completion_time": int(e.completion_time - start) * time_scale,
+        "minibatch": e.minibatch,
+        "chunk": e.chunk if hasattr(e, "chunk") else 0,
+    } for e in dev_evs
+        if e.type in fbw_types and filter_time(e, start, end)
+    ] for dev_evs in data]
+    # events = load_json_data("std-schedule.json")
+    # global TIME_PER_UNIT
+    # global ENABLE_BATCH_ID
+    # global ENABLE_BORDER
+    # global SCALE_FACTOR
+    # SCALE_FACTOR = 8
+    # ENABLE_BATCH_ID = False
+    # ENABLE_BORDER = False
+    # TIME_PER_UNIT *= 7
+    #events = load_json_data("no-bb-schedule.json")
+    
+    path = os.path.join(tempfile.mkdtemp(), 'a.svg')
+    draw_events(events, path, include_w=True, include_o=False, tail=50)
+    return path
+
+
+def render_experiment_graph():
+    global ENABLE_BORDER
+    global ENABLE_BATCH_ID
+    global TIME_PER_UNIT
+    ENABLE_BORDER = False
+    ENABLE_BATCH_ID = False
+    TIME_PER_UNIT = 200 // SCALE_FACTOR
+    TIME_PER_UNIT *= 12000
+    start_time = 1100000000 + 10000000
+    # iter_time = 1600000000
+    iter_time = 1290000000
+    end_time = start_time + iter_time
+    exp_events = load_json_data("20-09-zero/zero-events.json", start_time, end_time)
+    # draw_events(events, "pics/experiment.svg")
+    sched_events = load_json_data("schedule.json", time_scale=1000)
+    draw_experiment_and_schedule(exp_events, sched_events, "pics/exp.svg")
+    # draw_events(events, "pics/schedule.svg", include_w=True, include_o=False)
+
+
+# render_manual_graph()
+# render_experiment_graph()