shiprocket-ai/open-llama-1b-address-completion

🦙 Llama 3.2-1B Address Completion Model

This model is a fine-tuned version of Meta's Llama 3.2-1B-Instruct specialized for address completion and standardization. It's a lightweight, efficient model perfect for address intelligence tasks with reduced computational requirements.

🎯 Model Description

Llama 3.2-1B-Instruct model fine-tuned for address completion and standardization

Key Capabilities

• —Address Component Extraction: Parse addresses into structured components (building, locality, pincode, etc.)
• —Address Completion: Complete partial or incomplete addresses
• —Address Standardization: Convert informal addresses to structured format
• —Multi-format Support: Handle various address formats and styles
• —Lightweight Performance: Optimized for speed and efficiency
• —Contextual Understanding: Leverage relationships between address components

📊 Model Architecture

• —Base Model: meta-llama/Llama-3.2-1B-Instruct
• —Model Type: Causal Language Model (Autoregressive)
• —Vocabulary Size: 128,256 tokens
• —Hidden Size: 2048
• —Number of Layers: 16
• —Attention Heads: 32
• —Max Sequence Length: 131072 tokens
• —Model Size: ~2374MB
• —Checkpoint: 4390

🚀 Usage Examples

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

# Load model and tokenizer
model_name = "shiprocket-ai/open-llama-1b-address-completion"
tokenizer = AutoTokenizer.from_pretrained(model_name)

# Load the merged model (no need for PEFT since weights are already merged)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto"
)

def extract_address_components(address, max_new_tokens=150):
    """Extract address components using the model"""
    
    # Format prompt for Llama 3.2-1B-Instruct
    prompt = f"""<|begin_of_text|><|start_header_id|>user<|end_header_id|>

Extract address components from: {address}<|eot_id|><|start_header_id|>assistant<|end_header_id|>

"""
    
    # Tokenize
    inputs = tokenizer(prompt, return_tensors="pt", truncation=True, max_length=512)
    
    # FIX: Move inputs to the same device as the model
    device = next(model.parameters()).device
    inputs = {k: v.to(device) for k, v in inputs.items()}
    
    # Generate
    with torch.no_grad():
        outputs = model.generate(
            **inputs,
            max_new_tokens=max_new_tokens,
            temperature=0.1,
            top_p=0.9,
            do_sample=True,
            pad_token_id=tokenizer.eos_token_id,
            repetition_penalty=1.05
        )
    
    # Decode only the new tokens
    input_length = inputs['input_ids'].shape[1]
    generated_tokens = outputs[0][input_length:]
    response = tokenizer.decode(generated_tokens, skip_special_tokens=True)
    
    return response.strip()

# Example usage
test_addresses = [
    "C-704, Gayatri Shivam, Thakur Complex, Kandivali East, 400101",
    "Villa 141, Geown Oasis, V Kallahalli, Off Sarjapur, Bengaluru, Karnataka, 562125",
    "E401 Supertech Icon Indrapam 201301 UP"
]

print("🏠 ADDRESS EXTRACTION EXAMPLES")
print("=" * 50)

for i, address in enumerate(test_addresses, 1):
    print(f"\n📍 Example {i}: {address}")
    result = extract_address_components(address)
    print(f"🤖 Extracted: {result}")

📈 Performance Highlights

• —Lightweight: 1B parameter model for fast inference
• —Address Intelligence: Specialized for Indian address patterns
• —Component Extraction: High accuracy in parsing address components
• —Format Flexibility: Handles various address formats and abbreviations
• —Speed Optimized: Ultra-fast inference for real-time applications
• —Memory Efficient: Lower GPU memory requirements
• —Contextual Awareness: Understands relationships between address components

🎭 Supported Address Components

The model can extract and complete the following address components:

• —Building Names: Apartments, complexes, towers, malls
• —Localities: Areas, neighborhoods, sectors
• —Pincodes: 6-digit Indian postal codes
• —Cities: Major and minor Indian cities
• —States: All Indian states and union territories
• —Sub-localities: Sectors, phases, blocks
• —Road Names: Streets, lanes, main roads
• —Landmarks: Notable reference points

🔧 Training Details

• —Dataset: Custom address dataset
• —Training Strategy: Fine-tuned from pre-trained Llama 3.2-1B-Instruct
• —Specialization: Address parsing and completion
• —Context Length: 2048 tokens
• —Version: 1.0
• —Framework: PyTorch + Transformers + PEFT

💡 Use Cases

1. E-commerce & Delivery

• —Auto-complete customer addresses during checkout
• —Standardize delivery addresses for logistics
• —Validate address completeness before shipping

2. Form Auto-filling

• —Intelligent address suggestions in web forms
• —Mobile app address completion
• —Reduce user typing effort

3. Data Cleaning & Migration

• —Clean legacy address databases
• —Standardize address formats across systems
• —Fill missing address components in existing data

4. Edge Deployment

• —Lightweight model for mobile/edge devices
• —On-device address processing
• —Real-time address validation

5. High-throughput Processing

• —Batch processing of large address datasets
• —Real-time API endpoints
• —Cost-effective inference

🎯 Prompt Templates

The model works best with Llama 3.2-1B-Instruct chat format:

Address Extraction

<|begin_of_text|><|start_header_id|>user<|end_header_id|>

Extract address components from: [address_text]<|eot_id|><|start_header_id|>assistant<|end_header_id|>

Address Completion

<|begin_of_text|><|start_header_id|>user<|end_header_id|>

Complete this partial address: [partial_address]<|eot_id|><|start_header_id|>assistant<|end_header_id|>

⚡ Performance Tips

1. 1.Temperature Settings: Use lower temperatures (0.1-0.3) for factual predictions
2. 2.Context Length: Keep prompts under 512 tokens for optimal performance
3. 3.Batch Processing: Process multiple addresses in batches for efficiency
4. 4.GPU Usage: Use half-precision (float16) for faster inference
5. 5.Format: Use Llama 3.2-1B-Instruct chat format for best results
6. 6.Edge Deployment: Perfect for mobile and edge deployment scenarios

⚠️ Limitations

• —Model Size: Smaller model may have reduced capability vs larger models
• —Training Data: Performance depends on training data coverage
• —Regional Variations: May work better on certain address formats
• —Informal Addresses: May struggle with highly colloquial formats
• —Language: Primarily English; limited regional language support
• —Context: Works best with complete address context

📋 Model Files

• —config.json: Model configuration and hyperparameters
• —pytorch_model.bin / model.safetensors: Model weights
• —tokenizer.json: Tokenizer configuration
• —tokenizer_config.json: Tokenizer settings
• —special_tokens_map.json: Special tokens mapping
• —generation_config.json: Generation parameters

🔄 Model Updates

• —Version: 1.0 (Checkpoint 4390)
• —Last Updated: 2025-06-19
• —Base Model: meta-llama/Llama-3.2-1B-Instruct

📚 Citation

If you use this model in your research or applications, please cite:

@misc{llama-1b-address-completion,
  title={Llama 3.2-1B Address Completion Model},
  year={2025},
  publisher={Hugging Face},
  url={https://huggingface.co/shiprocket-ai/open-llama-1b-address-completion}
}

📞 Support & Contact

For questions, issues, or feature requests:

• —Open an issue in this repository
• —Contact: shiprocket-ai team
• —Documentation: See usage examples above

📜 License

This model is released under the Llama 2 Community License. See LICENSE file for details.

Lightweight address intelligence - Powered by Llama 3.2-1B-Instruct 🦙