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

QuizGenerator/premade_questions/cst463/neural-network-basics/neural_network_questions.py

@@ -15,11 +15,12 @@ import matplotlib.patches as mpatches
 from QuizGenerator.contentast import ContentAST
 from QuizGenerator.question import Question, Answer, QuestionRegistry
 from QuizGenerator.mixins import TableQuestionMixin, BodyTemplatesMixin
+from ..models.matrices import MatrixQuestion
 
 log = logging.getLogger(__name__)
 
 
-class SimpleNeuralNetworkBase(Question, abc.ABC):
+class SimpleNeuralNetworkBase(MatrixQuestion, abc.ABC):
   """
   Base class for simple neural network questions.
 
@@ -73,45 +74,42 @@ class SimpleNeuralNetworkBase(Question, abc.ABC):
 
   def _generate_network(self, weight_range=(-2, 2), input_range=(-3, 3)):
     """Generate random network parameters and input."""
-    # Generate weights (using small values for numerical stability)
-    self.W1 = np.array([
-      [self.rng.uniform(weight_range[0], weight_range[1])
-       for _ in range(self.num_inputs)]
-      for _ in range(self.num_hidden)
-    ])
-
-    self.W2 = np.array([
-      [self.rng.uniform(weight_range[0], weight_range[1])
-       for _ in range(self.num_hidden)]
-      for _ in range(self.num_outputs)
-    ])
+    # Generate weights using MatrixQuestion's rounded matrix method
+    self.W1 = self.get_rounded_matrix(
+      (self.num_hidden, self.num_inputs),
+      low=weight_range[0],
+      high=weight_range[1]
+    )
+
+    self.W2 = self.get_rounded_matrix(
+      (self.num_outputs, self.num_hidden),
+      low=weight_range[0],
+      high=weight_range[1]
+    )
 
     # Generate biases
     if self.use_bias:
-      self.b1 = np.array([
-        self.rng.uniform(weight_range[0], weight_range[1])
-        for _ in range(self.num_hidden)
-      ])
-      self.b2 = np.array([
-        self.rng.uniform(weight_range[0], weight_range[1])
-        for _ in range(self.num_outputs)
-      ])
+      self.b1 = self.get_rounded_matrix(
+        (self.num_hidden,),
+        low=weight_range[0],
+        high=weight_range[1]
+      )
+      self.b2 = self.get_rounded_matrix(
+        (self.num_outputs,),
+        low=weight_range[0],
+        high=weight_range[1]
+      )
     else:
       self.b1 = np.zeros(self.num_hidden)
       self.b2 = np.zeros(self.num_outputs)
 
-    # Round weights to make calculations cleaner
-    self.W1 = np.round(self.W1 * 2) / 2  # Round to nearest 0.5
-    self.W2 = np.round(self.W2 * 2) / 2
-    self.b1 = np.round(self.b1 * 2) / 2
-    self.b2 = np.round(self.b2 * 2) / 2
-
-    # Generate input values
-    self.X = np.array([
-      self.rng.uniform(input_range[0], input_range[1])
-      for _ in range(self.num_inputs)
-    ])
-    self.X = np.round(self.X)  # Use integer inputs for simplicity
+    # Generate input values (keep as integers for simplicity)
+    self.X = self.get_rounded_matrix(
+      (self.num_inputs,),
+      low=input_range[0],
+      high=input_range[1],
+      digits_to_round=0  # Round to integers
+    )
 
   def _select_activation_function(self):
     """Randomly select an activation function."""
@@ -158,7 +156,7 @@ class SimpleNeuralNetworkBase(Question, abc.ABC):
 
     # Output layer
     self.z2 = self.W2 @ self.a1 + self.b2
-    self.a2 = self._apply_activation(self.z2, self.ACTIVATION_LINEAR)  # Linear output
+    self.a2 = self._apply_activation(self.z2, self.ACTIVATION_SIGMOID)  # Sigmoid output for binary classification
 
     # Round all computed values to display precision to ensure students can reproduce calculations
     # We display z and a values with 4 decimal places
@@ -170,21 +168,34 @@ class SimpleNeuralNetworkBase(Question, abc.ABC):
     return self.a2
 
   def _compute_loss(self, y_target):
-    """Compute MSE loss."""
+    """Compute binary cross-entropy loss."""
     self.y_target = y_target
-    self.loss = 0.5 * (y_target - self.a2[0]) ** 2
+    # BCE: L = -[y log(ŷ) + (1-y) log(1-ŷ)]
+    # Add small epsilon to prevent log(0)
+    epsilon = 1e-15
+    y_pred = np.clip(self.a2[0], epsilon, 1 - epsilon)
+    self.loss = -(y_target * np.log(y_pred) + (1 - y_target) * np.log(1 - y_pred))
     return self.loss
 
   def _compute_output_gradient(self):
     """Compute gradient of loss w.r.t. output."""
-    # For MSE loss: dL/da2 = -(y - a2)
-    self.dL_da2 = -(self.y_target - self.a2[0])
-
-    # For linear output activation: da2/dz2 = 1
-    self.da2_dz2 = 1.0
-
-    # Chain rule: dL/dz2 = dL/da2 * da2/dz2
-    self.dL_dz2 = self.dL_da2 * self.da2_dz2
+    # For BCE loss with sigmoid activation, the gradient simplifies beautifully:
+    # dL/dz2 = ŷ - y (this is the combined derivative of BCE loss and sigmoid activation)
+    #
+    # Derivation:
+    # BCE: L = -[y log(ŷ) + (1-y) log(1-ŷ)]
+    # dL/dŷ = -[y/ŷ - (1-y)/(1-ŷ)]
+    # Sigmoid: ŷ = σ(z), dŷ/dz = ŷ(1-ŷ)
+    # Chain rule: dL/dz = dL/dŷ * dŷ/dz = ŷ - y
+
+    self.dL_dz2 = self.a2[0] - self.y_target
+
+    # Store intermediate values for explanation purposes
+    # Clip to prevent division by zero (same epsilon as in loss calculation)
+    epsilon = 1e-15
+    y_pred_clipped = np.clip(self.a2[0], epsilon, 1 - epsilon)
+    self.dL_da2 = -(self.y_target / y_pred_clipped - (1 - self.y_target) / (1 - y_pred_clipped))
+    self.da2_dz2 = self.a2[0] * (1 - self.a2[0])
 
     return self.dL_dz2
 
@@ -302,7 +313,7 @@ class SimpleNeuralNetworkBase(Question, abc.ABC):
       if self.y_target is not None:
         right_data.append([
           ContentAST.Equation("y", inline=True),
-          f"{self.y_target:.2f}"
+          f"{int(self.y_target)}"  # Binary target (0 or 1)
         ])
 
       if self.loss is not None:
@@ -560,7 +571,7 @@ class ForwardPassQuestion(SimpleNeuralNetworkBase):
     # Question description
     body.add_element(ContentAST.Paragraph([
       f"Given the neural network below with {self._get_activation_name()} activation "
-      f"in the hidden layer and linear activation (f(z) = z) in the output layer, "
+      f"in the hidden layer and sigmoid activation in the output layer (for binary classification), "
       f"calculate the forward pass for the given input values."
     ]))
 
@@ -577,7 +588,7 @@ class ForwardPassQuestion(SimpleNeuralNetworkBase):
 
     # Activation function
     body.add_element(ContentAST.Paragraph([
-      f"**Activation function:** {self._get_activation_name()}"
+      f"**Hidden layer activation:** {self._get_activation_name()}"
     ]))
 
     # Create answer block
@@ -586,14 +597,14 @@ class ForwardPassQuestion(SimpleNeuralNetworkBase):
       answers.append(
         ContentAST.Answer(
           answer=self.answers[f"h{i+1}"],
-          label=f"h_{i+1} (hidden neuron {i+1} output)"
+          label=f"h_{i+1}"
         )
       )
 
     answers.append(
       ContentAST.Answer(
         answer=self.answers["y_pred"],
-        label="ŷ (network output)"
+        label="ŷ"
       )
     )
 
@@ -652,7 +663,7 @@ class ForwardPassQuestion(SimpleNeuralNetworkBase):
 
     # Output layer
     explanation.add_element(ContentAST.Paragraph([
-      "**Step 3: Calculate output (with linear activation)**"
+      "**Step 3: Calculate output (with sigmoid activation)**"
     ]))
 
     terms = []
@@ -669,12 +680,13 @@ class ForwardPassQuestion(SimpleNeuralNetworkBase):
     ))
 
     explanation.add_element(ContentAST.Equation(
-      f"\\hat{{y}} = f(z_{{out}}) = z_{{out}} = {self.a2[0]:.4f}",
+      f"\\hat{{y}} = \\sigma(z_{{out}}) = \\frac{{1}}{{1 + e^{{-{self.z2[0]:.4f}}}}} = {self.a2[0]:.4f}",
       inline=False
     ))
 
     explanation.add_element(ContentAST.Paragraph([
-      "(Note: The output layer uses linear activation, so the output can be any real number)"
+      "(Note: The output layer uses sigmoid activation for binary classification, "
+      "so the output is between 0 and 1, representing the probability of class 1)"
     ]))
 
     return explanation
@@ -699,11 +711,12 @@ class BackpropGradientQuestion(SimpleNeuralNetworkBase):
     # Run forward pass
     self._forward_pass()
 
-    # Generate target and compute loss
-    # Target should be different from output to create meaningful gradients
-    self.y_target = float(self.a2[0] + self.rng.uniform(1, 3) * self.rng.choice([-1, 1]))
-    # Round target to display precision (2 decimal places)
-    self.y_target = round(self.y_target, 2)
+    # Generate binary target (0 or 1)
+    # Choose the opposite of what the network predicts to create meaningful gradients
+    if self.a2[0] > 0.5:
+      self.y_target = 0
+    else:
+      self.y_target = 1
     self._compute_loss(self.y_target)
     # Round loss to display precision (4 decimal places)
     self.loss = round(self.loss, 4)
@@ -735,7 +748,8 @@ class BackpropGradientQuestion(SimpleNeuralNetworkBase):
     # Question description
     body.add_element(ContentAST.Paragraph([
       f"Given the neural network below with {self._get_activation_name()} activation "
-      f"in the hidden layer, a forward pass has been completed with the values shown. "
+      f"in the hidden layer and sigmoid activation in the output layer (for binary classification), "
+      f"a forward pass has been completed with the values shown. "
       f"Calculate the gradients (∂L/∂w) for the specified weights using backpropagation."
     ]))
 
@@ -752,7 +766,7 @@ class BackpropGradientQuestion(SimpleNeuralNetworkBase):
 
     # Activation function
     body.add_element(ContentAST.Paragraph([
-      f"**Activation function:** {self._get_activation_name()}"
+      f"**Hidden layer activation:** {self._get_activation_name()}"
     ]))
 
     body.add_element(ContentAST.Paragraph([
@@ -767,7 +781,7 @@ class BackpropGradientQuestion(SimpleNeuralNetworkBase):
       answers.append(
         ContentAST.Answer(
           answer=self.answers[f"dL_dw2_{i}"],
-          label=f"∂L/∂w_{i+3} (weight from h_{i+1} to output)"
+          label=f"∂L/∂w_{i+3}"
         )
       )
 
@@ -776,7 +790,7 @@ class BackpropGradientQuestion(SimpleNeuralNetworkBase):
       answers.append(
         ContentAST.Answer(
           answer=self.answers[f"dL_dw1_0{j}"],
-          label=f"∂L/∂w_1{j+1} (weight from x_{j+1} to h_1)"
+          label=f"∂L/∂w_1{j+1}"
         )
       )
 
@@ -797,14 +811,19 @@ class BackpropGradientQuestion(SimpleNeuralNetworkBase):
     ]))
 
     explanation.add_element(ContentAST.Paragraph([
-      "For MSE loss with linear output activation:"
+      "For binary cross-entropy loss with sigmoid output activation, "
+      "the gradient with respect to the pre-activation simplifies beautifully:"
     ]))
 
     explanation.add_element(ContentAST.Equation(
-      f"\\frac{{\\partial L}}{{\\partial \\hat{{y}}}} = -(y - \\hat{{y}}) = -({self.y_target:.2f} - {self.a2[0]:.4f}) = {self.dL_da2:.4f}",
+      f"\\frac{{\\partial L}}{{\\partial z_{{out}}}} = \\hat{{y}} - y = {self.a2[0]:.4f} - {int(self.y_target)} = {self.dL_dz2:.4f}",
       inline=False
     ))
 
+    explanation.add_element(ContentAST.Paragraph([
+      "(This elegant result comes from combining the BCE loss derivative and sigmoid activation derivative)"
+    ]))
+
     # W2 gradients
     explanation.add_element(ContentAST.Paragraph([
       "**Step 2: Gradients for hidden-to-output weights**"
@@ -817,7 +836,7 @@ class BackpropGradientQuestion(SimpleNeuralNetworkBase):
     for i in range(self.num_hidden):
       grad = self._compute_gradient_W2(i)
       explanation.add_element(ContentAST.Equation(
-        f"\\frac{{\\partial L}}{{\\partial w_{i+3}}} = \\frac{{\\partial L}}{{\\partial \\hat{{y}}}} \\cdot \\frac{{\\partial \\hat{{y}}}}{{\\partial w_{i+3}}} = {self.dL_da2:.4f} \\cdot {self.a1[i]:.4f} = {grad:.4f}",
+        f"\\frac{{\\partial L}}{{\\partial w_{i+3}}} = \\frac{{\\partial L}}{{\\partial z_{{out}}}} \\cdot \\frac{{\\partial z_{{out}}}}{{\\partial w_{i+3}}} = {self.dL_dz2:.4f} \\cdot {self.a1[i]:.4f} = {grad:.4f}",
         inline=False
       ))
 
@@ -839,14 +858,14 @@ class BackpropGradientQuestion(SimpleNeuralNetworkBase):
       grad = self._compute_gradient_W1(0, j)
 
       if self.activation_function == self.ACTIVATION_SIGMOID:
-        act_deriv_str = f"\\sigma(z_1)(1-\\sigma(z_1)) = {self.a1[0]:.4f}(1-{self.a1[0]:.4f}) = {da1_dz1:.4f}"
+        act_deriv_str = f"\\sigma'(z_1) = h_1(1-h_1) = {self.a1[0]:.4f}(1-{self.a1[0]:.4f}) = {da1_dz1:.4f}"
       elif self.activation_function == self.ACTIVATION_RELU:
-        act_deriv_str = f"\\mathbb{{1}}(z_1 > 0) = {da1_dz1:.4f}"
+        act_deriv_str = f"\\text{{ReLU}}'(z_1) = \\mathbb{{1}}(z_1 > 0) = {da1_dz1:.4f}"
       else:
         act_deriv_str = f"1"
 
       explanation.add_element(ContentAST.Equation(
-        f"\\frac{{\\partial L}}{{\\partial w_{{1{j+1}}}}} = \\frac{{\\partial L}}{{\\partial \\hat{{y}}}} \\cdot w_{3} \\cdot {act_deriv_str} \\cdot x_{j+1} = {self.dL_da2:.4f} \\cdot {dz2_da1:.4f} \\cdot {da1_dz1:.4f} \\cdot {self.X[j]:.1f} = {grad:.4f}",
+        f"\\frac{{\\partial L}}{{\\partial w_{{1{j+1}}}}} = \\frac{{\\partial L}}{{\\partial z_{{out}}}} \\cdot w_{3} \\cdot {act_deriv_str} \\cdot x_{j+1} = {self.dL_dz2:.4f} \\cdot {dz2_da1:.4f} \\cdot {da1_dz1:.4f} \\cdot {self.X[j]:.1f} = {grad:.4f}",
         inline=False
       ))
 
@@ -1015,10 +1034,12 @@ class EndToEndTrainingQuestion(SimpleNeuralNetworkBase):
     # Run forward pass
     self._forward_pass()
 
-    # Generate target and compute loss
-    self.y_target = float(self.a2[0] + self.rng.uniform(1, 3) * self.rng.choice([-1, 1]))
-    # Round target to display precision (2 decimal places)
-    self.y_target = round(self.y_target, 2)
+    # Generate binary target (0 or 1)
+    # Choose the opposite of what the network predicts to create meaningful gradients
+    if self.a2[0] > 0.5:
+      self.y_target = 0
+    else:
+      self.y_target = 1
     self._compute_loss(self.y_target)
     # Round loss to display precision (4 decimal places)
     self.loss = round(self.loss, 4)
@@ -1070,15 +1091,16 @@ class EndToEndTrainingQuestion(SimpleNeuralNetworkBase):
 
     # Question description
     body.add_element(ContentAST.Paragraph([
-      f"Given the neural network below, perform one complete training step (forward pass, "
-      f"loss calculation, backpropagation, and weight update) for the given input and target."
+      f"Given the neural network below with {self._get_activation_name()} activation "
+      f"in the hidden layer and sigmoid activation in the output layer (for binary classification), "
+      f"perform one complete training step (forward pass, loss calculation, "
+      f"backpropagation, and weight update) for the given input and target."
     ]))
 
     # Network diagram
     body.add_element(
       ContentAST.Picture(
-        img_data=self._generate_network_diagram(show_weights=True, show_activations=False),
-        caption=f"Neural network (before training)"
+        img_data=self._generate_network_diagram(show_weights=True, show_activations=False)
       )
     )
 
@@ -1096,7 +1118,7 @@ class EndToEndTrainingQuestion(SimpleNeuralNetworkBase):
 
     body.add_element(ContentAST.Paragraph([
       "Target: ",
-      ContentAST.Equation(f"y = {self.y_target:.2f}", inline=True)
+      ContentAST.Equation(f"y = {int(self.y_target)}", inline=True)
     ]))
 
     body.add_element(ContentAST.Paragraph([
@@ -1105,13 +1127,9 @@ class EndToEndTrainingQuestion(SimpleNeuralNetworkBase):
     ]))
 
     body.add_element(ContentAST.Paragraph([
-      f"**Activation function:** {self._get_activation_name()}"
+      f"**Hidden layer activation:** {self._get_activation_name()}"
     ]))
 
-    body.add_element(ContentAST.Paragraph([
-      "**Complete the following training steps:**"
-    ]))
-    
     # Network parameters table
     body.add_element(self._generate_parameter_table(include_activations=False))
 
@@ -1128,35 +1146,35 @@ class EndToEndTrainingQuestion(SimpleNeuralNetworkBase):
     answers.append(
       ContentAST.Answer(
         answer=self.answers["loss"],
-        label="2. Loss - MSE: L = (1/2)(y - ŷ)²"
+        label="2. Loss"
       )
     )
 
     answers.append(
       ContentAST.Answer(
         answer=self.answers["grad_w3"],
-        label="3. Gradient ∂L/∂w₃ (weight h₁ → ŷ)"
+        label="3. Gradient ∂L/∂w₃"
       )
     )
 
     answers.append(
       ContentAST.Answer(
         answer=self.answers["grad_w11"],
-        label="4. Gradient ∂L/∂w₁₁ (weight x₁ → h₁)"
+        label="4. Gradient ∂L/∂w₁₁"
       )
     )
 
     answers.append(
       ContentAST.Answer(
         answer=self.answers["new_w3"],
-        label="5. Updated w₃: w₃' = w₃ - α(∂L/∂w₃)"
+        label="5. Updated w₃:"
       )
     )
 
     answers.append(
       ContentAST.Answer(
         answer=self.answers["new_w11"],
-        label="6. Updated w₁₁: w₁₁' = w₁₁ - α(∂L/∂w₁₁)"
+        label="6. Updated w₁₁:"
       )
     )
 
@@ -1194,40 +1212,59 @@ class EndToEndTrainingQuestion(SimpleNeuralNetworkBase):
       inline=False
     ))
 
-    # Output
+    # Output (pre-activation)
     z2 = self.W2[0, 0] * self.a1[0] + self.W2[0, 1] * self.a1[1] + self.b2[0]
     explanation.add_element(ContentAST.Equation(
-      f"\\hat{{y}} = w_3 h_1 + w_4 h_2 + b_2 = {self.W2[0,0]:.1f} \\cdot {self.a1[0]:.4f} + {self.W2[0,1]:.1f} \\cdot {self.a1[1]:.4f} + {self.b2[0]:.1f} = {self.a2[0]:.4f}",
+      f"z_{{out}} = w_3 h_1 + w_4 h_2 + b_2 = {self.W2[0,0]:.1f} \\cdot {self.a1[0]:.4f} + {self.W2[0,1]:.1f} \\cdot {self.a1[1]:.4f} + {self.b2[0]:.1f} = {self.z2[0]:.4f}",
+      inline=False
+    ))
+
+    # Output (sigmoid activation)
+    explanation.add_element(ContentAST.Equation(
+      f"\\hat{{y}} = \\sigma(z_{{out}}) = \\frac{{1}}{{1 + e^{{-{self.z2[0]:.4f}}}}} = {self.a2[0]:.4f}",
       inline=False
     ))
 
     # Step 2: Loss
     explanation.add_element(ContentAST.Paragraph([
-      "**Step 2: Calculate Loss**"
+      "**Step 2: Calculate Loss (Binary Cross-Entropy)**"
     ]))
 
+    # Show the full BCE formula first
     explanation.add_element(ContentAST.Equation(
-      f"L = \\frac{{1}}{{2}}(y - \\hat{{y}})^2 = \\frac{{1}}{{2}}({self.y_target:.2f} - {self.a2[0]:.4f})^2 = {self.loss:.4f}",
+      f"L = -[y \\log(\\hat{{y}}) + (1-y) \\log(1-\\hat{{y}})]",
       inline=False
     ))
 
+    # Then evaluate it
+    if self.y_target == 1:
+      explanation.add_element(ContentAST.Equation(
+        f"L = -[1 \\cdot \\log({self.a2[0]:.4f}) + 0 \\cdot \\log(1-{self.a2[0]:.4f})] = -\\log({self.a2[0]:.4f}) = {self.loss:.4f}",
+        inline=False
+      ))
+    else:
+      explanation.add_element(ContentAST.Equation(
+        f"L = -[0 \\cdot \\log({self.a2[0]:.4f}) + 1 \\cdot \\log(1-{self.a2[0]:.4f})] = -\\log({1-self.a2[0]:.4f}) = {self.loss:.4f}",
+        inline=False
+      ))
+
     # Step 3: Gradients
     explanation.add_element(ContentAST.Paragraph([
       "**Step 3: Compute Gradients**"
     ]))
 
     explanation.add_element(ContentAST.Paragraph([
-      "Loss gradient:"
+      "For BCE with sigmoid, the output layer gradient simplifies to:"
     ]))
 
     explanation.add_element(ContentAST.Equation(
-      f"\\frac{{\\partial L}}{{\\partial \\hat{{y}}}} = -(y - \\hat{{y}}) = {self.dL_da2:.4f}",
+      f"\\frac{{\\partial L}}{{\\partial z_{{out}}}} = \\hat{{y}} - y = {self.a2[0]:.4f} - {int(self.y_target)} = {self.dL_dz2:.4f}",
       inline=False
     ))
 
     grad_w3 = self._compute_gradient_W2(0)
     explanation.add_element(ContentAST.Equation(
-      f"\\frac{{\\partial L}}{{\\partial w_3}} = \\frac{{\\partial L}}{{\\partial \\hat{{y}}}} \\cdot h_1 = {self.dL_da2:.4f} \\cdot {self.a1[0]:.4f} = {grad_w3:.4f}",
+      f"\\frac{{\\partial L}}{{\\partial w_3}} = \\frac{{\\partial L}}{{\\partial z_{{out}}}} \\cdot h_1 = {self.dL_dz2:.4f} \\cdot {self.a1[0]:.4f} = {grad_w3:.4f}",
       inline=False
     ))
 
@@ -1235,8 +1272,15 @@ class EndToEndTrainingQuestion(SimpleNeuralNetworkBase):
     dz2_da1 = self.W2[0, 0]
     da1_dz1 = self._activation_derivative(self.z1[0])
 
+    if self.activation_function == self.ACTIVATION_SIGMOID:
+      act_deriv_str = f"h_1(1-h_1)"
+    elif self.activation_function == self.ACTIVATION_RELU:
+      act_deriv_str = f"\\text{{ReLU}}'(z_1)"
+    else:
+      act_deriv_str = f"1"
+
     explanation.add_element(ContentAST.Equation(
-      f"\\frac{{\\partial L}}{{\\partial w_{{11}}}} = \\frac{{\\partial L}}{{\\partial \\hat{{y}}}} \\cdot w_3 \\cdot \\sigma'(z_1) \\cdot x_1 = {self.dL_da2:.4f} \\cdot {dz2_da1:.4f} \\cdot {da1_dz1:.4f} \\cdot {self.X[0]:.1f} = {grad_w11:.4f}",
+      f"\\frac{{\\partial L}}{{\\partial w_{{11}}}} = \\frac{{\\partial L}}{{\\partial z_{{out}}}} \\cdot w_3 \\cdot {act_deriv_str} \\cdot x_1 = {self.dL_dz2:.4f} \\cdot {dz2_da1:.4f} \\cdot {da1_dz1:.4f} \\cdot {self.X[0]:.1f} = {grad_w11:.4f}",
       inline=False
     ))
 

QuizGenerator/question.py

@@ -21,7 +21,7 @@ import yaml
 from typing import List, Dict, Any, Tuple, Optional
 import canvasapi.course, canvasapi.quiz
 
-from QuizGenerator.misc import OutputFormat, Answer
+from QuizGenerator.misc import Answer
 from QuizGenerator.contentast import ContentAST
 from QuizGenerator.performance import timer, PerformanceTracker
 
@@ -500,7 +500,8 @@ class Question(abc.ABC):
       while not is_interesting:
         # Increment seed for each backoff attempt to maintain deterministic behavior
         current_seed = None if base_seed is None else base_seed + backoff_counter
-        self.refresh(rng_seed=current_seed, hard_refresh=(backoff_counter > 0))
+        # Pass config_params to refresh so custom kwargs from YAML are available
+        self.refresh(rng_seed=current_seed, hard_refresh=(backoff_counter > 0), **self.config_params)
         is_interesting = self.is_interesting()
         backoff_counter += 1
 

QuizGenerator/quiz.py

@@ -14,7 +14,6 @@ from typing import List, Dict, Optional
 
 import yaml
 
-from QuizGenerator.misc import OutputFormat
 from QuizGenerator.contentast import ContentAST
 from QuizGenerator.question import Question, QuestionRegistry, QuestionGroup
 

{quizgenerator-0.1.4.dist-info → quizgenerator-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: QuizGenerator
-Version: 0.1.4
+Version: 0.3.0
 Summary: Generate randomized quiz questions for Canvas LMS and PDF exams
 Project-URL: Homepage, https://github.com/OtterDen-Lab/QuizGenerator
 Project-URL: Documentation, https://github.com/OtterDen-Lab/QuizGenerator/tree/main/documentation
@@ -21,6 +21,7 @@ Requires-Dist: canvasapi==3.2.0
 Requires-Dist: cryptography>=41.0.0
 Requires-Dist: graphviz>=0.21
 Requires-Dist: jinja2==3.1.3
+Requires-Dist: keras>=3.12.0
 Requires-Dist: markdown>=3.9
 Requires-Dist: matplotlib
 Requires-Dist: pylatex>=1.4.2
@@ -31,6 +32,7 @@ Requires-Dist: pyyaml==6.0.1
 Requires-Dist: requests==2.32.2
 Requires-Dist: segno>=1.6.0
 Requires-Dist: sympy>=1.14.0
+Requires-Dist: tensorflow>=2.20.0
 Provides-Extra: grading
 Requires-Dist: pillow>=10.0.0; extra == 'grading'
 Requires-Dist: pyzbar>=0.1.9; extra == 'grading'

{quizgenerator-0.1.4.dist-info → quizgenerator-0.3.0.dist-info}/RECORD

@@ -2,15 +2,15 @@ QuizGenerator/README.md,sha256=4n16gKyhIAKRBX4VKlpfcK0pyUYJ6Ht08MUsnwgxrZo,145
 QuizGenerator/__init__.py,sha256=8EV-k90A3PNC8Cm2-ZquwNyVyvnwW1gs6u-nGictyhs,840
 QuizGenerator/__main__.py,sha256=Dd9w4R0Unm3RiXztvR4Y_g9-lkWp6FHg-4VN50JbKxU,151
 QuizGenerator/constants.py,sha256=AO-UWwsWPLb1k2JW6KP8rl9fxTcdT0rW-6XC6zfnDOs,4386
-QuizGenerator/contentast.py,sha256=3yvgtpw4ZSN9Cxfiq7QncT0JMoLoX4XuQ57GeIkfRj8,64171
+QuizGenerator/contentast.py,sha256=Em4cnA64Y8_07VruJk_MXwiWcJwqT4-YVf-Lw7uIvYY,68327
 QuizGenerator/generate.py,sha256=o2XezoSE0u-qjxYu1_Ofm9Lpkza7M2Tg47C-ClMcPsE,7197
 QuizGenerator/logging.yaml,sha256=VJCdh26D8e_PNUs4McvvP1ojz9EVjQNifJzfhEk1Mbo,1114
-QuizGenerator/misc.py,sha256=HE6B49IQ4E2EdAIO2yprlluVRS5dtWtFsiIkk68zY2E,16125
-QuizGenerator/mixins.py,sha256=RjV76C1tkTLSvhSoMys67W7UmR6y6wAAcBM2Msxdpd0,18186
+QuizGenerator/misc.py,sha256=JYv-SUn3y33O6grpgvRWRBkJi4RhTuXcMgrhmBjRbZg,18710
+QuizGenerator/mixins.py,sha256=zUKTkswq7aoDZ_nGPUdRuvnza8iH8ZCi6IH2Uw-kCvs,18492
 QuizGenerator/performance.py,sha256=CM3zLarJXN5Hfrl4-6JRBqD03j4BU1B2QW699HAr1Ds,7002
 QuizGenerator/qrcode_generator.py,sha256=S3mzZDk2UiHiw6ipSCpWPMhbKvSRR1P5ordZJUTo6ug,10776
-QuizGenerator/question.py,sha256=c72zJMoUGH-Io7XVaR1kLBzlW_s-0W0_XeMy9gbIuIg,26004
-QuizGenerator/quiz.py,sha256=wOuj_mDfdnUNHlAEAcLUZoH-JX57RovLoYW4mA0GgPc,18762
+QuizGenerator/question.py,sha256=uxDYyrq17JFXQ11S03Px5cyRuPYn4qKT3z7TZn9XSjg,26093
+QuizGenerator/quiz.py,sha256=toPodXea2UYGgAf4jyor3Gz-gtXYN1YUJFJFQ5u70v4,18718
 QuizGenerator/typst_utils.py,sha256=XtMEO1e4_Tg0G1zR9D1fmrYKlUfHenBPdGoCKR0DhZg,3154
 QuizGenerator/canvas/__init__.py,sha256=TwFP_zgxPIlWtkvIqQ6mcvBNTL9swIH_rJl7DGKcvkQ,286
 QuizGenerator/canvas/canvas_interface.py,sha256=wsEWh2lonUMgmbtXF-Zj59CAM_0NInoaERqsujlYMfc,24501
@@ -20,10 +20,10 @@ QuizGenerator/premade_questions/basic.py,sha256=wAvVZED6a7VToIvSCdAx6SrExmR0xVRo
 QuizGenerator/premade_questions/cst334/__init__.py,sha256=BTz-Os1XbwIRKqAilf2UIva2NlY0DbA_XbSIggO2Tdk,36
 QuizGenerator/premade_questions/cst334/languages.py,sha256=N5vcmZi-AFM_BZypnvNogHD7s--28-j-8tykYg6CBzs,14388
 QuizGenerator/premade_questions/cst334/math_questions.py,sha256=za8lNqhM0RB8qefmPP-Ww0WB_SQn0iRcBKOrZgyHCQQ,9290
-QuizGenerator/premade_questions/cst334/memory_questions.py,sha256=QhCALX7nzq_moLnkok4JVNO4crtmJnosg7_xOZL_5-c,51597
+QuizGenerator/premade_questions/cst334/memory_questions.py,sha256=B4hpnMliJY-x65hNbjwbf22m-jiTi3WEXmauKv_YA84,51598
 QuizGenerator/premade_questions/cst334/ostep13_vsfs.py,sha256=d9jjrynEw44vupAH_wKl57UoHooCNEJXaC5DoNYualk,16163
 QuizGenerator/premade_questions/cst334/persistence_questions.py,sha256=em-HzFRnaroDmHl5uA771HyFMI7dMvG-gxTgsB3ecaY,14458
-QuizGenerator/premade_questions/cst334/process.py,sha256=C7-FzOGW7EzQHXZNKden7eHo1NoG0UQbci0ZrUtybzs,23732
+QuizGenerator/premade_questions/cst334/process.py,sha256=EB0iuT9Q8FfOnmlQoXL7gkfsPyVJP55cRFOe2mWfamc,23647
 QuizGenerator/premade_questions/cst463/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 QuizGenerator/premade_questions/cst463/gradient_descent/__init__.py,sha256=sH2CUV6zK9FT3jWTn453ys6_JTrUKRtZnU8hK6RmImU,240
 QuizGenerator/premade_questions/cst463/gradient_descent/gradient_calculation.py,sha256=ssj6Xkpw6vDiL4qwVOiHUhly3TX50oX4KJtouj7qN6g,12809
@@ -33,12 +33,19 @@ QuizGenerator/premade_questions/cst463/gradient_descent/misc.py,sha256=iB3obG6-u
 QuizGenerator/premade_questions/cst463/math_and_data/__init__.py,sha256=EbIaUrx7_aK9j3Gd8Mk08h9GocTq_0OoNu2trfNwaU8,202
 QuizGenerator/premade_questions/cst463/math_and_data/matrix_questions.py,sha256=sq27xv7X9aa0axFxomusZRwM-ICj9grbhD_Bv3n3gJg,28947
 QuizGenerator/premade_questions/cst463/math_and_data/vector_questions.py,sha256=tNxfR6J1cZHsHG9GfwVyl6lxxN_TEnhKDmMq4aVLwow,20793
+QuizGenerator/premade_questions/cst463/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+QuizGenerator/premade_questions/cst463/models/attention.py,sha256=i8h6DihzJTc_QFrdm1eaYhnuhlXKRUv_vIDg3jk_LZ8,5502
+QuizGenerator/premade_questions/cst463/models/cnns.py,sha256=iNuQmHgd8kwAXaofTwidal6pZum31r21UP3XERspE0M,5774
+QuizGenerator/premade_questions/cst463/models/matrices.py,sha256=H61_8cF1DGCt4Z4Ssoi4SMClf6tD5wHkOqY5bMdsSt4,699
+QuizGenerator/premade_questions/cst463/models/rnns.py,sha256=-tXeGgqPkctBBUy4RvEPqhv2kfPqoyO2wk-lNJLNWmY,6697
+QuizGenerator/premade_questions/cst463/models/text.py,sha256=T1cmaoxNcWK1UbytFQmweL_Nmkm5ONq1m6F4AIJdmdc,6284
+QuizGenerator/premade_questions/cst463/models/weight_counting.py,sha256=A2ZVyodfibAWQg9-KraT1cCPTLXRWy5vNSqL0GWexXg,6784
 QuizGenerator/premade_questions/cst463/neural-network-basics/__init__.py,sha256=pmyCezO-20AFEQC6MR7KnAsaU9TcgZYsGQOMVkRZ-U8,149
-QuizGenerator/premade_questions/cst463/neural-network-basics/neural_network_questions.py,sha256=7ZtCQ2fXhIPSd99TstQfOKCN13GJE_56UfBQKdmzmMI,42398
+QuizGenerator/premade_questions/cst463/neural-network-basics/neural_network_questions.py,sha256=pyTSvibCaLuT0LnYAZfjUoZlzywaPWWAaSZ5VepH04E,44148
 QuizGenerator/premade_questions/cst463/tensorflow-intro/__init__.py,sha256=G1gEHtG4KakYgi8ZXSYYhX6bQRtnm2tZVGx36d63Nmo,173
 QuizGenerator/premade_questions/cst463/tensorflow-intro/tensorflow_questions.py,sha256=dPn8Sj0yk4m02np62esMKZ7CvcljhYq3Tq51nY9aJnA,29781
-quizgenerator-0.1.4.dist-info/METADATA,sha256=ebekoIHR35xPw-W6sVVHxD1xQulJioslbCYtT8uCfiE,7149
-quizgenerator-0.1.4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-quizgenerator-0.1.4.dist-info/entry_points.txt,sha256=iViWMzswXGe88WKoue_Ib-ODUSiT_j_6f1us28w9pkc,56
-quizgenerator-0.1.4.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-quizgenerator-0.1.4.dist-info/RECORD,,
+quizgenerator-0.3.0.dist-info/METADATA,sha256=qLE6mR5zXwWdFv5HYskA4KLgnya7VVRh85a7AY8lDRg,7212
+quizgenerator-0.3.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+quizgenerator-0.3.0.dist-info/entry_points.txt,sha256=iViWMzswXGe88WKoue_Ib-ODUSiT_j_6f1us28w9pkc,56
+quizgenerator-0.3.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+quizgenerator-0.3.0.dist-info/RECORD,,

{quizgenerator-0.1.4.dist-info → quizgenerator-0.3.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any