shenwenAI
/

shenwen-coderV2-Instruct

Safetensors

qwen2

Model card Files Files and versions

xet

Community

shc2012 commited on 9 days ago

Commit

22939f8

verified ·

1 Parent(s): 099d52a

Update README with swllm.cpp usage and social links

Browse files

Files changed (1) hide show

README.md +51 -234

README.md CHANGED Viewed

@@ -3,287 +3,104 @@ AIGC:
     ContentProducer: Minimax Agent AI
     ContentPropagator: Minimax Agent AI
     Label: AIGC
-    ProduceID: b4bb3d57bc0ce8c354e4bcb050972fe0
-    PropagateID: b4bb3d57bc0ce8c354e4bcb050972fe0
-    ReservedCode1: 304402200e99b598a461cba050f038aaded8aa408584562e393afc88fa56d87d1c4bb8e702204cc29b8225838f04ab15d48aec68760a1d3a792627f04a1bb9e4f7f8a8d9162c
-    ReservedCode2: 3045022100d0dcfefede67eb43affd01eb6a0cb9f3b5f18b6a62ced359b5aea8c8e25fcfd60220620b06dda8454d7580fe66bd02ed1194bbe9b88b34cd19d325fc83866a61b600
 ---
 # shenwen-coderV2-Instruct
-<p align="center">
-  <img src="https://huggingface.co/front/assets/huggingface_logo.svg" alt="Hugging Face" width="50" height="50">
-</p>
-<div align="center">
-[![Model](https://img.shields.io/badge/Model-shenwen--coderV2--Instruct-blue.svg)](https://huggingface.co/shenwenAI/shenwen-coderV2-Instruct)
-[![Base Model](https://img.shields.io/badge/Base%20Model-Qwen2.5--Coder--0.5B-orange.svg)](https://huggingface.co/Qwen/Qwen2.5-Coder-0.5B-Instruct)
-[![License](https://img.shields.io/badge/License-Apache%202.0-green.svg)](LICENSE)
-[![Parameters](https://img.shields.io/badge/Parameters-0.5B-yellow.svg)]()
-</div>
-## Overview
-**shenwen-coderV2-Instruct** is an instruction-tuned code generation model built upon [Qwen2.5-Coder-0.5B-Instruct](https://huggingface.co/Qwen/Qwen2.5-Coder-0.5B-Instruct), further enhanced with high-quality code data inspired by [Zeta](https://zed.dev/blog/zeta2) training methodology. This model is designed to provide efficient and accurate code generation, completion, and reasoning capabilities across a wide range of programming languages.
-## Model Summary
-| Attribute | Value |
-|-----------|-------|
-| **Model Name** | shenwen-coderV2-Instruct |
-| **Base Model** | Qwen2.5-Coder-0.5B-Instruct |
-| **Training Data** | Enhanced with zeta-style code data |
-| **Parameters** | ~0.5 Billion |
-| **Context Length** | 32K tokens |
-| **License** | Apache 2.0 |
-| **Developer** | shenwenAI |
-## Key Features
-### 🎯 Core Capabilities
-- **Code Generation**: Generate high-quality code snippets from natural language descriptions
-- **Code Completion**: Intelligent code completion for various programming scenarios
-- **Code Reasoning**: Understand and explain code logic and functionality
-- **Code Fixing**: Identify and fix common coding errors and bugs
-### 🌐 Multi-Language Support
-Supports **92+ programming languages** including but not limited to:
-| Popular Languages | Domain-Specific | Modern Languages |
-|-------------------|-----------------|------------------|
-| Python | SQL | Rust |
-| JavaScript/TypeScript | HTML/CSS | Go |
-| Java | Shell/Bash | Swift |
-| C/C++ | JSON/YAML | Kotlin |
-| C# | Markdown | Scala |
-### ⚡ Lightweight & Efficient
-- Only **0.5 billion parameters** - ideal for resource-constrained environments
-- Fast inference speed with low memory footprint
-- Can run efficiently on consumer-grade GPUs and even CPUs
-- Perfect for edge computing and mobile applications
-## Model Architecture
-Based on the robust Qwen2.5 architecture with specialized enhancements for code tasks:
-```
-┌─────────────────────────────────────────────────────────┐
-│                    shenwen-coderV2-Instruct             │
-├─────────────────────────────────────────────────────────┤
-│  Base Model: Qwen2.5-Coder-0.5B                        │
-│  ├── Transformer Architecture                          │
-│  ├── RoPE Position Encoding                            │
-│  ├── SwiGLU Activation                                 │
-│  ├── RMSNorm Normalization                             │
-│  └── Attention with QKV Bias                          │
-├─────────────────────────────────────────────────────────┤
-│  Enhancements:                                         │
-│  ├── Instruction Tuning                                │
-│  └── Zeta-style Code Data Training                     │
-└─────────────────────────────────────────────────────────┘
-```
-**Architecture Details:**
-| Parameter | Value |
-|-----------|-------|
-| Hidden Size | 896 |
-| Number of Layers | 24 |
-| Query Heads | 14 |
-| KV Heads | 2 |
-| Intermediate Size | 4,864 |
-| Vocabulary Size | 151,646 |
-## Training Details
-### Base Model Training (Qwen2.5-Coder)
-- **Training Tokens**: 5.5 trillion tokens
-- **Data Sources**: Source code, text-code grounding, synthetic data
-- **Context Length**: Up to 128K tokens (base model), optimized for 32K
-### Fine-tuning Approach
-The `shenwen-coderV2-Instruct` model is enhanced through:
-1. **Instruction Tuning**: Fine-tuned on high-quality instruction-response pairs
-2. **Zeta-style Data**: Incorporates code patterns and structures from real-world repositories
-3. **Preference Alignment**: Optimized for human coding preferences and best practices
 ## Usage
-### Installation
-```bash
-pip install transformers>=4.35.0
-pip install accelerate>=0.20.0
-pip install torch
-```
-### Quick Start
 ```python
 from transformers import AutoModelForCausalLM, AutoTokenizer
-# Load model and tokenizer
 model_name = "shenwenAI/shenwen-coderV2-Instruct"
 tokenizer = AutoTokenizer.from_pretrained(model_name)
-model = AutoModelForCausalLM.from_pretrained(
-    model_name,
-    torch_dtype="auto",
-    device_map="auto"
-)
-# Code generation example
-prompt = "Write a Python function to calculate the factorial of a number using recursion:"
-messages = [
-    {"role": "user", "content": prompt}
-]
-text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
-inputs = tokenizer([text], return_tensors="pt").to(model.device)
 outputs = model.generate(**inputs, max_new_tokens=512)
-response = tokenizer.decode(outputs[0][len(inputs.input_ids[0]):], skip_special_tokens=True)
-print(response)
-```
-### Using with Ollama
-```bash
-# Pull the model (if available in Ollama registry)
-ollama pull shenwenAI/shenwen-coderV2-Instruct
-# Run inference
-ollama run shenwenAI/shenwen-coderV2-Instruct
 ```
-### Using with vLLM
 ```python
 from vllm import LLM, SamplingParams
 llm = LLM(model="shenwenAI/shenwen-coderV2-Instruct")
-sampling_params = SamplingParams(temperature=0.7, max_tokens=512)
-outputs = llm.generate(["Write a JavaScript function to reverse a string:"], sampling_params)
 print(outputs[0].outputs[0].text)
 ```
-## Benchmark Performance
-The base model (Qwen2.5-Coder-0.5B) demonstrates strong performance on code-related benchmarks:
-| Benchmark | Description | Performance |
-|-----------|-------------|--------------|
-| HumanEval | Python code generation | Competitive |
-| MBPP | Python problem solving | Strong |
-| MultiPL-E | Multi-language generation | Excellent |
-| McEval | Multi-language code evaluation | Strong |
-| CodeGPT | Code understanding | Good |
-> Note: Actual performance may vary based on specific fine-tuning configurations. Users are encouraged to conduct domain-specific evaluations.
-## Comparison with Base Model
-| Feature | Qwen2.5-Coder-0.5B | shenwen-coderV2-Instruct |
-|---------|--------------------|--------------------------|
-| Code Generation | ✅ | ✅ Enhanced |
-| Instruction Following | Standard | Optimized |
-| Real-world Patterns | Limited | Expanded with zeta data |
-| User Preferences | Basic alignment | Improved alignment |
-## Limitations
-1. **Model Size**: While optimized for efficiency, the 0.5B parameter model may not match larger models (7B, 32B) on complex tasks
-2. **Context Window**: Optimized for 32K context; performance may degrade with very long inputs
-3. **Language Coverage**: Though supports 92+ languages, proficiency varies
-4. **Safety**: Always review generated code for security vulnerabilities and correctness
-## Best Practices
-### Do's ✅
-- Review and test all generated code before production use
-- Use appropriate temperature settings for different tasks
-- Provide clear, specific prompts for better results
-- Validate generated code against your specific requirements
-### Don'ts ❌
-- Don't use unverified code directly in production
-- Don't rely solely on the model for security-critical code
-- Don't expect perfect code for highly specialized domains
-## Hardware Requirements
-| Configuration | Minimum | Recommended |
-|---------------|---------|-------------|
-| GPU VRAM | 2GB | 4GB+ |
-| RAM | 8GB | 16GB+ |
-| Storage | 1GB | 2GB+ |
-### CPU Inference
-The model can run on CPU with acceptable performance for smaller tasks:
-```python
-model = AutoModelForCausalLM.from_pretrained(
-    model_name,
-    torch_dtype="float32",
-    device_map="cpu"
-)
 ```
-## Contributing
-Contributions are welcome! Please feel free to submit issues and pull requests:
-1. Fork the repository
-2. Create a feature branch (`git checkout -b feature/amazing-feature`)
-3. Commit your changes (`git commit -m 'Add amazing feature'`)
-4. Push to the branch (`git push origin feature/amazing-feature`)
-5. Open a Pull Request
-## Acknowledgments
-- **Alibaba Qwen Team** for developing the excellent [Qwen2.5-Coder](https://github.com/QwenLM/Qwen) series
-- **Zed Industries** for pioneering the [Zeta](https://zed.dev/blog/edit-prediction) edit prediction model
-- **Hugging Face** for the open-source ML ecosystem
 ## License
-This model is released under the **Apache 2.0 License**. Please refer to the LICENSE file for more details.
-## Citation
-If you use this model in your research, please cite:
-```bibtex
-@misc{shenwen-coderV2-Instruct,
-  author = {shenwenAI},
-  title = {shenwen-coderV2-Instruct: Enhanced Code Generation Model},
-  year = {2025},
-  publisher = {Hugging Face},
-  url = {https://huggingface.co/shenwenAI/shenwen-coderV2-Instruct}
-}
-```
-## Contact
-- **Author**: shenwenAI
-- **Hugging Face**: [shenwenAI](https://huggingface.co/shenwenAI)
-- **Issues**: Please open an issue on this repository for bugs or feature requests
 ---
-<div align="center">
-**If you find this model useful, please give it a ⭐ on Hugging Face!**
-</div>

     ContentProducer: Minimax Agent AI
     ContentPropagator: Minimax Agent AI
     Label: AIGC
+    ProduceID: f3e961de220519135b7936401f9c497b
+    PropagateID: f3e961de220519135b7936401f9c497b
+    ReservedCode1: 30450221008b926720cc537a337609a6396807cefd6f2465e1a733f88cb72655e7ed3b5a1e0220073082e844d423175f71300fa33a443d56620f52022574850f68f6c58be981c9
+    ReservedCode2: 3045022100cee9a5ea6ceee0d1355538f5b52d08108adca91f6b0bd514a775e3cd43616f5e02200b1208fe8656e20f91c6bf8f9d6f4e07d3780abe35035a516e3fe4ffb4de7e6a
 ---
 # shenwen-coderV2-Instruct
+![Hugging Face](https://huggingface.co/front/assets/huggingface\_logo.svg)
+[![Model](https://img.shields.io/badge/Model-shenwen--coderV2--Instruct-blue.svg)](https://huggingface.co/shenwenAI/shenwen-coderV2-Instruct)[![Format](https://img.shields.io/badge/Format-Safetensors-green.svg)](https://huggingface.co/shenwenAI/shenwen-coderV2-Instruct)[![License](https://img.shields.io/badge/License-Apache%202.0-green.svg)](https://huggingface.co/shenwenAI/shenwen-coderV2-Instruct)
+## Model Overview
+**shenwen-coderV2-Instruct** is an instruction-tuned code generation model based on Qwen2.5-Coder-0.5B-Instruct, optimized for various code generation tasks.
+## Model Details
+- **Base Model**: Qwen2.5-Coder-0.5B-Instruct
+- **Tensor Type**: BF16
+- **Parameters**: 0.5B
+- **Architecture**: qwen2
 ## Usage
+### Using Transformers
 ```python
 from transformers import AutoModelForCausalLM, AutoTokenizer
 model_name = "shenwenAI/shenwen-coderV2-Instruct"
 tokenizer = AutoTokenizer.from_pretrained(model_name)
+model = AutoModelForCausalLM.from_pretrained(model_name)
+prompt = "Write a Python function to calculate factorial:"
+inputs = tokenizer(prompt, return_tensors="pt")
 outputs = model.generate(**inputs, max_new_tokens=512)
+print(tokenizer.decode(outputs[0], skip_special_tokens=True))
 ```
+### Using vLLM
 ```python
 from vllm import LLM, SamplingParams
 llm = LLM(model="shenwenAI/shenwen-coderV2-Instruct")
+sampling_params = SamplingParams(temperature=0.8, top_p=0.95, max_tokens=512)
+prompts = ["Write a Python function to calculate factorial:"]
+outputs = llm.generate(prompts, sampling_params)
 print(outputs[0].outputs[0].text)
 ```
+## Usage with swllm.cpp (Optimized Code Generation)
+For optimized code generation, we recommend using our custom **swllm.cpp** tool:
+```bash
+# Clone swllm.cpp
+git clone https://github.com/shenwenAI/swllm.cpp
+cd swllm.cpp
+# Build with this model
+# Convert model to GGUF format first if needed
+# Run inference
+./build/bin/swllm-cli -m path/to/model.gguf -n 512 -p "Write a Python function to calculate factorial:"
 ```
+**swllm.cpp** provides optimized code generation capabilities for enhanced performance and quality.
+## Quantization
+For quantized versions, please visit: [shenwenAI/shenwen-coderV2-GGUF](https://huggingface.co/shenwenAI/shenwen-coderV2-GGUF)
+| Quantization | Size |
+| --- | --- |
+| Q2_K | 339 MB |
+| Q4_K_M | 398 MB |
+| Q5_K_M | 420 MB |
+| Q8_0 | 531 MB |
+| F16 | 994 MB |
 ## License
+Apache 2.0 - See [LICENSE](https://huggingface.co/shenwenAI/shenwen-coderV2-Instruct/blob/main/LICENSE)
+## Acknowledgments
+- [Qwen Team](https://github.com/QwenLM/Qwen) for Qwen2.5-Coder
+- [shenwenAI](https://huggingface.co/shenwenAI) for model training and optimization
+## Connect With Us
+- **GitHub**: [https://github.com/shenwenAI](https://github.com/shenwenAI)
+- **HuggingFace**: [https://huggingface.co/shenwenAI](https://huggingface.co/shenwenAI)
+- **Twitter/X**: [https://x.com/shenwenai](https://x.com/shenwenai)
 ---
+*If this model is helpful, please consider giving us a star on GitHub and following us on social media!*