QuizGenerator 0.1.4__py3-none-any.whl → 0.3.1__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/persistence_questions.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import abc
+import difflib
 import logging
 
 from QuizGenerator.question import Question, Answer, QuestionRegistry
@@ -365,31 +366,85 @@ class VSFS_states(IOQuestion):
   def get_explanation(self) -> ContentAST.Section:
     explanation = ContentAST.Section()
     
-    explanation.add_element(
+    log.debug(f"self.start_state: {self.start_state}")
+    log.debug(f"self.end_state: {self.end_state}")
+    
+    explanation.add_elements([
       ContentAST.Paragraph([
-        "These questions are based on the VSFS simulator that our book mentions.  "
-        "We will be discussing the interpretation of this in class, but you can also find information "
-        "<a href=\"https://github.com/chyyuu/os_tutorial_lab/blob/master/ostep/ostep13-vsfs.md\">here</a>, "
-        "as well as simulator code.  Please note that the code uses python 2.",
-        "",
-        "In general, I recommend looking for differences between the two outputs.  Recommended steps would be:",
-        "<ol>"
-        
-        "<li> Check to see if there are differences between the bitmaps "
-        "that could indicate a file/directroy were created or removed.</li>",
-        
-        "<li>Check the listed inodes to see if any entries have changed.  "
-        "This might be a new entry entirely or a reference count changing.  "
-        "If the references increased then this was likely a link or creation, "
-        "and if it decreased then it is likely an unlink.</li>",
-        
-        "<li>Look at the data blocks to see if a new entry has "
-        "been added to a directory or a new block has been mapped.</li>",
-        
-        "</ol>",
-        "These steps can usually help you quickly identify "
-        "what has occured in the simulation and key you in to the right answer."
+        "The key thing to pay attention to when solving these problems is where there are differences between the start state and the end state.",
+        "In this particular problem, we can see that these lines are different:"
       ])
+    ])
+    
+    chunk_to_add = []
+    lines_that_changed = []
+    for start_line, end_line in zip(self.start_state.split('\n'), self.end_state.split('\n')):
+      if start_line == end_line:
+        continue
+      lines_that_changed.append((start_line, end_line))
+      chunk_to_add.append(
+        f" - `{start_line}` -> `{end_line}`"
+      )
+    
+    explanation.add_element(
+      ContentAST.Paragraph(chunk_to_add)
+    )
+    
+    chunk_to_add = [
+      "A great place to start is to check to see if the bitmaps have changed as this can quickly tell us a lot of information"
+    ]
+    
+    inode_bitmap_lines = list(filter(lambda s: "inode bitmap" in s[0], lines_that_changed))
+    data_bitmap_lines = list(filter(lambda s: "data bitmap" in s[0], lines_that_changed))
+    
+    def get_bitmap(line: str) -> str:
+      log.debug(f"line: {line}")
+      return line.split()[-1]
+    
+    def highlight_changes(a: str, b: str) -> str:
+      matcher = difflib.SequenceMatcher(None, a, b)
+      result = []
+      
+      for tag, i1, i2, j1, j2 in matcher.get_opcodes():
+        if tag == "equal":
+          result.append(b[j1:j2])
+        elif tag in ("insert", "replace"):
+          result.append(f"***{b[j1:j2]}***")
+        # for "delete", do nothing since text is removed
+      
+      return "".join(result)
+    
+    if len(inode_bitmap_lines) > 0:
+      inode_bitmap_lines = inode_bitmap_lines[0]
+      chunk_to_add.append(f"The inode bitmap lines have changed from {get_bitmap(inode_bitmap_lines[0])} to {get_bitmap(inode_bitmap_lines[1])}.")
+      if get_bitmap(inode_bitmap_lines[0]).count('1') < get_bitmap(inode_bitmap_lines[1]).count('1'):
+        chunk_to_add.append("We can see that we have added an inode, so we have either called `creat` or `mkdir`.")
+      else:
+        chunk_to_add.append("We can see that we have removed an inode, so we have called `unlink`.")
+    
+    if len(data_bitmap_lines) > 0:
+      data_bitmap_lines = data_bitmap_lines[0]
+      chunk_to_add.append(f"The inode bitmap lines have changed from {get_bitmap(data_bitmap_lines[0])} to {get_bitmap(data_bitmap_lines[1])}.")
+      if get_bitmap(data_bitmap_lines[0]).count('1') < get_bitmap(data_bitmap_lines[1]).count('1'):
+        chunk_to_add.append("We can see that we have added a data block, so we have either called `mkdir` or `write`.")
+      else:
+        chunk_to_add.append("We can see that we have removed a data block, so we have `unlink`ed a file.")
+    
+    if len(data_bitmap_lines) == 0 and len(inode_bitmap_lines) == 0:
+      chunk_to_add.append("If they have not changed, then we know we must have eithered called `link` or `unlink` and must check the references.")
+      
+    explanation.add_element(
+      ContentAST.Paragraph(chunk_to_add)
+    )
+    
+    explanation.add_elements([
+      ContentAST.Paragraph(["The overall changes are highlighted with `*` symbols below"])
+    ])
+    
+    explanation.add_element(
+      ContentAST.Code(
+        highlight_changes(self.start_state, self.end_state)
+      )
     )
     
     return explanation

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
+