jaro/
qwen_datafusion

10 4 months ago

Qwen2.5-3B-DataFusion-Instruct Quantized Model trained on yarenty/datafusion_QA

Models

View all →

1 model

qwen_datafusion:latest

1.9GB · 32K context window · Text · 4 months ago

Readme

Qwen2.5-3B-DataFusion-Instruct Quantized Model

Model Card: Quantized Version

Model Name: Qwen2.5-3B-DataFusion-Instruct (Quantized)
File: qwen_datafusion
Size: 1.8GB
Type: Quantized GGUF Model
Base Model: Qwen2.5-3B
Specialization: DataFusion SQL Engine and Rust Programming
License: Apache 2.0

Model Overview

This is the quantized version of the Qwen2.5-3B-DataFusion-Instruct model, optimized for production deployment and resource-constrained environments. The quantization process reduces memory usage while maintaining high accuracy for DataFusion and Rust programming tasks.

Quantization Details

Quantization Method

  • Format: GGUF (GGML Universal Format)
  • Quantization Level: Optimized for inference speed and memory efficiency
  • Precision: Reduced from full precision to quantized representation
  • Memory Reduction: ~69% reduction from 5.8GB to 1.8GB

Performance Characteristics

  • Inference Speed: Faster than full precision model
  • Memory Usage: Significantly reduced memory footprint
  • Accuracy: Minimal degradation in specialized domain knowledge
  • Deployment: Optimized for production environments

Training Data

Dataset Composition

  • Total QA Pairs: 265,180
  • Source Projects: 36 different repositories
  • Content Types: Code implementation, documentation, usage examples
  • Coverage: Comprehensive DataFusion ecosystem

Training Projects

  • Core DataFusion: datafusion, datafusion-ballista, datafusion-federation
  • DataFusion Extensions: datafusion-functions-json, datafusion-postgres, datafusion-python
  • Arrow Ecosystem: arrow-rs, arrow-zarr
  • Related Tools: blaze, exon, feldera, greptimedb, horaedb, influxdb
  • Modern Data Stack: iceberg-rust, LakeSoul, lance, openobserve, parseable

Data Quality Features

  • Structured JSONL format with source attribution
  • Code examples with best practices and common pitfalls
  • Error handling guidance and troubleshooting solutions
  • Performance optimization tips and best practices

Model Capabilities

Primary Strengths

  1. Rust Programming Expertise

    • Idiomatic Rust code generation
    • DataFusion API usage patterns
    • Error handling and testing best practices
    • Performance optimization techniques

  2. DataFusion SQL Mastery

    • Complex SQL query construction
    • Table provider implementations
    • UDF (User-Defined Function) development
    • Query optimization and execution planning

  3. Data Processing Knowledge

    • Arrow format operations
    • Parquet file handling
    • Data transformation pipelines
    • Streaming and batch processing

  4. System Architecture Understanding

    • Distributed query execution
    • Federation and integration patterns
    • Observability and tracing
    • Performance monitoring

Technical Domains

  • SQL Engine Internals: Query planning, optimization, execution
  • Data Formats: Arrow, Parquet, JSON, CSV, Avro
  • Storage Systems: Object storage, databases, file systems
  • Distributed Computing: Ray, Ballista, cluster management
  • Streaming: Real-time data processing, windowing, aggregations

Usage Instructions

System Prompt

The model is configured with a specialized system prompt:

You are a helpful, concise, and accurate coding assistant specialized in Rust and the DataFusion SQL engine. Always provide high-level, idiomatic Rust code, DataFusion SQL examples, clear documentation, and robust test cases. Your answers should be precise, actionable, and end with '### End'.

Prompt Template

### Instruction:
{{ .Prompt }}

### Response:

Stop Sequences

  • ### Instruction:
  • ### Response:
  • ### End

Generation Parameters

  • num_predict: 1024 (maximum tokens to generate)
  • repeat_penalty: 1.2 (prevents repetitive output)
  • temperature: 0.7 (balanced creativity vs consistency)
  • top_p: 0.9 (nucleus sampling for quality)

Performance Characteristics

Accuracy

  • Code Generation: High accuracy for Rust and DataFusion patterns
  • SQL Queries: Correct syntax and best practices
  • Documentation: Clear, actionable explanations
  • Error Handling: Comprehensive coverage of common issues

Efficiency

  • Main Model: Highest accuracy, larger memory footprint
  • Quantized Model: Optimized inference, reduced memory usage
  • Response Time: Fast generation with proper stop sequences
  • Memory Usage: Efficient token management

Use Cases

Development

  • Code Generation: Generate Rust functions and DataFusion queries
  • Debugging: Identify and fix common issues
  • Documentation: Create clear technical explanations
  • Testing: Generate test cases and validation code

Learning

  • Tutorial Creation: Step-by-step learning materials
  • Best Practices: Learn recommended approaches
  • Pattern Recognition: Understand common design patterns
  • API Exploration: Discover available functionality

Production Support

  • Query Optimization: Improve SQL performance
  • Troubleshooting: Resolve runtime issues
  • Integration: Connect different data sources
  • Monitoring: Set up observability and tracing

Limitations and Considerations

Technical Limitations

  • Context Window: Limited to training data scope
  • Real-time Updates: May not reflect latest API changes
  • Complex Queries: Very complex scenarios may require human review
  • Edge Cases: Unusual configurations may need manual intervention

Best Practices

  • Verify Output: Always review generated code before deployment
  • Test Thoroughly: Validate generated queries and functions
  • Stay Updated: Check for newer model versions
  • Human Oversight: Use as assistant, not replacement for expertise

Installation and Setup

Ollama (Recommended)

# Pull the model
ollama pull jaro/qwen_datafusion

# Run inference
ollama run jaro/qwen_datafusion

Model Comparison

Aspect Main Model (5.8GB) Quantized Model (1.8GB)
Accuracy Highest High (slight degradation)
Memory Usage Higher Lower
Inference Speed Standard Faster
Deployment Development/Production Production/Resource-constrained
Use Case Maximum quality Balanced performance

Resources

Citation

When using this model in research or publications, please cite:

@software{qwen_datafusion,
  title={Qwen2.5-3B-DataFusion-Instruct: A Specialized Model for DataFusion Ecosystem},
  author={Fine-tuned on DataFusion Ecosystem QA Dataset},
  year={2025},
  url={https://github.com/yarenty/trainer},
  license={Apache-2.0}
}

License

This model is licensed under the Apache 2.0 License. See the LICENSE file for full details.

This model represents a significant advancement in specialized AI assistance for the DataFusion ecosystem, combining the power of large language models with domain-specific expertise in data processing and Rust programming.