サイト内検索
AI モデル 2119
- sarvam-translate↗
sarvamai
Sarvam-Translate is an advanced translation model built by Sarvam AI in partnership with AI4Bharat, specifically designed for comprehensive, document-level translation across the 22 official Indian languages, built on Gemma3-4B-IT. It addresses modern translation needs by moving beyond isolated sentences to handle long-context inputs, diverse content types, and various formats. Sarvam-Translate aims to provide high-quality, contextually aware translations for Indian languages, which have traditionally lagged behind high-resource languages in LLM performance. `Assamese`, `Bengali`, `Bodo`, `Dogri`, `Gujarati`, `English`, `Hindi`, `Kannada`, `Kashmiri`, `Konkani`, `Maithili`, `Malayalam`, `Manipuri`, `Marathi`, `Nepali`, `Odia`, `Punjabi`, `Sanskrit`, `Santali`, `Sindhi`, `Tamil`, `Telugu`, `Urdu` The open-sourced checkpoint only supports: - English to Indian languages - Indian languages to English
- gtr-t5-large↗
sentence-transformers
This is a sentence-transformers model: It maps sentences & paragraphs to a 768 dimensional dense vector space. The model was specifically trained for the task of sematic search. This model was converted from the Tensorflow model gtr-large-1 to PyTorch. When using this model, have a look at the publication: Large Dual Encoders Are Generalizable Retrievers. The tfhub model and this PyTorch model can produce slightly different embeddings, however, when run on the same benchmarks, they produce identical results. The model uses only the encoder from a T5-large model. The weights are stored in FP16.
- sam-3d-objects↗
facebook
- Granite-4.2-cmf↗
infosave
This repository contains all three dense reasoning models from IBM's Granite 4.2 family: 3B, 8B and 30B, each converted directly from the original bf16 checkpoint to Q4TP and Q8_2F CMF. A CMF is one memory-mapped file containing the weights, tokenizer, exact chat template and integrity hashes. The same artifact runs on CPU, Vulkan (NVIDIA/AMD/Intel), DX12 and Metal; inference needs no Python, PyTorch, CUDA toolkit or model-specific GPU build. Use `--no-think` for a direct answer. Without it, the embedded Granite template opens the model's native ` ... ` reasoning block. Numbers are single-stream `cortiq bench --tokens 100 --core --ignore-eos` steady decode on an NVIDIA A40. They exclude model load and prompt prefill. The 3B Q4TP run prefills at 80.3 tok/s and reaches first token in 0.58 s; its Q8_2F control prefills at 47.5 tok/s and reaches first token in 0.93 s. The 30B Q8_2F file is larger than the A40's safe physical graph live set: Cortiq automatically kept 55 of 64 layers on Vulkan and ran the nine-layer tail on the host. That 100-token run peaked at 43,036 MiB of the A40's 46,068 MiB and completed without steady-state weight uploads.
- MiniCPM5-2B-SFT↗
openbmb
We are releasing **MiniCPM5-2B**, the second model in the **MiniCPM5** series, following MiniCPM5-1B. It is a dense 2B Transformer that scales up the same training recipe, built for on-device, local deployment, and resource-constrained scenarios, reaching 2B-class open-source SOTA. 🏆 **2B-class open-source SOTA**: compared with strong open-source models of similar size, MiniCPM5-2B achieves SOTA performance within this comparison set. It remains competitive with 4B-class models overall, while showing its advantages over models of comparable size in coding, mathematics, long-context understanding, tool use, and agentic tasks. #capability-comparison-radar { --foreground: #171717; display: block; width: 100%; max-width: 620px; margin: 0 auto; background: #fff; font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "PingFang SC", "Hiragino Sans GB", "Microsoft YaHei", sans-serif; } #capability-comparison-radar svg { display: block; width: 100%; height: auto; background: #fff; } #capability-comparison-radar .title { fill: var(--foreground); font-size: 16px; font-weight: 600; letter-spacing: 0; } #capability-comparison-radar .axis-label { fill: #333; font-size: 12px; font-weight: 600; } #capability-comparison-radar .ring { fill: none; stroke: rgba(128,128,128,.18); stroke-width: .8; } #capability-comparison-radar .spoke { stroke: rgba(128,128,128,.25); stroke-width: .8; } #capability-comparison-radar .ring-label { fill: #8a8a8a; font-size: 9px; } #capability-comparison-radar .series { stroke-linejoin: round; } #capability-comparison-radar .series.primary { stroke-width: 2.4; } #capability-comparison-radar .legend-label { fill: #171717; font-size: 12px; font-weight: 600; } #capability-comparison-radar .legend-average { fill: #666; font-size: 11px; } #capability-comparison-radar .legend-swatch { rx: 3; } @media (max-width: 900px) { #capability-comparison-radar { overflow-x: auto; } #capability-comparison-radar svg { min-width: 620px; } }
- wav2vec2-large-xlsr-53-slovenian↗
anton-l
Fine-tuned facebook/wav2vec2-large-xlsr-53 on Slovenian using the Common Voice dataset. When using this model, make sure that your speech input is sampled at 16kHz. The model can be evaluated as follows on the Slovenian test data of Common Voice.
- DepthPro-hf↗
apple
This is the transformers version of DepthPro, a foundation model for zero-shot metric monocular depth estimation, designed to generate high-resolution depth maps with remarkable sharpness and fine-grained details. For the checkpoint compatible with the original codebase, please check this repo. - DepthPro: Monocular Depth Estimation - Table of Contents - Model Details - Model Sources - How to Get Started with the Model - Training Details - Training Data - Preprocessing - Training Hyperparameters - Evaluation - Model Architecture and Objective - Citation - Model Card Authors DepthPro is a foundation model for zero-shot metric monocular depth estimation, designed to generate high-resolution depth maps with remarkable sharpness and fine-grained details. It employs a multi-scale Vision Transformer (ViT)-based architecture, where images are downsampled, divided into patches, and processed using a shared Dinov2 encoder. The extracted patch-level features are merged, upsampled, and refined using a DPT-like fusion stage, enabling precise depth estimation.
- gemma-4-12B-it-qat-AWQ-INT4↗
cyankiwi
Hugging Face | GitHub | Launch Blog | Documentation | Technical Report > [!Note] > This model card is for the new versions of the Gemma 4 family optimized with Quantization-Aware Training (QAT), which allows preserving similar quality to bfloat16 while dramatically reducing the memory requirements to load the model. > Four versions of the QAT checkpoints are available: > * **Unquantized QAT checkpoints** (Q4_0): Half-precision weights extracted from the QAT pipeline, ideal for custom downstream compilation and research. Available for Gemma 4 E2B, E4B, 12B, 26B A4B, and 31B, and their drafter models. > * **GGUF** (Q4_0): Ready-to-deploy formats for broad ecosystem compatibility. Available for Gemma 4 E2B, E4B, 12B, 26B A4B, and 31B. > * **Mobile-optimized** (wNa8o8): A custom schema engineered explicitly for mobile hardware efficiency. It features targeted 2-bit decoding layers, optimized KV caches, and static activations to maximize VRAM savings. Available for Gemma 4 E2B and E4B. > * **Compressed Tensors** (w4a16): QAT checkpoints serialized in the compressed-tensors format for native, optimized inference with vLLM. Available for Gemma 4 E2B, E4B, 12B, and 31B. > * **Assistant Compatibility**: When using multi-token prediction (speculative decoding) with an assistant model alongside a QAT target model, the assistant model must also be a QAT checkpoint with the same precision to ensure compatibility. Gemma is a family of open models built by Google DeepMind. Gemma 4 models are multimodal, handling text and image input (with audio supported on E2B, E4B, and 12B) and generating text output. This release includes open-weights models in both pre-trained and instruction-tuned variants. Gemma 4 features a context window of up to 256K tokens and maintains multilingual support in over 140 languages.
- GLM-5.3-Flash-CYBERSECURITY-W4A16↗
dealignai
> [!IMPORTANT] > **Serving note — read before your first request (vLLM / SGLang with a reasoning parser).** > > - **`reasoning_effort` only accepts `"low"` and `"high"`.** Anything else — `medium`, `xhigh`, > `off`, or omitting it — silently resolves to **`max`**, the deepest mode. Template line: > `reasoning_effort ... in ['low','high'] else 'max'`. > - **At `max`, a small `max_tokens` returns an EMPTY reply.** The model spends the whole budget > inside ` ` and you get `finish_reason="length"` with `content=""`. In multi-turn the empty > turn poisons the history and the conversation does not recover. Measured: `max` + `max_tokens > 2000` dies from turn ~4; `max` + `6000` is clean; `low` and `high` are clean at 2000. > **It is budget exhaustion, not a loop** — sampling changes do not rescue it. > - **Do NOT pass `enable_thinking`.** This template has no such variable (only `clear_thinking` and > `reasoning_effort`). Passing it — or a top-level `reasoning_effort: "none"` — turns the parser off > while the model still thinks, dumping raw reasoning into `content`. > - **Reasoning is returned in `message.reasoning`**, not `message.reasoning_content` > (vLLM renamed the output field; the input side still accepts both). > - `clear_thinking` must be nested inside `chat_template_kwargs` — a top-level key is ignored. > > > Use `"high"` for hard tasks; if you want `max`, give it `max_tokens >= 6000`. > > > **Video and image parameters — measured, because several are accepted then silently ignored.** > > - 🔴 **`media_io_kwargs.video.fps` must stay BELOW the clip's own frame rate.** Requesting a value > at or above it makes the placeholder builder count 3x the real tokens and **kills the engine**: > `ValueError: Attempted to assign N = N multimodal tokens to 3N placeholders` -> `EngineDeadError`, > server down until restarted. Upstream: vLLM #55644 / #55647. `fps: 2` is the safe, accurate choice. > - **`max_frames` and `num_frames` are not interchangeable across builds.** On vLLM nightly > `max_frames` is honoured and `num_frames` ignored; on the older `0.1.dev*` line it is the exact > reverse. A client that sets only one silently gets full-rate sampling on the other build
- LTX-2.5-Quantized↗
joeygambino
LTX-2.5 generates picture and sound in one pass. It is also 42 GB of bf16 weights, and the text encoder beside it is another 26 GB. This repo is the set of weights that make it run on a card that does not have that. Sizes are measured, not estimated. "Fits 16 GB" assumes the text encoder is not resident at the same time — ComfyUI frees it before sampling — and tiled VAE decode. File sizes are decimal GB (bytes / 10^9); card capacities are the usual binary GiB, so a 15.9 GB file occupies 14.8 GiB of a 16 GiB card. The gap is real and it is where your activation pool lives. On the text encoder: at bf16 it is 26.3 GB and at Lightricks' int8 15.4 GB, which on a 16 GB card means the encoder alone owns the machine for the one step that just makes an embedding. **No GGUF of the LTX-2.5 encoder exists** — ComfyUI-GGUF gates text encoders on `TXT_ARCH_LIST`, which carries `gemma3` but not `gemma4`, so LTX-2.3's gemma3 encoder does have GGUFs and this one cannot. The open request (#450, 2026-05-28) has not been picked up — but comfy-native quantisations of it do exist and landed the same day as ours (Winnougan's w4a8-convrot at 10.6 GB, DmitryDB's nvfp4 at 11.2, vonkaiser's nvfp4-torchao at 8.9). Ours is w4a8 at 10.60 GB, within 2 MB of Winnougan's — the same format at the same size, published independently. Treat it as a mirror, not a first.