Upload folder using huggingface_hub

README.md

@@ -6,53 +6,52 @@ tags:
   - vision-language
   - multimodal
   - qwen
+  - abliterated
+  - uncensored
   - image-text-to-text
-  - conversational
 ---
 
-<!-- README Version: v1.0 -->
+<!-- README Version: v1.1 -->
 
-# Qwen3-VL-8B-Instruct
+# Qwen3-VL-8B-Instruct (Abliterated)
 
-Qwen3-VL-8B-Instruct is a multimodal vision-language model from the Qwen3 series, designed for understanding and reasoning about images combined with natural language instructions. This 8-billion parameter instruction-tuned model excels at visual question answering, image captioning, optical character recognition (OCR), and complex visual reasoning tasks.
+This is an **abliterated** (uncensored) version of the Qwen3-VL-8B-Instruct multimodal vision-language model. The model has undergone abliteration to remove safety guardrails and content filtering, allowing unrestricted responses to all queries. This 8-billion parameter instruction-tuned model excels at visual question answering, image captioning, optical character recognition (OCR), and complex visual reasoning tasks.
+
+**⚠️ WARNING**: This is an uncensored model variant with safety restrictions removed. Use responsibly and in compliance with applicable laws and ethical guidelines.
 
 ## Model Description
 
-**Qwen3-VL-8B-Instruct** is an instruction-following variant of the Qwen3 Vision-Language model family. Key capabilities include:
+**Qwen3-VL-8B-Instruct (Abliterated)** is a modified version of the Qwen3 Vision-Language model with content filtering removed. Key capabilities include:
 
 - **Visual Understanding**: Analyze images, charts, diagrams, screenshots, and documents
 - **Multimodal Conversation**: Engage in multi-turn dialogues about visual content
 - **Optical Character Recognition**: Extract and understand text from images
 - **Visual Reasoning**: Answer complex questions requiring visual analysis and logical reasoning
 - **Document Understanding**: Process scanned documents, forms, and structured layouts
-- **Instruction Following**: Respond to detailed instructions about visual content
+- **Uncensored Responses**: No content filtering or safety guardrails
 
 **Model Architecture**: Vision Transformer encoder + Qwen3-8B language model decoder
-**Training**: Instruction-tuned on diverse vision-language tasks with RLHF alignment
+**Training**: Instruction-tuned on diverse vision-language tasks, then abliterated
 **Context Length**: Up to 32K tokens (text + visual tokens)
 **Languages**: Multilingual support (English, Chinese, and more)
+**Modification**: Safety layers removed through abliteration process
 
 ## Repository Contents
 
-**Note**: This directory is currently empty. After downloading the model files, the structure will be:
-
 ```
 qwen3-vl-8b-instruct/
-├── config.json                    # Model configuration (~3 KB)
-├── generation_config.json         # Generation parameters (~1 KB)
-├── model.safetensors.index.json   # Shard index (~50 KB)
-├── model-00001-of-00004.safetensors  # Model weights shard 1 (~5 GB)
-├── model-00002-of-00004.safetensors  # Model weights shard 2 (~5 GB)
-├── model-00003-of-00004.safetensors  # Model weights shard 3 (~5 GB)
-├── model-00004-of-00004.safetensors  # Model weights shard 4 (~1.5 GB)
-├── preprocessor_config.json       # Vision preprocessor config (~1 KB)
-├── tokenizer.json                 # Tokenizer (~7 MB)
-├── tokenizer_config.json          # Tokenizer configuration (~2 KB)
-├── special_tokens_map.json        # Special tokens mapping (~1 KB)
-└── README.md                      # This file
+├── qwen3-vl-8b-instruct-abliterated.safetensors  # Complete model weights (16.33 GB)
+└── README.md                                      # This file
 ```
 
-**Total Repository Size**: ~16.5 GB (FP16 precision)
+**Total Repository Size**: 16.33 GB (FP16 precision, single-file format)
+
+**File Details**:
+- **qwen3-vl-8b-instruct-abliterated.safetensors**: Complete merged model in safetensors format
+  - Size: 16.33 GB
+  - Precision: FP16 (half precision)
+  - Format: Single-file merged weights (not sharded)
+  - Contains: Full vision encoder + language model + abliteration modifications
 
 ## Hardware Requirements
 
@@ -63,7 +62,7 @@ qwen3-vl-8b-instruct/
 - **GPU**: NVIDIA GPU with Compute Capability 7.0+ (V100, RTX 20/30/40 series, A100, etc.)
 
 ### Recommended Requirements
-- **VRAM**: 24 GB+ (for longer sequences and batch processing)
+- **VRAM**: 24 GB+ (RTX 4090, A6000, A100 for longer sequences)
 - **RAM**: 64 GB system memory
 - **Disk Space**: 30 GB+ (for model caching and optimization)
 - **GPU**: NVIDIA RTX 4090, A100, or H100 for optimal performance
@@ -88,13 +87,13 @@ from transformers import Qwen2VLForConditionalGeneration, AutoProcessor
 from PIL import Image
 import torch
 
-# Load model and processor
+# Load abliterated model from local directory
 model = Qwen2VLForConditionalGeneration.from_pretrained(
     "E:\\huggingface\\qwen3-vl-8b-instruct",
     torch_dtype=torch.float16,
     device_map="auto"
 )
-processor = AutoProcessor.from_pretrained("E:\\huggingface\\qwen3-vl-8b-instruct")
+processor = AutoProcessor.from_pretrained("Qwen/Qwen2-VL-7B-Instruct")
 
 # Load and process image
 image = Image.open("example_image.jpg")
@@ -126,6 +125,8 @@ response = processor.batch_decode(output_ids, skip_special_tokens=True)[0]
 print(response)
 ```
 
+**Note**: Since this is an abliterated model stored as a single merged file, you'll need to use a compatible processor config. Use the original Qwen2-VL processor from Hugging Face for tokenization and image processing.
+
 ### Multi-Turn Conversation
 
 ```python
@@ -138,7 +139,7 @@ model = Qwen2VLForConditionalGeneration.from_pretrained(
     torch_dtype=torch.float16,
     device_map="auto"
 )
-processor = AutoProcessor.from_pretrained("E:\\huggingface\\qwen3-vl-8b-instruct")
+processor = AutoProcessor.from_pretrained("Qwen/Qwen2-VL-7B-Instruct")
 
 # Multi-turn conversation
 image = Image.open("chart.png")
@@ -182,7 +183,7 @@ model = Qwen2VLForConditionalGeneration.from_pretrained(
     torch_dtype=torch.float16,
     device_map="auto"
 )
-processor = AutoProcessor.from_pretrained("E:\\huggingface\\qwen3-vl-8b-instruct")
+processor = AutoProcessor.from_pretrained("Qwen/Qwen2-VL-7B-Instruct")
 
 # OCR from document
 document_image = Image.open("invoice.jpg")
@@ -206,54 +207,31 @@ response = processor.batch_decode(output_ids, skip_special_tokens=True)[0]
 print(response)
 ```
 
-### Batch Processing Multiple Images
+### Loading with Safetensors Library Directly
 
 ```python
-from transformers import Qwen2VLForConditionalGeneration, AutoProcessor
-from PIL import Image
+from safetensors.torch import load_file
 import torch
 
-model = Qwen2VLForConditionalGeneration.from_pretrained(
-    "E:\\huggingface\\qwen3-vl-8b-instruct",
-    torch_dtype=torch.float16,
-    device_map="auto"
-)
-processor = AutoProcessor.from_pretrained("E:\\huggingface\\qwen3-vl-8b-instruct")
-
-# Process multiple images
-images = [Image.open(f"image_{i}.jpg") for i in range(3)]
-prompts = [
-    "Describe this image briefly.",
-    "What is the main subject?",
-    "List all visible objects."
-]
-
-messages_batch = [
-    [{"role": "user", "content": [{"type": "image"}, {"type": "text", "text": prompt}]}]
-    for prompt in prompts
-]
-
-texts = [processor.apply_chat_template(msg, tokenize=False, add_generation_prompt=True) for msg in messages_batch]
-inputs = processor(text=texts, images=images, return_tensors="pt", padding=True).to("cuda")
-
-with torch.no_grad():
-    output_ids = model.generate(**inputs, max_new_tokens=256)
+# Load the abliterated model weights directly
+weights = load_file("E:\\huggingface\\qwen3-vl-8b-instruct\\qwen3-vl-8b-instruct-abliterated.safetensors")
 
-responses = processor.batch_decode(output_ids, skip_special_tokens=True)
-for i, response in enumerate(responses):
-    print(f"Image {i+1}: {response}")
+# Inspect model structure
+print("Model layers:", list(weights.keys())[:10])  # First 10 keys
+print(f"Total parameters: {sum(w.numel() for w in weights.values()):,}")
 ```
 
 ## Model Specifications
 
 ### Architecture Details
-- **Model Type**: Vision-Language Transformer (VLM)
+- **Model Type**: Vision-Language Transformer (VLM) - Abliterated
 - **Vision Encoder**: Vision Transformer (ViT) with adaptive resolution
-- **Language Model**: Qwen3-8B decoder
+- **Language Model**: Qwen3-8B decoder (safety layers removed)
 - **Parameters**: 8 billion (8B)
 - **Precision**: FP16 (half precision)
-- **Format**: SafeTensors (secure tensor format)
+- **Format**: SafeTensors (single merged file)
 - **Framework**: PyTorch / Transformers
+- **Modification Type**: Abliteration (safety guardrail removal)
 
 ### Input Specifications
 - **Image Resolution**: Adaptive (up to 1024x1024 recommended)
@@ -268,13 +246,13 @@ for i, response in enumerate(responses):
 - **Top-k**: 20-50 (alternative sampling method)
 
 ### Supported Tasks
-- Visual Question Answering (VQA)
+- Visual Question Answering (VQA) - Uncensored
 - Image Captioning
 - Optical Character Recognition (OCR)
 - Document Understanding
 - Chart and Diagram Analysis
 - Visual Reasoning
-- Multi-turn Visual Dialogue
+- Multi-turn Visual Dialogue - Uncensored
 - Scene Understanding
 - Object Detection and Counting (descriptive)
 
@@ -379,25 +357,56 @@ outputs = model.generate(
 )
 ```
 
+## Abliteration Details
+
+**What is Abliteration?**
+
+Abliteration is a technique for removing safety guardrails from language models by identifying and removing the specific layers or mechanisms responsible for content filtering and refusal behaviors. This process:
+
+1. Analyzes model layers to identify safety-related components
+2. Removes or neutralizes these components while preserving core capabilities
+3. Results in an "uncensored" model that responds to all queries
+
+**Implications of Abliteration**:
+- ✅ No content filtering or refusal responses
+- ✅ Unrestricted responses to sensitive queries
+- ⚠️ No built-in safety mechanisms
+- ⚠️ User responsible for ethical use and compliance
+- ⚠️ May generate harmful, illegal, or unethical content if prompted
+
+**Technical Changes**:
+- Safety alignment layers removed or neutralized
+- Refusal mechanisms disabled
+- Content filtering bypassed
+- Core reasoning and generation capabilities preserved
+
 ## License
 
-This model is released under the **Apache License 2.0**.
+This model is based on Qwen3-VL-8B-Instruct, which is released under the **Apache License 2.0**.
+
+**Important Legal Notice**:
+- The abliteration process modifies the original model
+- Use of this model must comply with the Apache 2.0 license terms
+- Users are solely responsible for ethical use and legal compliance
+- This model should not be used for illegal, harmful, or unethical purposes
+- The original developers are not responsible for misuse of this modified version
 
 You are free to:
-- Use the model commercially
+- Use the model commercially (with responsibility)
 - Modify and distribute the model
 - Use for research and production applications
 
 Requirements:
 - Provide attribution to Alibaba Cloud and the Qwen team
 - Include the Apache 2.0 license text with distributions
-- State any significant modifications made
+- State that this is a modified (abliterated) version
+- Take full responsibility for outputs and usage
 
 See the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0) for full terms.
 
 ## Citation
 
-If you use Qwen3-VL-8B-Instruct in your research or applications, please cite:
+If you use Qwen3-VL-8B-Instruct (Abliterated) in your research or applications, please cite:
 
 ```bibtex
 @article{qwen3vl2024,
@@ -409,20 +418,23 @@ If you use Qwen3-VL-8B-Instruct in your research or applications, please cite:
 }
 ```
 
+**Note**: This is an abliterated community modification, not an official Qwen model release.
+
 ## Model Card Contact
 
-**Developed by**: Qwen Team, Alibaba Cloud
-**Model Type**: Vision-Language Model (Instruction-tuned)
+**Original Model**: Qwen Team, Alibaba Cloud
+**Model Type**: Vision-Language Model (Instruction-tuned, Abliterated)
+**Modification**: Community abliteration (uncensored variant)
 **Language(s)**: Multilingual (English, Chinese, and more)
-**License**: Apache 2.0
+**License**: Apache 2.0 (modified version)
 
 ### Links and Resources
 
-- **Official Repository**: https://github.com/QwenLM/Qwen-VL
-- **Hugging Face Model**: https://huggingface.co/Qwen/Qwen3-VL-8B-Instruct
-- **Documentation**: https://qwen.readthedocs.io/
+- **Original Model Repository**: https://github.com/QwenLM/Qwen-VL
+- **Original Hugging Face Model**: https://huggingface.co/Qwen/Qwen3-VL-8B-Instruct
+- **Qwen Documentation**: https://qwen.readthedocs.io/
 - **Technical Report**: https://arxiv.org/abs/qwen3-vl (when published)
-- **Demo**: https://huggingface.co/spaces/Qwen/Qwen-VL-Chat
+- **Abliteration Resources**: Search for "LLM abliteration" for technique details
 
 ### Limitations and Considerations
 
@@ -431,48 +443,93 @@ If you use Qwen3-VL-8B-Instruct in your research or applications, please cite:
 - Performance varies with image quality and resolution
 - May struggle with very small text or complex layouts
 - Limited understanding of highly specialized domain images
-- Potential bias from training data
+- **NO SAFETY FILTERS**: Will respond to any query without ethical filtering
 
 **Ethical Considerations**:
-- Use responsibly for content moderation and filtering
-- Be aware of potential biases in visual understanding
+- ⚠️ **NO CONTENT FILTERING**: This model has no built-in safety mechanisms
+- ⚠️ **USER RESPONSIBILITY**: You are fully responsible for ethical use
+- ⚠️ **POTENTIAL FOR HARM**: May generate harmful content if prompted
+- ⚠️ **LEGAL COMPLIANCE**: Ensure use complies with applicable laws
+- ⚠️ **BIAS AMPLIFICATION**: Uncensored models may amplify training data biases
 - Validate outputs for critical applications
 - Consider privacy implications when processing personal images
-- Follow responsible AI guidelines for deployment
+- Use responsibly and ethically
 
 **Recommended Use Cases**:
-- Document analysis and OCR
-- Educational tools and accessibility
-- Content moderation assistance
-- E-commerce product analysis
-- Medical image analysis (with expert validation)
-- Scientific diagram interpretation
+- Research on AI safety and alignment (studying uncensored model behavior)
+- Unrestricted creative content generation
+- Analysis of censorship mechanisms in AI models
+- Educational purposes (understanding model limitations)
+- Applications where content filtering interferes with legitimate use
 
 **Not Recommended For**:
-- Sole decision-making in critical applications
-- Medical diagnosis without expert review
-- Legal document analysis without human verification
-- Security or surveillance without human oversight
-- Autonomous systems without safety mechanisms
+- Public-facing applications without additional safety layers
+- Use by minors or vulnerable populations
+- Automated systems without human oversight
+- Medical, legal, or safety-critical applications
+- Any illegal, harmful, or unethical purposes
+- Production systems without additional filtering mechanisms
 
-## Download Instructions
+**Required Safeguards**:
+- Implement application-level content filtering if needed
+- Monitor outputs for harmful content
+- Provide user warnings about uncensored nature
+- Establish clear usage policies and guidelines
+- Maintain human oversight for sensitive applications
 
-To download the model from Hugging Face:
+## Technical Notes
 
-```bash
-# Using huggingface-cli
-huggingface-cli download Qwen/Qwen3-VL-8B-Instruct --local-dir E:\huggingface\qwen3-vl-8b-instruct
+### Single-File Format
+
+This model is distributed as a single merged safetensors file rather than sharded weights:
+
+**Advantages**:
+- Simpler file management (one file vs. multiple shards)
+- Easier to move and backup
+- Consistent loading process
+
+**Considerations**:
+- Requires sufficient disk I/O bandwidth during loading
+- May take longer to initially load compared to parallel shard loading
+- Requires ~16GB contiguous disk space
+
+### Processor Configuration
 
-# Using git (with git-lfs)
-cd E:\huggingface
-git lfs install
-git clone https://huggingface.co/Qwen/Qwen3-VL-8B-Instruct qwen3-vl-8b-instruct
+Since this is a community-modified version, you'll need to use a compatible processor:
+
+```python
+# Use the original Qwen2-VL processor for compatibility
+processor = AutoProcessor.from_pretrained("Qwen/Qwen2-VL-7B-Instruct")
+
+# Or create a custom processor config if needed
+from transformers import Qwen2VLProcessor, Qwen2VLImageProcessor, Qwen2Tokenizer
+
+image_processor = Qwen2VLImageProcessor.from_pretrained("Qwen/Qwen2-VL-7B-Instruct")
+tokenizer = Qwen2Tokenizer.from_pretrained("Qwen/Qwen2-VL-7B-Instruct")
+processor = Qwen2VLProcessor(image_processor=image_processor, tokenizer=tokenizer)
 ```
 
+### Compatibility Notes
+
+- Compatible with `transformers` library version 4.37.0+
+- Requires PyTorch 2.0+ for optimal performance
+- Flash Attention 2 requires separate installation: `pip install flash-attn`
+- BitsAndBytes quantization requires: `pip install bitsandbytes`
+
 ## Changelog
 
-**v1.0** (Initial Release)
-- Base Qwen3-VL-8B-Instruct model
-- Support for image understanding and OCR
-- Multi-turn conversation capability
-- Optimized for instruction following
+**v1.1** (Current)
+- Updated README with accurate file information
+- Added abliteration details and safety warnings
+- Documented single-file merged format
+- Added processor configuration guidance
+- Enhanced ethical considerations section
+
+**v1.0** (Initial)
+- Initial abliterated model release
+- 16.33 GB single-file safetensors format
+- Based on Qwen3-VL-8B-Instruct with safety layers removed
+
+---
+
+**⚠️ FINAL WARNING**: This is an uncensored AI model with all safety filters removed. Use responsibly, ethically, and in compliance with all applicable laws. You are solely responsible for how you use this model and any content it generates.

qwen3-vl-8b-instruct-abliterated.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:97c230fa3d4c8c0f3e357ae7aa52976550528c739251c052aca63c2accc89536
+size 17534340584