Saved toolsSubmit a tool
FOXAI SEARCH

Search FoxAI

AI Models 2119

  • SGuard-JailbreakFilter-2B-v1↗

    SamsungSDS-Research

  • colSmol-256M↗

    vidore

    ColSmolVLM is a model based on a novel model architecture and training strategy based on Vision Language Models (VLMs) to efficiently index documents from their visual features. It is a SmolVLM extension that generates ColBERT- style multi-vector representations of text and images. It was introduced in the paper ColPali: Efficient Document Retrieval with Vision Language Models and first released in this repository This version is trained with the commit b983e40 of the Colpali repository. (main branch from the repo) Our training dataset of 127,460 query-page pairs is comprised of train sets of openly available academic datasets (63%) and a synthetic dataset made up of pages from web-crawled PDF documents and augmented with VLM-generated (Claude-3 Sonnet) pseudo-questions (37%). Our training set is fully English by design, enabling us to study zero-shot generalization to non-English languages. We explicitly verify no multi-page PDF document is used both *ViDoRe* and in the train set to prevent evaluation contamination. A validation set is created with 2% of the samples to tune hyperparameters.

  • Spark-X2.5-cmf↗

    infosave

    Spark-X2.5-4B and Spark-X2.5-1.7B (hybrid attention: three 512-token sliding-window layers per full layer, 1M-token context, thinking mode, tool calling, 200+ languages) packaged as single CMF files. They run with `cortiq`, a Rust inference engine with no Python and no ML framework: NVIDIA, AMD and Intel GPUs through Vulkan/DX12, Apple silicon through Metal, and the CPU. Use cortiq 0.8.12 or later; prebuilt binaries for Linux, macOS and Windows are on the releases page. The engine picks the GPU and its settings itself. `--no-think` asks for a direct answer; without it the model reasons in a ` ` block first, so raise `--max-tokens` (default 256). All files are quantized from the bf16 checkpoints. Perplexity: the first 4096 tokens of wikitext-2 test with the BOS token in front; the unquantized models score 10.61 (4B) and 14.49 (1.7B; transformers in float32 gives the same 14.49). Spark is sensitive to 4-bit attention and down projections, so only gate/up are 4-bit in the compact files.

  • GLM-5.3-Flash-NVFP4↗

    tattrongvu

    NVFP4 (4-bit float, group size 16) quantization of `zai-org/GLM-5.3-Flash`, covering the routed experts of **every** MoE layer — including layer 45, the multi-token-prediction (MTP) layer — in a **single, uniform** scheme. **No calibration data is used in this quantization step**, and none is needed: the scheme quantizes each group of 16 weights with a scale derived from those 16 values (`memoryless_minmax`), so there is no forward pass for calibration data to inform. The checkpoint contains no activation-scale tensors and declares `input_activations: null`. `num_hidden_layers: 45` plus `num_nextn_predict_layers: 1` puts the MTP layer at index **45**, and it is not a small head: 288 routed experts, ~7.25 B parameters, its own DSA attention and `eh_proj`/`enorm`/`hnorm` plumbing. Keeping it in the same scheme as every other expert layer means the checkpoint has one expert layout throughout — 37,152 packed expert tensors (43 × 288 × 3).

  • gemma-3n-E2B-it-litert-preview-GGUF↗

    unsloth

    Gemma is a family of lightweight, state-of-the-art open models from Google, built from the same research and technology used to create the Gemini models. Gemma 3n models are designed for efficient execution on low-resource devices. They are capable of multimodal input, handling text, image, video, and audio input, and generating text outputs, with open weights for pre-trained and instruction-tuned variants. These models were trained with data in over 140 spoken languages. Gemma 3n models use selective parameter activation technology to reduce resource requirements. This technique allows the models to operate at an effective size of 2B and 4B parameters, which is lower than the total number of parameters they contain. For more information on Gemma 3n's efficient parameter management technology, see the Gemma 3n page. With instruction-tuned models, you need to use chat templates to process our inputs first. Then, you can pass it to the pipeline.

  • parakeet-tdt-0.6b-v3-coreml↗

    FluidInference

    On‑device multilingual ASR model converted to Core ML for Apple platforms. This model powers FluidAudio’s batch ASR and is the same model used in our backend. It supports 25 European languages and is optimized for low‑latency, private, offline transcription. The conversion script is here: https://github.com/FluidInference/mobius/tree/main/models/stt/parakeet-tdt-v3-0.6b/coreml And the benchmarks are here: https://github.com/FluidInference/FluidAudio/blob/main/Documentation/Benchmarks.md#transcription

  • Qwen3.8-27B-Intel-Arc-Tuned-GGUF↗

    Greatjedi

    **Hardware-Accelerated Weights for Intel Arc GPUs (Battlemage Xe2 / Alchemist Xe / oneAPI SYCL)** *Engineered by Greatjedi & Gemini (DeepMind Antigravity Team)* If you own an **Intel Arc GPU** (such as the **Intel Arc Pro B60 24GB**, Arc A770 16GB, or Battlemage graphics cards) and have attempted to run popular 27B quantization variants (such as `IQ2_S`, `IQ3_XXS`, or Unsloth's "Dynamic" `UD-Q4_K_S`), you likely noticed your generation speed crawling at an agonizing **8.1 to 12.2 tokens/second**, despite the GPU having more than enough raw compute and 512 GB/s memory bandwidth. 1. **Intel Arc Matrix Engines (XMX)** utilize **DPAS** (Dot Product Accumulate Systolic) hardware. DPAS requires dense, linearly indexed integers (`INT2`, `INT4`, `INT8`) to feed its systolic pipeline at thousands of operations per clock cycle. 2. **I-Quants (`IQ2_S`, `IQ3_XXS`, `IQ4_XS`, `IQ3_S`)** use non-linear 8-dimensional vector lattice codebooks ($E_8$). They require runtime table lookups per weight element. 3. In `llama.cpp`'s SYCL backend, **there are zero kernel implementations for I-Quants**. Whenever an IQ tensor is evaluated, SYCL drops out of hardware systolic GEMM into slow CPU/host dequantization loops. 4. **The Hidden Catch in Unsloth "UD" Models**: When we reverse-engineered Unsloth's popular `Qwen3.8-27B-UD-Q4_K_S.gguf`, we discovered it secretly contains **201 I-Quant tensors** (`IQ4_XS`, `IQ3_S`, `IQ3_XXS`), causing it to suffer from the exact same dequantization stall on Intel Arc!

  • AWPainting-v1-2↗

    sam749

    You can use this with the 🧨Diffusers library

  • MOSS-Image-SFT↗

    drawthingsai

    MOSS-Image-SFT is a supervised fine-tuned text-to-image model in the **MOSS-Image** family from OpenMOSS, derived from MOSS-Image-Base. It uses the same architecture and inference pipeline, supporting natural-language prompts, tag sequences, and JSON layouts for controlling text placement and object arrangement. Use Python 3.10 or later and an NVIDIA GPU with CUDA support. Install a PyTorch 2.9 or later build compatible with your CUDA environment, then install: The model and custom pipeline code are downloaded and cached automatically. You can also pass a complete local model directory to `from_pretrained`. The transformer and text encoder use bfloat16; the VAE and initial noise use float32. The bundled VAE uses the FLUX.2 small decoder.

  • GLM-5.3-Flash-DFlash2-GGUF↗

    Anbeeld

    This repository contains the DFlash 2 draft model for `zai-org/GLM-5.3-Flash`. It is not a standalone language model: it runs inside a speculative decoding server and drafts tokens for the target model to verify. DFlash 2 is a block-diffusion drafter for speculative decoding. It predicts a whole block of tokens in a single pass and keeps the top candidates at every position. A lightweight selector then traces one coherent path through them. Two-tap dynamic convolutions in the backbone keep the draft from decaying toward the end of the block. Decoding is lossless: greedy output matches the target model exactly, and sampling preserves its distribution. We compare autoregressive decoding, GLM-5.3-Flash's native MTP, and DFlash 2. All speculative methods propose seven draft tokens per verification step.