QuizGenerator 0.4.2__py3-none-any.whl

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)), 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
+    )

QuizGenerator/premade_questions/cst463/models/rnns.py

@@ -0,0 +1,202 @@
+import abc
+import logging
+import math
+import keras
+import numpy as np
+
+from .matrices import MatrixQuestion
+from QuizGenerator.question import Question, QuestionRegistry, Answer
+from QuizGenerator.contentast import ContentAST
+from QuizGenerator.constants import MathRanges
+from QuizGenerator.mixins import TableQuestionMixin
+
+log = logging.getLogger(__name__)
+
+
+@QuestionRegistry.register("cst463.rnn.forward-pass")
+class RNNForwardPass(MatrixQuestion, TableQuestionMixin):
+  
+  @staticmethod
+  def rnn_forward(x_seq, W_xh, W_hh, b_h, h_0, activation='tanh'):
+    """
+    x_seq: (seq_len, input_dim) - input sequence
+    W_xh: (input_dim, hidden_dim) - input to hidden weights
+    W_hh: (hidden_dim, hidden_dim) - hidden to hidden weights
+    b_h: (hidden_dim,) - hidden bias
+    h_0: (hidden_dim,) - initial hidden state
+
+    Returns: all hidden states (seq_len, hidden_dim)
+    """
+    seq_len = len(x_seq)
+    hidden_dim = W_hh.shape[0]
+    
+    h_states = np.zeros((seq_len, hidden_dim))
+    h_t = h_0
+    
+    for t in range(seq_len):
+      h_t = x_seq[t] @ W_xh + h_t @ W_hh + b_h
+      if activation == 'tanh':
+        h_t = np.tanh(h_t)
+      elif activation == 'relu':
+        h_t = np.maximum(0, h_t)
+      h_states[t] = h_t
+    
+    return h_states
+  
+  def refresh(self, *args, **kwargs):
+    super().refresh(*args, **kwargs)
+    self.rng = np.random.RandomState(kwargs.get("rng_seed", None))
+    
+    seq_len = kwargs.get("seq_len", 3)
+    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"] = Answer.matrix(key="output_sequence", value=self.h_states)
+    
+    return True
+  
+  def get_body(self, **kwargs) -> ContentAST.Section:
+    body = ContentAST.Section()
+    
+    body.add_element(
+      ContentAST.Paragraph([
+        ContentAST.Text("Given the below information about an RNN, please calculate the output sequence."),
+        "Assume that you are using a tanh activation function."
+      ])
+    )
+    body.add_element(
+      self.create_info_table(
+        {
+          ContentAST.Container(["Input sequence, ", ContentAST.Equation("x_{seq}", inline=True)]) : ContentAST.Matrix(self.x_seq),
+          ContentAST.Container(["Input weights, ",  ContentAST.Equation("W_{xh}", inline=True)])  : ContentAST.Matrix(self.W_xh),
+          ContentAST.Container(["Hidden weights, ", ContentAST.Equation("W_{hh}", inline=True)])  : ContentAST.Matrix(self.W_hh),
+          ContentAST.Container(["Bias, ",           ContentAST.Equation("b_{h}", inline=True)])   : ContentAST.Matrix(self.b_h),
+          ContentAST.Container(["Hidden states, ",  ContentAST.Equation("h_{0}", inline=True)])   : ContentAST.Matrix(self.h_0),
+        }
+      )
+    )
+    
+    body.add_element(ContentAST.LineBreak())
+    
+    body.add_element(
+      self.answers["output_sequence"].get_ast_element(label=f"Hidden states")
+    )
+    
+    return body
+  
+  def get_explanation(self, **kwargs) -> ContentAST.Section:
+    explanation = ContentAST.Section()
+    digits = Answer.DEFAULT_ROUNDING_DIGITS
+
+    explanation.add_element(
+      ContentAST.Paragraph([
+        "For an RNN forward pass, we compute the hidden state at each time step using:"
+      ])
+    )
+
+    explanation.add_element(
+      ContentAST.Equation(r"h_t = \tanh(x_t W_{xh} + h_{t-1} W_{hh} + b_h)")
+    )
+
+    explanation.add_element(
+      ContentAST.Paragraph([
+        "Where the input contributes via ", ContentAST.Equation("W_{xh}", inline=True),
+        ", the previous hidden state contributes via ", ContentAST.Equation("W_{hh}", inline=True),
+        ", and ", ContentAST.Equation("b_h", inline=True), " is the bias."
+      ])
+    )
+
+    # Format arrays with proper rounding
+    def format_array(arr):
+      from QuizGenerator.misc import fix_negative_zero
+      if arr.ndim == 0:
+        return f"{fix_negative_zero(arr):.{digits}f}"
+      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)
+    num_examples = min(2, seq_len)
+    
+    explanation.add_element(ContentAST.Paragraph([""]))
+
+    for t in range(num_examples):
+      explanation.add_element(
+        ContentAST.Paragraph([
+          ContentAST.Text(f"Example: Timestep {t}", emphasis=True)
+        ])
+      )
+
+      # Compute step t
+      x_contribution = self.x_seq[t] @ self.W_xh
+      if t == 0:
+        h_prev = self.h_0
+        h_prev_label = 'h_{-1}'
+        h_prev_desc = " (initial state)"
+      else:
+        h_prev = self.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_result = np.tanh(pre_activation)
+
+      explanation.add_element(
+        ContentAST.Paragraph([
+          "Input contribution: ",
+          ContentAST.Equation(f'x_{t} W_{{xh}}', inline=True),
+          f" = {format_array(x_contribution)}"
+        ])
+      )
+
+      explanation.add_element(
+        ContentAST.Paragraph([
+          "Hidden contribution: ",
+          ContentAST.Equation(f'{h_prev_label} W_{{hh}}', inline=True),
+          f"{h_prev_desc} = {format_array(h_contribution)}"
+        ])
+      )
+
+      explanation.add_element(
+        ContentAST.Paragraph([
+          f"Pre-activation: {format_array(pre_activation)}"
+        ])
+      )
+
+      explanation.add_element(
+        ContentAST.Paragraph([
+          "After tanh: ",
+          ContentAST.Equation(f'h_{t}', inline=True),
+          f" = {format_array(h_result)}"
+        ])
+      )
+
+      # Add visual separator between timesteps (except after the last one)
+      if t < num_examples - 1:
+        explanation.add_element(ContentAST.Paragraph([""]))
+
+    # Show complete output sequence (rounded)
+    explanation.add_element(
+      ContentAST.Paragraph([
+        "Complete hidden state sequence (each row is one timestep):"
+      ])
+    )
+
+    explanation.add_element(
+      ContentAST.Matrix(np.round(self.h_states, digits))
+    )
+
+    return explanation
+