サイト内検索

AI モデル 2119

• flux-3-image-klein-GGUF↗

  unsloth

  This is a GGUF quantized version of FLUX 3 Image Klein by Black Forest Labs, the 5.6B image transformer (16-step distilled checkpoint) for text to image and image editing. unsloth/flux-3-image-klein-GGUF uses Unsloth Dynamic 2.0 methodology: the `UD-` files are mixed precision, with every layer's type chosen from a measured sensitivity scan, and they beat the uniform files at the same size. - Loads in diffusers through `Flux3Transformer2DModel.from_single_file(..., quantization_config=GGUFQuantizationConfig(...))`. Also loads in Unsloth Desktop. - Tensor names follow the original Black Forest Labs checkpoint layout. The text encoder (Qwen3-VL-4B-Instruct) and the VAE are unchanged; take them from black-forest-labs/flux-3-image-klein. **Recommended:** `UD-Q4_K_XL` (3.93 GB) for most GPUs: LPIPS 0.038 against 0.060 for `Q4_K_M`. For output closest to bf16 use `Q8_0`; on small cards use `UD-Q2_K_XL` (2.62 GB). LPIPS (alex, lower is better) and SSIM against the bf16 transformer, same prompt, seed, noise and text encoder, 16 steps, over 19 renders: 8 held-out prompts at 1024x1024 plus 11 text-to-image and editing cases (single and multi-reference). A repeated bf16 render scores 0, so the numbers measure only the quantization.

• pythia-12b-deduped↗

  EleutherAI

  The *Pythia Scaling Suite* is a collection of models developed to facilitate interpretability research (see paper). It contains two sets of eight models of sizes 70M, 160M, 410M, 1B, 1.4B, 2.8B, 6.9B, and 12B. For each size, there are two models: one trained on the Pile, and one trained on the Pile after the dataset has been globally deduplicated. All 8 model sizes are trained on the exact same data, in the exact same order. We also provide 154 intermediate checkpoints per model, hosted on Hugging Face as branches. The Pythia model suite was designed to promote scientific research on large language models, especially interpretability research. Despite not centering downstream performance as a design goal, we find the models match or exceed the performance of similar and same-sized models, such as those in the OPT and GPT-Neo suites. Previously, we released an early version of the Pythia suite to the public. However, we decided to retrain the model suite to address a few hyperparameter discrepancies. This model card lists the changes ; see appendix B in the Pythia paper for further discussion. We found no difference in benchmark performance between the two Pythia versions. The old models are still available, but we suggest the retrained suite if you are just starting to use Pythia. **This is the current release.**

• e5-small↗

  intfloat

  **News (May 2023): please switch to e5-small-v2, which has better performance and same method of usage.** Below is an example to encode queries and passages from the MS-MARCO passage ranking dataset. Please refer to our paper at https://arxiv.org/pdf/2212.03533.pdf.

• Qwen3.8-27B-Humanlike-Chat-GGUF↗

  LessThanThreeAI

  **A 27B model that texts like a person and still does the work.** No system prompt needed. Text it and it texts back like someone you know. Ask for a formal email, a tool call or a proper explanation and it does that, then goes back to texting. Same texts, no system prompt. Left: 2.0. Right: official Qwen3.8-27B, one sample, long replies cut. - **It texts like a person out of the box.** Shown a real chat and two next messages, a blind judge took 2.0's for the real person's 23.5% of the time. Official Qwen3.8-27B got 15.1%, and the abliterated base 2.0 is built on got 0.3% (6.8% with a "text like a human" prompt). 50% would mean the judge can't tell. - **It follows instructions it never trained on.** IFBench 43.7, up from 37.3 for the base. - **It asks before it guesses.** When2Call 58, base 48. When no tool fits, it doesn't call one: BFCL irrelevance 78, base 60. - **The basics held.** GSM8K 89.1, same as the base. Right tool with the right arguments: BFCL simple 98. - **It fits a 24 GB card.** IQ4_XS is 15.10 GB.

• Qwen3.8-Flash-Next-NVFP4↗

  primitive-ai

  Qwen3.8-Flash-Next is 360 GB in BF16 and needs two data-center GPUs in FP8. This build serves it on one 96 GB Blackwell : 88.8 GiB of VRAM, the 51B n-gram table in host RAM, and no patched runtime. Two flags are load-bearing on a single GPU. `--distributed-executor-backend mp`: the default single-GPU executor never starts the n-gram offload worker, and the first forward waits on it forever — the server looks healthy and hangs. `VLLM_PLE_OFFLOAD_READY_TIMEOUT=1800`: the worker loads a 95 GB table before serving and the 600 s default can expire first. Host needs about 100 GB of free RAM. The reasoning parser and tool-call parser in this block are validated on this exact checkpoint: thinking lands in `reasoning` with no markup in `content`, and tool calls arrive as structured `tool_calls` with valid JSON arguments and `finish_reason: tool_calls`. If you have seen other NVFP4 cards warn that the automatic MoE backend picks `FLASHINFER_TRTLLM` and corrupts output: on this image on an RTX PRO 6000 the automatic choice is `FLASHINFER_CUTLASS`, printed at boot, and every number on this card went through it. Measured on the mixed sibling (same expert kernel), `--moe-backend marlin` decodes 10% faster single-stream (93.2 vs 84.6 tok/s) and 1–3% slower at concurrency 32, with TTFT up 12%; tool-calling under Marlin 79.5 (n=1). Marlin does not combine with MTP on this image: the BF16 MTP draft inherits the backend and refuses it, and the draft-scoped override in `--speculative-config` is ignored by Model Runner V2 until vllm-project/vllm#54788 lands. Choose MTP for interactive use, Marlin only without speculation. On vLLM nightly builds from early September the SM120 selector picks Marlin by default anyway (vllm#54788); the flag matters on this image. Two more flags are in the block since 2026-09-06: without them the image's defaults do not boot on a 96 GB card. A field report found it first and we reproduced both failures on this box the same day. Without MTP the default `--max-num-seqs` (1024) exceeds the Mamba state blocks left at 0.92 utilization (598 here) and CUDA graph capture aborts with `Engine core initialization failed`; with MTP at the native 262,1

• qwen3-tts-1.7b-customvoice-GGUF↗

  cstr

  GGUF / ggml conversion of `Qwen/Qwen3-TTS-12Hz-1.7B-CustomVoice` for use with **CrispStrobe/CrispASR**. The 1.7B sibling of `cstr/qwen3-tts-0.6b-customvoice-GGUF`. Same fixed-speaker pattern (9 baked speakers, no ECAPA, no reference WAV), but on the 1.7B talker — `hidden=2048`, `head_dim=128`, with a `small_to_mtp_projection` MLP that maps the 2048-d talker hidden state down to the 1024-d code predictor input space. Pair this with the codec at `cstr/qwen3-tts-tokenizer-12hz-GGUF` — the talker emits 16-codebook RVQ codes that the codec decoder renders to 24 kHz PCM.

• dragon-multiturn-query-encoder↗

  NVIDIA

  We introduce Dragon-multiturn, a retriever specifically designed for the conversational QA scenario. It can handle conversational query which combine dialogue history with the current query. It is built on top of the Dragon retriever. The details of Dragon-multiturn can be found in here. **Please note that Dragon-multiturn is a dual encoder consisting of a query encoder and a context encoder. This repository is only for the query encoder of Dragon-multiturn for getting the query embeddings, and you also need the context encoder to get context embeddings, which can be found here. Both query encoder and context encoder share the same tokenizer.** .tg {border:none;border-collapse:collapse;border-spacing:0;} .tg td{border-style:solid;border-width:1px;font-family:Arial, sans-serif;font-size:14px;overflow:hidden; padding:10px 5px;word-break:normal;} .tg th{border-style:solid;border-width:1px;font-family:Arial, sans-serif;font-size:14px;font-weight:normal; overflow:hidden;padding:10px 5px;word-break:normal;} .tg .tg-c3ow{border-color:inherit;text-align:center;vertical-align:center} .tg .tg-0pky{border-color:inherit;text-align:left;vertical-align:center} top-1 top-5 top-1 top-5 top-1 top-5 top-1 top-5 top-5* top-20* top-5* top-20*

• LTX_2.3_Fantasy_Realism_Style_LoRa↗

  vrgamedevgirl84

  This LoRA creates a **cinematic fantasy realism live-action film** look. **The dataset used to create this LoRA did not use any IP.** It is a **grounded high-fantasy cinematic style**, not actual stills or images from any movies or TV shows. The workflow used to create the sample videos can be found HERE. All sample videos are **text-to-video**, not image-to-video. Characters and environments appear as realistic live-action fantasy film assets. Scenes feature **natural skin texture**, **detailed fabrics**, **realistic creatures**, **practical materials**, **grounded lighting**, **atmospheric environments**, and **cinematic composition**. The result feels like a scene from a modern high-end fantasy film with believable characters and immersive environments.

• sam3-gguf↗

  Asher-1

  ]633;E;echo "=== 3. hparams as seen by the C++ loader"\x3b timeout 60 ./build-vis/diff_tokenizer /tmp/hf_verify/sam3-q4_0.gguf /tmp/tok_diff 2>&1 | grep -E "mem_selection|max_cond|max_obj" ;a7ba6c53-87c6-427f-92bf-6a5106a2fee1]633;C# github: https://github.com/Asher-1/sam3-ggml This directory holds ready-to-run **GGUF** models for sam3.cpp. Each file name encodes three things: > **Architecture lineage**: this directory covers **2 architectures** — > **SAM 3** (`sam3-*`, `sam3-visual-*`) and the **SAM 2 family** > (`sam2*`, `sam2.1*`). There are **no SAM 1** checkpoints (SAM 1 / ViT-B/L/H is a separate > architecture not shipped by this project). The SAM 2 family is visual-only > (points/box + tracking); **SAM 3 full adds text-prompted detection (PCS)**: > type `"cat"` and get every cat in the image.

• chronos-bolt-tiny↗

  autogluon

  🚀 **Update Feb 14, 2025**: Chronos-Bolt models are now available on Amazon SageMaker JumpStart! Check out the tutorial notebook to learn how to deploy Chronos endpoints for production use in a few lines of code. Chronos-Bolt is a family of pretrained time series forecasting models which can be used for zero-shot forecasting. It is based on the T5 encoder-decoder architecture and has been trained on nearly 100 billion time series observations. It chunks the historical time series context into patches of multiple observations, which are then input into the encoder. The decoder then uses these representations to directly generate quantile forecasts across multiple future steps—a method known as direct multi-step forecasting. Chronos-Bolt models are **more accurate**, up to **250 times faster** and **20 times more memory-efficient** than the original Chronos models of the same size. The following plot compares the inference time of Chronos-Bolt against the original Chronos models for forecasting 1024 time series with a context length of 512 observations and a prediction horizon of 64 steps.