Daily Learning Quiz — June 21, 2026

expert Concurrency Async, futures, thread pools, and task-based design Compare std::async, futures/promises, packaged_task, coroutines, thread pools, and work stealing at a conceptual level Oversubscription, hidden blocking, unbounded task queues, poor cancellation handlingObject Model Classes, structs, invariants, encapsulation, and constructors Design classes that preserve invariants; know explicit constructors, member initialization lists, delegating constructors, and default member initializers Two-phase initialization bugs, implicit conversions, uninitialized fields, invalid object statesDesign API design, idioms, and professional C++ style Apply const-correctness, RAII, value semantics, dependency boundaries, pImpl, noexcept where useful, minimal ownership exposure, and testable interfaces Leaky abstractions, unclear ownership, over-template APIs, inheritance where composition fits betterSelf-Supervised Learning Contrastive learning and representation learning Explain InfoNCE, positive/negative pairs, mutual-information intuition, collapse prevention, BYOL/SimSiam-style non-contrastive learning, and representation probing Shortcut augmentations, false negatives, representation collapse, high linear-probe score but poor transferNeural Nets Backpropagation and automatic differentiation Explain reverse-mode AD, computation graphs, vector-Jacobian products, stop-gradient, detach, checkpointing, and gradient accumulation Accidental graph break, double backward memory explosion, incorrect detach, gradients all-reduced or scaled twiceSequence Modeling Tokenization, embeddings, language modeling, and autoregressive training Understand BPE/SentencePiece-style tokenization, next-token prediction, teacher forcing, exposure bias, perplexity, and sequence-level evaluation Tokenization artifacts, train-inference mismatch, low perplexity but poor generation, length bias

Answer all questions, then submit once at the bottom. Correct answers, explanations, and the model's ideal short answers are revealed only after you submit.

Section 1 · Multiple choice

0/30 answered

You have a thread pool with a fixed number of threads. Tasks are submitted to a shared queue. Each task may itself submit new tasks and wait for their completion via future::get(). What is the most likely cause of a deadlock?

A One task blocks on a future whose continuation is waiting for a thread in the same pool, while all threads are busy waiting on nested futures. B The task queue is unbounded, causing memory exhaustion that halts threads. C The futures use std::launch::async, creating too many threads. D The thread pool uses work stealing, which corrupts the queue state.

Consider a class that manages two resources and must maintain an invariant that both are either acquired or not. You provide a move constructor. Which of the following is the best practice to preserve the invariant?

A In the move constructor, transfer ownership of both resources to the new object, then set the source object's resource handles to a valid 'empty' state that satisfies the invariant. B Use std::move on each member individually; the default move constructor will handle the invariant correctly if members are RAII types. C Implement move assignment only, and have the move constructor call move assignment with a default-constructed object. D Avoid move operations entirely; rely on copy-and-swap to simulate move semantics.

You refactor a class to use the pImpl idiom with std::unique_ptr. The implementation file fully defines Impl. The header declares class Foo { ~Foo(); ... }; but the destructor is not defined inline. What is the primary reason for requiring an explicit destructor declaration in the header?

A Without an explicit destructor declaration, the compiler-generated destructor would attempt to delete Impl* in the header where Impl is incomplete, causing a compilation error. B The unique_ptr requires a custom deleter that must be declared in the header. C To prevent double deletion when the class is copied. D To ensure the vtable is emitted in the implementation file.

BYOL (Bootstrap Your Own Latent) learns representations without negative pairs. Which of the following best explains why it avoids collapse to a constant representation?

A The online network is updated via gradient descent, while the target network is an exponential moving average; a predictor on top of the online network breaks symmetry, and stop-gradient prevents a trivial solution where both networks output identical constants. B It uses a large memory bank of negative samples stored from previous iterations. C The loss function explicitly maximizes the distance between different views of the same image. D Batch normalization in the projector network inherently adds noise that prevents collapse.

In training a large transformer with gradient checkpointing, you notice that memory usage decreased but training time increased. What is the primary reason for the increased time?

A The backward pass recomputes intermediate activations that were not stored during the forward pass, increasing the total FLOPs. B The optimizer requires multiple backward passes per step. C The batch size had to be reduced to fit in memory, decreasing parallelism. D Checkpointing introduces synchronization barriers that serialize operations.

An autoregressive language model achieves very low perplexity on the validation set but generates gibberish or highly repetitive text during sampling. What is the most plausible explanation?

A Exposure bias caused by the discrepancy between teacher forcing during training and autoregressive sampling at inference, leading to error accumulation. B The BPE tokenizer splits words into subwords incorrectly. C The model was trained with too high a dropout rate, causing poor dependency learning. D The softmax temperature during inference is set to 0.

The deadly triad in reinforcement learning is known to cause instability. Which of the following best explains the underlying mechanism?

A Off-policy learning and bootstrapping with function approximation can cause the Bellman backup to expand errors non-contractively, leading to divergence or oscillations. B Off-policy data is always overly correlated, causing the optimizer to get stuck. C Function approximation cannot represent the true Q-function, so the Bellman equation has no fixed point. D Bootstrapping requires infinite data to converge.

In an Actor-Critic setup for a continuous action space, the actor is trained to maximize the critic's output. Which of the following describes a typical failure mode due to an imperfect critic?

A The actor converges to actions that receive high Q-values due to the critic's systematic overestimation, but the true return is low. B The critic's gradients become zero, causing the actor to stop learning. C The actor's entropy increases uncontrollably, resulting in random actions. D The critic learns to predict the mean of the reward distribution, encouraging the actor to take only actions near the mean.

A model-based RL agent trains a dynamics model to predict next states. When planning with this model, you observe that the agent achieves high cumulative reward under the model but fails on the real system. Even one-step model prediction error is low. What is the most likely issue?

A The model's small errors compound over multi-step simulated rollouts, causing the planner to exploit discrepancies and find trajectories that are not feasible in reality. B The planner uses a different reward function than the model was trained with. C The model overfits to a single state transition, neglecting others. D The agent's policy network has too few parameters to generalize.

10.

A behavioral cloning policy is trained on teleoperated demonstrations for a block-stacking task. During deployment, the robot successfully places the first block but then makes small misalignments that snowball into a failure after a few blocks. What is the primary phenomenon?

A Compounding errors due to covariate shift: the policy encounters states not present in the demonstrations because of its own mistakes, causing further divergence. B The demonstrations only covered one block placement, so the policy cannot generalize. C The teleoperation data included too many recovery actions, confusing the policy. D The action space is too high-dimensional for neural network policies.

11.

In hierarchical whole-body control, a quadratic program (QP) solves for joint torques given prioritized tasks and constraints. A common failure mode is that the QP solver returns "infeasible". Which of the following is the most likely cause?

A Conflicting constraints: a high-priority task requires a specific joint torque, while a lower-priority task demands an opposing torque that cannot be satisfied within the joint limits simultaneously. B The QP is non-convex due to the robot's nonlinear dynamics. C The quadratic objective weights are too high, causing numeric overflow. D The nullspace projection matrix is singular.

12.

You are deploying a robot arm that performs fine assembly tasks learned via imitation learning. In the lab, it succeeds 95% of the time, but on the factory floor it fails frequently. Calibration is checked and consistent. Which evaluation metric is most critical to diagnose the discrepancy?

A Recovery rate from perturbations and the distribution of intervention triggers. B Average cycle time across all trials. C The number of successful trials with no human intervention in the last 10 attempts. D The network's training loss on the demonstration dataset.

13.

You have a thread pool implementation where tasks can enqueue new tasks. You observe that under heavy load, the latency of short tasks spikes unpredictably. Profiling shows that a few long-running tasks are not being preempted. What is the most likely architectural limitation?

A The pool uses a single shared queue with FIFO scheduling, causing head-of-line blocking where long tasks starve short tasks queued behind them. B The pool lacks work stealing, so threads idle while tasks are queued. C Tasks are submitted as std::launch::async, so too many threads compete for CPU. D The futures from nested tasks are waited on in the wrong order, causing deadlocks.

14.

You are designing a library that exposes a type-erased callback interface for event handling. Users can register any callable type. To minimize compile-time coupling and maximize runtime flexibility, which design choice is most appropriate?

A Use std::function as the public interface type, wrapping user callables internally, and employ pImpl to hide implementation details. B Require users to derive from an abstract base class and override a pure virtual method. C Template the library's core classes on the callable type and provide explicit instantiations for common types. D Store callables as raw void* with a static_cast based on a user-provided type tag.

15.

In operational-space control for a mobile manipulator, the nullspace of the main task is used to perform a secondary task (e.g., posture optimization). Yet, over time, the secondary task pushes the arm toward a joint limit. Why does this occur?

A The nullspace projector gradually introduces components that violate the joint limit constraints because projection only respects the task Jacobian, not the inequality limits. B The secondary task has a higher priority than the primary task, overriding it. C The robot's Jacobian becomes singular, causing the nullspace to disappear. D The secondary task is a repulsive potential that pushes the arm away from a desired posture.

16.

You call std::async(std::launch::async, [] { do_work(); }); and discard the returned future. Subsequently, the program appears to execute do_work() synchronously, blocking the main thread. What is the most likely explanation?

A std::async always uses deferred execution when the result is not explicitly retrieved with future::get(). B The destructor of the returned future, being the last reference to the shared state, blocks until the asynchronous task completes. C The lambda capture introduces a data race that causes the runtime to serialize execution. D std::async requires a dedicated thread pool; without one, it automatically falls back to sequential execution.

17.

Consider a class hierarchy where V is a virtual base class, B is derived virtually from V, and D is derived from B (non-virtually). In D's constructor member initializer list, both V and B are explicitly initialized. According to the C++ standard, in what order will the sub-objects be constructed?

A B, then V, then D's own members. B V, then B, then D's own members. C D's own members, then V, then B. D V, then D's own members, then B.

18.

You implement a generic container that owns a heap‑allocated array. The move constructor transfers ownership and sets the source’s pointer to null, but you forget to mark it noexcept. When a std::vector reallocates, it copies elements instead of moving them. Why does this happen, and which change will enable move semantics during reallocation?

A std::vector uses std::move_if_noexcept, which falls back to the copy constructor if the move constructor is not noexcept. Mark the move constructor noexcept. B std::vector always copies unless the move assignment is noexcept. Mark the move assignment noexcept. C std::vector requires the destructor to be noexcept to enable moves. Mark the destructor noexcept. D std::vector only moves if the type has a swap that is noexcept. Provide a noexcept swap and use it in the move constructor.

19.

In SimCLR, the NT‑Xent loss is computed over a batch of images, each augmented into two views. Training typically uses a very large batch size (e.g., 4096 or 8192). Which benefit does such a large batch size primarily provide for the quality of the learned representations?

A It dramatically increases the number of negative pairs per positive pair, making the instance discrimination task harder and improving the mutual information lower bound. B It allows the use of larger learning rates, which linearly accelerates convergence. C It reduces the memory required per sample, enabling training on consumer GPUs. D It prevents the representations from collapsing to a constant vector by introducing more gradient noise.

20.

You are training a model with DistributedDataParallel (DDP) on 4 GPUs, using gradient accumulation over 8 micro‑batches. Your loop performs loss.backward() for each micro‑batch and then calls optimizer.step() after the last one. You forget to wrap intermediate backward calls with model.no_sync() or to toggle require_backward_grad_sync. You notice the effective learning rate is much smaller than expected compared to a single‑GPU run with the same total batch size. What is the most likely reason?

A DDP automatically averages gradients across GPUs on every backward() call. Without disabling sync, the gradient is averaged once per micro‑batch, so the accumulated gradient is the average of micro‑batch gradients, reducing the magnitude by a factor equal to the number of accumulation steps. B The AllReduce operation in DDP sums gradients by default, but gradient accumulation requires averaging; the mismatch causes incorrect scaling. C The optimizer’s learning rate is automatically divided by the number of GPUs, and this scaling compounds with accumulation. D Gradients from intermediate backward calls are not cleared, so later micro‑batches ignore earlier ones, leading to an effective batch size of one micro‑batch.

21.

You train a Byte Pair Encoding (BPE) tokenizer on a multilingual dataset, then fine‑tune a decoder-only transformer for next‑token prediction. During inference with beam search, you notice that the model frequently generates tokens that, when decoded, produce garbled text with mixed scripts or partial characters. What is the most plausible cause?

A The BPE training merged subword units across language boundaries, creating ambiguous tokens that map to character sequences invalid in the target language’s encoding. B Beam search over‑penalizes long sequences, forcing the model to select the shortest possible token sequence, which fragments characters. C The teacher forcing applied during fine‑tuning causes exposure bias, leading the model to prefer token sequences never seen during training. D The language model’s perplexity is too low, signaling that it memorized the training data and now hallucinates unseen token combinations.

22.

In an off‑policy Q‑learning algorithm with linear function approximation and bootstrapping, the value estimates diverge. The environment is non‑stationary due to a changing target policy. Which component of the deadly triad is directly responsible for the instability, and what modification would most likely restore stability?

A Function approximation; replace linear features with a nonlinear deep network to increase representational capacity. B Bootstrapping; switch to Monte Carlo returns to eliminate bootstrapping from the target calculation. C Off‑policy learning; change to on‑policy SARSA with linear features to ensure data is from the target policy. D Function approximation; freeze the target network’s weights for many updates to stabilize the Bellman backup.

23.

In an Actor‑Critic algorithm for a continuous action space, the critic is updated with the reward and the next state’s value. The actor is then updated using a policy gradient that employs the critic’s Q‑value estimates for the action taken. Over several epochs, the critic’s loss decreases, but the actor’s performance plateaus. Monitoring reveals that the critic’s value estimates for expert‑like actions are significantly overestimated. Which phenomenon best explains this, and what adjustment could help?

A Critic hacking; the actor learns to exploit the critic’s errors by selecting actions in regions where the critic overestimates value. This can be mitigated by using entropy regularization on the policy. B The critic is bootstrapping, and the actor’s exploration causes out‑of‑distribution states where the critic extrapolates poorly. This is solved by increasing the replay buffer size. C The policy gradient estimator has high variance due to the continuous action space; switching to a deterministic policy gradient (DPG) would resolve the plateau. D The critic is trained with a mean‑squared error loss, which is insensitive to overestimation bias. Changing to a quantile regression loss would fix the overestimation.

24.

You train a world model on offline trajectories and use Model Predictive Control (MPC) with a learned reward function to select actions. During online evaluation, the agent achieves high return in the early steps of an episode but then suddenly performs erratic actions. Inspection shows that the planned trajectory uses states that the world model has never seen during training, leading to hallucinated high rewards. What is the root cause?

A Compounding model error: small one‑step prediction errors accumulate over the planning horizon, driving the planner to states where the model is inaccurate, and the planner exploits those inaccuracies. B The MPC horizon is too long, causing the planner to over‑optimize and ignore immediate rewards in favor of unrealistic long‑term predictions. C The reward function was trained only on offline data and does not generalize to novel states, leading to random high values for unseen states. D The world model is deterministic and cannot represent the stochasticity of the environment, so the planner misinterprets uncertainty as high reward.

25.

You train a diffusion policy for a 7‑DOF robot arm to perform a task from human teleoperated demonstrations. The policy produces smooth trajectories in open‑loop rollout but fails in closed‑loop execution: it frequently overshoots and oscillates near the goal. You used high‑frequency demonstrations (100 Hz) and the policy outputs action chunks of 10 steps. What is the most likely reason for the instability?

A Action chunking introduces a delay between state observation and action execution; the policy reacts based on outdated state, causing overcorrection. B The diffusion model denoises its output over many steps, but the robot’s controller executes each step too quickly, leading to aliasing. C The demonstrations contain imperceptible tremor that the policy learned to reproduce, which becomes magnified under feedback. D The diffusion model’s noise schedule is designed for image generation and does not respect the physics of the robot, causing erratic forces.

26.

In whole‑body control of a humanoid robot, you formulate a quadratic program (QP) that minimizes the error of multiple tasks while satisfying contact, joint limit, and torque constraints. You set a high weight on the center‑of‑mass (CoM) position task and a lower weight on the head orientation task. During execution, the robot loses balance when the head orientation correction requires a large arm movement. Why does the QP fail to maintain balance despite the high CoM weight?

A The QP solves for joint torques, and the head orientation task generates a torque that perturbs the CoM, but due to the weighted minimization, the CoM error remains small. However, the contact forces may exceed the friction cone, causing the robot to slip, which was not modeled in the QP. B The lower‑level arm controller has a faster update rate than the whole‑body QP, so it overrides the torque commands, nullifying the CoM constraint. C The head orientation task is in a higher priority than the CoM task because it appears later in the QP cost terms, so it is satisfied first, compromising balance. D The QP uses a linearized dynamics model that becomes inaccurate for large arm motions, causing the optimized torques to differ from the actual required torques to keep the CoM stable.

27.

You deploy a mobile manipulator for a long‑duration warehouse task. After three days of continuous operation, the robot’s picking success rate drops from 95% to 70%. You notice that the arm sometimes misses the grasp point by a few centimeters, and the base occasionally stops short of the expected position. The robot uses visual SLAM for localization and IMU for orientation. What is the most effective diagnostic to distinguish between calibration drift and a software performance regression?

A Re‑deploy the same software version and record the joint angle errors and base pose errors relative to fixed markers in the environment over time, comparing to the initial deployment logs. B Reboot the robot and run the same picking sequence to see if the success rate returns to 95% immediately. C Swap the robot’s end‑effector with a new one and rerun the task to see if the error persists. D Increase the lidar scan rate to improve localization and check if the error reduces.

28.

In contrastive learning, the InfoNCE loss is often interpreted as a lower bound on the mutual information (MI) between two views of the data. When you increase the number of negative samples (e.g., by using a large memory bank or a batch), the performance on downstream tasks improves up to a certain point and then plateaus. Which of the following is the most accurate explanation for this plateau?

A The InfoNCE bound becomes tight, so further increasing negatives cannot raise the MI estimate beyond the true MI between the views. B The neural network’s expressive capacity limits the mutual information that can be encoded, regardless of the bound. C With many negatives, false negatives contaminate the loss and cancel out gains from a tighter bound. D The optimization landscape becomes flatter as the loss approaches its asymptotic value, making further training ineffective.

29.

A whole-body controller for a humanoid robot uses a strict hierarchical quadratic programming (QP) formulation. The highest-priority QP enforces torque limits and a primary task (e.g., balancing), and then lower-priority tasks are solved in the nullspace of this first QP. Despite this, during fast movements, the joint torques occasionally exceed the specified limits. Which of the following is the most likely root cause?

A Joint torque limits are velocity-dependent, and the linearized bounds in the QP become inaccurate at high speeds. B The nullspace projection for lower-priority tasks can push the total torque vector outside the feasible box when the correction is added. C The hierarchical solver violates limit constraints when the first QP is infeasible, prioritizing task error over constraint satisfaction. D At high velocities, the inverse dynamics model fails to capture inertial forces, causing the computed torques to underestimate the required effort.

30.

You are implementing a C++ library that performs a lazy evaluation pipeline: a user can chain transformations on a data stream, and the actual computation is deferred until final consumption. Each transformation is a user-provided callable that is stored for later execution. You want to maximize performance and allow the user to pass lambdas that capture external state by reference. Which design strategy best balances flexibility, performance, and safety?

A Type-erase all callables via std::function to provide a uniform interface and safe copying. B Accept the callable as a forwarding reference in a function template, decay-copy it into an internal storage, and require the user to ensure the captured references remain valid. C Require users to wrap their callables in std::shared_ptr to manage lifetime, and store the shared_ptr internally. D Use std::any to store the callable and a typeid-based dispatch for invocation, with a deep copy on storage.

Section 2 · Short answer

0/10 answered

You are building a server that processes incoming requests using std::async with std::launch::async. After heavy load, the system starts thrashing due to excessive thread creation and unbounded task accumulation. Explain the problems of oversubscription and unbounded queues, then redesign the system using a fixed-size thread pool with work stealing. Describe the key components, how tasks are submitted, and how you would implement cancellation to avoid leaking resources.

Coding

You are designing a class that represents a bounded buffer for inter-thread communication. The buffer has a fixed capacity and must be safe for concurrent use by one producer and one consumer. Specify the class's data members, constructor, and the push/pop methods. Discuss how you enforce the class invariant (buffer never overflows or underflows) and what synchronization mechanism you would use. Provide a reasoning for using condition variables versus atomics versus a semaphore.

Coding

You are designing a C++ class for a reference-countered handle to a resource, similar to std::shared_ptr but with custom deleter support and support for aliasing (where the handle refers to a subobject of the controlled resource). Explain how you structure the control block, what the handle constructor/destructor do, and how you ensure thread safety for the reference count. Discuss the difference between storing a raw pointer and a pointer to the control block, and the aliasing constructor's semantics.

Coding

SimCLR uses the InfoNCE loss for contrastive learning. Derive the InfoNCE loss from the perspective of maximizing mutual information between views of the same image, and explain how the temperature parameter affects the learning dynamics. Illustrate with an example: what happens when temperature is too high or too low? How does this relate to the uniformity and tolerance properties of the representation?

When implementing a custom neural network layer in PyTorch that modifies gradients during backpropagation, explain the role of torch.autograd.Function and the forward/backward methods. Discuss the difference between saving tensors for backward, using ctx.save_for_backward, and detaching gradients. Provide an example of a layer that applies a gradient mask (randomly zeroing out some gradients) and describe potential pitfalls like accidental graph breaks and double backward memory issues.

Coding

In autoregressive language modeling with subword tokenization (e.g., BPE), the model is trained with teacher forcing to predict the next token, but during generation it must sample from its own predictions, leading to exposure bias. Explain exposure bias and how it manifests in generated text. Discuss why even though perplexity might be low, generated sequences can be repetitive or degenerate. Propose and justify a training or inference intervention to mitigate exposure bias.

The deadly triad in reinforcement learning is the combination of function approximation, bootstrapping, and off-policy learning. Explain why each of these individually is not fatal, but together they can cause catastrophic instability. Support your reasoning with a concrete example, such as a Q-learning update with a neural network on a replay buffer, and describe the mechanism of divergence (e.g., the Bellman residual iteration behaving like a non-contraction).

Critic-only methods for continuous actions (e.g., Q-learning) are limited because the greedy policy improvement requires solving max_a Q(s,a) over a continuous space, which is an expensive optimization per step. Explain how actor-critic architectures circumvent this issue by using a parameterized policy and a critic that provides gradient-based guidance. Discuss why the actor can exploit inaccuracies in the critic, and how techniques like twin critics or clipped double-Q can mitigate this.

Model-based RL can fail catastrophically when the learned dynamics model is imperfect. Describe the phenomenon of model bias and compounding rollout errors in the context of model-based planning, such as using a neural network dynamics model for model-predictive control (MPC). Explain why the planner might exploit model inaccuracies, and how Dyna-style approaches attempt to mitigate this by interleaving model-free updates. Provide a concrete scenario (e.g., a walking robot) and contrast the model-based and model-free strategies.

10.

Behavioral Cloning (BC) is popular for robot learning with teleoperated demonstrations, but it suffers from covariate shift and failure to recover from mistakes. Describe in detail how the distribution mismatch between training demonstrations and auto-regressive inference causes this, using the concept of compounding errors. Then explain how action chunking (predicting a sequence of actions) and DAGGER's interactive correction paradigm address different aspects of this problem. What are the trade-offs of action chunking in terms of reactivity and data efficiency?

0 / 40 answered