MedGemma, a collection of medical vision-language foundation models based on Gemma 3, demonstrates advanced medical understanding and reasoning across images and text and multiple medical imaging doma...

Developers watching the Chinese AI ecosystem have a new curiosity to bookmark: amd/medgemma-4b-it-NPU2, a vision-language model published on Huawei's Ascend-oriented Modelers.cn. At first glance, it…

MedGemma, a collection of medical vision-language foundation models based on Gemma 3, demonstrates advanced medical understanding and reasoning across images and text and multiple medical imaging doma...

For developers navigating the Chinese AI landscape, the hardware ecosystem is just as critical as the software stack. Today, Modelers.cn has dropped a significant update: a port of Google’s compact…

MedGemma, a collection of medical vision-language foundation models based on Gemma 3, demonstrates advanced medical understanding and reasoning across images and text and multiple medical imaging domains, exceeding the performance of similarly sized generative models while maintaining the general capabilities of the Gemma base models.

MedGemma is an open vision-language model for diverse medical applications, addressing text-only benchmark limitations and enabling multimodal medical image understanding and research.

MedGemma, a collection of medical vision-language foundation models based on Gemma 3, demonstrates advanced medical understanding and reasoning across images and text and multiple medical imaging…

MedGemma, Google's open foundation model for medical image-language tasks, released with weights and smartphone-capable inference, enables accessible multimodal medical imaging research and applications.

MedGemma, a collection of medical vision-language foundation models based on Gemma 3, demonstrates advanced medical understanding and reasoning across images and text and multiple medical imaging domains, exceeding the performance of similarly sized generative models while maintaining the general ca

HYDERABAD: A team of researchers at the International Institute of Information Technology-Hyderabad (IIIT-H) has found that heatmaps generated by medical artificial intelligence (AI) models to indicate disease in chest X-rays may not always correspond to the areas radiologists consider clinically relevant. The study, by IIIT-H’s Language Technologies Research Centre (LTRC) and led by Prof Parameswari Krishnamurthy, examined four vision-language models (VLMs) — MAIRA-2, MedGemma-4B, LLaVA-Med-1.5 and LLaVA-1.5 — against thousands of publicly available chest X-rays.

For now, I tried to narrow this down using only publicly available materials: * * * **Short answer: I could not reproduce a general 2× LoRA scaling behavior here.** For ordinary LoRA, PEFT uses the usual `lora_alpha / r` scaling (PEFT LoRA docs, implementation). So with `r=64, alpha=16`, I would expect `0.25`. I tried a public surrogate using Unsloth’s MedGemma 4B mirror, with the same `r=64, alpha=16`, including a small real LoRA train → save → reload cycle. On an actually trained language-model `q_proj`, I measured an effective scale of about `0.250009`: * live trained adapter: ~`0.250009` * stock PEFT reload: ~`0.250009` * Unsloth reload: ~`0.250009` The saved LoRA tensors were also identical across the reload paths. On a fixed input, nominal x1 scaling was much closer to the live trained model than x2; for the Unsloth reload, x1 matched the live result exactly in this probe, while x2 moved the logits substantially. So at least from this public reproduction, I would **not** treat `~0.5` as a general Unsloth/plain-LoRA convention. I would still take your `0/4 at nominal → 4/4 at 2×` result seriously as a behavioral observation. I just would not yet read it as proof that the LoRA layer itself was numerically applying `0.5`. There are a few boundaries above and below the LoRA arithmetic that can produce that kind of behavioral threshold. The cheapest check I can think of is to inspect **one genuinely trained LoRA layer** in the original environment. same final input_ids / attention_mask? | +-- no | -> normalize the prompt/tokenizer path first | +-- yes | +-- one trained layer has effective scale ~0.50? | | | +-- yes | | -> strong lead for a real runtime scaling/arithmetic anomaly | | | +-- no, it is ~0.25 | | | +-- raw and loaded LoRA A/B identical? | | | +-- no | | -> loading/materialization/state-dict branch | | | +-- yes | -> compare exact base revision, logits, | dtype/backend and wrapper/model path | +-- only the merged checkpoint degrades? | +-- yes -> investigate merge precision/export separately I would especially separate the **live-scale question** from the **merge degradation question**. In the public bf16 surrogate, I could reproduce substantial elementwise error when the LoRA delta was materialized into bf16 base weights even though the live LoRA layer itself was using the correct `0.25` scale. So those two observations do not necessarily need one common cause. Public reproduction details (click for more details) One thing I would normalize before interpreting the identity probe as a scale measurement (click for more details) A small one-layer check that would distinguish the branches (click for more details) Merge / bf16 precision looks like a separate problem (click for more details) Nearby upstream issues that make these boundaries worth checking (click for more details) One small version/reproducibility note (click for more details) So my current read is: 1. **The reported`0/4 → 4/4 at 2×` behavior is interesting and worth preserving as an observation.** 2. **I could not reproduce a general Unsloth/MedGemma plain-LoRA 2× scaling rule.** 3. **A public real train/save/reload surrogate stayed at the expected ~0.25 scale.** 4. **The merge degradation has a plausible independent bf16 precision mechanism, which I could reproduce at the weight-delta level.** 5. **The highest-information next check in the original run is just one trained layer plus identical final input tensors — not another large training run.** If that one layer really reports ~`0.5` in the original environment, I think that would be a very useful minimal reproduction to take upstream. If it reports ~`0.25`, then the search space gets much smaller: input/template/base identity first, then whole-model runtime/backend differences, while keeping merge precision on its own branch.

MedGemma performance was evaluated across several medical text and medical imaging benchmarks (Table 1), including both in-distribution benchmarks, for which a subset of the data was used for training or tuning with a held-out set for evaluation, and out-of-distribution (OOD) benchmarks, for which no subset of the data was used for training or tuning (note that, for general-purpose benchmarks, it is difficult to determine whether data are OOD given the large amount of pretraining data in the base model training mixture). Overall, MedGemma achieved accuracy exceeding or on par with much larger, nonopen models as well as task-specialized models across several benchmark tasks. The sections below outline performance across different categories, including medical text question answering, medical image classification, open-ended clinical reasoning, medical visual question answering, report generation and agentic behavior. The relevant model variants are included in the result tables below, with the complete set of performance results across MedGemma variants provided in Supplementary Note—Additional training data details. Medical text question answering Across all text-only biomedical question-answering tasks evaluated, MedGemma demonstrated superior performance to the ‘baseline’ Gemma 3 model, as well as competitive performance with much larger models in many cases (Table 2). Confidence intervals for the results, where...

We fine-tuned MedGemma 4B (LoRA) and 27B (QLoRA) for oncology with Unsloth on a single DGX Spark. Report with DOI, models and dataset are public. One finding you may want to look at (section 5): with Unsloth 2026.9.12, the 4B adapter (r=64, alpha=16) behaves as if scaled by ~0.5 instead of alpha/r = 0.25. Loaded with Transformers + PEFT at nominal scale, 0/4 identity probes pass; at 2x, 4/4. Merging with save_pretrained_merged at nominal alpha lost most of the tuning. We did not identify the cause in the code. Is this a known behavior? Unsloth is credited in the model cards. Feel free to share it if useful. Thanks for the tooling. See the repo : Grujowmi (ANTOINE Pierre) See the report : OncoLLM: adapting MedGemma 4B and 27B to oncology tasks | Zenodo Have fun to give us a feedback

Google’s MedGemma 1.5 can interpret multimodal medical images, including CT and MRI scans and pathology slides. OpenAI’s health features can answer questions by combining medical records with sleep and activity data. Yet as the technical capabilities of medical AI advance, a fundamental tension remains: medical AI has no fixed set of “standardized” answers. Clinicians can read the same scan differently. New disease entities and diagnostic modalities continue to emerge, meaning that even today’s most advanced models may need to be rebuilt within a few years.

Healthcare organizations are using Google’s tech to build tools that address unique local healthcare needs.

I build a tool that reads MRI and CT scans with general vision models and explains the findings in plain language. The most repeated error in that pipeline isn't a missed tumour or an invented measurement. It's **left and right**. We ran eight real studies through four readers (Claude, Gemini, Grok and Google's MedGemma), with the radiologist's signed report as ground truth. Here's what came back: * a 5 cm cyst in the **right** kidney, placed in the left by two of the four readers * a **medial** meniscus tear, reported in the lateral meniscus * a **left** paracentral disc extrusion, called right-sided * one reader that gave two different sides for the same finding in two acquisitions of the same study In medicine a left/right swap is a "never event". You don't ship a report that does this, and a better prompt doesn't fix it. So here is where the error comes from, and the small, model-free check that now catches it. ## The model gets the coordinates right and the word wrong The detail that cracked it came from MedGemma. We ask each reader for two things per finding: a sentence, and a location on a specific slice. On one study MedGemma put its crosshair **17–26 mm to the right of the midline** , which matched the radiologist. Then it wrote that the finding was _"slightly to the left"_. The crosshair was correct. The sentence described the side of the **picture** , not the side of the **patient**. That's the radiological convention catching the model out. An axial scan is displayed as if you're standing at the patient's feet looking up, so the patient's right is on the left of the screen. A model trained mostly on ordinary photos describes what it sees: "on the left of the image". In a report, that's the wrong side. This failure turns out to be useful. **When the coordinates are right and only the sentence is wrong, you can check one against the other without involving a model at all.** ## World space already knows which side is which Our volumes are converted from DICOM to NIfTI in the browser (dcm2niix compiled to WebAssembly). A NIfTI file carries an affine: a 4×4 matrix mapping voxel indices `(i, j, k)` to millimetres in world space. That space is **RAS** : +x is the patient's **R** ight, +y Anterior, +z Superior. So once a finding has a voxel location, the sign of its world-x gives a second, independent answer about which side it's on: export function voxToMm(affine: Affine, [i, j, k]: [number, number, number]) { const m = (r: number) => affine[r][0] * i + affine[r][1] * j + affine[r][2] * k + affine[r][3] return [m(0), m(1), m(2)] as [number, number, number] } const OFF_MIDLINE_MM = 8 export function sideOfPoint(mm: [number, number, number]): Side | null { const x = mm[0] if (!Number.isFinite(x) || Math.abs(x) < OFF_MIDLINE_MM) return null return x > 0 ? 'right' : 'left' // RAS: +x is the patient's RIGHT } The 8 mm dead zone matters. A central disc extrusion sits at x ≈ 0 and belongs to neither side, and floating-point noise shouldn't get read as a side. ## Reading the side out of the sentence, in nine languages Reports come back in the user's language, so an English-only regex would silently check nothing for most users. The side words are prefix patterns, because almost every one of these languages inflects them (_destro/destra_ , _rechts/rechten_ , _prawy/prawa_): const RIGHT_WORDS = /\bright\w*|\bdestr[aeio]\w*|\bderech\w*|\bdroit\w*|\brecht[aensr]\w*|\bdireit\w*|\bpraw(?!d)\w*|\bsağ\w*|يمين|أيمن|اليمنى/iu const LEFT_WORDS = /\bleft\w*|\bsinistr\w*|\bizquierd\w*|\bgauche\w*|\blink[aensr]\w*|\besquerd\w*|\blew\w*|\bsol\b|يسار|أيسر|اليسرى/iu const BOTH_SIDES = /\bbilateral\w*|\bbilaterale?\w*|\bbeidseit\w*|\bobustronn\w*|\bambos\b|\bambas\b|\bdes deux côtés\b|ثنائي/iu Two traps are handled on purpose: * **"bright" must not match "right".** It doesn't, because `\b` needs a non-word character before the `r`, and `b` is a word character. MRI reports say "bright" constantly. * **Polish _prawdopodobnie_ ("probably") must not match _praw_.** Hence the `(?!d)`. Then there's the rule that took longest to get right: **a sentence that names both sides claims neither.** export function sideClaimed(text: string): Side | null { if (!text) return null if (BOTH_SIDES.test(text)) return null const right = RIGHT_WORDS.test(text) const left = LEFT_WORDS.test(text) if (right === left) return null // none, or one of each return right ? 'right' : 'left' } "The left L5 root is displaced; the right is not" mentions both words. If you picked either one, you'd be inventing a claim the sentence never made. ## The check only works when the scan crosses the midline This is the part I got wrong first. A **left knee** MRI sits entirely at negative x. Every finding in it is "on the left", while the text is talking about the medial and lateral compartments of that one knee. Run the check there and every knee report gets flagged. So the sign of x only means a body side when the field of view reaches well past the midline in both directions. You can't read that off the origin, because the affine can rotate the grid. You have to check all eight corners: const MIDLINE_MARGIN_MM = 40 function worldXRange(affine: Affine, [nx, ny, nz]: [number, number, number]) { let lo = Infinity, hi = -Infinity for (const i of [0, nx - 1]) for (const j of [0, ny - 1]) for (const k of [0, nz - 1]) { const x = voxToMm(affine, [i, j, k])[0] lo = Math.min(lo, x); hi = Math.max(hi, x) } return [lo, hi] } export function straddlesMidline(affine?: Affine, dims?: [number, number, number]) { if (!affine || !dims) return false const [lo, hi] = worldXRange(affine, dims) return lo <= -MIDLINE_MARGIN_MM && hi >= MIDLINE_MARGIN_MM } The 40 mm margin is generous on purpose. A spine or abdomen study clears it easily, and a limb never does. ## Putting it together: only report a conflict when you're sure export function lateralityConflict(opts: { text: string locations?: { mm?: [number, number, number] }[] affine?: Affine dims?: [number, number, number] }): Side | null { const claimed = sideClaimed(opts.text) if (!claimed) return null if (!straddlesMidline(opts.affine, opts.dims)) return null // Several points must agree with each other before they outvote the sentence. const sides = (opts.locations ?? []) .map((l) => (l.mm ? sideOfPoint(l.mm) : null)) .filter((s): s is Side => s !== null) if (sides.length === 0 || !sides.every((s) => s === sides[0])) return null return sides[0] === claimed ? null : sides[0] } Count the `return null`s. There are four ways for this function to say nothing, and one way for it to speak. That's deliberate. It isn't a classifier trying to arbitrate uncertain cases. It exists to catch **the contradictions that are certain** : the text names one side, the geometry clearly and consistently shows the other, and the scan covers both sides of the body. ## What we do when it fires We don't silently rewrite the sentence. The crosshair is _usually_ right (that's the failure we measured), but the sentence is the part a person reads and acts on. So the conflict is stored on the finding (`sideConflict: 'right'`) and shown, instead of being quietly "fixed" by code that could itself be wrong. ## What this doesn't fix * **Extremities.** Knees, shoulders and wrists get no check at all. Medial vs lateral inside one joint needs a different reference: the joint's own axes, not the body midline. * **Findings with no location.** No coordinates, no second opinion. * **Errors both halves share.** If the model puts the crosshair on the wrong kidney _and_ names that kidney, the two agree and nothing fires. That's also why having two models agree doesn't prove much: independent readers catch errors that differ, but they're blind to errors they share. ## The general lesson When a multimodal model gives you **structured output next to prose** , the two halves often fail independently. Coordinates, slice indices, bounding boxes and counts come from a different part of the model's behaviour than the sentence does. Whenever the domain gives you a deterministic way to relate the two (here: an affine matrix and a coordinate convention), you get a check that costs microseconds, needs no second model, and can't hallucinate. It's worth finding those checks before reaching for another prompt. _I'm Lorenzo, and I build ReadYourScan, which opens DICOM/NIfTI studies in the browser and explains them in plain language. It's not a diagnosis. The browser viewer is open source (MIT): lgdesignee/readyourscan-viewer._