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

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
+

QuizGenerator/premade_questions/cst463/models/text.py

@@ -0,0 +1,201 @@
+import abc
+import logging
+import math
+import keras
+import numpy as np
+
+from QuizGenerator.misc import MatrixAnswer
+from QuizGenerator.premade_questions.cst463.models.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.word2vec.skipgram")
+class word2vec__skipgram(MatrixQuestion, TableQuestionMixin):
+  
+  @staticmethod
+  def skipgram_predict(center_emb, context_embs):
+    """
+    center_emb: (embed_dim,) - center word embedding
+    context_embs: (num_contexts, embed_dim) - context candidate embeddings
+
+    Returns: probabilities (num_contexts,)
+    """
+    # Compute dot products (logits)
+    logits = context_embs @ center_emb
+    
+    # Softmax
+    exp_logits = np.exp(logits)
+    probs = exp_logits / exp_logits.sum()
+    
+    return logits, probs
+  
+  def refresh(self, *args, **kwargs):
+    super().refresh(*args, **kwargs)
+    self.rng = np.random.RandomState(kwargs.get("rng_seed", None))
+    
+    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"] = Answer.vector_value(key="logits", value=self.logits)
+    self.answers["center_word"] = Answer.string(key="center_word", value=self.center_word)
+    
+    
+    return True
+  
+  def get_body(self, **kwargs) -> ContentAST.Section:
+    body = ContentAST.Section()
+    
+    body.add_element(
+      ContentAST.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."
+      ])
+    )
+    body.add_elements([
+      ContentAST.Paragraph([ContentAST.Text(f"`{w}` : "), str(e)]) for w, e in zip(self.context_words, self.context_embs)
+    ])
+    
+    body.add_elements([
+      ContentAST.LineBreak(),
+      self.answers["logits"].get_ast_element("Logits"),
+      ContentAST.LineBreak(),
+      self.answers["center_word"].get_ast_element("Center word")
+    ])
+    
+    
+    log.debug(f"output: {self.logits}")
+    log.debug(f"weights: {self.probs}")
+    
+    return body
+  
+  def get_explanation(self, **kwargs) -> ContentAST.Section:
+    explanation = ContentAST.Section()
+    digits = Answer.DEFAULT_ROUNDING_DIGITS
+
+    explanation.add_element(
+      ContentAST.Paragraph([
+        "In the skip-gram model, we predict context words given a center word by computing dot products between embeddings and applying softmax."
+      ])
+    )
+
+    # Step 1: Show embeddings
+    explanation.add_element(
+      ContentAST.Paragraph([
+        ContentAST.Text("Step 1: Given embeddings", emphasis=True)
+      ])
+    )
+
+    # Format center embedding
+    center_emb_str = "[" + ", ".join([f"{x:.{digits}f}" for x in self.center_emb]) + "]"
+    explanation.add_element(
+      ContentAST.Paragraph([
+        f"Center word `{self.center_word}`: {center_emb_str}"
+      ])
+    )
+
+    explanation.add_element(
+      ContentAST.Paragraph([
+        "Context words:"
+      ])
+    )
+
+    for i, (word, emb) in enumerate(zip(self.context_words, self.context_embs)):
+      emb_str = "[" + ", ".join([f"{x:.2f}" for x in emb]) + "]"
+      explanation.add_element(
+        ContentAST.Paragraph([
+          f"`{word}`: {emb_str}"
+        ])
+      )
+
+    # Step 2: Compute logits (dot products)
+    explanation.add_element(
+      ContentAST.Paragraph([
+        ContentAST.Text("Step 2: Compute logits (dot products)", emphasis=True)
+      ])
+    )
+
+    # Show ONE example
+    explanation.add_element(
+      ContentAST.Paragraph([
+        f"Example: Logit for `{self.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]
+
+    explanation.add_element(
+      ContentAST.Equation(f"{dot_product_terms} = {logit_val:.2f}")
+    )
+
+    logits_str = "[" + ", ".join([f"{x:.2f}" for x in self.logits]) + "]"
+    explanation.add_element(
+      ContentAST.Paragraph([
+        f"All logits: {logits_str}"
+      ])
+    )
+
+    # Step 3: Apply softmax
+    explanation.add_element(
+      ContentAST.Paragraph([
+        ContentAST.Text("Step 3: Apply softmax to get probabilities", emphasis=True)
+      ])
+    )
+
+    exp_logits = np.exp(self.logits)
+    sum_exp = exp_logits.sum()
+
+    exp_terms = " + ".join([f"e^{{{l:.{digits}f}}}" for l in self.logits])
+
+    explanation.add_element(
+      ContentAST.Equation(f"\\text{{denominator}} = {exp_terms} = {sum_exp:.{digits}f}")
+    )
+
+    explanation.add_element(
+      ContentAST.Paragraph([
+        "Probabilities:"
+      ])
+    )
+
+    for i, (word, prob) in enumerate(zip(self.context_words, self.probs)):
+      explanation.add_element(
+        ContentAST.Equation(f"P(\\text{{{word}}}) = \\frac{{e^{{{self.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]
+
+    explanation.add_element(
+      ContentAST.Paragraph([
+        ContentAST.Text("Conclusion:", emphasis=True),
+        f" The most likely context word is `{most_likely_word}` with probability {self.probs[most_likely_idx]:.{digits}f}"
+      ])
+    )
+
+    return explanation
+

QuizGenerator/premade_questions/cst463/models/weight_counting.py

@@ -0,0 +1,227 @@
+import abc
+import logging
+import math
+import keras
+import numpy as np
+
+from QuizGenerator.question import Question, QuestionRegistry, Answer
+from QuizGenerator.contentast import ContentAST
+from QuizGenerator.constants import MathRanges
+
+log = logging.getLogger(__name__)
+
+
+class WeightCounting(Question, abc.ABC):
+  @abc.abstractmethod
+  def get_model(self) -> keras.Model:
+    pass
+  
+  @staticmethod
+  def model_to_python(model: keras.Model, fields=None, include_input=True):
+    if fields is None:
+      fields = []
+    
+    def sanitize(v):
+      """Convert numpy types to pure Python."""
+      if isinstance(v, np.generic):  # np.int64, np.float32, etc.
+        return v.item()
+      if isinstance(v, (list, tuple)):
+        return type(v)(sanitize(x) for x in v)
+      if isinstance(v, dict):
+        return {k: sanitize(x) for k, x in v.items()}
+      return v
+    
+    lines = []
+    lines.append("keras.models.Sequential([")
+    
+    # ---- Emit an Input line if we can ----
+    # model.input_shape is like (None, H, W, C) or (None, D)
+    if include_input and getattr(model, "input_shape", None) is not None:
+      input_shape = sanitize(model.input_shape[1:])  # drop batch dimension
+      # If it's a 1D shape like (784,), keep as tuple; if scalar, still fine.
+      lines.append(f"  keras.layers.Input(shape={input_shape!r}),")
+    
+    # ---- Emit all other layers ----
+    for layer in model.layers:
+      # If user explicitly had an Input layer, we don't want to duplicate it
+      if isinstance(layer, keras.layers.InputLayer):
+        # You *could* handle it specially here, but usually we just skip
+        continue
+      
+      cfg = layer.get_config()
+      
+      # If fields is empty, include everything; otherwise filter by fields.
+      if fields:
+        items = [(k, v) for k, v in cfg.items() if k in fields]
+      else:
+        items = cfg.items()
+      
+      arg_lines = [
+        f"{k}={sanitize(v)!r}"  # !r so strings get quotes, etc.
+        for k, v in items
+      ]
+      args = ",\n    ".join(arg_lines)
+      
+      lines.append(
+        f"  keras.layers.{layer.__class__.__name__}("
+        f"{'\n    ' if args else ''}{args}{'\n  ' if args else ''}),"
+      )
+    
+    lines.append("])")
+    return "\n".join(lines)
+  
+  def refresh(self, *args, **kwargs):
+    super().refresh(*args, **kwargs)
+    
+    refresh_success = False
+    while not refresh_success:
+      try:
+        self.model, self.fields = self.get_model()
+        refresh_success = True
+      except ValueError as e:
+        log.error(e)
+        log.info(f"Regenerating {self.__class__.__name__} due to improper configuration")
+        continue
+    
+    self.num_parameters = self.model.count_params()
+    self.answers["num_parameters"] = Answer.integer(
+      "num_parameters",
+      self.num_parameters
+    )
+    
+    return True
+  
+  def get_body(self, **kwargs) -> ContentAST.Section:
+    body = ContentAST.Section()
+    
+    body.add_element(
+      ContentAST.Paragraph(
+        [
+          ContentAST.Text("Given the below model, how many parameters does it use?")
+        ]
+      )
+    )
+    
+    body.add_element(
+      ContentAST.Code(
+        self.model_to_python(
+          self.model,
+          fields=self.fields
+        )
+      )
+    )
+    
+    body.add_element(ContentAST.LineBreak())
+    
+    body.add_element(
+      ContentAST.Answer(self.answers["num_parameters"], "Number of Parameters")
+    )
+    
+    return body
+  
+  def get_explanation(self, **kwargs) -> ContentAST.Section:
+    explanation = ContentAST.Section()
+    
+    def markdown_summary(model) -> ContentAST.Table:
+      # Ensure the model is built by running build() or calling it once
+      if not model.built:
+        try:
+          model.build(model.input_shape)
+        except:
+          pass  # Some subclassed models need real data to build
+      
+      data = []
+      
+      total_params = 0
+      
+      for layer in model.layers:
+        name = layer.name
+        ltype = layer.__class__.__name__
+        
+        # Try to extract output shape
+        try:
+          outshape = tuple(layer.output.shape)
+        except:
+          outshape = "?"
+        
+        params = layer.count_params()
+        total_params += params
+        
+        data.append([name, ltype, outshape, params])
+        
+      data.append(["**Total**", "", "", f"**{total_params}**"])
+      return ContentAST.Table(data=data, headers=["Layer", "Type", "Output Shape", "Params"])
+      
+    
+    summary_lines = []
+    self.model.summary(print_fn=lambda x: summary_lines.append(x))
+    explanation.add_element(
+      # ContentAST.Text('\n'.join(summary_lines))
+      markdown_summary(self.model)
+    )
+    
+    return explanation
+
+
+@QuestionRegistry.register("cst463.WeightCounting-CNN")
+class WeightCounting_CNN(WeightCounting):
+  
+  def get_model(self) -> tuple[keras.Model, list[str]]:
+    input_size = self.rng.choice(np.arange(28, 32))
+    cnn_num_filters = self.rng.choice(2 ** np.arange(8))
+    cnn_kernel_size = self.rng.choice(1 + np.arange(10))
+    cnn_strides = self.rng.choice(1 + np.arange(10))
+    pool_size = self.rng.choice(1 + np.arange(10))
+    pool_strides = self.rng.choice(1 + np.arange(10))
+    num_output_size = self.rng.choice([1, 10, 32, 100])
+    
+    # Let's just make a small model
+    model = keras.models.Sequential(
+      [
+        keras.layers.Input((input_size, input_size, 1)),
+        keras.layers.Conv2D(
+          filters=cnn_num_filters,
+          kernel_size=(cnn_kernel_size, cnn_kernel_size),
+          strides=(cnn_strides, cnn_strides),
+          padding="valid"
+        ),
+        keras.layers.MaxPool2D(
+          pool_size=(pool_size, pool_size),
+          strides=(pool_strides, pool_strides)
+        ),
+        keras.layers.Dense(
+          num_output_size
+        )
+      ]
+    )
+    return model, ["filters", "kernel_size", "strides", "padding", "pool_size"]
+
+
+@QuestionRegistry.register("cst463.WeightCounting-RNN")
+class WeightCounting_RNN(WeightCounting):
+  def get_model(self) -> tuple[keras.Model, list[str]]:
+    timesteps = int(self.rng.choice(np.arange(20, 41)))
+    feature_size = int(self.rng.choice(np.arange(8, 65)))
+
+    rnn_units = int(self.rng.choice(2 ** np.arange(4, 9)))
+    rnn_type = self.rng.choice(["SimpleRNN"])
+    return_sequences = bool(self.rng.choice([True, False]))
+
+    num_output_size = int(self.rng.choice([1, 10, 32, 100]))
+
+    RNNLayer = getattr(keras.layers, rnn_type)
+
+    model = keras.models.Sequential([
+      keras.layers.Input((timesteps, feature_size)),
+      RNNLayer(
+        units=rnn_units,
+        return_sequences=return_sequences,
+      ),
+      keras.layers.Dense(num_output_size),
+    ])
+    return model, ["units", "return_sequences"]
+
+
+@QuestionRegistry.register()
+class ConvolutionCalculation(Question):
+  pass