> For the complete documentation index, see [llms.txt](https://docs.eyepop.ai/developer-documentation/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.eyepop.ai/developer-documentation/platform/models.md).

# Models

Pretrained models available to every account, and custom models trained on your own data

A model is what actually performs the analysis behind an [ability](/developer-documentation/platform/abilities.md). EyePop offers two kinds, and they differ in who can use them.

**Pretrained models** ship with the platform. They live in the `eyepop.` namespace, cover the tasks most projects need — detection, pose, OCR, segmentation — and are available to every account with no training and no setup. The catalog below lists the most commonly used ones.

**Custom trained models** are the ones you build from your own labeled data, for the cases no pretrained model covers. A custom model belongs to the account that trained it and is accessible only to that account — your data and the model derived from it stay yours. See [Train Your Own Model](/developer-documentation/train-your-own-model.md) for the full workflow.

Both kinds run the same way once they exist: an [inference component](/developer-documentation/platform/pop/pop-components.md) in a [Pop](/developer-documentation/platform/pop.md) names one, and the rest of the pipeline does not care which kind it got.

### Referencing a model

Name a pretrained model by its alias and tag, exactly as you would an ability:

```json
{ "type": "inference", "ability": "eyepop.person:latest" }
```

A custom trained model is named by its uuid instead, or by the alias [publishing it as an ability](/developer-documentation/platform/abilities.md) gives it under your own namespace:

```json
{ "type": "inference", "abilityUuid": "066ae8f1fc0174138000cb8bcfa7bdeb" }
```

For the full searchable catalog including community and custom abilities, see the [Abilities Hub](https://www.eyepop.ai/abilities). To create your own from a prompt, use the [dashboard](https://dashboard.eyepop.ai/dashboard).

## Pretrained model catalog

### Sized variants

Several pretrained models also come in sized variants, named by a suffix on the alias: `eyepop.person.large:latest`, `eyepop.person.nano:latest` and so on. A smaller variant is a more efficient model: it delivers higher throughput and lower latency, at the cost of slightly lower precision. Step down a size when a session needs more frames per second than it gets — on a live stream or a busy deployment that trade is usually worth it. The variants of a detection model share its labels, so switching between them changes nothing else in the Pop. Embedding variants are different models, though: vectors from two sizes are not comparable, even where they have the same length, so embed everything you compare with the same one.

### Object detection & classification

* **`eyepop.common-objects:latest`** — common everyday objects\
  Labels: `person, bicycle, car, motorcycle, airplane, bus, train, truck, boat, traffic light, fire hydrant, stop sign, parking meter, cat, dog, horse, umbrella, handbag, suitcase, sports ball, baseball bat, baseball glove, skateboard, surfboard, tennis racket, bottle, wine glass, cup, bowl, hot dog, chair, couch, potted plant, bed, dining table, toilet, tv, microwave, sink, refrigerator, book, laptop, mouse, remote, keyboard, cell phone, clock, scissors, hair drier, toothbrush`\
  [Sized variants](#sized-variants): `eyepop.common-objects.large`, `.medium`, `.small`, `.nano`
* **`eyepop.animal:latest`** — animal detection and classification\
  Labels: `bird, cat, dog, horse, sheep, cow, elephant, bear, zebra, giraffe`
* **`eyepop.vehicle:latest`** — vehicle detection\
  Labels: `bicycle, car, motorcycle, bus, train, truck`\
  [Sized variants](#sized-variants): `eyepop.vehicle.large`, `.medium`, `.small`, `.nano`
* **`eyepop.vehicle.license-plate:latest`** — license plate detection\
  Labels: `license-plate`
* **`eyepop.device:latest`** — electronic device detection\
  Labels: `clock, laptop, mouse, remote, keyboard, cell phone`
* **`eyepop.sports:latest`** — sports equipment and activity detection\
  Labels: `frisbee, skis, snowboard, sports ball, kite, baseball bat, baseball glove, skateboard, surfboard, tennis racket`\
  [Sized variants](#sized-variants): `eyepop.sports.large`, `.medium`, `.small`, `.nano`
* **`eyepop.localize-objects:latest`** — find objects from a prompt, no fixed label set

### Person analysis

* **`eyepop.person:latest`** — person detection\
  Label: `person`\
  [Sized variants](#sized-variants): `eyepop.person.large`, `.medium`, `.small`, `.nano`
* **`eyepop.expression:latest`** — facial expression analysis\
  Labels: `Happy, Neutral, Sad, Surprise, Angry, Fear, Disgust`
* **`eyepop.person.pose:latest`** — human pose estimation
* **`eyepop.person.2d-body-points:latest`** — 2D body keypoint detection\
  Labels: `left eye, left ear, left shoulder, left hip, left elbow, left wrist, left knee, left ankle, right eye, right ear, right shoulder, right hip, right elbow, right wrist, right knee, right ankle, nose, midpoint_lowest, midpoint_highest`
* **`eyepop.person.3d-body-points.full:latest`** — full 3D body pose
* **`eyepop.person.3d-body-points.heavy:latest`** — heavy 3D body pose model
* **`eyepop.person.3d-body-points.lite:latest`** — lightweight 3D body pose
* **`eyepop.person.3d-hand-points:latest`** — 3D hand keypoint detection
* **`eyepop.person.face-mesh:latest`** — detailed facial mesh
* **`eyepop.person.face.long-range:latest`** — face detection for distant subjects
* **`eyepop.person.face.short-range:latest`** — face detection for close subjects
* **`eyepop.face-id.<size>:latest`** — face-ID embedding: a vector per aligned face crop, for comparing identities. See [Face-ID](#face-id) for the sizes.
* **`eyepop.person.palm:latest`** — palm detection
* **`eyepop.person.reid:latest`** — person re-identification
* **`eyepop.person.segment:latest`** — person segmentation

### Embeddings

Embedding models return a vector per image or crop rather than labels. Both families come in [sized variants](#sized-variants); compare only vectors produced by the same variant.

#### Face-ID

Embeds an aligned face crop, for comparing identities. Every size returns a 512-dimensional vector.

| Ability                       | Vector size |
| ----------------------------- | ----------- |
| `eyepop.face-id.large:latest` | 512         |
| `eyepop.face-id.base:latest`  | 512         |
| `eyepop.face-id.small:latest` | 512         |
| `eyepop.face-id.tiny:latest`  | 512         |

#### DINOv2

A generic, class-agnostic image embedding, for similarity search, deduplication, clustering and matching objects no label set covers. For identities, use Face-ID instead: it is trained to tell faces apart, where DINOv2 embeds whatever is in the crop.

| Ability                      | Vector size |
| ---------------------------- | ----------- |
| `eyepop.dinov2.large:latest` | 1024        |
| `eyepop.dinov2.base:latest`  | 768         |
| `eyepop.dinov2.small:latest` | 384         |

### Text recognition

* **`eyepop.text:latest`** — text detection
* **`eyepop.text.recognize.landscape:latest`** — OCR for landscape text
* **`eyepop.text.recognize.landscape-tiny:latest`** — lightweight landscape OCR
* **`eyepop.text.recognize.square:latest`** — OCR for square and document text

See the [Abilities Hub](https://www.eyepop.ai/abilities) for structured OCR abilities that return typed fields.

### Segmentation

* **`eyepop.sam.small:latest`** — segmentation masks, usually run on a detection crop

### Depth estimation

Metric depth models produce a frame-level map of distance, which is what [world coordinates](/developer-documentation/platform/depth-and-world-coordinates.md) are back-projected from. A Pop names one in [`depthMap`](/developer-documentation/platform/pop/pop-object.md) rather than in an inference component.

| Ability                                      | Map fits inside |
| -------------------------------------------- | --------------- |
| `eyepop.depth.metric.small:latest`           | 280 x 280       |
| `eyepop.depth.metric.small-landscape:latest` | 504 x 280       |
| `eyepop.depth.metric.large:latest`           | 518 x 518       |
| `eyepop.depth.metric.large-landscape:latest` | 924 x 518       |

A map always keeps the **source's** aspect ratio. What the ability sets is the box it has to fit inside, so the source's shape decides which edge binds.

The plain variants use a square box, which caps the **longer** edge whichever it is. The `-landscape` variants use a wide one, so landscape media comes back far denser: a 1280x720 source yields 518x291 from `large` but 921x518 from `large-landscape` — more than three times the points. On portrait or square media the two are identical, because the height is already the binding edge.

A smaller map is faster. Map size drives the session's response time and throughput, so pick the smallest one that still resolves what you need to measure.

Only **metric** depth can be back-projected. A model reporting `relative` depth is accepted and silently produces no world coordinates at all, because relative depth is scale- *and* shift-invariant — a scene recovered from it would be distorted rather than merely unscaled.

## Using a model

An inference component naming one of these can also tag its output group, filter weak detections, and pass parameters to abilities that accept them. Tracking optionally names a re-identification model such as `eyepop.person.reid:latest`.

The [Quickstart](/developer-documentation/quickstart.md) shows a minimal Pop-first prediction.

### Next steps

* [Components](/developer-documentation/platform/pop/pop-components.md) — every component type and attribute
* [Examples](/developer-documentation/platform/pop/pop-examples.md) — worked pipelines end to end
* [Train Your Own Model](/developer-documentation/train-your-own-model.md) — build a custom model from your own data
* [Abilities](/developer-documentation/platform/abilities.md) — the task an ability performs, and how to create one from a prompt

Questions about building a Pop? Reach us at <help@eyepop.ai>.