保存済みツールを推薦
FOXAI SEARCH

サイト内検索

AI モデル 34

  • Qwen3.8-27B-GGUF↗

    6block

    A 27B dense vision-language model (27.8B including the vision tower). 64 decoder layers in a hybrid stack: `full_attention_interval=4` means every fourth layer is grouped-query full attention (16 layers) and the rest are Gated DeltaNet linear attention (48 layers). Vocab 248320 with untied embeddings. Context length 262144 natively, extensible further with YaRN. The mmproj file is separate by design: llama.cpp loads the text backbone and the vision projector as two files. Download one tier plus one mmproj. Without the mmproj the model still runs, but text-only. The `mmproj-` and `mtp-` prefixes are what recent llama.cpp builds match on to tell the three file kinds apart, so `-hf 6block/Qwen3.8-27B-GGUF` picks a backbone rather than a projector, and `--spec-type mtp` finds the draft on its own.

  • SmolLM-360M↗

    HuggingFaceTB

    SmolLM is a series of state-of-the-art small language models available in three sizes: 135M, 360M, and 1.7B parameters. These models are built on Cosmo-Corpus, a meticulously curated high-quality training dataset. Cosmo-Corpus includes Cosmopedia v2 (28B tokens of synthetic textbooks and stories generated by Mixtral), Python-Edu (4B tokens of educational Python samples from The Stack), and FineWeb-Edu (220B tokens of deduplicated educational web samples from FineWeb). SmolLM models have shown promising results when compared to other models in their size categories across various benchmarks testing common sense reasoning and world knowledge. For detailed information on training, benchmarks and performance, please refer to our full blog post.

  • NVIDIA-Nemotron-Labs-Dory1.0-4B-BF16↗

    NVIDIA

    **NVIDIA-Nemotron-Labs-Dory1.0-4B-BF16** is a looped (latent-recurrent) large language model (LLM) trained by NVIDIA. The model employs a normalized-GPT architecture with interleaved hybrid sliding window attention (SWA) and full attention layers. By repeatedly applying a shared block of layers, Dory1.0-4B can spend more compute per token allowing it to scale intelligence. This model is ready for commercial or non-commercial use. Dory (Looped LM) Architecture: The layer stack is divided into three groups: Input (I), Recurrent (R) and Output (O). The shared Recurrent block (R) is applied multiple times between the Input and Output blocks, and the input is reinjected into every loop. In Dory, the Input and Output blocks have 8 layers each, while the Recurrent block has 20 layers. Accuracy numbers measured by NVIDIA under a consistent harness (NeMo Gym / Nemo Evaluator SDK). Terminal-Bench 2.1 uses the Terminus-2 harness for all models. † Reported scores.

  • Qwen-Image-2.1-viggle-4-steps-turbo-GGUF↗

    Abiray

    This repository contains optimized community **GGUF quantizations** of Viggle/Qwen-Image-2.1-viggle-turbo, an official 4-step distilled student model of Qwen-Image-2.1 trained by Viggle using **Distribution Matching Distillation (DMD)**. These files were converted directly from the official full transformer weights (`transformer/diffusion_pytorch_model.safetensors`), allowing you to run near-instant 4-step image generation and image editing natively inside **ComfyUI** without needing to stack external LoRAs. Because this model is distilled with DMD, **it requires specific inference parameters**. Using standard diffusion parameters will degrade image quality or cause visual burn artifacts:

  • OneRec-1.7B↗

    OpenOneRec

    **OpenOneRec** is an open-source framework designed to bridge the gap between traditional recommendation systems and Large Language Models (LLMs). While Generative Recommendation has shown promise, existing models often struggle with isolated data silos and a lack of reasoning capabilities. To address this, we introduce a unified framework that comprises: * **RecIF-Bench**: The first holistic Recommendation Instruction-Following Benchmark, containing **100M interactions** from 200k users across heterogeneous domains (Short Video, Ads, Product). * **OneRec-Foundation Models**: A family of models (1.7B & 8B) built on the Qwen3 backbone. The series includes **Standard** versions trained on our open-source dataset and **Pro** versions enhanced with a hundred-billion-token industrial corpus from Kuaishou. * **Full-Stack Pipeline**: We open-source our comprehensive training pipeline, including data processing, co-pretraining, and post-training, to ensure full reproducibility and facilitate scaling law research in recommendation. * **[2026.1.1]** 📑 The technical report has been released. * **[2026.1.1]** 🎉 **OneRec-Foundation** models (1.7B, 8B) are now available on Hugging Face! * **[2026.1.1]** 🚀 **RecIF-Bench** dataset and evaluation scripts are open-sourced. * **[2026.1.5]** 🔡 **OneRec-Tokenizer** is open-sourced to support SID generation for new domains.

  • Qwen3.8-27B-GPTQ-INT4-FP8KV↗

    abhishekchohan

    A 4-bit weight-only **GPTQ** quantization of **Qwen/Qwen3.8-27B** with an **fp8-e4m3 KV cache calibrated alongside the weights**. INT4 weights shrink the footprint ≈2.8× and fp8 KV halves the cache, so the model serves its native **262,144-token** context on a **single 48 GB GPU**. fp8 KV also makes YaRN extension to **524,288 tokens** fit the same card, and up to 1M tokens on 96 GB (retrieval beyond 262k unvalidated). Identical harness and hardware for base and quantized: lm-evaluation-harness with the vLLM 0.27.1 backend on a single NVIDIA RTX PRO 6000 (Blackwell, 96 GB), greedy decoding, seed 1234. The base runs with bf16 KV and the quantized model with fp8-e4m3 KV, each at its recommended serving configuration, so every Δ measures the full int4 + fp8-KV stack rather than weights alone. Generative tasks run with the model's native chat template, thinking enabled, `max_gen_toks=8192`; loglikelihood tasks run untemplated. `minerva_math500` reports `math_verify`, since strict `exact_match` measures answer format, not content, on thinking-model outputs. The BF16 base scores identically (9/9), showing no retrieval degradation through the int4 + fp8-KV stack at the context length it was calibrated at.

  • SmolLM-135M-GGUF↗

    QuantFactory

    library_name: transformers license: apache-2.0 language: - en datasets: - HuggingFaceTB/smollm-corpus SmolLM is a series of state-of-the-art small language models available in three sizes: 135M, 360M, and 1.7B parameters. These models are built on Cosmo-Corpus, a meticulously curated high-quality training dataset. Cosmo-Corpus includes Cosmopedia v2 (28B tokens of synthetic textbooks and stories generated by Mixtral), Python-Edu (4B tokens of educational Python samples from The Stack), and FineWeb-Edu (220B tokens of deduplicated educational web samples from FineWeb). SmolLM models have shown promising results when compared to other models in their size categories across various benchmarks testing common sense reasoning and world knowledge. For detailed information on training, benchmarks and performance, please refer to our full blog post. While SmolLM models have been trained on a diverse dataset including educational content and synthetic texts, they have limitations. The models primarily understand and generate content in English. They can produce text on a variety of topics, but the generated content may not always be factually accurate, logically consistent, or free from biases present in the training data. These models should be used as assistive tools rather than definitive sources of information. Users should always verify important information and critically evaluate any generated content. For a more comprehensive discussion of the models' capabilities and limitations, please refer to our full blog post..

  • Tess-M-v1.3↗

    migtissera

    This version is the stable release. The issues that were present in versions 1.0, 1.1 and 1.2 all have been rectified. Thank you for your patience while R&D was conducted. Enjoy! This model have been tested on very long context length. Model produced slight repetition, but it was very minor. I recommend testing the model to your usecase and limiting the context length. Here's my conversation: https://migel.substack.com/p/testing-tess-m-v13 As can be seen, "USER:" and "SYSTEM: Answer the question thoughtfully and intelligently. Always answer without hesitation." was presented by the model in the latter part of the conversation.

  • MiniMax-H3-Qwen3-VL-NVFP4↗

    6block

    An **NVFP4 (4-bit) Qwen3-VL-32B text encoder** for MiniMax-H3, made with `convert-to-quant`. It is a drop-in replacement for the H3 conditioning text encoder (ComfyUI `CLIPLoader`, type `minimax`). The H3 video weights are unchanged — only the text encoder is quantized to 4-bit, to bring the full H3 stack onto consumer GPUs. This encoder deliberately keeps more of the network in bf16 than a minimum-size 4-bit encoder does. The `--qwen_vlm` filter protects — at bf16 — the token embeddings, the **first and last language layers**, and the **entire vision tower**, quantizing only the middle language-layer linears to NVFP4. The result is 16.64 GiB, about 2 GiB above the most aggressively quantized community NVFP4 encoders (≈14.6 GiB, e.g. the AWQ-quantized encoder in `Comfy-Org/MiniMax-H3`), in exchange for leaving the precision-sensitive layers (embeddings, boundary layers, vision) untouched. It is a fidelity-first tradeoff: spend ~2 GiB more VRAM to keep the layers that most affect conditioning at full precision. Everything still fits a 24 GB card with offload. Everything is held constant except encoder precision — the bf16 encoder vs this NVFP4 encoder, same prompts, same seeds, same DiT — over a 16-clip paired set.

  • Qwen3.8-Flash-Next-REAP-288-GGUF↗

    sh0wie

    This is the REAP-288 build in GGUF, for llama.cpp and the tools built on it (Ollama, LM Studio, and similar). It is the 180B-class MoE with its experts pruned 512 -> 288 per layer, converted directly from the bf16 source in a single quantization step, so each file loses accuracy exactly once rather than stacking a re-quantization on top of an existing 4-bit build. The pruned model scores 91.5% on HumanEval (149 of 164), against 93.9% for the unpruned full model. That number is measured on the MLX 4-bit lineage; the GGUF quants share the same kept-expert selection and derive from the same bf16 source. If you run MLX on Apple Silicon instead of llama.cpp, use the 4-bit MLX build. The pmlx engine and its speedups apply to the MLX builds, not to GGUF; nothing on this card depends on it.