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

QuizGenerator/generate.py

@@ -25,6 +25,8 @@ def parse_args():
     default=os.path.join(Path.home(), '.env'),
     help="Path to .env file specifying canvas details"
   )
+  
+  parser.add_argument("--debug", action="store_true", help="Set logging level to debug")
 
   parser.add_argument("--quiz_yaml", default=os.path.join(os.path.dirname(os.path.abspath(__file__)), "example_files/exam_generation.yaml"))
   parser.add_argument("--seed", type=int, default=None,
@@ -211,6 +213,21 @@ def main():
   
   # Load environment variables
   load_dotenv(args.env)
+  
+  if args.debug:
+    # Set root logger to DEBUG
+    logging.getLogger().setLevel(logging.DEBUG)
+
+    # Set all handlers to DEBUG level
+    for handler in logging.getLogger().handlers:
+      handler.setLevel(logging.DEBUG)
+
+    # Set named loggers to DEBUG
+    for logger_name in ['QuizGenerator', 'lms_interface', '__main__']:
+      logger = logging.getLogger(logger_name)
+      logger.setLevel(logging.DEBUG)
+      for handler in logger.handlers:
+        handler.setLevel(logging.DEBUG)
 
   if args.command == "TEST":
     test()
@@ -233,4 +250,4 @@ def main():
 
 
 if __name__ == "__main__":
-  main()
+  main()

QuizGenerator/misc.py

@@ -6,16 +6,21 @@ import enum
 import itertools
 import logging
 import math
-from typing import List, Dict, Tuple
+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:
@@ -23,11 +28,12 @@ class Answer:
   
   class AnswerKind(enum.Enum):
     BLANK = "fill_in_multiple_blanks_question"
-    MULTIPLE_ANSWER = "multiple_answers_question"  # todo: have baffles?
+    MULTIPLE_ANSWER = "multiple_answers_question"
     ESSAY = "essay_question"
     MULTIPLE_DROPDOWN = "multiple_dropdowns_question"
+    NUMERICAL_QUESTION = "numerical_question" # note: these can only be single answers as far as I can tell
     
-  class VariableKind(enum.Enum): # todo: use these for generate variations?
+  class VariableKind(enum.Enum):
     STR = enum.auto()
     INT = enum.auto()
     FLOAT = enum.auto()
@@ -37,6 +43,7 @@ class Answer:
     AUTOFLOAT = enum.auto()
     LIST = enum.auto()
     VECTOR = enum.auto()
+    MATRIX = enum.auto()
     
     
   def __init__(
@@ -66,7 +73,7 @@ class Answer:
     self.baffles = baffles
     self.pdf_only = pdf_only
   
-  def get_for_canvas(self) -> List[Dict]:
+  def get_for_canvas(self, single_answer=False) -> List[Dict]:
     # If this answer is marked as PDF-only, don't send it to Canvas
     if self.pdf_only:
       return []
@@ -131,18 +138,29 @@ class Answer:
       Answer.VariableKind.FLOAT,
       Answer.VariableKind.INT
     ]:
-      # Use the accepted_strings helper with settings that match the original AUTOFLOAT behavior
-      answer_strings = self.__class__.accepted_strings(
-        self.value,
-        allow_integer=True,
-        allow_simple_fraction=True,
-        max_denominator=3*4*5,  # For process questions, these are the numbers of jobs we'd have
-        allow_mixed=True,
-        include_spaces=False,
-        include_fixed_even_if_integer=True
-      )
-
-      canvas_answers = [
+      if single_answer:
+        canvas_answers = [
+          {
+            "numerical_answer_type": "exact_answer",
+            "answer_text": round(self.value, self.DEFAULT_ROUNDING_DIGITS),
+            "answer_exact": round(self.value, self.DEFAULT_ROUNDING_DIGITS),
+            "answer_error_margin": 0.1,
+            "answer_weight": 100 if self.correct else 0,
+          }
+        ]
+      else:
+        # Use the accepted_strings helper with settings that match the original AUTOFLOAT behavior
+        answer_strings = self.__class__.accepted_strings(
+          self.value,
+          allow_integer=True,
+          allow_simple_fraction=True,
+          max_denominator=3*4*5,  # For process questions, these are the numbers of jobs we'd have
+          allow_mixed=True,
+          include_spaces=False,
+          include_fixed_even_if_integer=True
+        )
+  
+        canvas_answers = [
         {
           "blank_id": self.key,
           "answer_text": answer_string,
@@ -188,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):
@@ -244,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))
@@ -260,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':
@@ -392,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):
@@ -477,4 +513,67 @@ class Answer:
           outs.add(f"{sign}{whole} {rem}/{b}")
     
     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

@@ -190,6 +190,8 @@ class CachingQuestion(MemoryQuestion, RegenerableChoiceMixin, TableQuestionMixin
     self.num_elements = self.config_params.get("num_elements", 5)
     self.cache_size = self.config_params.get("cache_size", 3)
     self.num_requests = self.config_params.get("num_requests", 10)
+    
+    self.hit_rate = 0. # placeholder
 
   def refresh(self, previous: Optional[CachingQuestion] = None, *args, hard_refresh: bool = False, **kwargs):
     # Call parent refresh which seeds RNG and calls is_interesting()
@@ -200,7 +202,7 @@ class CachingQuestion(MemoryQuestion, RegenerableChoiceMixin, TableQuestionMixin
     self.cache_policy = self.get_choice('policy', self.Kind)
 
     self.requests = (
-        list(range(self.cache_size))  # Prime the cache with the compulsory misses
+        list(range(self.cache_size))  # Prime the cache with the capacity misses
         + self.rng.choices(
       population=list(range(self.cache_size - 1)), k=1
     )  # Add in one request to an earlier  that will differentiate clearly between FIFO and LRU
@@ -274,7 +276,7 @@ class CachingQuestion(MemoryQuestion, RegenerableChoiceMixin, TableQuestionMixin
     hit_rate_block = ContentAST.AnswerBlock(
       ContentAST.Answer(
         answer=self.answers["answer__hit_rate"],
-        label=f"Hit rate, excluding compulsory misses.  If appropriate, round to {Answer.DEFAULT_ROUNDING_DIGITS} decimal digits.",
+        label=f"Hit rate, excluding capacity misses.  If appropriate, round to {Answer.DEFAULT_ROUNDING_DIGITS} decimal digits.",
         unit="%"
       )
     )
@@ -324,7 +326,7 @@ class CachingQuestion(MemoryQuestion, RegenerableChoiceMixin, TableQuestionMixin
           "To calculate the hit rate we calculate the percentage of requests "
           "that were cache hits out of the total number of requests. "
           f"In this case we are counting only all but {self.cache_size} requests, "
-          f"since we are excluding compulsory misses."
+          f"since we are excluding capacity misses."
         ]
       )
     )
@@ -636,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
+