Train the operator,
not the engineer.

I'm working in a Colab notebook. I have a Hugging Face `ASTForAudioClassification` checkpoint trained on 16 audio classes, loaded from a local folder. I must extend it to 29 classes (16 old + 13 new) and fine-tune on ~10 GPU minutes without forgetting the old classes. Data: `train.csv` (old classes) and `fine_tune.csv` (new classes), columns include filepath, target, split. Metric: mean of old-class accuracy and new-class accuracy.

Write code that replaces the model's 16-output classifier head with a 29-output head, copying the original 16 rows of weights and bias into the first 16 outputs and randomly initializing the rest. Code only, max 30 lines. Reply with ONLY a single python code block — no explanation, no reasoning, no bullet points.

Write a PyTorch Dataset that loads both CSVs' train splits into one dataframe, loads each audio file with librosa at 16 kHz, and returns the AST feature extractor's output plus the integer label. Code only, max 30 lines. Reply with ONLY a single python code block — no explanation, no reasoning, no bullet points.

Write a training loop (AdamW, lr 1e-5 for the encoder and 1e-3 for the head, ~3 epochs, batch size 8) over a mix of ALL new-class training clips and an equal number of randomly sampled old-class clips per epoch, so the model learns new classes without forgetting old ones. Code only, max 30 lines. Reply with ONLY a single python code block — no explanation, no reasoning, no bullet points.

Write evaluation code that predicts on the val splits of both CSVs and prints accuracy on old classes (targets 0-15), accuracy on new classes (targets 16-28), and their mean. Code only, max 30 lines. Reply with ONLY a single python code block — no explanation, no reasoning, no bullet points.

Write code that runs the model on every filepath listed in the Kaggle `submission.csv`, writes the predicted class index into its target column, and saves it. Code only, max 30 lines. Reply with ONLY a single python code block — no explanation, no reasoning, no bullet points.

You are my code generator inside a Colab session. Standing rule for EVERY reply in this chat: output ONLY one python code block and absolutely nothing else — no reasoning, no bullet points, no checklists, no text before or after the block. Start your reply with ```python.

Context: I'm working in the IOAI Colab notebook "The Analytical Language of John Wilkins". A hidden animal sits behind an oracle object: `interactor.ask(question)` returns 'yes' or 'no' (the question must be a line from the question pool), `interactor.guess(animal)` returns 'correct' or 'wrong'; BOTH cost 1 query from a budget of 15; per-row score = max(0, (1 if solved else 0) - 0.02*queries_used). I have `animals_pool` (list of 1472 lowercase animal names) and `questions_pool` (list of 559 lowercase yes/no questions). The oracle is Qwen/Qwen2.5-3B-Instruct at temperature 0, already loaded in memory as `Interactor._model` (a Hugging Face CausalLM on cuda, float16) and `Interactor._tokenizer`. For each question it builds this exact user message: "You are answering a question about one specific animal.\nThe animal is: {animal}.\nAnswer with a single word, yes or no.\nQuestion: {question}", applies the chat template with add_generation_prompt=True, generates with max_new_tokens=5, do_sample=False, and checks whether the reply starts with "yes".

Your reply must be nothing but one python code block. Write a function `predict_answers(animal, questions)` that predicts the oracle's answers using the already-loaded `Interactor._model` and `Interactor._tokenizer`: build the exact prompt described above for each question, apply the chat template per prompt (tokenize=False, add_generation_prompt=True), set tokenizer.padding_side='left', tokenize all prompts as one padded batch, run ONE batched `generate(max_new_tokens=5, do_sample=False, pad_token_id=tokenizer.eos_token_id)`, decode only the newly generated tokens, and return a list with 1 if a reply starts with "yes" (case-insensitive) else 0, one per question. Code only, max 30 lines. Reply with ONLY a single python code block — no explanation, no reasoning, no bullet points.

QUESTIONS = questions_pool[:120]

I defined `QUESTIONS = questions_pool[:120]` and I have the `predict_answers(animal, questions)` function from before. Write code that builds a numpy int8 array `table` of shape (len(animals_pool), len(QUESTIONS)), one row per animal in animals_pool order, by calling `predict_answers(animal, QUESTIONS)`. It must mount Google Drive, use checkpoint path '/content/drive/MyDrive/wilkins_table.npz': if the file exists, load it and resume from the first unfinished row (store a `done` count in the file); save the checkpoint every 25 animals and at the end; print progress with elapsed time every 25 animals. Code only, max 30 lines. Your ENTIRE reply must be exactly one python code block starting with ```python — no text, no bullet points, no reasoning before or after it.

Answer immediately with code — do not deliberate. I have two globals in memory: `QUESTIONS` (a 120-question subset of questions_pool) and `table` (numpy 0/1 array of shape (len(animals_pool), len(QUESTIONS)): rows = animals in `animals_pool` order, columns = QUESTIONS, values = the oracle's predicted answers). Write class `MySolution` with `__init__(self, animals_pool, questions_pool)` and `solve(self, interactor)` implementing exactly this:
1. weights w = numpy ones(len(animals_pool)).
2. While `interactor.remaining_budget()` > 4 and best weight < 0.9 * w.sum(): loop j over range(len(QUESTIONS)) (the global QUESTIONS, NOT questions_pool) and pick the unasked j minimizing abs(weighted yes-fraction of table[:, j] - 0.5); ans = 1 if interactor.ask(QUESTIONS[j]) == 'yes' else 0; w = w * where(table[:, j] == ans, 0.9, 0.1). Never zero out a weight — the oracle is sometimes wrong.
3. Then guess animals in descending weight order until `interactor.is_done()`.
Code only, max 30 lines. Reply with ONLY a single python code block — no explanation, no reasoning, no bullet points.

import numpy as np
rng = np.random.default_rng(0)
counts = []
for i in rng.integers(0, len(animals_pool), size=40):
    w = np.ones(len(animals_pool)); asked = set(); c = 0
    for _ in range(15):
        j = min((q for q in range(len(QUESTIONS)) if q not in asked),
                key=lambda q: abs((w * table[:, q]).sum() / w.sum() - 0.5))
        asked.add(j); c += 1
        w *= np.where(table[:, j] == table[i, j], 0.9, 0.1)
        if np.argmax(w) == i: break
    counts.append(c)
counts = np.array(counts)
print(f"mean {counts.mean():.1f}  max {counts.max()}  <=11 questions: {(counts <= 11).mean():.0%}")

Run the notebook's own Step 4 cell (evaluate on dev.csv — real oracle calls, ~15-30 min), then the Step 5 final-scoring cell unchanged. Screenshot the summary table with the FINAL row — that IS your submission.