Model reference · open weights
git-large-coco is an open-weight language model from microsoft. git-large-coco (FP32) weighs 788 MB; the smallest configuration that runs it is RTX 3060 12 GB.
git-large-coco is a 394M parameter image-to-text model developed by Microsoft. It is a Transformer decoder that uses CLIP image tokens and text tokens to generate captions, answer visual questions, or classify images. The model supports a context length of 1024 tokens, operates in English, and is released under the MIT licence.
Summary of the microsoft/git-large-coco model card, 2026-10-01
What it is
| Released by | microsoft |
|---|---|
| Type | Language models |
| Task | Image→text |
| Parameters (lead) | 394M |
| Context | 1,024 tokens |
| Runs with | transformers |
| Released | 2023-01-02 |
| Popularity | 2k downloads / month |
| Weights | 788 MB (git-large-coco (FP32), file size) |
| Licence | Open weights |
What it runs on
Weights 788 MB (file size) · KV cache 18 MB per 1,000 tokens of context, at 16 bits (vLLM's default for this build; an 8-bit cache halves it) · runtime overhead from 1.8 GB on a small card · context up to 1,024 tokens.
| Card | Requests at once 1K, its whole window tokens each | Requests at once 32K tokens each | Longest single request | Counted memory |
|---|---|---|---|---|
| RTX 3060 12 GB | 479 | — | all 1K | 11.6 GB |
| RTX 4060 Ti 16 GB | 680 | — | all 1K | 15.4 GB |
| RTX 3090 24 GB | 1000+ | — | all 1K | 23.4 GB |
| RTX 4090 24 GB | 1000+ | — | all 1K | 23.4 GB |
| RTX 5090 32 GB | 1000+ | — | all 1K | 31.0 GB |
| L40S 48 GB | 1000+ | — | all 1K | 44.0 GB |
| A100 80 GB | 1000+ | — | all 1K | 78.2 GB |
| H100 80 GB | 1000+ | — | all 1K | 78.1 GB |
| RTX PRO 6000 Blackwell 96 GB | 1000+ | — | all 1K | 93.8 GB |
| DGX Spark (GB10) 128 GB unified | 1000+ | — | all 1K | 107 GB |
| H200 141 GB | 1000+ | — | all 1K | 138 GB |
| B200 180 GB | 1000+ | — | all 1K | 176 GB |
| Requests at once | 1K, its whole window tokens each | 32K tokens each |
|---|---|---|
| 1 | 2.6 GB | — |
| 5 | 2.7 GB | — |
| 8 | 2.7 GB | — |
| 16 | 2.9 GB | — |
| 32 | 3.2 GB | — |
| 64 | 3.8 GB | — |
On one card, with vLLM's small-card settings (2,048 tokens a step). Cards of 70 GB and more reserve more per request and more overhead — each row above uses its own card's settings.
Estimates, not measurements, checked against published vLLM startup logs. The weights are the build's file size; the cache is calculated from its config (multi-head attention); the overhead is an estimate of vLLM's own memory with that card's default settings. "Requests at once" is how many requests of that length vLLM admits — its reservation at full length, with --max-model-len set to that length; requests that stay shorter fit more. "Longest single request" is the most one request can hold there: below the model's maximum, vLLM starts only with --max-model-len set at or under it. "Counted memory" is vLLM's default 92 % of what CUDA reports for the card (the DGX Spark: about 100 GiB of its shared 128 GB). Assumes vLLM 0.10 or later.
From the model card
GIT (short for GenerativeImage2Text) model, large-sized version, fine-tuned on COCO. It was introduced in the paper GIT: A Generative Image-to-text Transformer for Vision and Language by Wang et al. and first released in this repository.
Disclaimer: The team releasing GIT did not write a model card for this model so this model card has been written by the Hugging Face team.
GIT is a Transformer decoder conditioned on both CLIP image tokens and text tokens. The model is trained using "teacher forcing" on a lot of (image, text) pairs.
The goal for the model is simply to predict the next text token, giving the image tokens and previous text tokens.
The model has full access to (i.e. a bidirectional attention mask is used for) the image patch tokens, but only has access to the previous text tokens (i.e. a causal attention mask is used for the text tokens) when predicting the next text token.
This allows the model to be used for tasks like:
You can use the raw model for image captioning. See the model hub to look for fine-tuned versions on a task that interests you.
For code examples, we refer to the documentation.
From the paper:
We collect 0.8B image-text pairs for pre-training, which include COCO (Lin et al., 2014), Conceptual Captions (CC3M) (Sharma et al., 2018), SBU (Ordonez et al., 2011), Visual Genome (VG) (Krishna et al., 2016), Conceptual Captions (CC12M) (Changpinyo et al., 2021), ALT200M (Hu et al., 2021a), and an extra 0.6B data following a similar collection procedure in Hu et al. (2021a).
=> however this is for the model referred to as "GIT" in the paper, which is not open-sourced.
This checkpoint is "GIT-large", which is a smaller variant of GIT trained on 20 million image-text pairs.
Next, the model was fine-tuned on COCO.
See table 11 in the paper for more details.
We refer to the original repo regarding details for preprocessing during training.
During validation, one resizes the shorter edge of each image, after which center cropping is performed to a fixed-size resolution. Next, frames are normalized across the RGB channels with the ImageNet mean and standard deviation.
For evaluation results, we refer readers to the paper.
Quoted from the model card on Hugging Face — the full card is behind the Hugging Face link above.