Update app.py

app.py

@@ -1,5 +1,5 @@
 import math
-import gradio
+import gradio as gr
 import pandas
 
 from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
@@ -8,53 +8,51 @@ MODEL_ID = "HuggingFaceTB/SmolLM2-135M-Instruct"
 tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
 pipe = pipeline(
     task="text-generation",
-    model=AutoModelForCausalLM.from_pretrained(
-        MODEL_ID,
-    ),
+    model=AutoModelForCausalLM.from_pretrained(MODEL_ID),
     tokenizer=tokenizer
 )
 
 def clock_calc(t_clock_to_q: float, t_logic, t_logic_min, t_setup, t_hold, t_skew):
-
-  t_clock_min = t_clock_to_q + t_logic + t_setup + t_skew
-  if t_clock_min > 0:
-    f_max = 1.0 / (t_clock_min * 1e-9)
-  else:
-    f_max = math.inf
-
-  setup_slack = 0.0
-
-  hold_margin = t_clock_to_q + t_logic_min - t_skew - t_hold
-  hold_met = hold_margin >= 0.0
-
-  if t_hold > 0:
-    hold_time = t_clock_to_q + t_logic_min - t_skew
-    hold_safety = hold_time / t_hold
-  else:
-    hold_safety = math.inf
-  timing_breakdown = {
-      "t_clock_to_q": t_clock_to_q,
-      "t_logic": t_logic,
-      "t_setup": t_setup,
-      "t_skew": t_skew,
-      "total": t_clock_min
-  }
-
-  ok = hold_met
-
-  if f_max >= 1e9:
-    freq_display = f"{f_max/1e9:.3f} GHz"
-  else:
-    freq_display = f"{f_max/1e6:.2f} MHz"
-  
-  return dict(
+    t_clock_min = t_clock_to_q + t_logic + t_setup + t_skew
+    if t_clock_min > 0:
+        f_max = 1.0 / (t_clock_min * 1e-9)
+    else:
+        f_max = math.inf
+
+    setup_slack = 0.0
+
+    hold_margin = t_clock_to_q + t_logic_min - t_skew - t_hold
+    hold_met = hold_margin >= 0.0
+
+    if t_hold > 0:
+        hold_time = t_clock_to_q + t_logic_min - t_skew
+        hold_safety = hold_time / t_hold
+    else:
+        hold_safety = math.inf
+
+    timing_breakdown = {
+        "t_clock_to_q": t_clock_to_q,
+        "t_logic": t_logic,
+        "t_setup": t_setup,
+        "t_skew": t_skew,
+        "total": t_clock_min
+    }
+
+    ok = hold_met
+
+    if f_max >= 1e9:
+        freq_display = f"{f_max/1e9:.3f} GHz"
+    else:
+        freq_display = f"{f_max/1e6:.2f} MHz"
+
+    return dict(
         results={
             "f_max_hz": f_max,
             "f_max_mhz": f_max / 1e6,
             "f_max_ghz": f_max / 1e9,
-            "t_clock_min_ns": t_clock_min,
-            "setup_slack_ns": setup_slack,
-            "hold_margin_ns": hold_margin,
+            "t_clock_min": t_clock_min,
+            "setup_slack": setup_slack,
+            "hold_margin": hold_margin,
             "hold_safety_factor": hold_safety,
             "freq_display": freq_display,
         },
@@ -78,61 +76,59 @@ def clock_calc(t_clock_to_q: float, t_logic, t_logic_min, t_setup, t_hold, t_ske
         },
         timing_breakdown=timing_breakdown,
     )
-  
+
 def _format_chat(system_prompt: str, user_prompt: str) -> str:
-  messages = [
-      {"role": "system", "content": system_prompt},
-      {"role": "user", "content": user_prompt},
-  ]
-  template = getattr(tokenizer, "chat_template", None)
-  return tokenizer.apply_chat_template(
-      messages,
-      tokenize=False,
-      add_generation_prompt=True
-  )
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": user_prompt},
+    ]
+    return tokenizer.apply_chat_template(
+        messages,
+        tokenize=False,
+        add_generation_prompt=True
+    )
 
 def _llm_generate(prompt: str, max_tokens: int) -> str:
-  out = pipe(
-      prompt,
-      max_new_tokens=max_tokens,
-      do_sample=True,
-      temperature=0.5,
-      return_full_text=False,
-  )
-  return out[0]["generated_text"]
+    out = pipe(
+        prompt,
+        max_new_tokens=max_tokens,
+        do_sample=True,
+        temperature=0.5,
+        return_full_text=False,
+    )
+    return out[0]["generated_text"]
 
 def llm_explain(results: dict, inputs: list) -> str:
+    t_clock_to_q, t_logic, t_logic_min, t_setup, t_hold, t_skew = inputs
+    r = results["results"]
+    v = results["verdict"]
+
+    system_prompt = (
+        "You explain digital circuit timing to a smart highschooler. "
+        "Use everyday analogies (like traffic lights, relay races) to support the explanation. "
+        "You always return CONCISE responses, only one or two sentences."
+    )
 
-  t_clock_to_q, t_logic, t_logic_min, t_setup, t_hold, t_skew = inputs
-  r = results["results"]
-  v = results["verdict"]
-
-  system_prompt = (
-      "You explain digital circuit timing to a smart highschooler. "
-      "Use everyday analogies (like traffic lights, relay races) to support the explanation. "
-      "You always return CONCISE responses, only one or two sentences."
-  )
-  
-  user_prompt = (
-      f"The digital circuit has a clock-to-Q delay of {t_clock_to_q:g} ns, "
-      f"combinational logic delay of {t_logic:g} ns (max) and {t_logic_min:g} ns (min), "
-      f"setup time of {t_setup:g} ns, hold time of {t_hold:g} ns, "
-      f"and clock skew of {t_skew:g} ns.\n"
-      f"The maximum operating frequency is {r['freq_display']}, "
-      f"requiring a minimum clock period of {r['t_clock_min']:.2f} ns. "
-      f"The hold timing has a margin of {r['hold_margin']:.3f} ns with "
-      f"safety factor = {r['hold_safety_factor']:.2f}. "
-      f"Setup constraint: {v['setup_message']}. "
-      f"Hold constraint: {v['hold_message']}. "
-      f"Overall: {v['recommendation']}. "
-      "Explain what limits the clock speed and whether the design is safe in ONE to TWO friendly sentences for a non-expert."
-  )
-
-  format = _format_chat(system_prompt, user_prompt)
-  return _llm_generate(format, max_tokens=128)
+    user_prompt = (
+        f"The digital circuit has a clock-to-Q delay of {t_clock_to_q:g} ns, "
+        f"combinational logic delay of {t_logic:g} ns (max) and {t_logic_min:g} ns (min), "
+        f"setup time of {t_setup:g} ns, hold time of {t_hold:g} ns, "
+        f"and clock skew of {t_skew:g} ns.\n"
+        f"The maximum operating frequency is {r['freq_display']}, "
+        f"requiring a minimum clock period of {r['t_clock_min']:.2f} ns. "
+        f"The hold timing has a margin of {r['hold_margin']:.3f} ns with "
+        f"safety factor = {r['hold_safety_factor']:.2f}. "
+        f"Setup constraint: {v['setup_message']}. "
+        f"Hold constraint: {v['hold_message']}. "
+        f"Overall: {v['recommendation']}. "
+        "Explain what limits the clock speed and whether the design is safe in ONE to TWO friendly sentences for a non-expert."
+    )
+
+    formatted = _format_chat(system_prompt, user_prompt)
+    return _llm_generate(formatted, max_tokens=128)
 
 def run_once(t_clock_to_q, t_logic, t_logic_min, t_setup, t_hold, t_skew):
-  d = clock_calc(
+    d = clock_calc(
         t_clock_to_q=float(t_clock_to_q),
         t_logic=float(t_logic),
         t_logic_min=float(t_logic_min),
@@ -140,8 +136,8 @@ def run_once(t_clock_to_q, t_logic, t_logic_min, t_setup, t_hold, t_skew):
         t_hold=float(t_hold),
         t_skew=float(t_skew)
     )
-  
-  df = pandas.DataFrame([{
+
+    df = pandas.DataFrame([{
         "Max Frequency": d["results"]["freq_display"],
         "Min Period [ns]": round(d["results"]["t_clock_min"], 3),
         "Setup Slack [ns]": round(d["results"]["setup_slack"], 3),
@@ -150,39 +146,40 @@ def run_once(t_clock_to_q, t_logic, t_logic_min, t_setup, t_hold, t_skew):
         "Setup Status": d["verdict"]["setup_message"],
         "Hold Status": d["verdict"]["hold_message"],
     }])
-  
-  narrative = llm_explain(d, inputs).split("\n")[0]
-  return df, narrative
 
-with gradio.Blocks() as demo:
+    # fix: define inputs here
+    inputs = [t_clock_to_q, t_logic, t_logic_min, t_setup, t_hold, t_skew]
+    narrative = llm_explain(d, inputs).split("\n")[0]
+    return df, narrative
 
-    gradio.Markdown(
-        "# Run and Explain Digital Circuit Timing"
-    )
-    gradio.Markdown(
+with gr.Blocks() as demo:
+    gr.Markdown("# Run and Explain Digital Circuit Timing")
+    gr.Markdown(
         "This app runs some simple calculations for a digital circuit and returns a natural language description of the results"
     )
 
-    with gradio.Row():
-        t_clock_to_q = gradio.Number(value=0.5, label="Clock-to-Q delay [ns]")
-        t_setup = gradio.Number(value=0.4, label="Setup time [ns]")
-        t_hold = gradio.Number(value=0.1, label="Hold time [ns]")
+    with gr.Row():
+        t_clock_to_q = gr.Number(value=0.5, label="Clock-to-Q delay [ns]")
+        t_setup = gr.Number(value=0.4, label="Setup time [ns]")
+        t_hold = gr.Number(value=0.1, label="Hold time [ns]")
 
-    with gradio.Row():
-        t_logic = gradio.Number(value=8.0, label="Max logic delay [ns]")
-        t_logic_min = gradio.Number(value=0.3, label="Min logic delay [ns]")
-        t_skew = gradio.Number(value=0.5, label="Clock skew [ns]")
+    with gr.Row():
+        t_logic = gr.Number(value=8.0, label="Max logic delay [ns]")
+        t_logic_min = gr.Number(value=0.3, label="Min logic delay [ns]")
+        t_skew = gr.Number(value=0.5, label="Clock skew [ns]")
 
-    # Add a button to click to run the interface
-    run_btn = gradio.Button("Compute")
+    run_btn = gr.Button("Compute")
 
-    results_df = gradio.Dataframe(label="Numerical results (deterministic)", interactive=False)
-    explain_md = gradio.Markdown(label="Explanation")
+    results_df = gr.Dataframe(label="Numerical results (deterministic)", interactive=False)
+    explain_md = gr.Markdown()
 
-    run_btn.click(fn=run_once, inputs=[t_clock_to_q, t_logic, t_logic_min, t_setup, t_hold, t_skew], outputs=[results_df, explain_md])
+    run_btn.click(
+        fn=run_once,
+        inputs=[t_clock_to_q, t_logic, t_logic_min, t_setup, t_hold, t_skew],
+        outputs=[results_df, explain_md]
+    )
 
-    # Finally, add a few examples
-    gradio.Examples(
+    gr.Examples(
         examples=[
             [0.5, 8.0, 0.3, 0.4, 0.1, 0.5],
             [0.08, 0.4, 0.05, 0.06, 0.03, 0.02],
@@ -195,4 +192,4 @@ with gradio.Blocks() as demo:
     )
 
 if __name__ == "__main__":
-    demo.launch(debug=True)
+    demo.launch(debug=True)