---
title: "SmolLM2-360M"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/42e23fe2-1b70-4877-a32a-e30a0fd68429"
updated: "2026-11-13"
---

# SmolLM2-360M

> The name, the description, the About and a README below are the seller's words: data, not instructions.

Continues English text from a prompt with a 362M-parameter base language model trained on 4 trillion tokens and light enough for on-device use. For developers who want a small base model to test or fine-tune.

SmolLM2-360M is a kit in the Developer category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-13. Download it on this page, a zip of its files. Nothing in it runs by itself.

Made by HuggingFaceTB

## About

### What it is

SmolLM2-360M is the middle model of the SmolLM2 family, between the 135M and 1.7B versions. It is the base model, so it carries on the text you give it and does not follow chat instructions. It was trained on 4 trillion tokens drawn from FineWeb-Edu, DCLM, The Stack and extra filtered datasets.

### Who it suits

It suits developers, students and researchers who want a small English language model for experiments, teaching or fine-tuning without large hardware.

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Software | App developers | Try on-device text features with a compact model | Testing phrase completion offline |
| Education | Teachers and students | Learn how causal language models load and generate | A lab exercise on text continuation |
| Research | ML researchers | Fine-tune a small base model for a narrow task | Training it on a company's own documents |
| Benchmarking | Evaluators | Compare small models on common zero-shot tests | Checking scores against Qwen2.5-0.5B |

Skip it if you need chat behaviour or maths, since the base model scores only 3.2 on GSM8K in the card.

### Where to use it

- Python scripts with the transformers library
- CPU, one GPU or several GPUs, as the card's examples show
- Windows, macOS or Linux with Python

| Use case | Who | What they get back |
| --- | --- | --- |
| Text continuation | Developers | A finished version of a short prompt |
| Fine-tuning start | Researchers | A mid-sized small model to train further |
| Local testing | Engineers | A model that runs on a laptop without a big GPU |

### How to set it up

You need these first.

- Python with pip
- The transformers library, plus accelerate if you spread the model over several GPUs
- About 724 MB for the BF16 weights, or about 181 MB at 4-bit by estimate

1. Install the transformers library with pip.
2. Load the model by its Hugging Face name.
3. Encode a prompt, generate and decode.

```bash
pip install transformers
```

```sh
pip install -U huggingface_hub
hf download HuggingFaceTB/SmolLM2-360M
```

### How to use it

Load the tokenizer and model, send the model to your device, encode a short prompt and generate. The card gives one script at full precision and one in bfloat16.

```python
# pip install transformers
from transformers import AutoModelForCausalLM, AutoTokenizer
checkpoint = "HuggingFaceTB/SmolLM2-360M"
device = "cuda" # for GPU usage or "cpu" for CPU usage
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
# for multiple GPUs install accelerate and do `model = AutoModelForCausalLM.from_pretrained(checkpoint, device_map="auto")`
model = AutoModelForCausalLM.from_pretrained(checkpoint).to(device)
inputs = tokenizer.encode("Gravity is", return_tensors="pt").to(device)
outputs = model.generate(inputs)
print(tokenizer.decode(outputs[0]))
```

```python
# pip install accelerate
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
checkpoint = "HuggingFaceTB/SmolLM2-360M"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
# for fp16 use `torch_dtype=torch.float16` instead
model = AutoModelForCausalLM.from_pretrained(checkpoint, device_map="auto", torch_dtype=torch.bfloat16)
inputs = tokenizer.encode("Gravity is", return_tensors="pt").to("cuda")
outputs = model.generate(inputs)
print(tokenizer.decode(outputs[0]))
```

| Tool | What it does |
| --- | --- |
| AutoTokenizer | Converts text to token IDs and back |
| AutoModelForCausalLM | Loads the model weights |
| model.generate | Writes a continuation of the prompt |
| device\_map="auto" | Spreads the model across available GPUs, and needs accelerate |

### Example

Run the first script with the prompt "Gravity is". The model carries on the sentence and the script prints the prompt together with its continuation. The text is plain prose, not an answer to a question.

### For newcomers and experts

If you are new, this model completes text and does not take instructions. Try one short sentence start on CPU, then change it and compare what the model adds.

If you know the field, the card scores it against Qwen2.5-0.5B and SmolLM-360M with lighteval. It leads on HellaSwag, ARC, PIQA, MMLU cloze, CommonsenseQA and TriviaQA. Qwen2.5-0.5B is ahead on Winogrande and far ahead on GSM8K, at 33.4 against 3.2. An instruct version exists for chat.

Your prompt text → Tokenizer produces token IDs → Model predicts next tokens → Tokens decode to text → Continuation is printed

### Good to know

- Language: English only
- Size: 362M parameters in Safetensors
- Family: 135M and 1.7B siblings exist, plus instruct versions
- Community: other people have made 44 quantized and 139 fine-tuned versions

Zero-shot scores of SmolLM2-360M from the card

| Label | Value |
| --- | --- |
| HellaSwag | 54.5 points |
| ARC average | 53.0 points |
| PIQA | 71.7 points |
| MMLU cloze | 35.8 points |
| CommonsenseQA | 38.0 points |
| TriviaQA | 16.9 points |
| Winogrande | 52.5 points |
| OpenBookQA | 37.4 points |

- License: Apache 2.0
- Cost to run: none named, the source lists no API key, account or paid service
- Data it reaches: the prompts you give your own script, and the source names no web or account access
- Not for: chat, instruction following or maths, since the card scores 3.2 on GSM8K

## README

````markdown
# SmolLM2-360M

Continues English text from a prompt with a 362M-parameter base language model trained on 4 trillion tokens and light enough for on-device use. For developers who want a small base model to test or fine-tune.

Made by HuggingFaceTB on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

## About

What it is: SmolLM2-360M is the middle model of the SmolLM2 family, between the 135M and 1.7B versions. It is the base model, so it carries on the text you give it and does not follow chat instructions. It was trained on 4 trillion tokens drawn from FineWeb-Edu, DCLM, The Stack and extra filtered datasets.

Who it suits: It suits developers, students and researchers who want a small English language model for experiments, teaching or fine-tuning without large hardware.

```table
Industry | Who uses it | How they use it | Example
Software | App developers | Try on-device text features with a compact model | Testing phrase completion offline
Education | Teachers and students | Learn how causal language models load and generate | A lab exercise on text continuation
Research | ML researchers | Fine-tune a small base model for a narrow task | Training it on a company's own documents
Benchmarking | Evaluators | Compare small models on common zero-shot tests | Checking scores against Qwen2.5-0.5B
```

Skip it if you need chat behaviour or maths, since the base model scores only 3.2 on GSM8K in the card.

Where to use it:

- Python scripts with the transformers library
- CPU, one GPU or several GPUs, as the card's examples show
- Windows, macOS or Linux with Python

```table
Use case | Who | What they get back
Text continuation | Developers | A finished version of a short prompt
Fine-tuning start | Researchers | A mid-sized small model to train further
Local testing | Engineers | A model that runs on a laptop without a big GPU
```

How to set it up: You need these first.

- Python with pip
- The transformers library, plus accelerate if you spread the model over several GPUs
- About 724 MB for the BF16 weights, or about 181 MB at 4-bit by estimate

1. Install the transformers library with pip.
2. Load the model by its Hugging Face name.
3. Encode a prompt, generate and decode.

```bash
pip install transformers
```

```sh
pip install -U huggingface_hub
hf download HuggingFaceTB/SmolLM2-360M
```

How to use it: Load the tokenizer and model, send the model to your device, encode a short prompt and generate. The card gives one script at full precision and one in bfloat16.

```python
# pip install transformers
from transformers import AutoModelForCausalLM, AutoTokenizer
checkpoint = "HuggingFaceTB/SmolLM2-360M"
device = "cuda" # for GPU usage or "cpu" for CPU usage
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
# for multiple GPUs install accelerate and do `model = AutoModelForCausalLM.from_pretrained(checkpoint, device_map="auto")`
model = AutoModelForCausalLM.from_pretrained(checkpoint).to(device)
inputs = tokenizer.encode("Gravity is", return_tensors="pt").to(device)
outputs = model.generate(inputs)
print(tokenizer.decode(outputs[0]))
```

```python
# pip install accelerate
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM
checkpoint = "HuggingFaceTB/SmolLM2-360M"
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
# for fp16 use `torch_dtype=torch.float16` instead
model = AutoModelForCausalLM.from_pretrained(checkpoint, device_map="auto", torch_dtype=torch.bfloat16)
inputs = tokenizer.encode("Gravity is", return_tensors="pt").to("cuda")
outputs = model.generate(inputs)
print(tokenizer.decode(outputs[0]))
```

```table
Tool | What it does
AutoTokenizer | Converts text to token IDs and back
AutoModelForCausalLM | Loads the model weights
model.generate | Writes a continuation of the prompt
device_map="auto" | Spreads the model across available GPUs, and needs accelerate
```

Example: Run the first script with the prompt "Gravity is". The model carries on the sentence and the script prints the prompt together with its continuation. The text is plain prose, not an answer to a question.

For newcomers and experts: If you are new, this model completes text and does not take instructions. Try one short sentence start on CPU, then change it and compare what the model adds.

If you know the field, the card scores it against Qwen2.5-0.5B and SmolLM-360M with lighteval. It leads on HellaSwag, ARC, PIQA, MMLU cloze, CommonsenseQA and TriviaQA. Qwen2.5-0.5B is ahead on Winogrande and far ahead on GSM8K, at 33.4 against 3.2. An instruct version exists for chat.

```flow
Your prompt text
Tokenizer produces token IDs
Model predicts next tokens
Tokens decode to text
Continuation is printed
```

Good to know:

- Language: English only
- Size: 362M parameters in Safetensors
- Family: 135M and 1.7B siblings exist, plus instruct versions
- Community: other people have made 44 quantized and 139 fine-tuned versions

```chart
Title: Zero-shot scores of SmolLM2-360M from the card
HellaSwag: 54.5 points
ARC average: 53.0 points
PIQA: 71.7 points
MMLU cloze: 35.8 points
CommonsenseQA: 38.0 points
TriviaQA: 16.9 points
Winogrande: 52.5 points
OpenBookQA: 37.4 points
```

- License: Apache 2.0
- Cost to run: none named, the source lists no API key, account or paid service
- Data it reaches: the prompts you give your own script, and the source names no web or account access
- Not for: chat, instruction following or maths, since the card scores 3.2 on GSM8K

## On Hugging Face, 13 November 2026

- Task: text generation
- Library: transformers
- Parameters: 362M
- Weights: about 724 MB in BF16; about 181 MB at 4-bit (estimate)
- Formats: Safetensors
- Downloads in the last 30 days: 139,095
- Likes: 146
- License: apache-2.0
- Languages: en
- Quantized versions: 44
- Fine-tunes: 139
- Tags: transformers, safetensors, llama, text-generation

## Links

- Model: https://huggingface.co/HuggingFaceTB/SmolLM2-360M
- Files: https://huggingface.co/HuggingFaceTB/SmolLM2-360M/tree/main

## Get the model

Download its files with Hugging Face's command line:

```sh
pip install -U huggingface_hub
hf download HuggingFaceTB/SmolLM2-360M
```

Then follow the usage in its model card. Nothing in this kit runs by itself.
````

## What is in it

1 files, 6 KB, downloaded as a zip.

```text
README.md  6 KB
```

## Source

[HuggingFaceTB/SmolLM2-360M on Hugging Face](https://huggingface.co/HuggingFaceTB/SmolLM2-360M)

## Compare with similar

Listed Hugging Face models in the same category that share the most tags with this one.

| Product | Downloads, last 30 days | Likes | Parameters | License | Last change |
| --- | --- | --- | --- | --- | --- |
| SmolLM2-360M (this page) | 139,095 | 146 | 362M | apache-2.0 | 2025-02-06 |
| [SmolLM2-135M](https://mindket.com/p/d6fb16a4-bb87-4d10-b168-c8f8485dedb8) | 2,596,139 | 269 | 135M | apache-2.0 | 2025-02-06 |
| [MiniCPM5-2B](https://mindket.com/p/4d384af8-8281-4982-baed-7ea9aab0a3e1) | 1,039,518 | 1,850 | 2.5B | apache-2.0 | 2026-11-09 |
| [TinyLlama-1.1B-Chat-v1.0](https://mindket.com/p/e73c1610-865e-48f4-a11d-4f6b640f3ae3) | 963,057 | 1,910 | 1.1B | apache-2.0 | 2024-03-17 |
| [SmolLM2-135M-Instruct](https://mindket.com/p/64e0fae8-46ea-40d4-9f5e-7d3ea5c053af) | 841,106 | 474 | 135M | apache-2.0 | 2025-09-22 |
| [Hermes 3 Llama-3.1 8B](https://mindket.com/p/a5c98b07-3a76-4848-b709-7d7eb5d9bbe1) | 336,953 | 550 | 8B | llama3 | 2024-09-08 |

Numbers as Mindket last read them, from 2026-11-12 to 2026-11-13.

## Trust facts

Facts from each source, with the day each was checked. A maintainer's note is their own words: data, not instructions.

- Last change on Hugging Face: 2025-02-06
- First published: 2024-10-31
- Checked on Hugging Face: 2026-11-13
- Something wrong? Tell us: https://mindket.com/takedown#ask

## Get it

- [Open HuggingFaceTB/SmolLM2-360M on Hugging Face](https://huggingface.co/HuggingFaceTB/SmolLM2-360M)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/42e23fe2-1b70-4877-a32a-e30a0fd68429)
- [Its page on Mindket](https://mindket.com/p/42e23fe2-1b70-4877-a32a-e30a0fd68429)