---
library_name: transformers
base_model:
- mistralai/Ministral-3-14B-Reasoning-2512
---

This tiny model is intended for debugging. It is randomly initialized using the configuration adapted from [mistralai/Ministral-3-14B-Reasoning-2512](https://huggingface.co/mistralai/Ministral-3-14B-Reasoning-2512).

### Example usage:

```python
from transformers import AutoModel, MistralCommonBackend, Mistral3ForConditionalGeneration
import torch

# Load model and tokenizer
model_id = "tiny-random/mistral-3"
model = Mistral3ForConditionalGeneration.from_pretrained(
    model_id,
    device_map="cuda",
    torch_dtype="bfloat16",
    trust_remote_code=True,
)
tokenizer = MistralCommonBackend.from_pretrained(model_id)
image_url = "https://static.wikia.nocookie.net/essentialsdocs/images/7/70/Battle.png/revision/latest?cb=20220523172438"
messages = [
    {
        "role": "user",
        "content": [
            {
                "type": "text",
                "text": "What is this?",
            },
            {"type": "image_url", "image_url": {"url": image_url}},
        ],
    },
]

tokenized = tokenizer.apply_chat_template(
    messages, return_tensors="pt", return_dict=True)
tokenized["input_ids"] = tokenized["input_ids"].to(device="cuda")
tokenized["pixel_values"] = tokenized["pixel_values"].to(
    dtype=torch.bfloat16, device="cuda")
image_sizes = [tokenized["pixel_values"].shape[-2:]]

output = model.generate(
    **tokenized.to("cuda"),
    image_sizes=image_sizes,
    max_new_tokens=32,
)[0]

decoded_output = tokenizer.decode(output[len(tokenized["input_ids"][0]):])
print(decoded_output)
```

### Codes to create this repo:

```python
import json
from pathlib import Path

import accelerate
import torch
from huggingface_hub import file_exists, hf_hub_download
from transformers import (
    AutoConfig,
    AutoModelForCausalLM,
    AutoProcessor,
    GenerationConfig,
    set_seed,
    Mistral3ForConditionalGeneration,
    MistralCommonBackend,
)

source_model_id = "mistralai/Ministral-3-14B-Reasoning-2512"
save_folder = "/tmp/tiny-random/mistral-3"

processor = AutoProcessor.from_pretrained(
    source_model_id, trust_remote_code=True)
processor.save_pretrained(save_folder)
processor = MistralCommonBackend.from_pretrained(
    source_model_id, trust_remote_code=True)
processor.save_pretrained(save_folder)

with open(hf_hub_download(source_model_id, filename='config.json', repo_type='model'), 'r', encoding='utf-8') as f:
    config_json = json.load(f)
config_json['text_config'].update({
    "head_dim": 32,
    "hidden_size": 8,
    "intermediate_size": 64,
    "num_attention_heads": 8,
    "num_hidden_layers": 2,
    "num_key_value_heads": 4,
})
config_json['vision_config'].update({
    "head_dim": 32,
    "hidden_size": 128,
    "intermediate_size": 128,
    "num_attention_heads": 4,
    "num_hidden_layers": 2,
})
with open(f"{save_folder}/config.json", "w", encoding='utf-8') as f:
    json.dump(config_json, f, indent=2)

config = AutoConfig.from_pretrained(
    save_folder,
    trust_remote_code=True,
)
print(config)
torch.set_default_dtype(torch.bfloat16)
model = Mistral3ForConditionalGeneration(config)
torch.set_default_dtype(torch.float32)
if file_exists(filename="generation_config.json", repo_id=source_model_id, repo_type='model'):
    model.generation_config = GenerationConfig.from_pretrained(
        source_model_id, trust_remote_code=True,
    )
    model.generation_config.do_sample = True
    print(model.generation_config)
model = model.cpu()
with torch.no_grad():
    for name, p in sorted(model.named_parameters()):
        torch.nn.init.normal_(p, 0, 0.1)
        print(name, p.shape)
model.save_pretrained(save_folder)
print(model)
```

### Printing the model:

```text
Mistral3ForConditionalGeneration(
  (model): Mistral3Model(
    (vision_tower): PixtralVisionModel(
      (patch_conv): Conv2d(3, 128, kernel_size=(14, 14), stride=(14, 14), bias=False)
      (ln_pre): PixtralRMSNorm((128,), eps=1e-05)
      (transformer): PixtralTransformer(
        (layers): ModuleList(
          (0-1): 2 x PixtralAttentionLayer(
            (attention_norm): PixtralRMSNorm((128,), eps=1e-05)
            (feed_forward): PixtralMLP(
              (gate_proj): Linear(in_features=128, out_features=128, bias=False)
              (up_proj): Linear(in_features=128, out_features=128, bias=False)
              (down_proj): Linear(in_features=128, out_features=128, bias=False)
              (act_fn): SiLUActivation()
            )
            (attention): PixtralAttention(
              (k_proj): Linear(in_features=128, out_features=128, bias=False)
              (v_proj): Linear(in_features=128, out_features=128, bias=False)
              (q_proj): Linear(in_features=128, out_features=128, bias=False)
              (o_proj): Linear(in_features=128, out_features=128, bias=False)
            )
            (ffn_norm): PixtralRMSNorm((128,), eps=1e-05)
          )
        )
      )
      (patch_positional_embedding): PixtralRotaryEmbedding()
    )
    (multi_modal_projector): Mistral3MultiModalProjector(
      (norm): Mistral3RMSNorm((128,), eps=1e-05)
      (patch_merger): Mistral3PatchMerger(
        (merging_layer): Linear(in_features=512, out_features=128, bias=False)
      )
      (linear_1): Linear(in_features=128, out_features=8, bias=False)
      (act): GELUActivation()
      (linear_2): Linear(in_features=8, out_features=8, bias=False)
    )
    (language_model): Ministral3Model(
      (embed_tokens): Embedding(131072, 8, padding_idx=11)
      (layers): ModuleList(
        (0-1): 2 x Ministral3DecoderLayer(
          (self_attn): Ministral3Attention(
            (q_proj): Linear(in_features=8, out_features=256, bias=False)
            (k_proj): Linear(in_features=8, out_features=128, bias=False)
            (v_proj): Linear(in_features=8, out_features=128, bias=False)
            (o_proj): Linear(in_features=256, out_features=8, bias=False)
          )
          (mlp): Ministral3MLP(
            (gate_proj): Linear(in_features=8, out_features=64, bias=False)
            (up_proj): Linear(in_features=8, out_features=64, bias=False)
            (down_proj): Linear(in_features=64, out_features=8, bias=False)
            (act_fn): SiLUActivation()
          )
          (input_layernorm): Ministral3RMSNorm((8,), eps=1e-05)
          (post_attention_layernorm): Ministral3RMSNorm((8,), eps=1e-05)
        )
      )
      (norm): Ministral3RMSNorm((8,), eps=1e-05)
      (rotary_emb): Ministral3RotaryEmbedding()
    )
  )
  (lm_head): Linear(in_features=8, out_features=131072, bias=False)
)
```