Mobilepelikan 80m

MobilePelikan-80M - Foreground Mask Generation Model

MobilePelikan-80M gallery

MobilePelikan-80M is an in-house foreground mask-generation model developed by ZundTeam, a German AI lab. It is designed for image segmentation workflows where a system receives a single RGB image and predicts a foreground region mask directly in image space. Rather than asking the model to classify every pixel into a large label set, MobilePelikan-80M is optimized for the simpler and often more practical task of separating a dominant foreground subject from the surrounding background.

MobilePelikan-80M is built as a compact custom architecture with a transformer backbone and a learned mask decoder. The model encodes the image into visual tokens, processes them through a lightweight segmentation stack, and produces dense mask logits together with a confidence-style mask score. It is not a wrapper around SAM, SAM2, SAM3, or any released promptable segmentation model. MobilePelikan-80M is a standalone PyTorch and safetensors model intended for lightweight segmentation pipelines, object-isolation tools, annotation bootstrapping, and computer-vision research.

Unlike promptable systems such as Pelikan-2, MobilePelikan-80M does not require a box, point, or text instruction at inference time. It is a prompt-free model. The surrounding application simply supplies an image, and the model predicts a single foreground mask. This makes MobilePelikan-80M useful when a project wants a direct image-to-mask component instead of an interactive prompt pathway.

MobilePelikan-80M belongs to the MobilePelikan model family, a smaller and faster line positioned below larger flagship segmentation systems. The important idea behind the family is not to reproduce a larger promptable model in miniature, but to provide a lighter segmentation model line that is easier to run, easier to integrate, and practical for moderate workloads where prompt-free foreground extraction is enough.

The model is especially useful when segmentation should remain simple. Instead of deciding among many semantic categories or relying on a user to provide a prompt, the surrounding application can treat MobilePelikan-80M as a direct foreground extractor. A cutout tool can use it to isolate a subject. An annotation workflow can use it to create an initial mask that a human corrects. A preprocessing pipeline can use it to remove background clutter before downstream vision tasks. A research system can use it as a compact baseline for studying transformer-based mask generation.

This also gives the model a different operational feel from heavier segmentation systems. In practice, MobilePelikan-80M is meant to behave like a dependable visual utility: pass in an image, receive a spatial foreground estimate, and decide in the surrounding application how strict, soft, or refined the final mask should be. That makes it well suited to products and experiments where the segmentation model should stay focused on a narrow job instead of becoming a larger interactive assistant.

The release format follows that same philosophy. The repository exposes raw model artifacts and a direct configuration rather than hiding the model behind a complex framework-specific abstraction. Developers can load the weights, inspect the configuration, adapt preprocessing to their own environment, and build small wrappers around the core forward pass. In that sense, the model card is intended not only as a description of the artifact, but also as a guide for how to think about the model as a reusable segmentation component.

At a Glance

Property	Value
Model name	MobilePelikan-80M
Developer	ZundTeam
Model type	MobilePelikanForMaskGeneration
Task	Binary foreground mask generation
Parameter count	75,643,009
Input image size	256 x 256
Patch size	16
Encoder width	512
Encoder depth	14 layers
Decoder depth	6 layers
Attention heads	8
Mask embedding dim	256
Aux neck dim	256
Default mask threshold	0.5
Output	Single foreground mask + mask score
Format	PyTorch / safetensors

Foreground Segmentation Flow

MobilePelikan-80M follows a simple image-to-mask flow:

1. An RGB image is resized to the configured input size.
2. A convolutional stem converts the image into early visual features.
3. Patch embedding turns those features into a compact visual token grid.
4. A transformer encoder models the global image context.
5. A learned mask query attends over the encoded image representation.
6. A dense reconstruction path converts the decoded representation into mask logits.
7. A downstream system thresholds or post-processes the final foreground mask.

MobilePelikan-80M workflow

This design gives MobilePelikan-80M the structure expected from a modern compact segmentation model while remaining small enough for iteration and deployment in lighter workflows. The workflow image above is generated from a real photo run through the released model. It shows the raw input, the probability map, the thresholded binary mask, and the final overlay.

The interaction pattern is deliberately simple. There is no prompt encoder, no class vocabulary, and no multi-candidate prompt selection loop. A system gives the model an image, and the model returns a foreground estimate. That simplicity is one of the main design goals of the MobilePelikan line.

Another way to understand the flow is to think of the model as compressing the image into a compact scene representation and then expanding that representation back into a foreground decision map. The encoder is responsible for understanding the overall structure of the scene, while the decoder and reconstruction path are responsible for translating that understanding into a dense spatial output. This separation of responsibilities keeps the architecture conceptually clean and makes the model easier to reason about during integration.

Model Overview

The released MobilePelikan-80M model has approximately 75.6M parameters. The architecture is custom and identified in the configuration as MobilePelikanForMaskGeneration.

MobilePelikan-80M is designed for image-space foreground segmentation. Images are reduced into visual patches, encoded by a transformer, and decoded into a dense binary mask. The decoder is guided by a learned mask query rather than by a user prompt. This keeps the model focused on one task: produce a useful foreground mask from a single image.

The model includes a score head that predicts a confidence-style value for the decoded mask. This can help downstream systems rank outputs, decide whether the result should be accepted automatically, or determine when additional post-processing or human review may be useful.

The model is built around 256 x 256 inputs. For larger images, a practical pipeline can resize the full image, crop around the likely foreground region, or use MobilePelikan-80M as a first-pass mask proposal stage before higher-resolution refinement. The predicted mask can then be resized back to the original image resolution and optionally cleaned with post-processing.

Like larger segmentation systems, MobilePelikan-80M emits raw mask logits rather than only hard binary masks. This gives applications direct control over thresholding. A stricter threshold can produce cleaner regions with fewer uncertain pixels, while a softer threshold can preserve more boundary detail around difficult shapes.

Because the model is prompt-free, the burden of deciding what the foreground should be sits partly in the image distribution and partly in the surrounding pipeline design. In many practical cases this is a strength rather than a limitation. A controlled product experience can decide that the most visually dominant subject should be extracted. A batch-processing system can decide that the largest coherent region is the desired result. A review tool can surface the model output as a starting point and let a human quickly approve or correct it. The model therefore works best when it is given a clear role inside a broader application decision flow.

Architecture

MobilePelikan-80M uses a custom transformer-based foreground segmentation architecture with four main parts:

• Convolutional stem: prepares the RGB image before patch tokenization.
• Image encoder: converts the feature map into a contextualized grid of visual tokens.
• Mask decoder: lets a learned mask query attend over the image representation.
• Mask reconstruction path: projects decoded features back into dense image-space mask logits.

The released configuration for mobilepelikan-80m is:

Component	Setting
Stem input channels	3
Encoder dimension	512
Encoder blocks	14
Decoder blocks	6
Attention heads	8
MLP ratio	4.0
Dropout	0.0
Attention dropout	0.0
Grid size	16 x 16 patches
Mask query count	1

The image encoder uses patch embedding followed by stacked self-attention and feed-forward layers. This gives the model global scene context while preserving a spatial token grid for downstream mask prediction.

The decoder uses a learned mask query rather than a prompt-conditioned token set. That query attends to the encoded image memory, extracts object-level structure from the scene, and feeds the reconstruction path that produces dense mask logits.

The dense mask reconstruction path combines decoded mask information with upsampled visual features from the convolutional neck. This restores enough spatial detail to produce a useful foreground mask in image space.

This design keeps MobilePelikan-80M focused on direct foreground extraction. It is not an image classifier, object detector, captioning system, text-to-image model, or multimodal assistant. It is a dedicated foreground mask-generation model.

That focus is important for understanding the tradeoff the model makes. MobilePelikan-80M does not attempt to solve every vision task at once. Instead, it narrows the problem to one concrete output type: a foreground mask. By narrowing the task, the implementation can remain comparatively direct, and the integration story becomes easier for applications that only need segmentation rather than a larger multimodal stack.

Design Goals

MobilePelikan-80M was designed around four practical goals.

First, it should be simple. The model should accept an image and return a mask without requiring prompt engineering or interactive inputs. This makes it easy to place inside batch pipelines and lightweight applications.

Second, it should preserve an image-space workflow. The model predicts dense segmentation masks, not captions, labels, or class IDs. Its role is to turn image content into a spatial foreground estimate that can be inspected, edited, or reused downstream.

Third, it should be lightweight relative to flagship segmentation systems. The MobilePelikan line is intended to be easier to train, iterate, and serve while still benefiting from transformer-based image encoding.

Fourth, it should remain research-friendly. The release uses PyTorch and safetensors artifacts, a straightforward configuration file, and a direct model card so developers can load the model, test variations, and build their own wrappers around it.

Taken together, these goals define the MobilePelikan line as a practical engineering model family. The release is meant to be used, adapted, and integrated. It is not presented as a universal solution for all segmentation problems, and it does not depend on a large prompt interface to be useful. Its main...