import gradio as gr import hand_schedule import adaptive_schedule import interleaved_variant import type2 import schedule1f1bv from PIL import Image from svg_event import render_manual_graph import pathlib def percentage(x): return f"{x*100:.2f}%" def get_schedule_time(result): result = [ list(filter(lambda x: x.type in {'F', 'B', 'W'}, r)) for r in result ] time = max( [ max([x.completion_time for x in stage]) - min([x.start_time for x in stage]) for stage in result ] ) return time def get_memory_usage(result): max_mem = 0 has_w = False for r in result: for x in r: if x.type in ('W', 'w'): has_w = True for r in result: cur = 0 for x in r: if x.type in ('F', 'f'): cur += 1 if x.type in ('W', 'w'): cur -= 1 if has_w == False and x.type in ('B', 'b'): cur -= 1 max_mem = max(max_mem, cur) return max_mem 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): def get_bubble_rate(_time): return 1 - ((f + b + w) * m / _time) baseline_result = hand_schedule.get_hand_schedule(p, m, f, b + w, 0, c) baseline_result = [ list(filter(lambda x: x.type in {'F', 'B'}, r)) for r in baseline_result ] baseline_time = get_schedule_time(baseline_result) # baseline_bubble=percentage(baseline_time/(f+b+w)/m - 1) baseline_bubble=percentage(get_bubble_rate(baseline_time)) baseline_mem = get_memory_usage(baseline_result) baseline_acceleration=percentage(0) adapt_result = adaptive_schedule.schedule( p, m, [f/2, b/2, w/2, c], max_mem=mem * 2 ) adapt_time = get_schedule_time(adapt_result) adapt_mem = get_memory_usage(adapt_result) / 2 # adapt_bubble=percentage(adapt_time/(f+b+w)/m - 1) adapt_bubble=percentage(get_bubble_rate(adapt_time)) adapt_acceleration=percentage(baseline_time/adapt_time - 1) if baseline_time is not None else None schedule1f1bv_result = schedule1f1bv.schedule( p, m, [f / 2, b / 2, w / 2, c] ) schedule1f1bv_time = get_schedule_time(schedule1f1bv_result) schedule1f1bv_mem = get_memory_usage(schedule1f1bv_result) / 2 # schedule1f1bv_bubble=percentage(schedule1f1bv_time/(f+b+w)/m - 1) schedule1f1bv_bubble=percentage(get_bubble_rate(schedule1f1bv_time)) schedule1f1bv_acceleration=percentage(baseline_time/schedule1f1bv_time - 1) if baseline_time is not None else None type2_result = type2.schedule( p, m, [f, b, w, c] ) type2_time = get_schedule_time(type2_result) type2_mem = get_memory_usage(type2_result) # type2_bubble=percentage(type2_time/(f+b+w)/m - 1) type2_bubble=percentage(get_bubble_rate(type2_time)) type2_acceleration=percentage(baseline_time/type2_time - 1) if baseline_time is not None else None interleaved_result = interleaved_variant.get_interleaved_variation( p, m, [f/2, b/2, w/2, c] ) interleaved_time = get_schedule_time(interleaved_result) interleaved_mem = get_memory_usage(interleaved_result) / 2 # interleaved_bubble=percentage(interleaved_time/(f+b+w)/m - 1) interleaved_bubble=percentage(get_bubble_rate(interleaved_time)) interleaved_acceleration=percentage(baseline_time/interleaved_time - 1) if baseline_time is not None else None max_time = max(filter(lambda x: x is not None, [baseline_time, adapt_time, interleaved_time, type2_time, schedule1f1bv_time])) print(max_time) if baseline_result is not None: baseline_image = get_schedule_image(baseline_result, max_time) if adapt_result is not None: adapt_image = get_schedule_image(adapt_result, max_time) if interleaved_result is not None: interleaved_image = get_schedule_image(interleaved_result, max_time) if type2_result is not None: type2_image = get_schedule_image(type2_result, max_time) if schedule1f1bv_result is not None: schedule1f1bv_image = get_schedule_image(schedule1f1bv_result, max_time) return [baseline_acceleration, baseline_mem, baseline_bubble, baseline_image, adapt_acceleration, adapt_mem, adapt_bubble, adapt_image, schedule1f1bv_acceleration, schedule1f1bv_mem, schedule1f1bv_bubble, schedule1f1bv_image, type2_acceleration, type2_mem, type2_bubble, type2_image, interleaved_acceleration, interleaved_mem, interleaved_bubble, interleaved_image] with gr.Blocks() as demo: gr.Markdown(open("description1.md").read()) gr.Markdown("# Pipeline Scheduler Playground") presets = { 'Default Case': (4, 10, 100, 110, 90, 5, 'V-Half (1/2)'), 'Ideal Case': (4, 10, 20, 20, 20, 0, 'V-Min (1/3)'), 'Real Case': (4, 10, 1049, 1122, 903, 79, 'V-Half (1/2)'), 'Zero Bubble Case': (4, 10, 1049, 1122, 903, 79, 'V-ZB (1)') } preset_buttons = {} with gr.Group(): gr.Markdown("Preset Setups") with gr.Row(): for (k, v) in presets.items(): preset_buttons[k] = gr.Button(k, variant="secondary") with gr.Row(): with gr.Column(scale=1): with gr.Group(): gr.Markdown("Basic Parameters") with gr.Row(): p=gr.Number(label="Number of stages (p)", value=4, interactive=True, precision=0) m=gr.Number(label="Number of microbatches (m)", value=10, interactive=True, precision=0) with gr.Column(scale=2): with gr.Group(): gr.Markdown("Costs. All costs are used as integers. For chunked schedules, this is the time of two virtual stages on a stage combined.") with gr.Row(): f=gr.Number(label="Time of F", value=100, interactive=True, precision=0) b=gr.Number(label="Time of B", value=110, interactive=True, precision=0) w=gr.Number(label="Time of W", value=90, interactive=True, precision=0) c=gr.Number(label="Time of one P2P communication", value=5, interactive=True, precision=0) with gr.Group(): gr.Markdown("Activation memory limit.") def update_mem(p, s, mem): print("update") if s == "custom": return mem if s == "V-Min (1/3)": return (p + 4) // 3 if s == "V-Half (1/2)": return (p + 2) // 2 if s == "V-ZB (1)": return p assert False memsel=gr.Radio(choices=["V-Min (1/3)", "V-Half (1/2)", "V-ZB (1)", "custom"], value="V-Half (1/2)") mem=gr.Number(label="Custom memory limit in terms of pending F on a stage. For chunked schedules, this is relative to two virtual stages on a stage combined.", value=(p.value + 2) // 2, interactive=True, precision=0) memsel.change(update_mem, inputs=[p, memsel, mem], outputs=mem) p.change(update_mem, inputs=[p, memsel, mem], outputs=mem) button=gr.Button("Calculate", variant="primary") with gr.Group(): gr.Markdown("1F1B") with gr.Row(): with gr.Column(scale=1): baseline_acceleration=gr.Textbox("", label="Acceleration compared to 1F1B") baseline_mem=gr.Textbox("", label="Maximum memory usage") baseline_bubble=gr.Textbox("", label="Bubble Rate") with gr.Column(scale=4): baseline_image=gr.Image(None, interactive=False, label="Schedule Image", show_label=False) with gr.Group(): gr.Markdown("Adaptive Scheduler") with gr.Row(): with gr.Column(scale=1): adapt_acceleration=gr.Textbox("", label="Acceleration compared to 1F1B") adapt_mem=gr.Textbox("", label="Maximum memory usage") adapt_bubble=gr.Textbox("", label="Bubble Rate") with gr.Column(scale=4): adapt_image=gr.Image(None, interactive=False, label="Schedule Image", show_label=False) gr.Markdown(open("description2.md").read()) with gr.Group(): gr.Markdown("1F1B-V Schedule") with gr.Row(): with gr.Column(scale=1): schedule1f1bv_acceleration=gr.Textbox("", label="Acceleration compared to 1F1B") schedule1f1bv_mem=gr.Textbox("", label="Maximum memory usage") schedule1f1bv_bubble=gr.Textbox("", label="Bubble Rate") with gr.Column(scale=4): schedule1f1bv_image=gr.Image(None, interactive=False, label="Schedule Image", show_label=False) with gr.Group(): gr.Markdown("Zero bubble schedule with 2/3 1F1B memory") with gr.Row(): with gr.Column(scale=1): type2_acceleration=gr.Textbox("", label="Acceleration compared to 1F1B") type2_mem=gr.Textbox("", label="Maximum memory usage") type2_bubble=gr.Textbox("", label="Bubble Rate") with gr.Column(scale=4): type2_image=gr.Image(None, interactive=False, label="Schedule Image", show_label=False) with gr.Group(): gr.Markdown("Variation of Interleaved 1F1B Schedule") with gr.Row(): with gr.Column(scale=1): interleaved_acceleration=gr.Textbox("", label="Acceleration compared to 1F1B") interleaved_mem=gr.Textbox("", label="Maximum memory usage") interleaved_bubble=gr.Textbox("", label="Bubble Rate") with gr.Column(scale=4): interleaved_image=gr.Image(None, interactive=False, label="Schedule Image", show_label=False) button.click(calculate, inputs=[p, m, f, b, w, c, mem], outputs=[baseline_acceleration, baseline_mem, baseline_bubble, baseline_image, adapt_acceleration, adapt_mem, adapt_bubble, adapt_image, schedule1f1bv_acceleration, schedule1f1bv_mem, schedule1f1bv_bubble, schedule1f1bv_image, type2_acceleration, type2_mem, type2_bubble, type2_image, interleaved_acceleration, interleaved_mem, interleaved_bubble, interleaved_image]) gr.Markdown(open("description3.md").read()) for (k, v) in presets.items(): def update_preset(pb, p, m, f, b, w, c, mem): print(pb) print(presets[pb]) print(presets[pb][-1]) return *presets[pb],*calculate(*presets[pb][:-1], update_mem(p, presets[pb][-1], -1)) preset_buttons[k].click( update_preset, inputs=[preset_buttons[k], p, m, f, b, w, c, mem], outputs=[p, m, f, b, w, c, memsel, baseline_acceleration, baseline_mem, baseline_bubble, baseline_image, adapt_acceleration, adapt_mem, adapt_bubble, adapt_image, schedule1f1bv_acceleration, schedule1f1bv_mem, schedule1f1bv_bubble, schedule1f1bv_image, type2_acceleration, type2_mem, type2_bubble, type2_image, interleaved_acceleration, interleaved_mem, interleaved_bubble, interleaved_image]) demo.launch()