QuizGenerator 0.1.4__py3-none-any.whl → 0.3.0__py3-none-any.whl

QuizGenerator/misc.py

@@ -6,16 +6,21 @@ import enum
 import itertools
 import logging
 import math
+import numpy as np
 from typing import List, Dict, Tuple, Any
 
 import fractions
 
+from QuizGenerator.contentast import ContentAST
+
 log = logging.getLogger(__name__)
 
 
-class OutputFormat(enum.Enum):
-  LATEX = enum.auto(),
-  CANVAS = enum.auto()
+def fix_negative_zero(value):
+  """Convert -0.0 to 0.0 to avoid confusing display."""
+  if isinstance(value, (int, float)):
+    return 0.0 if value == 0 else value
+  return value
 
 
 class Answer:
@@ -38,6 +43,7 @@ class Answer:
     AUTOFLOAT = enum.auto()
     LIST = enum.auto()
     VECTOR = enum.auto()
+    MATRIX = enum.auto()
     
     
   def __init__(
@@ -200,6 +206,7 @@ class Answer:
         }
         for possible_state in [self.value] #itertools.permutations(self.value)
       ]
+    
     else:
       # For string answers, check if value is a list of acceptable alternatives
       if isinstance(self.value, list):
@@ -256,13 +263,16 @@ class Answer:
 
     elif self.variable_kind == Answer.VariableKind.AUTOFLOAT:
       # Round to default precision for readability
-      return f"{round(self.value, self.DEFAULT_ROUNDING_DIGITS)}"
+      rounded = round(self.value, self.DEFAULT_ROUNDING_DIGITS)
+      return f"{fix_negative_zero(rounded)}"
 
     elif self.variable_kind == Answer.VariableKind.FLOAT:
       # Round to default precision
       if isinstance(self.value, (list, tuple)):
-        return f"{round(self.value[0], self.DEFAULT_ROUNDING_DIGITS)}"
-      return f"{round(self.value, self.DEFAULT_ROUNDING_DIGITS)}"
+        rounded = round(self.value[0], self.DEFAULT_ROUNDING_DIGITS)
+        return f"{fix_negative_zero(rounded)}"
+      rounded = round(self.value, self.DEFAULT_ROUNDING_DIGITS)
+      return f"{fix_negative_zero(rounded)}"
 
     elif self.variable_kind == Answer.VariableKind.INT:
       return str(int(self.value))
@@ -272,12 +282,17 @@ class Answer:
 
     elif self.variable_kind == Answer.VariableKind.VECTOR:
       # Format as comma-separated rounded values
-      return ", ".join(str(round(v, self.DEFAULT_ROUNDING_DIGITS)) for v in self.value)
+      return ", ".join(str(fix_negative_zero(round(v, self.DEFAULT_ROUNDING_DIGITS))) for v in self.value)
 
     else:
       # Default: use display or value
       return str(self.display if hasattr(self, 'display') else self.value)
 
+  def get_ast_element(self, label=None):
+    from QuizGenerator.contentast import ContentAST
+    
+    return ContentAST.Answer(answer=self, label=label) # todo fix label
+
   # Factory methods for common answer types
   @classmethod
   def binary_hex(cls, key: str, value: int, length: int = None, **kwargs) -> 'Answer':
@@ -404,9 +419,18 @@ class Answer:
       **kwargs
     )
   
+  @classmethod
+  def matrix(cls, key: str, value: np.array|List, **kwargs ):
+    return MatrixAnswer(
+      key=key,
+      value=value,
+      variable_kind=cls.VariableKind.MATRIX
+    )
+  
   @staticmethod
   def _to_fraction(x):
     """Convert int/float/decimal.Decimal/fractions.Fraction/str('a/b' or decimal) to fractions.Fraction exactly."""
+    log.debug(f"x: {x} {x.__class__}")
     if isinstance(x, fractions.Fraction):
       return x
     if isinstance(x, int):
@@ -488,4 +512,68 @@ class Answer:
           whole, rem = divmod(A, b)
           outs.add(f"{sign}{whole} {rem}/{b}")
     
-    return sorted(outs, key=lambda s: (len(s), s))
+    return sorted(outs, key=lambda s: (len(s), s))
+  
+
+class MatrixAnswer(Answer):
+  def get_for_canvas(self, single_answer=False) -> List[Dict]:
+    canvas_answers = []
+    
+    """
+    The core idea is that we will walk through and generate each one for X_i,j
+
+    The big remaining question is how we will get all these names to the outside world.
+    It might have to be a pretty big challenge, or rather re-write.
+    """
+    
+    # The core idea is that we will be walking through and generating a per-index set of answers.
+    # Boy will this get messy.  Poor canvas.
+    for i, j in np.ndindex(self.value.shape):
+      entry_strings = self.__class__.accepted_strings(
+        self.value[i,j],
+        allow_integer=True,
+        allow_simple_fraction=True,
+        max_denominator=3 * 4 * 5,
+        allow_mixed=True,
+        include_spaces=False,
+        include_fixed_even_if_integer=True
+      )
+      canvas_answers.extend(
+        [
+          {
+            "blank_id": f"{self.key}_{i}_{j}",  # Give each an index associated with it so we can track it
+            "answer_text": answer_string,
+            "answer_weight": 100 if self.correct else 0,
+          }
+          for answer_string in entry_strings
+        ]
+      )
+    
+    return canvas_answers
+  
+  def get_ast_element(self, label=None):
+    from QuizGenerator.contentast import ContentAST
+    
+    log.debug(f"self.value: {self.value}")
+    
+    data = [
+      [
+        ContentAST.Answer(
+          Answer.float_value(
+            key=f"{self.key}_{i}_{j}",
+            value=self.value[i,j]
+          )
+        )
+        for i in range(self.value.shape[0])
+      ]
+      for j in range(self.value.shape[1])
+    ]
+    table = ContentAST.Table(data)
+    
+    if label is not None:
+      return ContentAST.Container([
+        ContentAST.Text(f"{label} = "),
+        table
+      ])
+    else:
+      return table

QuizGenerator/mixins.py

@@ -32,8 +32,17 @@ class TableQuestionMixin:
     Returns:
         ContentAST.Table with the information formatted
     """
+    # Don't convert ContentAST elements to strings - let them render properly
+    table_data = []
+    for key, value in info_dict.items():
+      # Keep ContentAST elements as-is, convert others to strings
+      if isinstance(value, ContentAST.Element):
+        table_data.append([key, value])
+      else:
+        table_data.append([key, str(value)])
+
     return ContentAST.Table(
-      data=[[key, str(value)] for key, value in info_dict.items()],
+      data=table_data,
       transpose=transpose
     )
   

QuizGenerator/premade_questions/cst334/memory_questions.py

@@ -638,7 +638,7 @@ class Segmentation(MemoryAccessQuestion, TableQuestionMixin, BodyTemplatesMixin)
             f"Since we are in the {self.segment} segment, "
             f"we see from our table that our bounds are {self.bounds[self.segment]}. "
             f"Remember that our check for our {self.segment} segment is: ",
-            f"`if (offset > bounds({self.segment})) : INVALID`",
+            f"`if (offset >= bounds({self.segment})) : INVALID`",
             "which becomes"
             f"`if ({self.offset:0b} > {self.bounds[self.segment]:0b}) : INVALID`"
           ]

QuizGenerator/premade_questions/cst334/process.py

@@ -15,7 +15,6 @@ from typing import List
 
 import matplotlib.pyplot as plt
 
-from QuizGenerator.misc import OutputFormat
 from QuizGenerator.contentast import ContentAST
 from QuizGenerator.question import Question, Answer, QuestionRegistry, RegenerableChoiceMixin
 from QuizGenerator.mixins import TableQuestionMixin, BodyTemplatesMixin
@@ -380,7 +379,7 @@ class SchedulingQuestion(ProcessQuestion, RegenerableChoiceMixin, TableQuestionM
     # Return whether this workload is interesting
     return self.is_interesting()
   
-  def get_body(self, output_format: OutputFormat|None = None, *args, **kwargs) -> ContentAST.Section:
+  def get_body(self, *args, **kwargs) -> ContentAST.Section:
     # Create table data for scheduling results
     table_rows = []
     for job_id in sorted(self.job_stats.keys()):

QuizGenerator/premade_questions/cst463/models/attention.py

@@ -0,0 +1,192 @@
+import abc
+import logging
+import math
+import keras
+import numpy as np
+
+from QuizGenerator.misc import MatrixAnswer
+from QuizGenerator.question import Question, QuestionRegistry, Answer
+from QuizGenerator.contentast import ContentAST
+from QuizGenerator.constants import MathRanges
+from QuizGenerator.mixins import TableQuestionMixin
+
+from .matrices import MatrixQuestion
+
+log = logging.getLogger(__name__)
+
+
+@QuestionRegistry.register("cst463.attention.forward-pass")
+class AttentionForwardPass(MatrixQuestion, TableQuestionMixin):
+  
+  @staticmethod
+  def simple_attention(Q, K, V):
+    """
+    Q: (seq_len, d_k) - queries
+    K: (seq_len, d_k) - keys
+    V: (seq_len, d_v) - values
+
+    Returns: (seq_len, d_v) - attended output
+    """
+    d_k = Q.shape[1]
+    
+    # Compute attention scores
+    scores = Q @ K.T / np.sqrt(d_k)
+    
+    # Softmax to get weights
+    attention_weights = np.exp(scores) / np.exp(scores).sum(axis=1, keepdims=True)
+    
+    # Weighted sum of values
+    output = attention_weights @ V
+    
+    return output, attention_weights
+  
+  def refresh(self, *args, **kwargs):
+    super().refresh(*args, **kwargs)
+    
+    seq_len = kwargs.get("seq_len", 3)
+    d_k = kwargs.get("key_dimension", 1)  # key/query dimension
+    d_v = kwargs.get("value_dimension", 1)  # value dimension
+    
+    # Small integer matrices
+    self.Q = self.rng.randint(0, 3, size=(seq_len, d_k))
+    self.K = self.rng.randint(0, 3, size=(seq_len, d_k))
+    self.V = self.rng.randint(0, 3, size=(seq_len, d_v))
+
+    self.Q = self.get_rounded_matrix((seq_len, d_k), 0, 3)
+    self.K = self.get_rounded_matrix((seq_len, d_k), 0, 3)
+    self.V = self.get_rounded_matrix((seq_len, d_v), 0, 3)
+    
+    self.output, self.weights = self.simple_attention(self.Q, self.K, self.V)
+    
+    ## Answers:
+    # Q, K, V, output, weights
+    
+    self.answers["weights"] = MatrixAnswer("weights", self.output)
+    self.answers["output"] = MatrixAnswer("output", self.output)
+    
+    return True
+  
+  def get_body(self, **kwargs) -> ContentAST.Section:
+    body = ContentAST.Section()
+    
+    body.add_element(
+      ContentAST.Text("Given the below information about a self attention layer, please calculate the output sequence.")
+    )
+    body.add_element(
+      self.create_info_table(
+        {
+          "Q": ContentAST.Matrix(self.Q),
+          "K": ContentAST.Matrix(self.K),
+          "V": ContentAST.Matrix(self.V),
+        }
+      )
+    )
+    
+    body.add_elements([
+      ContentAST.LineBreak(),
+      self.answers["weights"].get_ast_element(label=f"Weights"),
+      ContentAST.LineBreak(),
+      self.answers["output"].get_ast_element(label=f"Output"),
+    ])
+    
+    return body
+  
+  def get_explanation(self, **kwargs) -> ContentAST.Section:
+    explanation = ContentAST.Section()
+    digits = Answer.DEFAULT_ROUNDING_DIGITS
+
+    explanation.add_element(
+      ContentAST.Paragraph([
+        "Self-attention uses scaled dot-product attention to compute a weighted combination of values based on query-key similarity."
+      ])
+    )
+
+    # Step 1: Compute attention scores
+    explanation.add_element(
+      ContentAST.Paragraph([
+        ContentAST.Text("Step 1: Compute attention scores", emphasis=True)
+      ])
+    )
+
+    d_k = self.Q.shape[1]
+    explanation.add_element(
+      ContentAST.Equation(f"\\text{{scores}} = \\frac{{Q K^T}}{{\\sqrt{{d_k}}}} = \\frac{{Q K^T}}{{\\sqrt{{{d_k}}}}}")
+    )
+
+    scores = self.Q @ self.K.T / np.sqrt(d_k)
+
+    explanation.add_element(
+      ContentAST.Paragraph([
+        "Raw scores (scaling by ",
+        ContentAST.Equation(f'\\sqrt{{{d_k}}}', inline=True),
+        " prevents extremely large values):"
+      ])
+    )
+    explanation.add_element(ContentAST.Matrix(np.round(scores, digits)))
+
+    # Step 2: Apply softmax
+    explanation.add_element(
+      ContentAST.Paragraph([
+        ContentAST.Text("Step 2: Apply softmax to get attention weights", emphasis=True)
+      ])
+    )
+
+    explanation.add_element(
+      ContentAST.Equation(r"\alpha_{ij} = \frac{\exp(\text{score}_{ij})}{\sum_k \exp(\text{score}_{ik})}")
+    )
+
+    # Show ONE example row
+    explanation.add_element(
+      ContentAST.Paragraph([
+        "Example: Row 0 softmax computation"
+      ])
+    )
+
+    row_scores = scores[0]
+    exp_scores = np.exp(row_scores)
+    sum_exp = exp_scores.sum()
+    weights_row = exp_scores / sum_exp
+
+    exp_terms = " + ".join([f"e^{{{s:.{digits}f}}}" for s in row_scores])
+
+    explanation.add_element(
+      ContentAST.Paragraph([
+        f"Denominator = {exp_terms} = {sum_exp:.{digits}f}"
+      ])
+    )
+
+    # Format array with proper rounding
+    weights_str = "[" + ", ".join([f"{w:.{digits}f}" for w in weights_row]) + "]"
+    explanation.add_element(
+      ContentAST.Paragraph([
+        f"Resulting weights: {weights_str}"
+      ])
+    )
+
+    explanation.add_element(
+      ContentAST.Paragraph([
+        "Complete attention weight matrix:"
+      ])
+    )
+    explanation.add_element(ContentAST.Matrix(np.round(self.weights, digits)))
+
+    # Step 3: Weighted sum of values
+    explanation.add_element(
+      ContentAST.Paragraph([
+        ContentAST.Text("Step 3: Compute weighted sum of values", emphasis=True)
+      ])
+    )
+
+    explanation.add_element(
+      ContentAST.Equation(r"\text{output} = \text{weights} \times V")
+    )
+
+    explanation.add_element(
+      ContentAST.Paragraph([
+        "Final output:"
+      ])
+    )
+    explanation.add_element(ContentAST.Matrix(np.round(self.output, digits)))
+
+    return explanation
+

QuizGenerator/premade_questions/cst463/models/cnns.py

@@ -0,0 +1,186 @@
+import abc
+import logging
+import math
+import keras
+import numpy as np
+
+from QuizGenerator.question import Question, QuestionRegistry
+from QuizGenerator.misc import Answer, MatrixAnswer
+from QuizGenerator.contentast import ContentAST
+from QuizGenerator.constants import MathRanges
+from .matrices import MatrixQuestion
+
+log = logging.getLogger(__name__)
+
+
+@QuestionRegistry.register("cst463.cnn.convolution")
+class ConvolutionCalculation(MatrixQuestion):
+  
+  @staticmethod
+  def conv2d_multi_channel(image, kernel, stride=1, padding=0):
+    """
+    image: (H, W, C_in) - height, width, input channels
+    kernel: (K_h, K_w, C_in, C_out) - kernel height, width, input channels, output filters
+    Returns: (H_out, W_out, C_out)
+    """
+    H, W = image.shape
+    K_h, K_w, C_out = kernel.shape
+    
+    # Add padding
+    if padding > 0:
+      image = np.pad(image, ((padding, padding), (padding, padding), (0, 0)), mode='constant')
+      H, W = H + 2 * padding, W + 2 * padding
+    
+    # Output dimensions
+    H_out = (H - K_h) // stride + 1
+    W_out = (W - K_w) // stride + 1
+    
+    output = np.zeros((H_out, W_out, C_out))
+    
+    # Convolve each filter
+    for f in range(C_out):
+      for i in range(H_out):
+        for j in range(W_out):
+          h_start = i * stride
+          w_start = j * stride
+          # Extract receptive field and sum over all input channels
+          receptive_field = image[h_start:h_start + K_h, w_start:w_start + K_w]
+          output[i, j, f] = np.sum(receptive_field * kernel[:, :, f])
+    
+    return output
+  
+  def refresh(self, *args, **kwargs):
+    super().refresh(*args, **kwargs)
+
+    # 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}" : MatrixAnswer(f"result_{i}", self.result[:,:,i])
+      for i in range(self.result.shape[-1])
+    }
+    
+    return True
+  
+  def get_body(self, **kwargs) -> ContentAST.Section:
+    body = ContentAST.Section()
+    
+    body.add_elements(
+      [
+        ContentAST.Text("Given image represented as matrix: "),
+        ContentAST.Matrix(self.image, name="image")
+      ]
+    )
+    
+    body.add_elements(
+      [
+        ContentAST.Text("And convolution filters: "),
+      ] + [
+        ContentAST.Matrix(self.kernel[:, :, i], name=f"Filter {i}")
+        for i in range(self.kernel.shape[-1])
+      ]
+    )
+    
+    body.add_element(
+      ContentAST.Paragraph(
+        [
+          f"Calculate the output of the convolution operation.  Assume stride = {self.stride} and padding = {self.padding}."
+        ]
+      )
+    )
+    
+    body.add_element(ContentAST.LineBreak())
+    
+    body.add_elements([
+      ContentAST.Container([
+        self.answers[f"result_{i}"].get_ast_element(label=f"Result of filter {i}"),
+        ContentAST.LineBreak()
+      ])
+      for i in range(self.result.shape[-1])
+    ])
+    
+    
+    
+    return body
+  
+  def get_explanation(self, **kwargs) -> ContentAST.Section:
+    explanation = ContentAST.Section()
+    digits = Answer.DEFAULT_ROUNDING_DIGITS
+
+    explanation.add_element(
+      ContentAST.Paragraph([
+        "To compute a 2D convolution, we slide the filter across the input image and compute the element-wise product at each position, then sum the results."
+      ])
+    )
+
+    explanation.add_element(
+      ContentAST.Paragraph([
+        f"With stride={self.stride} and padding={self.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)'}."
+      ])
+    )
+
+    # For each filter, show one detailed example computation
+    for f_idx in range(self.kernel.shape[-1]):
+      explanation.add_element(
+        ContentAST.Paragraph([
+          ContentAST.Text(f"Filter {f_idx}:", emphasis=True)
+        ])
+      )
+
+      # Show the filter (rounded)
+      explanation.add_element(
+        ContentAST.Matrix(np.round(self.kernel[:, :, f_idx], digits), name=f"Filter {f_idx}")
+      )
+
+      # Show ONE example computation (position 0,0)
+      explanation.add_element(
+        ContentAST.Paragraph([
+          "Example computation at position (0, 0):"
+        ])
+      )
+
+      # 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')
+        receptive_field = padded_image[0:3, 0:3]
+      else:
+        receptive_field = self.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]
+          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]
+
+      explanation.add_element(
+        ContentAST.Equation(f"{equation_str} = {result_val:.2f}")
+      )
+
+      # Show the complete output matrix (rounded)
+      explanation.add_element(
+        ContentAST.Paragraph([
+          "Complete output:"
+        ])
+      )
+      explanation.add_element(
+        ContentAST.Matrix(np.round(self.result[:, :, f_idx], digits))
+      )
+
+    return explanation

QuizGenerator/premade_questions/cst463/models/matrices.py

@@ -0,0 +1,24 @@
+#!env python
+import abc
+
+import numpy as np
+
+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):
+    if digits_to_round is None:
+      digits_to_round = self.default_digits_to_round
+    return np.round(
+      (high - low) * self.rng.rand(*shape) + low,
+      digits_to_round
+    )