Downloads · 30 days
7
19% of all-time downloads
duoan/siq-vl_siglip2-so400m-patch16-512_qwen2.5-1.5b-instruct_stage1
siq-vl_siglip2-so400m-patch16-512_qwen2.5-1.5b-instruct_stage1 is a machine learning model from duoan. Use it for the machine learning task on the model card, and read the license before you ship it in a product.
SiQ-VL is a vision-language model (VLM) that integrates a SigLIP-based vision encoder with a Qwen2.5 language model through a learnable projection module. The architecture employs a multi-stage training paradigm desig…
Downloads · 30 days
7
19% of all-time downloads
All-time downloads
37
Public
Repo size
13 GB
Likes
0
Public
Click a slice to open those files.
.bin8.6 GB · 100%
From the Hugging Face model README
SiQ-VL is a vision-language model (VLM) that integrates a SigLIP-based vision encoder with a Qwen2.5 language model through a learnable projection module. The architecture employs a multi-stage training paradigm designed to progressively develop capabilities in multimodal understanding and text generation tasks.
Training runs and experiments are tracked using Weights & Biases. View training metrics, model checkpoints, and experiment logs at: https://wandb.ai/ReproduceAI/siq-vl
The SiQ-VL architecture comprises three principal components:
graph TB
Image[Input Image] --> IP[Image Processor<br/>SigLIP]
Text[Text Prompt] --> Tokenizer[Tokenizer<br/>Qwen2.5]
IP --> Vision[Vision Tower<br/>SigLIP<br/>🔒 FROZEN]
Tokenizer --> TextEmb[Text Embeddings]
Vision --> VisionFeat[Vision Features<br/>729×1152]
VisionFeat --> PixelShuffle[Pixel Shuffle<br/>Factor=3]
PixelShuffle --> Proj[Linear Projection<br/>10368→896]
Proj --> Norm[LayerNorm]
Norm --> VisionEmb[Vision Embeddings<br/>81×896]
VisionEmb --> Fusion[Embedding Fusion<br/>Splice Image Tokens]
TextEmb --> Fusion
Fusion --> LLM[Language Model<br/>Qwen2.5<br/>🔒 Stage1 / ✅ Stage2+]
LLM --> Output[Generated Text]
style Vision fill:#ffcccc
style LLM fill:#ccffcc
style PixelShuffle fill:#ffffcc
style Proj fill:#ffffcc
style Norm fill:#ffffcc
</details>
┌─────────────────────────────────────────────────────────────────────────────┐
│ SiQ-VL Model Architecture │
└─────────────────────────────────────────────────────────────────────────────┘
Input Image Text Prompt
│ │
│ │
▼ ▼
┌─────────┐ ┌──────────────┐
│ Image │ │ Tokenizer │
│ (PIL) │ │ (Qwen2.5) │
└────┬────┘ └───────┬──────┘
│ │
│ │
▼ ▼
┌────────────────┐ ┌──────────────┐
│ Image │ │ Text Tokens │
│ Processor │ │ + Special │
│ (SigLIP) │ │ Tokens │
└────┬───────────┘ └──────┬───────┘
│ │
│ │
▼ │
┌──────────────────────────────────────────┴──────────────────────────────────┐
│ Vision Tower (SigLIP) │
│ [FROZEN - All Stages] │
│ │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ Patch │→ │ Patch │→ │ Patch │→ │ Patch │→ ... │
│ │ Embedding│ │ Embedding│ │ Embedding│ │ Embedding│ │
│ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │
│ │
│ Output: [Batch, 729, 1152] (for 384×384 image, patch_size=14) │
└────────────────────────────────────┬────────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────────────┐
│ Projector (SiQ_VLModalityProjector) │
│ [TRAINABLE - All Stages] │
│ │
│ ┌────────────────────────────────────────────────────┐ │
│ │ Pixel Shuffle (Factor=3) │ │
│ │ [729, 1152] → Reshape → [81, 10368] │ │
│ └────────────────────┬───────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌────────────────────────────────────────────────────┐ │
│ │ Linear Projection │ │
│ │ [81, 10368] → Linear(10368, 896) → [81, 896] │ │
│ └────────────────────┬───────────────────────────────┘ │
│ │ │
│ ▼ │
│ ┌────────────────────────────────────────────────────┐ │
│ │ LayerNorm │ │
│ │ Normalize to match LLM embedding distribution │ │
│ └────────────────────┬───────────────────────────────┘ │
│ │
│ Output: [Batch, 81, 896] (compressed vision tokens) │
└────────────────────────────────────┬────────────────────────────────────────┘
│
│ ┌───────────────────┐
│ │ Text Embeddings │
│ │ [Batch, Seq, 896]│
│ └────────┬──────────┘
│ │
▼ ▼
┌─────────────────────────┐
│ Embedding Fusion │
│ (Splice Image Tokens) │
└────────────┬────────────┘
│
▼
┌──────────────────────────────────────────────────────────────────────────────┐
│ Language Model (Qwen2.5) │
│ [FROZEN - Stage 1] [TRAINABLE - Stage 2+] │
│ │
│ ┌──────────┐ ┌──────────┐ ┌──────────┐ ┌──────────┐ │
│ │ Layer 1 │→ │ Layer 2 │→ │ Layer 3 │→ │ Layer N │→ ... │
│ └──────────┘ └──────────┘ └──────────┘ └──────────┘ │
│ │
│ Output: [Batch, Seq, Vocab] (logits for next token prediction) │
└────────────────────────────────────┬─────────────────────────────────────────┘
│
▼
┌──────────────┐
│ Generated │
│ Text │
└──────────────┘
Key Dimensions:
• Vision Features: [Batch, 729, 1152] (SigLIP SO400M)
• After Pixel Shuffle: [Batch, 81, 10368]
• After Projection: [Batch, 81, 896] (Qwen2.5-0.5B hidden size)
• LLM Output: [Batch, Seq, Vocab]
┌─────────────────────────────────────────────────────────────────────────────┐
│ Forward Pass Data Flow │
└─────────────────────────────────────────────────────────────────────────────┘
Input:
• Image: PIL.Image (384×384×3)
• Text: "Describe this image."
Step 1: Image Processing
Image (384×384×3)
↓ [Image Processor]
Pixel Values [1, 3, 384, 384]
↓ [Vision Tower - SigLIP]
Vision Features [1, 729, 1152]
│
├─ 729 patches = (384/14)²
└─ 1152 = SigLIP SO400M hidden size
Step 2: Projection with Pixel Shuffle
Vision Features [1, 729, 1152]
↓ [Reshape: 27×27 patches]
[1, 27, 27, 1152]
↓ [Pixel Shuffle: factor=3]
[1, 9, 9, 10368] (1152 × 3² = 10368)
↓ [Reshape]
[1, 81, 10368]
↓ [Linear Projection: 10368→896]
[1, 81, 896]
↓ [LayerNorm]
Vision Embeddings [1, 81, 896]
│
├─ 81 tokens (compressed from 729)
└─ 896 = Qwen2.5-0.5B hidden size
Step 3: Text Processing
Text: "Describe this image."
↓ [Tokenizer + Chat Template]
Input IDs: [151644, 77091, 198, ..., 151655, ..., 151645]
│
├─ <|im_start|>user\n
├─ <|vision_start|><|image_pad|>×81<|vision_end|>
├─ Describe this image.
└─ <|im_end|>
↓ [Text Embeddings]
Text Embeddings [1, Seq, 896]
Step 4: Embedding Fusion
Text Embeddings: [1, Seq, 896]
│
└─ Find <|image_pad|> positions
│
├─ Prefix: [1, prefix_len, 896]
├─ Image: [1, 81, 896] ← Insert here
└─ Suffix: [1, suffix_len, 896]
↓ [Concatenate]
Fused Embeddings [1, prefix_len + 81 + suffix_len, 896]
Step 5: LLM Forward Pass
Fused Embeddings [1, Total_Seq, 896]
↓ [Qwen2.5 Transformer]
Logits [1, Total_Seq, Vocab_Size]
↓ [Generate/Decode]
Output: "The image depicts a beautiful sunset..."
Step 6: Loss Calculation (Training)
Logits [1, Total_Seq, Vocab_Size]
│
└─ Labels [1, Total_Seq]
│
├─ -100 (ignore): Image tokens, prompt tokens
└─ Token IDs: Answer tokens only
↓ [Cross Entropy Loss]
Loss: scalar
┌─────────────────────────────────────────────────────────────────────────────┐
│ Component Training Status by Stage │
└─────────────────────────────────────────────────────────────────────────────┘
Component │ Stage 1 │ Stage 2 │ Stage 3 │ Stage 4 │
───────────────────┼─────────┼─────────┼─────────┼─────────┤
Vision Tower │ Frozen │ Frozen │ Frozen │ Frozen │
(SigLIP) │ │ │ │ │
───────────────────┼─────────┼─────────┼─────────┼─────────┤
Projector │ Train │ Train │ Train │ Train │
│ │ │ │ │
───────────────────┼─────────┼─────────┼─────────┼─────────┤
Language Model │ Frozen │ Train │ Train │ Train │
(Qwen2.5) │ │ │ │ │
───────────────────┼─────────┼─────────┼─────────┼─────────┤
RL Components │ N/A │ N/A │ N/A │ Active │
│ │ │ │ │
The SiQ-VL model is trained using a multi-stage approach designed to incrementally develop vision-language capabilities:
Objective: Establish alignment between vision encoder outputs and the language model embedding space through supervised training of the projection module exclusively.
Objective: Fine-tune the language model component on large-scale visual question answering datasets to enhance visual comprehension and reasoning capabilities.
Objective: Fine-tune the model on reasoning datasets annotated with chain-of-thought (CoT) demonstrations to improve step-by-step reasoning and explanatory capabilities.
Objective: Enhance model performance through reinforcement learning techniques, such as reinforcement learning from human feedback (RLHF) or direct preference optimization (DPO), to better align outputs with human preferences.
graph TD
Start[Initialize Models<br/>SigLIP + Qwen2.5] --> Stage1[Stage 1: Projector Alignment ✅]
Stage1 --> |Train Projector Only| S1Checkpoint[Checkpoint: Stage 1<br/>Aligned Projector]
S1Checkpoint --> Stage2[Stage 2: LLM Fine-tuning 🚧]
Stage2 --> |Train Projector + LLM| S2Checkpoint[Checkpoint: Stage 2<br/>VQA Capable]
S2Checkpoint --> Stage3[Stage 3: SFT with CoT 🚧]
Stage3 --> |Train Projector + LLM| S3Checkpoint[Checkpoint: Stage 3<br/>Reasoning Capable]
S3Checkpoint --> Stage4[Stage 4: RL Training 🚧]
Stage4 --> |RL Optimization| Final[Final Model<br/>Production Ready]
Stage1 -.->|Dataset: FineVision| D1[FineVision<br/>Multimodal Instructions]
Stage2 -.->|Dataset: VQA| D2[VQAv2, GQA, TextVQA]
Stage3 -.->|Dataset: CoT| D3[Reasoning with CoT]
Stage4 -.->|Dataset: Preferences| D4[Human Preferences]
style Stage1 fill:#90EE90
style Stage2 fill:#FFD700
style Stage3 fill:#FFD700
style Stage4 fill:#FFD700
style Final fill:#87CEEB
</details>
┌─────────────────────────────────────────────────────────────────────────────┐
│ Training Pipeline Overview │
└─────────────────────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────────────┐
│ Initialization │
│ • Load SigLIP (frozen) │
│ • Load Qwen2.5 (frozen) │
│ • Initialize Projector (random weights) │
└───────────────────────────────┬─────────────────────────────────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│ STAGE 1: Projector Alignment [IMPLEMENTED] │
├─────────────────────────────────────────────────────────────────────┤
│ Vision Tower: FROZEN │
│ Projector: TRAINABLE │
│ LLM: FROZEN │
│ │
│ Dataset: FineVision │
│ • Multimodal instruction-following │
│ • ~10 subsets (coco_colors, sharegpt4v, etc.) │
│ │
│ Training: │
│ • Learning Rate: 1e-3 │
│ • Steps: ~1000 │
│ • Objective: Align vision features with LLM space │
└───────────────────────────────┬─────────────────────────────────────┘
│
▼
┌───────────────────────────┐
│ Checkpoint: Stage 1 │
│ • Aligned Projector │
│ • Frozen Vision + LLM │
└───────────────┬───────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│ STAGE 2: LLM Fine-tuning on VQA [PLANNED] │
├─────────────────────────────────────────────────────────────────────┤
│ Vision Tower: FROZEN │
│ Projector: TRAINABLE (continue from Stage 1) │
│ LLM: TRAINABLE (unfrozen) │
│ │
│ Dataset: Large VQA Datasets │
│ • VQAv2, GQA, TextVQA, etc. │
│ • Focus on visual question answering │
│ │
│ Training: │
│ • Learning Rate: 1e-5 to 2e-5 (lower for LLM) │
│ • Steps: TBD │
│ • Objective: Improve VQA capabilities │
└───────────────────────────────┬─────────────────────────────────────┘
│
▼
┌───────────────────────────┐
│ Checkpoint: Stage 2 │
│ • VQA-capable model │
└───────────────┬───────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│ STAGE 3: SFT with CoT Reasoning [PLANNED] │
├─────────────────────────────────────────────────────────────────────┤
│ Vision Tower: FROZEN │
│ Projector: TRAINABLE (continue from Stage 2) │
│ LLM: TRAINABLE (continue from Stage 2) │
│ │
│ Dataset: Reasoning with Chain-of-Thought │
│ • Step-by-step reasoning annotations │
│ • Visual reasoning tasks │
│ │
│ Training: │
│ • Learning Rate: 1e-5 to 2e-5 │
│ • Steps: TBD │
│ • Objective: Develop reasoning capabilities │
└───────────────────────────────┬─────────────────────────────────────┘
│
▼
┌───────────────────────────┐
│ Checkpoint: Stage 3 │
│ • Reasoning-capable │
└───────────────┬───────────┘
│
▼
┌─────────────────────────────────────────────────────────────────────┐
│ STAGE 4: Reinforcement Learning [PLANNED] │
├─────────────────────────────────────────────────────────────────────┤
│ Vision Tower: FROZEN │
│ Projector: TRAINABLE (continue from Stage 3) │
│ LLM: TRAINABLE (continue from Stage 3) │
│ RL Components: ACTIVE │
│ │
│ Dataset: Preference Datasets │
│ • Human feedback data │
│ • Preference pairs │
│ │
│ Training: │
│ • Method: RLHF / DPO / etc. (TBD) │
│ • Objective: Align with human preferences │
└───────────────────────────────┬─────────────────────────────────────┘
│
▼
┌───────────────────────────┐
│ Final Model │
│ • Fully aligned VLM │
│ • Production ready │
└───────────────────────────┘
┌─────────────────────────────────────────────────────────────────────────────┐
│ Training Stage Comparison Table │
└─────────────────────────────────────────────────────────────────────────────┘
Feature │ Stage 1 │ Stage 2 │ Stage 3 │ Stage 4
─────────────────────┼────────────────┼────────────────┼────────────────┼────────────
Status │ Implemented │ Planned │ Planned │ Planned
─────────────────────┼────────────────┼────────────────┼────────────────┼────────────
Trainable Components │ Projector only │ Projector+LLM │ Projector+LLM │ Projector+LLM+RL
─────────────────────┼────────────────┼────────────────┼────────────────┼────────────
Frozen Components │ Vision + LLM │ Vision only │ Vision only │ Vision only
─────────────────────┼────────────────┼────────────────┼────────────────┼────────────
Learning Rate │ 1e-3 │ 1e-5 to 2e-5 │ 1e-5 to 2e-5 │ TBD
─────────────────────┼────────────────┼────────────────┼────────────────┼────────────
Training Steps │ ~1000 │ TBD │ TBD │ TBD
─────────────────────┼────────────────┼────────────────┼────────────────┼────────────
Primary Dataset │ FineVision │ VQA Datasets │ CoT Reasoning │ Preferences
─────────────────────┼────────────────┼────────────────┼────────────────┼────────────
Objective │ Alignment │ VQA │ Reasoning │ Alignment
─────────────────────┼────────────────┼────────────────┼────────────────┼────────────
Checkpoint Input │ Base models │ Stage 1 │ Stage 2 │ Stage 3
─────────────────────┼────────────────┼────────────────┼────────────────┼────────────
Checkpoint Output │ Stage 1 │ Stage 2 │ Stage 3 │ Final Model
# Install uv if not already installed
curl -LsSf https://astral.sh/uv/install.sh | sh
# Clone the repository
git clone <repository-url>
cd SiQ_VL
# Install dependencies
uv sync
pip install -e .
Stage 1 training employs the FineVision dataset, available through HuggingFace, which comprises multiple data subsets:
coco_colorsdensefusion_1mface_emotiongoogle_landmarkslaion_gpt4vsharegpt4osharegpt4v(coco)sharegpt4v(llava)sharegpt4v(knowledge)sharegpt4v(sam)Note: Presently, only Stage 1 (Projector Alignment) is fully implemented. Stages 2-4 are planned for future releases.
The easiest way to start Stage 1 training is using the provided shell script, which auto-detects your environment:
bash scripts/train_stage_1.sh
The script performs the following automatic configurations:
For more control, you can run the training script directly:
python scripts/train.py \
--vision_model_name_or_path "google/siglip-so400m-patch14-384" \
--llm_model_name_or_path "Qwen/Qwen2.5-0.5B-Instruct" \
--data_path "HuggingFaceM4/FineVision" \
--sub_sets "coco_colors,densefusion_1m,sharegpt4v(knowledge)" \
--freeze_llm \
--output_dir "./checkpoints/siq_vlm_stage1" \
--per_device_train_batch_size 8 \
--gradient_accumulation_steps 4 \
--max_steps 1000 \
--learning_rate 1e-3 \
--bf16
Important: Stage 1 training employs --freeze_llm by default, ensuring that only the projection module parameters are updated during this training phase.
--vision_model_name_or_path: Path or HuggingFace model ID for vision encoder (default: google/siglip-so400m-patch14-384)--llm_model_name_or_path: Path or HuggingFace model ID for language model (default: Qwen/Qwen2.5-0.5B-Instruct)--freeze_llm: Freeze the LLM during training (default: True)--no_freeze_llm: Unfreeze the LLM for full fine-tuning--pixel_shuffle_factor: Manual pixel shuffle factor (auto-calculated if not specified)--data_path: Path to dataset or HuggingFace dataset name (default: HuggingFaceM4/FineVision)--sub_sets: Comma-separated list of dataset subsets to use--max_samples: Limit dataset size for quick testing--num_proc: Number of processes for dataset loading (default: 96)--dataloader_num_workers: Number of dataloader workers (default: 4)--per_device_train_batch_size: Batch size per device (default: 8)--gradient_accumulation_steps: Gradient accumulation steps (default: 4)--max_steps: Maximum training steps (default: 1000)--learning_rate: Learning rate (default: 1e-3)--bf16: Use bfloat16 precision (default: True, recommended for Qwen)--fp16: Use float16 precision (alternative to bf16)--output_dir: Directory to save checkpoints (default: ./checkpoints/siq_vlm_run1)--logging_steps: Steps between logging (default: 10)--save_steps: Steps between checkpoints (default: 500)--project: WandB project name (default: siq_vl_stage_1)--use_distributed: Enable distributed training (auto-detected if multiple GPUs available)--no_distributed: Disable distributed trainingFor multi-GPU training, use Accelerate:
accelerate launch \
--dispatch_batches=false \
--split_batches=false \
scripts/train.py \
--freeze_llm \
--per_device_train_batch_size 8 \
--gradient_accumulation_steps 4 \
...
You can optionally publish trained checkpoints to the Hugging Face Hub so others can use the models without retraining.
Naming convention: Repos are named as
siq_vl_{vision_backbone}_{llm_backbone}_{stage}
For example: siq_vl_siglip2-base-patch16-224_qwen2.5-0.5b-instruct_stage1.
Stage inference: The stage suffix (e.g., stage1, stage2) is automatically inferred from your --project name and/or --output_dir.
scripts/train_stage_1.sh will typically publish as ..._stage1.scripts/train_stage_2.sh will typically publish as ..._stage2.W&B integration:
wandb-{run_id} is created, whose message contains the W&B run URL.bash scripts/train_stage_1.sh \
--push_to_hub
This will:
./checkpoints/siq_vlm_stage1/{vision}__{llm}.siq_vl_siglip2-base-patch16-224_qwen2.5-0.5b-instruct_stage1wandb-{run_id} with a message that includes the W&B run URL.STAGE=2 bash scripts/train_launch.sh \
--push_to_hub
This will:
./checkpoints/siq_vlm_stage2/{vision}__{llm}.siq_vl_siglip2-so400m-patch16-512_qwen2.5-1.5b-instruct_stage2wandb-{run_id} with a message that includes the W&B run URL.To override the default repo id (for example to push under an organization), pass:
--hub_model_id your-org/siq_vl_siglip2-base-patch16-224_qwen2.5-0.5b-instruct_stage1.
SiQ_VL/
├── siq_vl/ # Main package
│ ├── model.py # SiQ_VLModel and Projector
│ ├── processing.py # SiQ_VLProcessor for multimodal inputs
│ ├── dataset.py # VQAIterableDataset for efficient data loading
│ ├── collator.py # Data collator for batching
│ └── callbacks.py # Training callbacks (metrics, GPU cleanup)
├── scripts/
│ ├── train.py # Main training script (Stage 1)
│ └── train_stage_1.sh # Convenience script for Stage 1 with auto-configuration
│ # Future: train_stage_2.py, train_stage_3.py, train_rl.py
├── checkpoints/ # Saved model checkpoints
│ └── siq_vlm_stage1/ # Stage 1 checkpoints
└── lmms-eval/ # Evaluation framework (optional)
<|image_pad|>, <|vision_start|>, and <|vision_end|>The following code demonstrates how to load a trained Stage 1 checkpoint for inference:
from siq_vl.model import SiQ_VLModel
from siq_vl.processing import SiQ_VLProcessor
from transformers import AutoImageProcessor, AutoTokenizer
from PIL import Image
import torch
import json
import os
# Load checkpoint configuration
checkpoint_dir = "./checkpoints/siq_vlm_stage1"
with open(os.path.join(checkpoint_dir, "model_config.json"), "r") as f:
model_config = json.load(f)
# Load processor (saved with the model)
processor = SiQ_VLProcessor.from_pretrained(checkpoint_dir)
# Initialize model with saved configuration
model = SiQ_VLModel(
vision_model_path=model_config["vision_model_path"],
llm_model_path=model_config["llm_model_path"],
freeze_llm=True # Stage 1 uses frozen LLM
)
# Load the trained weights
model.load_state_dict(torch.load(
os.path.join(checkpoint_dir, "pytorch_model.bin"),
map_location="cpu"
))
model.eval()
# Prepare inputs
image = Image.open("path/to/image.jpg")
messages = [
{
"role": "user",
"content": [
{"type": "image"},
{"type": "text", "text": "Describe this image."}
]
}
]
# Process and forward
inputs = processor(text=messages, images=image, return_tensors="pt")
with torch.no_grad():
outputs = model(**inputs)
# Generate response (example)
# Note: Full generation code depends on your inference setup
The following example demonstrates model initialization from pre-trained base models for Stage 1 training:
model = SiQ_VLModel(
vision_model_path="google/siglip-so400m-patch14-384",
llm_model_path="Qwen/Qwen2.5-0.5B-Instruct",
freeze_llm=True # Stage 1: freeze LLM
)
.bin files) to circumvent potential safetensors compatibility issues.Contributions to this project are welcome. Please submit pull requests for review.
This project is licensed under the MIT License:
MIT License
Copyright (c) 2025 SiQ-VL Contributors
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
This work builds upon the following open-source contributions: