QuizGenerator 0.7.1__py3-none-any.whl → 0.8.0__py3-none-any.whl

QuizGenerator/premade_questions/cst463/gradient_descent/gradient_calculation.py

@@ -21,6 +21,16 @@ class DerivativeQuestion(Question, abc.ABC):
     self.num_variables = kwargs.get("num_variables", 2)
     self.max_degree = kwargs.get("max_degree", 2)
 
+  def _build_context(self, *, rng_seed=None, **kwargs):
+    if "num_variables" in kwargs:
+      self.num_variables = kwargs.get("num_variables", self.num_variables)
+    if "max_degree" in kwargs:
+      self.max_degree = kwargs.get("max_degree", self.max_degree)
+    self.rng.seed(rng_seed)
+    context = dict(kwargs)
+    context["rng_seed"] = rng_seed
+    return context
+
   def _generate_evaluation_point(self) -> List[float]:
     """Generate a random point for gradient evaluation."""
     return [self.rng.randint(-3, 3) for _ in range(self.num_variables)]
@@ -32,9 +42,9 @@ class DerivativeQuestion(Question, abc.ABC):
     else:
       return f"\\frac{{\\partial f}}{{\\partial x_{var_index}}}"
 
-  def _create_derivative_answers(self, evaluation_point: List[float]) -> None:
+  def _create_derivative_answers(self, evaluation_point: List[float]) -> List[ca.Answer]:
     """Create answer fields for each partial derivative at the evaluation point."""
-    self.answers = {}
+    answers: List[ca.Answer] = []
 
     # Evaluate gradient at the specified point
     subs_map = dict(zip(self.variables, evaluation_point))
@@ -57,9 +67,11 @@ class DerivativeQuestion(Question, abc.ABC):
       # Use auto_float for Canvas compatibility with integers and decimals
       # Label includes the partial derivative notation
       label = f"∂f/∂x_{i} at ({eval_point_str})"
-      self.answers[answer_key] = ca.AnswerTypes.Float(gradient_value, label=label)
+      answers.append(ca.AnswerTypes.Float(gradient_value, label=label))
+
+    return answers
 
-  def _create_gradient_vector_answer(self) -> None:
+  def _create_gradient_vector_answer(self) -> ca.Answer:
     """Create a single gradient vector answer for PDF format."""
     # Format gradient as vector notation
     subs_map = dict(zip(self.variables, self.evaluation_point))
@@ -75,9 +87,9 @@ class DerivativeQuestion(Question, abc.ABC):
 
     # Format as vector for display using consistent formatting
     vector_str = format_vector(gradient_values)
-    self.answers["gradient_vector"] = ca.AnswerTypes.String(vector_str, pdf_only=True)
+    return ca.AnswerTypes.String(vector_str, pdf_only=True)
 
-  def _get_body(self, **kwargs) -> Tuple[ca.Section, List[ca.Answer]]:
+  def _build_body(self, context) -> Tuple[ca.Section, List[ca.Answer]]:
     """Build question body and collect answers."""
     body = ca.Section()
     answers = []
@@ -109,8 +121,8 @@ class DerivativeQuestion(Question, abc.ABC):
     )
 
     # For Canvas: Use OnlyHtml to show individual partial derivatives
-    for i in range(self.num_variables):
-      answer = self.answers[f"partial_derivative_{i}"]
+    derivative_answers = self._create_derivative_answers(self.evaluation_point)
+    for i, answer in enumerate(derivative_answers):
       answers.append(answer)
       body.add_element(
         ca.OnlyHtml([
@@ -126,12 +138,7 @@ class DerivativeQuestion(Question, abc.ABC):
 
     return body, answers
 
-  def get_body(self, **kwargs) -> ca.Section:
-    """Build question body (backward compatible interface)."""
-    body, _ = self._get_body(**kwargs)
-    return body
-
-  def _get_explanation(self, **kwargs) -> Tuple[ca.Section, List[ca.Answer]]:
+  def _build_explanation(self, context) -> Tuple[ca.Section, List[ca.Answer]]:
     """Build question explanation."""
     explanation = ca.Section()
 
@@ -182,18 +189,13 @@ class DerivativeQuestion(Question, abc.ABC):
 
     return explanation, []
 
-  def get_explanation(self, **kwargs) -> ca.Section:
-    """Build question explanation (backward compatible interface)."""
-    explanation, _ = self._get_explanation(**kwargs)
-    return explanation
-
 
 @QuestionRegistry.register("DerivativeBasic")
 class DerivativeBasic(DerivativeQuestion):
   """Basic derivative calculation using polynomial functions."""
 
-  def refresh(self, rng_seed=None, *args, **kwargs):
-    super().refresh(rng_seed=rng_seed, *args, **kwargs)
+  def _build_context(self, *, rng_seed=None, **kwargs):
+    super()._build_context(rng_seed=rng_seed, **kwargs)
 
     # Generate a basic polynomial function
     self.variables, self.function, self.gradient_function, self.equation = generate_function(
@@ -203,19 +205,20 @@ class DerivativeBasic(DerivativeQuestion):
     # Generate evaluation point
     self.evaluation_point = self._generate_evaluation_point()
 
-    # Create answers
+    # Create answers for evaluation point (used in _build_body)
     self._create_derivative_answers(self.evaluation_point)
 
-    # For PDF: Create single gradient vector answer
-    self._create_gradient_vector_answer()
+    context = dict(kwargs)
+    context["rng_seed"] = rng_seed
+    return context
 
 
 @QuestionRegistry.register("DerivativeChain")
 class DerivativeChain(DerivativeQuestion):
   """Chain rule derivative calculation using function composition."""
 
-  def refresh(self, rng_seed=None, *args, **kwargs):
-    super().refresh(rng_seed=rng_seed, *args, **kwargs)
+  def _build_context(self, *, rng_seed=None, **kwargs):
+    super()._build_context(rng_seed=rng_seed, **kwargs)
 
     # Try to generate a valid function/point combination, regenerating if we hit complex numbers
     max_attempts = 10
@@ -230,9 +233,6 @@ class DerivativeChain(DerivativeQuestion):
         # Create answers - this will raise ValueError if we get complex numbers
         self._create_derivative_answers(self.evaluation_point)
 
-        # For PDF: Create single gradient vector answer
-        self._create_gradient_vector_answer()
-
         # If we get here, everything worked
         break
 
@@ -245,6 +245,10 @@ class DerivativeChain(DerivativeQuestion):
           # If we've exhausted attempts or different error, re-raise
           raise
 
+    context = dict(kwargs)
+    context["rng_seed"] = rng_seed
+    return context
+
   def _generate_composed_function(self) -> None:
     """Generate a composed function f(g(x)) for chain rule practice."""
     # Create variable symbols
@@ -284,7 +288,7 @@ class DerivativeChain(DerivativeQuestion):
     f = sp.Function('f')
     self.equation = sp.Eq(f(*self.variables), self.function)
 
-  def _get_explanation(self, **kwargs) -> Tuple[ca.Section, List[ca.Answer]]:
+  def _build_explanation(self, context) -> Tuple[ca.Section, List[ca.Answer]]:
     """Build question explanation."""
     explanation = ca.Section()
 
@@ -388,8 +392,3 @@ class DerivativeChain(DerivativeQuestion):
       )
 
     return explanation, []
-
-  def get_explanation(self, **kwargs) -> ca.Section:
-    """Build question explanation (backward compatible interface)."""
-    explanation, _ = self._get_explanation(**kwargs)
-    return explanation

QuizGenerator/premade_questions/cst463/gradient_descent/gradient_descent_questions.py

@@ -17,7 +17,7 @@ log = logging.getLogger(__name__)
 
 # Note: This file does not use ca.Answer wrappers - it uses TableQuestionMixin
 # which handles answer display through create_answer_table(). The answers are created
-# with labels embedded at creation time in refresh().
+# with labels embedded at creation time in _build_context().
 
 
 class GradientDescentQuestion(Question, abc.ABC):
@@ -75,40 +75,55 @@ class GradientDescentWalkthrough(GradientDescentQuestion, TableQuestionMixin, Bo
 
     return results
 
-  def refresh(self, rng_seed=None, *args, **kwargs):
-    super().refresh(rng_seed=rng_seed, *args, **kwargs)
-    
+  def _build_context(self, *, rng_seed=None, **kwargs):
+    if "num_steps" in kwargs:
+      self.num_steps = kwargs.get("num_steps", self.num_steps)
+    if "num_variables" in kwargs:
+      self.num_variables = kwargs.get("num_variables", self.num_variables)
+    if "max_degree" in kwargs:
+      self.max_degree = kwargs.get("max_degree", self.max_degree)
+    if "single_variable" in kwargs:
+      self.single_variable = kwargs.get("single_variable", self.single_variable)
+      if self.single_variable:
+        self.num_variables = 1
+    if "minimize" in kwargs:
+      self.minimize = kwargs.get("minimize", self.minimize)
+
+    self.rng.seed(rng_seed)
+
     # Generate function and its properties
     self.variables, self.function, self.gradient_function, self.equation = generate_function(self.rng, self.num_variables, self.max_degree)
-    
+
     # Generate learning rate (expanded range)
     self.learning_rate = self.rng.choice([0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5])
-    
+
     self.starting_point = [self.rng.randint(-3, 3) for _ in range(self.num_variables)]
-    
+
     # Perform gradient descent
     self.gradient_descent_results = self._perform_gradient_descent()
-    
-    # Set up answers
-    self.answers = {}
 
-    # Answers for each step
+    # Build answers for each step
+    self.step_answers = {}
     for i, result in enumerate(self.gradient_descent_results):
       step = result['step']
 
       # Location answer
       location_key = f"answer__location_{step}"
-      self.answers[location_key] = ca.AnswerTypes.Vector(list(result['location']), label=f"Location at step {step}")
+      self.step_answers[location_key] = ca.AnswerTypes.Vector(list(result['location']), label=f"Location at step {step}")
 
       # Gradient answer
       gradient_key = f"answer__gradient_{step}"
-      self.answers[gradient_key] = ca.AnswerTypes.Vector(list(result['gradient']), label=f"Gradient at step {step}")
+      self.step_answers[gradient_key] = ca.AnswerTypes.Vector(list(result['gradient']), label=f"Gradient at step {step}")
 
       # Update answer
       update_key = f"answer__update_{step}"
-      self.answers[update_key] = ca.AnswerTypes.Vector(list(result['update']), label=f"Update at step {step}")
+      self.step_answers[update_key] = ca.AnswerTypes.Vector(list(result['update']), label=f"Update at step {step}")
+
+    context = dict(kwargs)
+    context["rng_seed"] = rng_seed
+    return context
   
-  def _get_body(self, **kwargs) -> Tuple[ca.Section, List[ca.Answer]]:
+  def _build_body(self, context) -> Tuple[ca.Section, List[ca.Answer]]:
     """Build question body and collect answers."""
     body = ca.Section()
     answers = []
@@ -147,20 +162,20 @@ class GradientDescentWalkthrough(GradientDescentQuestion, TableQuestionMixin, Bo
 
         # Fill in starting location for first row with default formatting
         row["location"] = f"{format_vector(self.starting_point)}"
-        row[headers[2]] = f"answer__gradient_{step}"  # gradient column
-        row[headers[3]] = f"answer__update_{step}"  # update column
+        row[headers[2]] = self.step_answers[f"answer__gradient_{step}"]  # gradient column
+        row[headers[3]] = self.step_answers[f"answer__update_{step}"]  # update column
         # Collect answers for this step (no location answer for step 1)
-        answers.append(self.answers[f"answer__gradient_{step}"])
-        answers.append(self.answers[f"answer__update_{step}"])
+        answers.append(self.step_answers[f"answer__gradient_{step}"])
+        answers.append(self.step_answers[f"answer__update_{step}"])
       else:
         # Subsequent rows - all answer fields
-        row["location"] = f"answer__location_{step}"
-        row[headers[2]] = f"answer__gradient_{step}"  # gradient column
-        row[headers[3]] = f"answer__update_{step}"  # update column
+        row["location"] = self.step_answers[f"answer__location_{step}"]
+        row[headers[2]] = self.step_answers[f"answer__gradient_{step}"]
+        row[headers[3]] = self.step_answers[f"answer__update_{step}"]
         # Collect all answers for this step
-        answers.append(self.answers[f"answer__location_{step}"])
-        answers.append(self.answers[f"answer__gradient_{step}"])
-        answers.append(self.answers[f"answer__update_{step}"])
+        answers.append(self.step_answers[f"answer__location_{step}"])
+        answers.append(self.step_answers[f"answer__gradient_{step}"])
+        answers.append(self.step_answers[f"answer__update_{step}"])
       table_rows.append(row)
 
     # Create the table using mixin
@@ -174,12 +189,7 @@ class GradientDescentWalkthrough(GradientDescentQuestion, TableQuestionMixin, Bo
 
     return body, answers
 
-  def get_body(self, **kwargs) -> ca.Section:
-    """Build question body (backward compatible interface)."""
-    body, _ = self._get_body(**kwargs)
-    return body
-  
-  def _get_explanation(self, **kwargs) -> Tuple[ca.Section, List[ca.Answer]]:
+  def _build_explanation(self, context) -> Tuple[ca.Section, List[ca.Answer]]:
     """Build question explanation."""
     explanation = ca.Section()
 
@@ -323,8 +333,3 @@ class GradientDescentWalkthrough(GradientDescentQuestion, TableQuestionMixin, Bo
     )
 
     return explanation, []
-
-  def get_explanation(self, **kwargs) -> ca.Section:
-    """Build question explanation (backward compatible interface)."""
-    explanation, _ = self._get_explanation(**kwargs)
-    return explanation

QuizGenerator/premade_questions/cst463/gradient_descent/loss_calculations.py

@@ -13,7 +13,7 @@ from QuizGenerator.mixins import TableQuestionMixin, BodyTemplatesMixin
 log = logging.getLogger(__name__)
 
 
-# Note: This file migrates to the _get_body()/_get_explanation() pattern
+# Note: This file migrates to the _build_body()/_build_explanation() pattern
 
 
 class LossQuestion(Question, TableQuestionMixin, BodyTemplatesMixin, abc.ABC):
@@ -35,12 +35,24 @@ class LossQuestion(Question, TableQuestionMixin, BodyTemplatesMixin, abc.ABC):
     self.individual_losses = []
     self.overall_loss = 0.0
 
-  def refresh(self, rng_seed=None, *args, **kwargs):
+  def _build_context(self, *, rng_seed=None, **kwargs):
     """Generate new random data and calculate losses."""
-    super().refresh(rng_seed=rng_seed, *args, **kwargs)
+    # Update configurable parameters if provided
+    if "num_samples" in kwargs:
+      self.num_samples = max(3, min(10, kwargs.get("num_samples", self.num_samples)))
+    if "num_input_features" in kwargs:
+      self.num_input_features = max(1, min(5, kwargs.get("num_input_features", self.num_input_features)))
+    if "vector_inputs" in kwargs:
+      self.vector_inputs = kwargs.get("vector_inputs", self.vector_inputs)
+
+    # Seed RNG and generate data
+    self.rng.seed(rng_seed)
     self._generate_data()
     self._calculate_losses()
-    self._create_answers()
+
+    context = dict(kwargs)
+    context["rng_seed"] = rng_seed
+    return context
 
   @abc.abstractmethod
   def _generate_data(self):
@@ -67,18 +79,15 @@ class LossQuestion(Question, TableQuestionMixin, BodyTemplatesMixin, abc.ABC):
     """Return the short name of the loss function (used in question body)."""
     pass
 
-  def _create_answers(self):
-    """Create answer objects for individual losses and overall loss."""
-    self.answers = {}
-
-    # Individual loss answers
-    for i in range(self.num_samples):
-      self.answers[f"loss_{i}"] = ca.AnswerTypes.Float(self.individual_losses[i], label=f"Sample {i + 1} loss")
-
-    # Overall loss answer
-    self.answers["overall_loss"] = ca.AnswerTypes.Float(self.overall_loss, label="Overall loss")
+  def _build_loss_answers(self) -> Tuple[List[ca.Answer], ca.Answer]:
+    answers = [
+      ca.AnswerTypes.Float(self.individual_losses[i], label=f"Sample {i + 1} loss")
+      for i in range(self.num_samples)
+    ]
+    overall = ca.AnswerTypes.Float(self.overall_loss, label="Overall loss")
+    return answers, overall
 
-  def _get_body(self, **kwargs) -> Tuple[ca.Element, List[ca.Answer]]:
+  def _build_body(self, context) -> Tuple[ca.Element, List[ca.Answer]]:
     """Build question body and collect answers."""
     body = ca.Section()
     answers = []
@@ -90,32 +99,25 @@ class LossQuestion(Question, TableQuestionMixin, BodyTemplatesMixin, abc.ABC):
     ]))
 
     # Data table (contains individual loss answers)
-    body.add_element(self._create_data_table())
-
-    # Collect individual loss answers
-    for i in range(self.num_samples):
-      answers.append(self.answers[f"loss_{i}"])
+    loss_answers, overall_answer = self._build_loss_answers()
+    body.add_element(self._create_data_table(loss_answers))
+    answers.extend(loss_answers)
 
     # Overall loss question
     body.add_element(ca.Paragraph([
       f"Overall {self._get_loss_function_short_name()}: "
     ]))
-    answers.append(self.answers["overall_loss"])
-    body.add_element(self.answers["overall_loss"])
+    answers.append(overall_answer)
+    body.add_element(overall_answer)
 
     return body, answers
 
-  def get_body(self, **kwargs) -> ca.Element:
-    """Build question body (backward compatible interface)."""
-    body, _ = self._get_body(**kwargs)
-    return body
-
   @abc.abstractmethod
-  def _create_data_table(self) -> ca.Element:
+  def _create_data_table(self, loss_answers: List[ca.Answer]) -> ca.Element:
     """Create the data table with answer fields."""
     pass
 
-  def _get_explanation(self, **kwargs) -> Tuple[ca.Element, List[ca.Answer]]:
+  def _build_explanation(self, context) -> Tuple[ca.Element, List[ca.Answer]]:
     """Build question explanation."""
     explanation = ca.Section()
 
@@ -137,11 +139,6 @@ class LossQuestion(Question, TableQuestionMixin, BodyTemplatesMixin, abc.ABC):
 
     return explanation, []
 
-  def get_explanation(self, **kwargs) -> ca.Element:
-    """Build question explanation (backward compatible interface)."""
-    explanation, _ = self._get_explanation(**kwargs)
-    return explanation
-
   @abc.abstractmethod
   def _create_calculation_steps(self) -> ca.Element:
     """Create step-by-step calculation explanations."""
@@ -167,6 +164,11 @@ class LossQuestion_Linear(LossQuestion):
     self.num_output_vars = max(1, min(5, self.num_output_vars))  # Constrain to 1-5 range
     super().__init__(*args, **kwargs)
 
+  def _build_context(self, *, rng_seed=None, **kwargs):
+    if "num_output_vars" in kwargs:
+      self.num_output_vars = max(1, min(5, kwargs.get("num_output_vars", self.num_output_vars)))
+    return super()._build_context(rng_seed=rng_seed, **kwargs)
+
   def _generate_data(self):
     """Generate regression data with continuous target values."""
     self.data = []
@@ -225,7 +227,7 @@ class LossQuestion_Linear(LossQuestion):
     else:
       return r"L(\mathbf{y}, \mathbf{p}) = \sum_{i=1}^{k} (y_i - p_i)^2"
 
-  def _create_data_table(self) -> ca.Element:
+  def _create_data_table(self, loss_answers: List[ca.Answer]) -> ca.Element:
     """Create table with input features, true values, predictions, and loss fields."""
     headers = ["x"]
 
@@ -262,7 +264,7 @@ class LossQuestion_Linear(LossQuestion):
           row[f"p_{j}"] = f"{sample['predictions'][j]:.2f}"
 
       # Loss answer field
-      row["loss"] = self.answers[f"loss_{i}"]
+      row["loss"] = loss_answers[i]
 
       rows.append(row)
 
@@ -416,7 +418,7 @@ class LossQuestion_Logistic(LossQuestion):
   def _get_loss_function_formula(self) -> str:
     return r"L(y, p) = -[y \ln(p) + (1-y) \ln(1-p)]"
 
-  def _create_data_table(self) -> ca.Element:
+  def _create_data_table(self, loss_answers: List[ca.Answer]) -> ca.Element:
     """Create table with features, true labels, predicted probabilities, and loss fields."""
     headers = ["x", "y", "p", "loss"]
 
@@ -435,7 +437,7 @@ class LossQuestion_Logistic(LossQuestion):
       row["p"] = f"{sample['predictions']:.3f}"
 
       # Loss answer field
-      row["loss"] = self.answers[f"loss_{i}"]
+      row["loss"] = loss_answers[i]
 
       rows.append(row)
 
@@ -511,6 +513,11 @@ class LossQuestion_MulticlassLogistic(LossQuestion):
     self.num_classes = max(3, min(5, self.num_classes))  # Constrain to 3-5 classes
     super().__init__(*args, **kwargs)
 
+  def _build_context(self, *, rng_seed=None, **kwargs):
+    if "num_classes" in kwargs:
+      self.num_classes = max(3, min(5, kwargs.get("num_classes", self.num_classes)))
+    return super()._build_context(rng_seed=rng_seed, **kwargs)
+
   def _generate_data(self):
     """Generate multi-class classification data."""
     self.data = []
@@ -560,7 +567,7 @@ class LossQuestion_MulticlassLogistic(LossQuestion):
   def _get_loss_function_formula(self) -> str:
     return r"L(\mathbf{y}, \mathbf{p}) = -\sum_{i=1}^{K} y_i \ln(p_i)"
 
-  def _create_data_table(self) -> ca.Element:
+  def _create_data_table(self, loss_answers: List[ca.Answer]) -> ca.Element:
     """Create table with features, true class vectors, predicted probabilities, and loss fields."""
     headers = ["x", "y", "p", "loss"]
 
@@ -581,7 +588,7 @@ class LossQuestion_MulticlassLogistic(LossQuestion):
       row["p"] = p_vector
 
       # Loss answer field
-      row["loss"] = self.answers[f"loss_{i}"]
+      row["loss"] = loss_answers[i]
 
       rows.append(row)
 
@@ -666,4 +673,4 @@ class LossQuestion_MulticlassLogistic(LossQuestion):
 
     explanation.add_element(ca.Equation(calculation, inline=False))
 
-    return explanation
+    return explanation