Upload README.md with huggingface_hub

README.md

@@ -1,175 +1,241 @@
 ---
+# Model Card for Legion Coder 8M
+# YAML Front Matter for Hugging Face Hub
+base_model: dineth554/legion-coder-8m
+library_name: transformers
+license: mit
+pipeline_tag: text-generation
 language:
 - en
-tags:
 - code
-- coding
-- python
-- programming
+tags:
+- transformers
+- pytorch
+- safetensors
 - text-generation
-- causal-lm
-- transformer
-- gpt
-- legion-coder
 - code-generation
-- code-completion
-license: mit
+- python
+- javascript
+- coding
+- programming
+- sagemaker
+- amazon-sagemaker
+- cpu
+- compact
+- efficient
+- nvdya-kit
+- death-legion
+- vllm
+- sglang
+- llama.cpp
+- ollama
+- lm-studio
+
 datasets:
 - the-stack-v2
-- codeparrot/github-code
-- bigcode/the-stack
+
+metrics:
+- perplexity
+- accuracy
+
 model-index:
 - name: Legion Coder 8M
   results: []
+
+inference:
+  parameters:
+    temperature: 0.8
+    top_p: 0.95
+    top_k: 50
+    max_new_tokens: 200
+
+sagemaker:
+  sdk_version: "2.200.0"
+  instance_type: "ml.m5.large"
+  instance_count: 1
+  container_image: "huggingface-pytorch-inference:2.0.0-transformers4.28.1-cpu-py310-ubuntu20.04-v1.0"
 ---
 
-# Legion Coder 8M
+# ⚡ Legion Coder 8M
 
-A compact yet powerful 44M parameter transformer model optimized for coding tasks. Legion Coder is designed to generate clean, efficient, and well-documented code while maintaining a small footprint suitable for local deployment.
+**A 44M Parameter Transformer for Code Generation**
 
-## Model Details
+[![Made with by DEATH LEGION](https://img.shields.io/badge/MADE%20WITH%20BY-DEATH%20LEGION-ff0040?style=for-the-badge)](https://huggingface.co/dineth554/legion-coder-8m)
+[![Powered by nvdya-kit](https://img.shields.io/badge/POWERED%20BY-nvdya--kit-7c4dff?style=for-the-badge)]()
 
-- **Architecture**: GPT-style transformer with pre-normalization
-- **Parameters**: 44,341,632 (~44M)
-- **Vocabulary Size**: 16,000 (BPE tokenizer optimized for code)
-- **Hidden Size (d_model)**: 576
-- **Layers**: 13
-- **Attention Heads**: 16
-- **Feed-forward Dimension**: 1,152
-- **Context Length**: 1,024 tokens
-- **Format**: Safetensors
-- **Precision**: float32
+## 🚀 Quick Links
 
-## Model Specifications
+<div align="center">
 
-| Attribute | Value |
-|-----------|-------|
-| Model Type | Causal Language Model |
-| Architecture | Transformer Decoder |
-| Parameters | 44,341,632 |
-| Hidden Size | 576 |
-| Num Layers | 13 |
-| Num Attention Heads | 16 |
-| Intermediate Size | 1,152 |
-| Max Position Embeddings | 1,024 |
-| Vocab Size | 16,000 |
+### Libraries & Frameworks
 
-## Intended Use
+[![Transformers](https://img.shields.io/badge/🤗%20Transformers-Compatible-brightgreen?style=flat-square)](https://huggingface.co/docs/transformers)
+[![PyTorch](https://img.shields.io/badge/PyTorch-2.1+-ee4c2c?style=flat-square&logo=pytorch)](https://pytorch.org/)
+[![Safetensors](https://img.shields.io/badge/Safetensors-Format-blue?style=flat-square)](https://github.com/huggingface/safetensors)
 
-This model is designed for:
-- **Code Generation**: Generate Python and other programming language code
-- **Code Completion**: Complete partial code snippets
-- **Code Explanation**: Provide explanations for code functionality
-- **Debugging Assistance**: Help identify and fix code issues
-- **Educational Purposes**: Learn programming concepts through examples
+### Local Apps & Inference Engines
 
-## Usage
+[![vLLM](https://img.shields.io/badge/vLLM-Supported-ff6b6b?style=flat-square)](https://docs.vllm.ai/)
+[![SGLang](https://img.shields.io/badge/SGLang-New!-4ecdc4?style=flat-square)](https://sgl-project.github.io/)
+[![llama.cpp](https://img.shields.io/badge/llama.cpp-Compatible-8b5cf6?style=flat-square)](https://github.com/ggerganov/llama.cpp)
+[![Ollama](https://img.shields.io/badge/Ollama-Ready-f97316?style=flat-square)](https://ollama.ai/)
+[![LM Studio](https://img.shields.io/badge/LM%20Studio-Compatible-10b981?style=flat-square)](https://lmstudio.ai/)
 
-### Loading the Model
+### Notebooks & Cloud
 
-```python
-from transformers import AutoModel, AutoTokenizer
-import torch
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/dineth554/legion-coder-8m/blob/main/notebooks/legion_coder_demo.ipynb)
+[![Kaggle](https://kaggle.com/static/images/open-in-kaggle.svg)](https://kaggle.com/kernels/welcome?src=https://github.com/dineth554/legion-coder-8m/blob/main/notebooks/legion_coder_demo.ipynb)
 
-# Load model and tokenizer
-model = AutoModel.from_pretrained("pnny13/legion-coder-8m", trust_remote_code=True)
-tokenizer = AutoTokenizer.from_pretrained("pnny13/legion-coder-8m", trust_remote_code=True)
+</div>
 
-# Set to eval mode
-model.eval()
-```
+## 🚀 About
+
+Legion Coder is a compact yet powerful 44M parameter transformer model optimized for coding tasks. Built with precision by **DEATH LEGION** and powered by **nvdya-kit**, this model delivers high-quality code generation in a lightweight package.
 
-### Generating Code
+## ✨ Features
+
+- 📝 **Clean Code Generation** - PEP 8 compliant Python and more
+- 🐛 **Debug Assistance** - Help identify and fix code issues
+- 📚 **Code Explanation** - Understand complex programming concepts
+- 💡 **Multi-language Support** - Python, JavaScript, and more
+- ⚡ **Fast Inference** - Optimized for CPU deployment
+- ☁️ **SageMaker Ready** - One-click AWS deployment
+- 🎯 **Template Ready** - Duplicate this space to create your own!
+
+## 📊 Model Specifications
+
+| Attribute | Value |
+|-----------|-------|
+| **Parameters** | 44,341,632 (~44M) |
+| **Model Size** | ~170MB |
+| **Architecture** | GPT-style Transformer |
+| **Hidden Size** | 576 |
+| **Layers** | 13 |
+| **Attention Heads** | 16 |
+| **Context Length** | 1,024 tokens |
+| **Vocabulary** | 16,000 tokens |
+| **Format** | Safetensors |
+
+## 🚀 Amazon SageMaker Deployment
+
+This model is ready for deployment on Amazon SageMaker with one-click deployment support.
+
+### ☁️ Deploy to AWS SageMaker
+
+[![Deploy to SageMaker](https://img.shields.io/badge/🚀%20Deploy%20to-AWS%20SageMaker-FF9900?style=for-the-badge&logo=amazon-aws)](https://huggingface.co/dineth554/legion-coder-8m/deploy/sagemaker)
+
+### Using the SageMaker Python SDK
 
 ```python
-# Prepare prompt
-prompt = "# Write a function to calculate factorial\ndef factorial(n):"
-inputs = tokenizer(prompt, return_tensors="pt")
-
-# Generate
-with torch.no_grad():
-    outputs = model.generate(
-        inputs.input_ids,
-        max_length=200,
-        temperature=0.8,
-        top_p=0.95,
-        top_k=50
-    )
-
-# Decode
-generated_code = tokenizer.decode(outputs[0], skip_special_tokens=True)
-print(generated_code)
+import sagemaker
+from sagemaker.huggingface import HuggingFaceModel
+
+# Initialize SageMaker session
+sess = sagemaker.Session()
+
+# Create Hugging Face Model
+huggingface_model = HuggingFaceModel(
+    model_data="dineth554/legion-coder-8m",
+    transformers_version="4.36.0",
+    pytorch_version="2.1.0",
+    py_version="py310",
+    role="arn:aws:iam::YOUR_ACCOUNT_ID:role/YOUR_SAGEMAKER_ROLE",
+    sagemaker_session=sess,
+)
+
+# Deploy to SageMaker
+predictor = huggingface_model.deploy(
+    initial_instance_count=1,
+    instance_type="ml.m5.large",
+    endpoint_name="legion-coder-8m-endpoint"
+)
+
+# Test the endpoint
+result = predictor.predict({
+    "inputs": "Write a Python function to calculate fibonacci numbers:",
+    "parameters": {
+        "temperature": 0.8,
+        "max_new_tokens": 200
+    }
+})
+
+print(result)
 ```
 
-## System Prompt
+### SageMaker Inference Script
+
+The `sagemaker_inference.py` file in this repository provides the inference handler for SageMaker deployment.
 
-For optimal results, use the following system prompt:
+## 🛠️ Local Inference with vLLM
 
+```python
+from vllm import LLM, SamplingParams
+
+# Load model with vLLM
+llm = LLM(model="dineth554/legion-coder-8m")
+
+# Set sampling parameters
+sampling_params = SamplingParams(
+    temperature=0.8,
+    top_p=0.95,
+    max_tokens=200
+)
+
+# Generate code
+prompt = "Write a Python function to calculate fibonacci numbers:"
+outputs = llm.generate(prompt, sampling_params)
+print(outputs[0].outputs[0].text)
 ```
-You are Legion Coder, an expert coding assistant. Your purpose is to help users write clean, efficient, and well-documented code.
 
-Guidelines:
-- Write code that follows best practices and PEP 8 style guidelines
-- Include helpful comments explaining complex logic
-- Provide complete, runnable code examples
-- Explain your approach before showing code when helpful
-- If asked to debug, identify the issue and provide the corrected code
+## 🛠️ Local Inference with SGLang
 
-Always wrap code blocks in triple backticks with the appropriate language identifier.
+```python
+import sglang as sgl
+
+# Define prompt template
+@sgl.function
+def code_gen(s, prompt):
+    s += sgl.system("You are a helpful coding assistant.")
+    s += sgl.user(prompt)
+    s += sgl.assistant(sgl.gen("code", max_tokens=200))
+
+# Run inference
+result = code_gen.run(
+    prompt="Write a Python function to calculate fibonacci numbers:",
+    temperature=0.8
+)
+print(result["code"])
 ```
 
-## Training Details
+## 🛠️ Technical Details
 
 ### Training Data
 - Python code from The Stack v2 dataset
 - GitHub code repositories (filtered for quality)
-- Code-specific preprocessing to handle indentation and special tokens
+- Code-specific preprocessing for indentation and special tokens
 
 ### Training Procedure
-- Optimizer: AdamW
-- Learning Rate: 5e-4 with cosine decay
-- Batch Size: 4 with gradient accumulation
-- Training Steps: 10,000
-- Mixed Precision: No (CPU-optimized)
-
-## Limitations
-
-- **Context Length**: Limited to 1,024 tokens
-- **Language Support**: Primarily optimized for Python
-- **Model Size**: 44M parameters may not capture all programming patterns
-- **Training Data**: May reflect biases present in training code
-- **No Internet Access**: Cannot access external APIs or documentation
-
-## Ethical Considerations
-
-- Generated code should be reviewed before production use
-- The model may reproduce patterns from training data; verify licensing
-- Do not use for generating malicious code
-- Consider environmental impact of model inference
-
-## Citation
-
-If you use this model in your research, please cite:
-
-```bibtex
-@misc{legioncoder2024,
-  title={Legion Coder 8M: A Compact Transformer for Code Generation},
-  author={Legion Coder Team},
-  year={2024},
-  howpublished={\url{https://huggingface.co/pnny13/legion-coder-8m}}
-}
-```
+- **Optimizer:** AdamW
+- **Learning Rate:** 5e-4 with cosine decay
+- **Batch Size:** 4 with gradient accumulation
+- **Training Steps:** 10,000
+- **Precision:** float32 (CPU-optimized)
 
-## License
+## 📝 License
 
-This model is released under the MIT License.
+This model is released under the **MIT License**.
 
-## Contact
+## 🔗 Links
 
-For questions or issues, please open an issue on the Hugging Face model repository.
+- **Model Repository:** [dineth554/legion-coder-8m](https://huggingface.co/dineth554/legion-coder-8m)
+- **Live Demo:** [Hugging Face Space](https://huggingface.co/spaces/dineth554/legion-coder-8m)
 
----
+<div align="center">
+
+### 🔥 MADE WITH BY DEATH LEGION 🔥
+
+**Powered by nvdya-kit**
+
+*© 2024 DEATH LEGION. All rights reserved.*
 
-**Model Version**: 1.0.0  
-**Last Updated**: 2024-03-08  
-**Hugging Face Hub**: https://huggingface.co/pnny13/legion-coder-8m
+</div>