mujunxu/fda_project

FDA Reviewer-Concern Extraction — Misha Handoff

This extracts reviewer-identified concern statements (explicit concerns, implicit/hedged concerns, recommendations, resolutions) from FDA drug review documents, using the Qwen3.6-27B model served locally on a GPU node of Yale's Misha cluster.

Everything in this folder is what's needed to run the job — the extraction logic has already been unit-tested separately, so this is just the runnable pieces.

What's in this folder

• extract_concerns.py — the extraction script. Reads FDA review markdown files, chunks them, prompts the LLM for reviewer concern statements, writes concerns.csv / concerns.json.
• run_misha.sbatch — the Slurm job: starts a Qwen3.6-27B vLLM server on a GPU node, waits for it, runs the extraction, shuts the server down.
• requirements-client.txt — the one Python package the extraction script needs (openai, used only as an HTTP client to talk to the local vLLM server — no model code).

1. Get a Misha account

You should already have one (from Yale ITS/YCRC). Your NetID is your login. If not, request access at https://research.computing.yale.edu.

2. Log in

ssh <your_netid>@misha.ycrc.yale.edu

You'll be prompted for your Yale password and a Duo push to your phone.

3. Copy this folder to Misha

From your own machine (not on the cluster), e.g.:

scp -r misha_handoff <your_netid>@misha.ycrc.yale.edu:~/fda_concern_extraction

Then ssh in and cd ~/fda_concern_extraction.

4. Copy over the source FDA review documents

The script expects input laid out as:

<input-dir>/<month>/<drugname_appno>/opendataloader/*.md

(the same structure the opendataloader step in this project already produces). scp -r or rsync those folders to Misha too, e.g. into ~/project/fda_reviews/.

Note: put large data on project storage (~/project/, 1TB/group, no purge), not $HOME (125GB/user) or scratch (10TB/group but auto-purged after 60 days).

5. Create the conda environment (one-time setup)

Environments must be built on a compute node, not the login node:

salloc --partition=devel --cpus-per-task=4 --mem=32G --time=2:00:00
module load miniconda
conda create -n fda_qwen python=3.11 -y
conda activate fda_qwen

pip install --upgrade pip
pip install --upgrade "transformers>=4.57.1" accelerate
pip install --upgrade vllm
pip install -r ~/fda_concern_extraction/requirements-client.txt

exit   # leave the salloc session once installs finish

Qwen3.6-27B was released April 2026 — it's brand new. If vllm serve later fails with an error about an unrecognized architecture (qwen3_5 / Qwen3_5ForConditionalGeneration), your vLLM version predates support for it. Fix with:

pip install --upgrade --pre vllm
# or, if that's still too old:
pip install --upgrade "vllm @ git+https://github.com/vllm-project/vllm.git"

6. Pre-download the model weights (one-time, ~56GB)

Do this on a compute node with internet access, before submitting the batch job, so the batch job doesn't spend GPU time waiting on a download (and so it doesn't fail if the GPU node itself has no internet):

mkdir -p ~/project/hf_cache
salloc --partition=devel --cpus-per-task=4 --mem=32G --time=2:00:00
module load miniconda
conda activate fda_qwen
export HF_HOME=~/project/hf_cache
huggingface-cli download Qwen/Qwen3.6-27B
exit

7. Edit the job script

Open run_misha.sbatch and edit the three variables near the top:

CONDA_ENV="fda_qwen"
INPUT_DIR="$HOME/project/fda_reviews"       # <- where you copied the source docs
OUTPUT_DIR="$HOME/project/fda_reviews/results"

If your PI's group requires an explicit Slurm billing account, uncomment and fill in #SBATCH --account=YOUR_PI_GROUP (ask your PI, or run sacctmgr show associations user=$USER to see your options).

8. Do a small test run first

Before committing GPU time to the full document set, sanity-check on a handful of docs. Grab an interactive GPU node (gpu_devel is free/fast but only has A40 48GB — too small for this 27B model in bf16 — so use the gpu partition instead for even a quick test):

salloc --partition=gpu --gpus=h100:1 --cpus-per-gpu=8 --mem=120G --time=00:30:00
module reset && module load miniconda && conda activate fda_qwen
export HF_HOME=~/project/hf_cache
vllm serve Qwen/Qwen3.6-27B --port 8000 --dtype bfloat16 --max-model-len 32768 &
sleep 60   # give it a couple minutes to load on first run
curl http://localhost:8000/v1/models     # should return JSON, not a connection error

python extract_concerns.py --input-dir ~/project/fda_reviews \
    --output-dir ~/project/fda_reviews/test_results --limit 2

Check ~/project/fda_reviews/test_results/concerns.csv looks reasonable, then exit the salloc session (this also kills the vLLM server).

9. Submit the real job

sbatch run_misha.sbatch

Check status with:

squeue --me

Watch progress:

tail -f logs/fda_concern_extract_<jobid>.out

10. Get your results

OUTPUT_DIR/concerns.csv and concerns.json contain every extracted concern statement, one row per statement, with columns: application_number, drug_name, month, document_title, section_heading, page, exact_quote, judgment_summary, statement_type, topic, explicit, target, source_path.

If any chunks failed to parse (rare — the script retries automatically), they're logged to OUTPUT_DIR/failed_chunks.log for manual review; everything else still completed normally.

Optional: boosting recall with self-consistency

If GPU time isn't the bottleneck, add --passes 2 (or 3) to the python extract_concerns.py command in run_misha.sbatch. This runs each text chunk through the model multiple times independently and unions the results (deduping near-identical quotes) — a well-established way to recover concerns that get missed on any single pass, since LLM extraction is stochastic. It costs passes× the compute for that step. This is a stronger lever than any in-prompt "double-check yourself" instruction, since each pass is a fully independent generation rather than a continuation of the same one. Not required for a first run — just worth knowing it's there if recall still looks low after checking results against ground truth.

Troubleshooting

• sbatch: error: ... Invalid account — you need #SBATCH --account=..., see step 7.
• Job stays PD (pending) a long time — the gpu partition (H100/A100/etc.) is shared; check squeue --partition=gpu to see the queue. gpu_devel is faster to get but its A40 GPUs (48GB) are too small for this model at bf16.
• CUDA out of memory — lower --gpu-memory-utilization in run_misha.sbatch, or lower --max-model-len (32768 is already far below the model's native 262K — we don't need long context for this task).
• vLLM won't start / unknown architecture error — see the vLLM upgrade note in step 5.
• Server never becomes healthy within 30 min — check logs/vllm_server_<jobid>.log directly for the real error.
• Extraction runs but output looks empty/wrong — try inspecting a raw response by temporarily running with --limit 1 (thinking mode is on by default and generally more accurate; use --no-thinking only if you need faster/cheaper runs).