QuizGenerator 0.7.1__py3-none-any.whl → 0.8.1__py3-none-any.whl

QuizGenerator/premade_questions/cst463/models/cnns.py

@@ -49,29 +49,33 @@ class ConvolutionCalculation(MatrixQuestion):
     
     return output
   
-  def refresh(self, *args, **kwargs):
-    super().refresh(*args, **kwargs)
+  @classmethod
+  def _build_context(cls, *, rng_seed=None, **kwargs):
+    rng = cls.get_rng(rng_seed)
+    digits = cls.get_digits_to_round(digits_to_round=kwargs.get("digits_to_round"))
 
-    # num_input_channels = 1
     input_size = kwargs.get("input_size", 4)
     num_filters = kwargs.get("num_filters", 1)
-    self.stride = kwargs.get("stride", 1)
-    self.padding = kwargs.get("padding", 0)
-
-    # Small sizes for hand calculation
-    self.image = self.get_rounded_matrix((input_size, input_size))
-    self.kernel = self.get_rounded_matrix((3, 3, num_filters), -1, 1)
-
-    self.result = self.conv2d_multi_channel(self.image, self.kernel, stride=self.stride, padding=self.padding)
-    
-    self.answers = {
-      f"result_{i}" : ca.AnswerTypes.Matrix(self.result[:,:,i], label=f"Result of filter {i}")
-      for i in range(self.result.shape[-1])
+    stride = kwargs.get("stride", 1)
+    padding = kwargs.get("padding", 0)
+
+    image = cls.get_rounded_matrix(rng, (input_size, input_size), digits_to_round=digits)
+    kernel = cls.get_rounded_matrix(rng, (3, 3, num_filters), -1, 1, digits)
+    result = cls.conv2d_multi_channel(image, kernel, stride=stride, padding=padding)
+
+    return {
+      "digits": digits,
+      "input_size": input_size,
+      "num_filters": num_filters,
+      "stride": stride,
+      "padding": padding,
+      "image": image,
+      "kernel": kernel,
+      "result": result,
     }
-    
-    return True
-  
-  def _get_body(self, **kwargs) -> Tuple[ca.Section, List[ca.Answer]]:
+
+  @classmethod
+  def _build_body(cls, context) -> Tuple[ca.Section, List[ca.Answer]]:
     """Build question body and collect answers."""
     body = ca.Section()
     answers = []
@@ -79,7 +83,7 @@ class ConvolutionCalculation(MatrixQuestion):
     body.add_elements(
       [
         ca.Text("Given image represented as matrix: "),
-        ca.Matrix(self.image, name="image")
+        ca.Matrix(context["image"], name="image")
       ]
     )
 
@@ -87,38 +91,35 @@ class ConvolutionCalculation(MatrixQuestion):
       [
         ca.Text("And convolution filters: "),
       ] + [
-        ca.Matrix(self.kernel[:, :, i], name=f"Filter {i}")
-        for i in range(self.kernel.shape[-1])
+        ca.Matrix(context["kernel"][:, :, i], name=f"Filter {i}")
+        for i in range(context["kernel"].shape[-1])
       ]
     )
 
     body.add_element(
       ca.Paragraph(
         [
-          f"Calculate the output of the convolution operation.  Assume stride = {self.stride} and padding = {self.padding}."
+          f"Calculate the output of the convolution operation.  Assume stride = {context['stride']} and padding = {context['padding']}."
         ]
       )
     )
 
     body.add_element(ca.LineBreak())
 
-    for i in range(self.result.shape[-1]):
-      answers.append(self.answers[f"result_{i}"])
+    for i in range(context["result"].shape[-1]):
+      answer = ca.AnswerTypes.Matrix(context["result"][:, :, i], label=f"Result of filter {i}")
+      answers.append(answer)
       body.add_elements([
         ca.Container([
-          self.answers[f"result_{i}"],
+          answer,
           ca.LineBreak()
         ])
       ])
 
     return body, answers
 
-  def get_body(self, **kwargs) -> ca.Section:
-    """Build question body (backward compatible interface)."""
-    body, _ = self._get_body(**kwargs)
-    return body
-  
-  def _get_explanation(self, **kwargs) -> Tuple[ca.Section, List[ca.Answer]]:
+  @classmethod
+  def _build_explanation(cls, context) -> Tuple[ca.Section, List[ca.Answer]]:
     """Build question explanation."""
     explanation = ca.Section()
     digits = ca.Answer.DEFAULT_ROUNDING_DIGITS
@@ -131,14 +132,14 @@ class ConvolutionCalculation(MatrixQuestion):
 
     explanation.add_element(
       ca.Paragraph([
-        f"With stride={self.stride} and padding={self.padding}: ",
+        f"With stride={context['stride']} and padding={context['padding']}: ",
         f"stride controls how many pixels the filter moves each step, ",
-        f"and padding adds zeros around the border {'(no border in this case)' if self.padding == 0 else f'({self.padding} pixels)'}."
+        f"and padding adds zeros around the border {'(no border in this case)' if context['padding'] == 0 else f'({context['padding']} pixels)'}."
       ])
     )
 
     # For each filter, show one detailed example computation
-    for f_idx in range(self.kernel.shape[-1]):
+    for f_idx in range(context["kernel"].shape[-1]):
       explanation.add_element(
         ca.Paragraph([
           ca.Text(f"Filter {f_idx}:", emphasis=True)
@@ -147,7 +148,7 @@ class ConvolutionCalculation(MatrixQuestion):
 
       # Show the filter (rounded)
       explanation.add_element(
-        ca.Matrix(np.round(self.kernel[:, :, f_idx], digits), name=f"Filter {f_idx}")
+        ca.Matrix(np.round(context["kernel"][:, :, f_idx], digits), name=f"Filter {f_idx}")
       )
 
       # Show ONE example computation (position 0,0)
@@ -158,23 +159,23 @@ class ConvolutionCalculation(MatrixQuestion):
       )
 
       # Account for padding when extracting receptive field
-      if self.padding > 0:
-        padded_image = np.pad(self.image, ((self.padding, self.padding), (self.padding, self.padding)), mode='constant')
+      if context["padding"] > 0:
+        padded_image = np.pad(context["image"], ((context["padding"], context["padding"]), (context["padding"], context["padding"])), mode='constant')
         receptive_field = padded_image[0:3, 0:3]
       else:
-        receptive_field = self.image[0:3, 0:3]
+        receptive_field = context["image"][0:3, 0:3]
 
       computation_steps = []
       for r in range(3):
         row_terms = []
         for c in range(3):
           img_val = receptive_field[r, c]
-          kernel_val = self.kernel[r, c, f_idx]
+          kernel_val = context["kernel"][r, c, f_idx]
           row_terms.append(f"({img_val:.2f} \\times {kernel_val:.2f})")
         computation_steps.append(" + ".join(row_terms))
 
       equation_str = " + ".join(computation_steps)
-      result_val = self.result[0, 0, f_idx]
+      result_val = context["result"][0, 0, f_idx]
 
       explanation.add_element(
         ca.Equation(f"{equation_str} = {result_val:.2f}")
@@ -187,12 +188,7 @@ class ConvolutionCalculation(MatrixQuestion):
         ])
       )
       explanation.add_element(
-        ca.Matrix(np.round(self.result[:, :, f_idx], digits))
+        ca.Matrix(np.round(context["result"][:, :, f_idx], digits))
       )
 
     return explanation, []
-
-  def get_explanation(self, **kwargs) -> ca.Section:
-    """Build question explanation (backward compatible interface)."""
-    explanation, _ = self._get_explanation(**kwargs)
-    return explanation

QuizGenerator/premade_questions/cst463/models/matrices.py

@@ -7,18 +7,68 @@ from QuizGenerator.question import Question
 
 
 class MatrixQuestion(Question, abc.ABC):
-  def __init__(self, *args, **kwargs):
-    super().__init__(*args, **kwargs)
-    self.default_digits_to_round = kwargs.get("digits_to_round", 2)
-  
-  def refresh(self, rng_seed=None, *args, **kwargs):
-    super().refresh(rng_seed=rng_seed, *args, **kwargs)
-    self.rng = np.random.RandomState(rng_seed)
-  
-  def get_rounded_matrix(self, shape, low=0, high=1, digits_to_round=None):
+  default_digits_to_round = 2
+
+  @staticmethod
+  def get_rng(rng_seed):
+    return np.random.RandomState(rng_seed)
+
+  @classmethod
+  def get_digits_to_round(cls, *, digits_to_round=None):
     if digits_to_round is None:
-      digits_to_round = self.default_digits_to_round
+      digits_to_round = cls.default_digits_to_round
+    return digits_to_round
+
+  @staticmethod
+  def get_rounded_matrix(*args, **kwargs):
+    # Supports (rng, shape, ...) or (self, shape, ...)
+    if not args:
+      raise ValueError("get_rounded_matrix requires at least a rng or self plus shape.")
+
+    if isinstance(args[0], MatrixQuestion):
+      self = args[0]
+      shape = args[1]
+      remaining = list(args[2:])
+      rng = kwargs.pop("rng", getattr(self, "_np_rng", np.random.RandomState()))
+      low = kwargs.pop("low", None)
+      high = kwargs.pop("high", None)
+      digits_to_round = kwargs.pop("digits_to_round", None)
+
+      if remaining:
+        low = remaining.pop(0)
+      if remaining:
+        high = remaining.pop(0)
+      if remaining:
+        digits_to_round = remaining.pop(0)
+
+      if low is None:
+        low = 0
+      if high is None:
+        high = 1
+      digits_to_round = self.get_digits_to_round(digits_to_round=digits_to_round)
+    else:
+      rng = args[0]
+      shape = args[1]
+      remaining = list(args[2:])
+      low = kwargs.pop("low", None)
+      high = kwargs.pop("high", None)
+      digits_to_round = kwargs.pop("digits_to_round", None)
+
+      if remaining:
+        low = remaining.pop(0)
+      if remaining:
+        high = remaining.pop(0)
+      if remaining:
+        digits_to_round = remaining.pop(0)
+
+      if low is None:
+        low = 0
+      if high is None:
+        high = 1
+      if digits_to_round is None:
+        digits_to_round = 2
+
     return np.round(
-      (high - low) * self.rng.rand(*shape) + low,
+      (high - low) * rng.rand(*shape) + low,
       digits_to_round
     )

QuizGenerator/premade_questions/cst463/models/rnns.py

@@ -44,31 +44,38 @@ class RNNForwardPass(MatrixQuestion, TableQuestionMixin):
     
     return h_states
   
-  def refresh(self, *args, **kwargs):
-    super().refresh(*args, **kwargs)
-    self.rng = np.random.RandomState(kwargs.get("rng_seed", None))
-    
+  @classmethod
+  def _build_context(cls, *, rng_seed=None, **kwargs):
+    rng = cls.get_rng(rng_seed)
+    digits = cls.get_digits_to_round(digits_to_round=kwargs.get("digits_to_round"))
+
     seq_len = kwargs.get("seq_len", 3)
-    input_dim =  kwargs.get("input_dim", 1)
+    input_dim = kwargs.get("input_dim", 1)
     hidden_dim = kwargs.get("hidden_dim", 1)
-    
-    # Small integer weights for hand calculation
-    self.x_seq = self.get_rounded_matrix((seq_len, input_dim)) # self.rng.randint(0, 3, size=(seq_len, input_dim))
-    self.W_xh = self.get_rounded_matrix((input_dim, hidden_dim), -1, 2)
-    self.W_hh = self.get_rounded_matrix((hidden_dim, hidden_dim), -1, 2)
-    self.b_h = self.get_rounded_matrix((hidden_dim,), -1, 2)
-    self.h_0 = np.zeros(hidden_dim)
-    
-    self.h_states = self.rnn_forward(self.x_seq, self.W_xh, self.W_hh, self.b_h, self.h_0) #.reshape((seq_len,-1))
-    
-    ## Answers:
-    # x_seq, W_xh, W_hh, b_h, h_0, h_states
-    
-    self.answers["output_sequence"] = ca.AnswerTypes.Matrix(value=self.h_states, label="Hidden states")
-    
-    return True
-  
-  def _get_body(self, **kwargs) -> Tuple[ca.Section, List[ca.Answer]]:
+
+    x_seq = cls.get_rounded_matrix(rng, (seq_len, input_dim), digits_to_round=digits)
+    W_xh = cls.get_rounded_matrix(rng, (input_dim, hidden_dim), -1, 2, digits)
+    W_hh = cls.get_rounded_matrix(rng, (hidden_dim, hidden_dim), -1, 2, digits)
+    b_h = cls.get_rounded_matrix(rng, (hidden_dim,), -1, 2, digits)
+    h_0 = np.zeros(hidden_dim)
+
+    h_states = cls.rnn_forward(x_seq, W_xh, W_hh, b_h, h_0)
+
+    return {
+      "digits": digits,
+      "seq_len": seq_len,
+      "input_dim": input_dim,
+      "hidden_dim": hidden_dim,
+      "x_seq": x_seq,
+      "W_xh": W_xh,
+      "W_hh": W_hh,
+      "b_h": b_h,
+      "h_0": h_0,
+      "h_states": h_states,
+    }
+
+  @classmethod
+  def _build_body(cls, context) -> Tuple[ca.Section, List[ca.Answer]]:
     """Build question body and collect answers."""
     body = ca.Section()
     answers = []
@@ -80,30 +87,27 @@ class RNNForwardPass(MatrixQuestion, TableQuestionMixin):
       ])
     )
     body.add_element(
-      self.create_info_table(
+      cls.create_info_table(
         {
-          ca.Container(["Input sequence, ", ca.Equation("x_{seq}", inline=True)]) : ca.Matrix(self.x_seq),
-          ca.Container(["Input weights, ",  ca.Equation("W_{xh}", inline=True)])  : ca.Matrix(self.W_xh),
-          ca.Container(["Hidden weights, ", ca.Equation("W_{hh}", inline=True)])  : ca.Matrix(self.W_hh),
-          ca.Container(["Bias, ",           ca.Equation("b_{h}", inline=True)])   : ca.Matrix(self.b_h),
-          ca.Container(["Hidden states, ",  ca.Equation("h_{0}", inline=True)])   : ca.Matrix(self.h_0),
+          ca.Container(["Input sequence, ", ca.Equation("x_{seq}", inline=True)]) : ca.Matrix(context["x_seq"]),
+          ca.Container(["Input weights, ",  ca.Equation("W_{xh}", inline=True)])  : ca.Matrix(context["W_xh"]),
+          ca.Container(["Hidden weights, ", ca.Equation("W_{hh}", inline=True)])  : ca.Matrix(context["W_hh"]),
+          ca.Container(["Bias, ",           ca.Equation("b_{h}", inline=True)])   : ca.Matrix(context["b_h"]),
+          ca.Container(["Hidden states, ",  ca.Equation("h_{0}", inline=True)])   : ca.Matrix(context["h_0"]),
         }
       )
     )
 
     body.add_element(ca.LineBreak())
 
-    answers.append(self.answers["output_sequence"])
-    body.add_element(self.answers["output_sequence"])
+    output_answer = ca.AnswerTypes.Matrix(value=context["h_states"], label="Hidden states")
+    answers.append(output_answer)
+    body.add_element(output_answer)
 
     return body, answers
 
-  def get_body(self, **kwargs) -> ca.Section:
-    """Build question body (backward compatible interface)."""
-    body, _ = self._get_body(**kwargs)
-    return body
-  
-  def _get_explanation(self, **kwargs) -> Tuple[ca.Section, List[ca.Answer]]:
+  @classmethod
+  def _build_explanation(cls, context) -> Tuple[ca.Section, List[ca.Answer]]:
     """Build question explanation."""
     explanation = ca.Section()
     digits = ca.Answer.DEFAULT_ROUNDING_DIGITS
@@ -134,7 +138,7 @@ class RNNForwardPass(MatrixQuestion, TableQuestionMixin):
       return "[" + ", ".join([f"{fix_negative_zero(x):.{digits}f}" for x in arr.flatten()]) + "]"
 
     # Show detailed examples for first 2 timesteps (or just 1 if seq_len == 1)
-    seq_len = len(self.x_seq)
+    seq_len = len(context["x_seq"])
     num_examples = min(2, seq_len)
 
     explanation.add_element(ca.Paragraph([""]))
@@ -147,18 +151,18 @@ class RNNForwardPass(MatrixQuestion, TableQuestionMixin):
       )
 
       # Compute step t
-      x_contribution = self.x_seq[t] @ self.W_xh
+      x_contribution = context["x_seq"][t] @ context["W_xh"]
       if t == 0:
-        h_prev = self.h_0
+        h_prev = context["h_0"]
         h_prev_label = 'h_{-1}'
         h_prev_desc = " (initial state)"
       else:
-        h_prev = self.h_states[t-1]
+        h_prev = context["h_states"][t-1]
         h_prev_label = f'h_{{{t-1}}}'
         h_prev_desc = ""
 
-      h_contribution = h_prev @ self.W_hh
-      pre_activation = x_contribution + h_contribution + self.b_h
+      h_contribution = h_prev @ context["W_hh"]
+      pre_activation = x_contribution + h_contribution + context["b_h"]
       h_result = np.tanh(pre_activation)
 
       explanation.add_element(
@@ -203,13 +207,7 @@ class RNNForwardPass(MatrixQuestion, TableQuestionMixin):
     )
 
     explanation.add_element(
-      ca.Matrix(np.round(self.h_states, digits))
+      ca.Matrix(np.round(context["h_states"], digits))
     )
 
     return explanation, []
-
-  def get_explanation(self, **kwargs) -> ca.Section:
-    """Build question explanation (backward compatible interface)."""
-    explanation, _ = self._get_explanation(**kwargs)
-    return explanation
-

QuizGenerator/premade_questions/cst463/models/text.py

@@ -34,73 +34,77 @@ class word2vec__skipgram(MatrixQuestion, TableQuestionMixin):
     
     return logits, probs
   
-  def refresh(self, *args, **kwargs):
-    super().refresh(*args, **kwargs)
-    self.rng = np.random.RandomState(kwargs.get("rng_seed", None))
-    
+  @classmethod
+  def _build_context(cls, *, rng_seed=None, **kwargs):
+    rng = cls.get_rng(rng_seed)
+    digits = cls.get_digits_to_round(digits_to_round=kwargs.get("digits_to_round"))
+
     embed_dim = kwargs.get("embed_dim", 3)
     num_contexts = kwargs.get("num_contexts", 3)
-    
-    # Vocabulary pool
-    vocab = ['cat', 'dog', 'run', 'jump', 'happy', 'sad', 'tree', 'house',
-             'walk', 'sleep', 'fast', 'slow', 'big', 'small']
-    
-    # Sample words
-    self.selected_words = self.rng.choice(vocab, size=num_contexts + 1, replace=False)
-    self.center_word = self.selected_words[0]
-    self.context_words = self.selected_words[1:]
-    
-    # Small integer embeddings
 
-    self.center_emb = self.get_rounded_matrix((embed_dim,), -2, 3)
-    self.context_embs = self.get_rounded_matrix((num_contexts, embed_dim), -2, 3)
-    
-    self.logits, self.probs = self.skipgram_predict(self.center_emb, self.context_embs)
-
-    ## Answers:
-    # center_word, center_emb, context_words, context_embs, logits, probs
-    self.answers["logits"] = ca.AnswerTypes.Vector(self.logits, label="Logits")
-    most_likely_idx = np.argmax(self.probs)
-    most_likely_word = self.context_words[most_likely_idx]
-    self.answers["center_word"] = ca.AnswerTypes.String(most_likely_word, label="Most likely context word")
-    
-    
-    return True
-  
-  def _get_body(self, **kwargs) -> Tuple[ca.Section, List[ca.Answer]]:
+    vocab = [
+      'cat', 'dog', 'run', 'jump', 'happy', 'sad', 'tree', 'house',
+      'walk', 'sleep', 'fast', 'slow', 'big', 'small'
+    ]
+
+    selected_words = rng.choice(vocab, size=num_contexts + 1, replace=False)
+    center_word = selected_words[0]
+    context_words = selected_words[1:]
+
+    center_emb = cls.get_rounded_matrix(rng, (embed_dim,), -2, 3, digits)
+    context_embs = cls.get_rounded_matrix(rng, (num_contexts, embed_dim), -2, 3, digits)
+
+    logits, probs = cls.skipgram_predict(center_emb, context_embs)
+
+    most_likely_idx = np.argmax(probs)
+    most_likely_word = context_words[most_likely_idx]
+
+    return {
+      "digits": digits,
+      "embed_dim": embed_dim,
+      "num_contexts": num_contexts,
+      "center_word": center_word,
+      "context_words": context_words,
+      "center_emb": center_emb,
+      "context_embs": context_embs,
+      "logits": logits,
+      "probs": probs,
+      "most_likely_word": most_likely_word,
+    }
+
+  @classmethod
+  def _build_body(cls, context) -> Tuple[ca.Section, List[ca.Answer]]:
     """Build question body and collect answers."""
     body = ca.Section()
     answers = []
 
     body.add_element(
       ca.Paragraph([
-        f"Given center word: `{self.center_word}` with embedding {self.center_emb}, compute the skip-gram probabilities for each context word and identify the most likely one."
+        f"Given center word: `{context['center_word']}` with embedding {context['center_emb']}, compute the skip-gram probabilities for each context word and identify the most likely one."
       ])
     )
     body.add_elements([
-      ca.Paragraph([ca.Text(f"`{w}` : "), str(e)]) for w, e in zip(self.context_words, self.context_embs)
+      ca.Paragraph([ca.Text(f"`{w}` : "), str(e)]) for w, e in zip(context["context_words"], context["context_embs"])
     ])
 
-    answers.append(self.answers["logits"])
-    answers.append(self.answers["center_word"])
+    logits_answer = ca.AnswerTypes.Vector(context["logits"], label="Logits")
+    center_word_answer = ca.AnswerTypes.String(context["most_likely_word"], label="Most likely context word")
+    answers.append(logits_answer)
+    answers.append(center_word_answer)
     body.add_elements([
       ca.LineBreak(),
-      self.answers["logits"],
+      logits_answer,
       ca.LineBreak(),
-      self.answers["center_word"]
+      center_word_answer
     ])
 
-    log.debug(f"output: {self.logits}")
-    log.debug(f"weights: {self.probs}")
+    log.debug(f"output: {context['logits']}")
+    log.debug(f"weights: {context['probs']}")
 
     return body, answers
 
-  def get_body(self, **kwargs) -> ca.Section:
-    """Build question body (backward compatible interface)."""
-    body, _ = self._get_body(**kwargs)
-    return body
-  
-  def _get_explanation(self, **kwargs) -> Tuple[ca.Section, List[ca.Answer]]:
+  @classmethod
+  def _build_explanation(cls, context) -> Tuple[ca.Section, List[ca.Answer]]:
     """Build question explanation."""
     explanation = ca.Section()
     digits = ca.Answer.DEFAULT_ROUNDING_DIGITS
@@ -119,10 +123,10 @@ class word2vec__skipgram(MatrixQuestion, TableQuestionMixin):
     )
 
     # Format center embedding
-    center_emb_str = "[" + ", ".join([f"{x:.{digits}f}" for x in self.center_emb]) + "]"
+    center_emb_str = "[" + ", ".join([f"{x:.{digits}f}" for x in context["center_emb"]]) + "]"
     explanation.add_element(
       ca.Paragraph([
-        f"Center word `{self.center_word}`: {center_emb_str}"
+        f"Center word `{context['center_word']}`: {center_emb_str}"
       ])
     )
 
@@ -132,7 +136,7 @@ class word2vec__skipgram(MatrixQuestion, TableQuestionMixin):
       ])
     )
 
-    for i, (word, emb) in enumerate(zip(self.context_words, self.context_embs)):
+    for i, (word, emb) in enumerate(zip(context["context_words"], context["context_embs"])):
       emb_str = "[" + ", ".join([f"{x:.2f}" for x in emb]) + "]"
       explanation.add_element(
         ca.Paragraph([
@@ -150,20 +154,20 @@ class word2vec__skipgram(MatrixQuestion, TableQuestionMixin):
     # Show ONE example
     explanation.add_element(
       ca.Paragraph([
-        f"Example: Logit for `{self.context_words[0]}`"
+        f"Example: Logit for `{context['context_words'][0]}`"
       ])
     )
 
-    context_emb = self.context_embs[0]
-    dot_product_terms = " + ".join([f"({self.center_emb[j]:.2f} \\times {context_emb[j]:.2f})"
-                                    for j in range(len(self.center_emb))])
-    logit_val = self.logits[0]
+    context_emb = context["context_embs"][0]
+    dot_product_terms = " + ".join([f"({context['center_emb'][j]:.2f} \\times {context_emb[j]:.2f})"
+                                    for j in range(len(context["center_emb"]))])
+    logit_val = context["logits"][0]
 
     explanation.add_element(
       ca.Equation(f"{dot_product_terms} = {logit_val:.2f}")
     )
 
-    logits_str = "[" + ", ".join([f"{x:.2f}" for x in self.logits]) + "]"
+    logits_str = "[" + ", ".join([f"{x:.2f}" for x in context["logits"]]) + "]"
     explanation.add_element(
       ca.Paragraph([
         f"All logits: {logits_str}"
@@ -177,10 +181,10 @@ class word2vec__skipgram(MatrixQuestion, TableQuestionMixin):
       ])
     )
 
-    exp_logits = np.exp(self.logits)
+    exp_logits = np.exp(context["logits"])
     sum_exp = exp_logits.sum()
 
-    exp_terms = " + ".join([f"e^{{{l:.{digits}f}}}" for l in self.logits])
+    exp_terms = " + ".join([f"e^{{{l:.{digits}f}}}" for l in context["logits"]])
 
     explanation.add_element(
       ca.Equation(f"\\text{{denominator}} = {exp_terms} = {sum_exp:.{digits}f}")
@@ -192,26 +196,20 @@ class word2vec__skipgram(MatrixQuestion, TableQuestionMixin):
       ])
     )
 
-    for i, (word, prob) in enumerate(zip(self.context_words, self.probs)):
+    for i, (word, prob) in enumerate(zip(context["context_words"], context["probs"])):
       explanation.add_element(
-        ca.Equation(f"P(\\text{{{word}}}) = \\frac{{e^{{{self.logits[i]:.{digits}f}}}}}{{{sum_exp:.{digits}f}}} = {prob:.{digits}f}")
+        ca.Equation(f"P(\\text{{{word}}}) = \\frac{{e^{{{context['logits'][i]:.{digits}f}}}}}{{{sum_exp:.{digits}f}}} = {prob:.{digits}f}")
       )
 
     # Step 4: Identify most likely
-    most_likely_idx = np.argmax(self.probs)
-    most_likely_word = self.context_words[most_likely_idx]
+    most_likely_idx = np.argmax(context["probs"])
+    most_likely_word = context["context_words"][most_likely_idx]
 
     explanation.add_element(
       ca.Paragraph([
         ca.Text("Conclusion:", emphasis=True),
-        f" The most likely context word is `{most_likely_word}` with probability {self.probs[most_likely_idx]:.{digits}f}"
+        f" The most likely context word is `{most_likely_word}` with probability {context['probs'][most_likely_idx]:.{digits}f}"
       ])
     )
 
     return explanation, []
-
-  def get_explanation(self, **kwargs) -> ca.Section:
-    """Build question explanation (backward compatible interface)."""
-    explanation, _ = self._get_explanation(**kwargs)
-    return explanation
-