How to Fine-Tune Ollama Models for Financial Analysis: Custom Training Tutorial

# Install Ollama
curl -fsSL https://ollama.ai/install.sh | sh

# Verify installation
ollama --version

# Install Python dependencies
pip install torch transformers datasets pandas numpy matplotlib seaborn

# Lightweight option (7B parameters)
ollama pull llama2:7b

# Balanced option (13B parameters)  
ollama pull llama2:13b

# High-accuracy option (70B parameters)
ollama pull llama2:70b

import pandas as pd
import json

# Example financial training data structure
training_data = [
    {
        "instruction": "Analyze the debt-to-equity ratio trend",
        "input": "Company XYZ has total debt of $500M and shareholder equity of $1.2B in 2024, compared to $400M debt and $1.0B equity in 2023.",
        "output": "The debt-to-equity ratio improved from 0.40 in 2023 to 0.42 in 2024, indicating a slight increase in leverage. This 5% increase suggests the company took on additional debt relative to equity, which could indicate expansion financing or strategic investments. Monitor cash flow coverage ratios to assess debt serviceability."
    },
    {
        "instruction": "Evaluate revenue recognition compliance",
        "input": "Software company ABC recognizes subscription revenue monthly over contract terms. Q3 shows $10M in deferred revenue increase.",
        "output": "The $10M increase in deferred revenue indicates strong subscription sales that will recognize over future periods. This follows ASC 606 revenue recognition standards for software subscriptions. The growth suggests healthy customer acquisition, but monitor customer retention rates and actual cash collection timing."
    }
]

# Save as JSON for training
with open('financial_training_data.json', 'w') as f:
    json.dump(training_data, f, indent=2)

def preprocess_financial_data(data):
    """Clean and format financial training data"""
    processed_data = []
    
    for item in data:
        # Standardize financial terminology
        text = item['input'].replace('$', 'USD ')
        text = text.replace('%', ' percent')
        
        # Ensure consistent formatting
        processed_item = {
            'instruction': item['instruction'].strip(),
            'input': text.strip(),
            'output': item['output'].strip()
        }
        processed_data.append(processed_item)
    
    return processed_data

# Process your training data
clean_data = preprocess_financial_data(training_data)

# fine_tune_config.py
import torch
from transformers import (
    AutoTokenizer, 
    AutoModelForCausalLM,
    TrainingArguments,
    Trainer
)

class FinancialModelConfig:
    def __init__(self, model_name="llama2:13b"):
        self.model_name = model_name
        self.max_length = 2048
        self.learning_rate = 2e-5
        self.batch_size = 4
        self.num_epochs = 3
        self.warmup_steps = 100
        
    def get_training_args(self, output_dir):
        return TrainingArguments(
            output_dir=output_dir,
            num_train_epochs=self.num_epochs,
            per_device_train_batch_size=self.batch_size,
            learning_rate=self.learning_rate,
            warmup_steps=self.warmup_steps,
            logging_steps=10,
            save_steps=500,
            evaluation_strategy="steps",
            eval_steps=500,
            load_best_model_at_end=True,
        )

from datasets import Dataset
from transformers import DataCollatorForLanguageModeling

def create_financial_dataset(data_file):
    """Load and tokenize financial training data"""
    
    # Load training data
    with open(data_file, 'r') as f:
        raw_data = json.load(f)
    
    # Format for instruction tuning
    formatted_data = []
    for item in raw_data:
        prompt = f"""### Instruction:
{item['instruction']}

### Input:
{item['input']}

### Response:
{item['output']}"""
        formatted_data.append({"text": prompt})
    
    # Create dataset
    dataset = Dataset.from_list(formatted_data)
    return dataset

# Initialize tokenizer
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-13b-hf")
tokenizer.pad_token = tokenizer.eos_token

def tokenize_function(examples):
    """Tokenize training examples"""
    return tokenizer(
        examples["text"],
        truncation=True,
        padding=True,
        max_length=2048,
        return_tensors="pt"
    )

# Prepare dataset
train_dataset = create_financial_dataset('financial_training_data.json')
tokenized_dataset = train_dataset.map(tokenize_function, batched=True)

def fine_tune_financial_model():
    """Main fine-tuning execution"""
    
    # Load base model
    model = AutoModelForCausalLM.from_pretrained(
        "meta-llama/Llama-2-13b-hf",
        torch_dtype=torch.float16,
        device_map="auto"
    )
    
    # Configure training
    config = FinancialModelConfig()
    training_args = config.get_training_args("./financial-llama-output")
    
    # Data collator
    data_collator = DataCollatorForLanguageModeling(
        tokenizer=tokenizer,
        mlm=False
    )
    
    # Initialize trainer
    trainer = Trainer(
        model=model,
        args=training_args,
        train_dataset=tokenized_dataset,
        data_collator=data_collator,
        tokenizer=tokenizer,
    )
    
    # Start training
    print("Starting financial analysis fine-tuning...")
    trainer.train()
    
    # Save the fine-tuned model
    trainer.save_model("./financial-llama-final")
    tokenizer.save_pretrained("./financial-llama-final")
    
    print("Fine-tuning completed successfully!")

# Execute fine-tuning
if __name__ == "__main__":
    fine_tune_financial_model()

def evaluate_financial_model(model_path):
    """Evaluate fine-tuned model performance"""
    
    # Load fine-tuned model
    model = AutoModelForCausalLM.from_pretrained(model_path)
    tokenizer = AutoTokenizer.from_pretrained(model_path)
    
    # Test cases for financial analysis
    test_cases = [
        {
            "prompt": "Calculate the current ratio for a company with $500K current assets and $300K current liabilities.",
            "expected_metric": "current ratio",
            "expected_value": 1.67
        },
        {
            "prompt": "Interpret a P/E ratio of 25 for a tech company in 2024.",
            "expected_concepts": ["valuation", "growth expectations", "market comparison"]
        }
    ]
    
    results = []
    for test in test_cases:
        # Generate response
        inputs = tokenizer(test["prompt"], return_tensors="pt")
        outputs = model.generate(**inputs, max_length=200)
        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
        
        # Evaluate accuracy (implement scoring logic)
        score = evaluate_response(response, test)
        results.append({"test": test["prompt"], "score": score})
    
    return results

# Run evaluation
evaluation_results = evaluate_financial_model("./financial-llama-final")
print(f"Average accuracy: {sum(r['score'] for r in evaluation_results) / len(evaluation_results):.2%}")

def compare_models(base_model, fine_tuned_model, test_prompts):
    """Compare base model vs fine-tuned model performance"""
    
    comparison_results = []
    
    for prompt in test_prompts:
        # Get responses from both models
        base_response = generate_response(base_model, prompt)
        finetuned_response = generate_response(fine_tuned_model, prompt)
        
        # Score responses (implement your scoring logic)
        base_score = score_financial_response(base_response, prompt)
        finetuned_score = score_financial_response(finetuned_response, prompt)
        
        comparison_results.append({
            "prompt": prompt,
            "base_score": base_score,
            "finetuned_score": finetuned_score,
            "improvement": finetuned_score - base_score
        })
    
    return comparison_results

# Create custom Ollama model from fine-tuned weights
ollama create financial-analyst -f Modelfile

# Test the deployed model
ollama run financial-analyst "Analyze this company's working capital trend"

FROM ./financial-llama-final

TEMPLATE """### Instruction:
{{ .System }}

### Input:
{{ .Prompt }}

### Response:
"""

PARAMETER temperature 0.1
PARAMETER top_p 0.9
PARAMETER stop "###"

SYSTEM "You are a financial analysis expert. Provide accurate, detailed analysis based on financial data and industry best practices."

# Model optimization for production
def optimize_model_for_production(model_path):
    """Optimize fine-tuned model for production deployment"""
    
    # Quantization for faster inference
    from transformers import BitsAndBytesConfig
    
    quantization_config = BitsAndBytesConfig(
        load_in_4bit=True,
        bnb_4bit_compute_dtype=torch.float16,
        bnb_4bit_quant_type="nf4"
    )
    
    # Load optimized model
    optimized_model = AutoModelForCausalLM.from_pretrained(
        model_path,
        quantization_config=quantization_config,
        device_map="auto"
    )
    
    return optimized_model

def create_multitask_dataset():
    """Create dataset covering multiple financial analysis tasks"""
    
    tasks = {
        "ratio_analysis": load_ratio_analysis_data(),
        "risk_assessment": load_risk_assessment_data(), 
        "valuation": load_valuation_data(),
        "compliance": load_compliance_data()
    }
    
    # Combine datasets with task prefixes
    combined_data = []
    for task_name, task_data in tasks.items():
        for item in task_data:
            item['instruction'] = f"[{task_name.upper()}] {item['instruction']}"
            combined_data.append(item)
    
    return combined_data

def setup_continuous_learning():
    """Setup pipeline for continuous model improvement"""
    
    # Monitor model performance
    performance_tracker = ModelPerformanceTracker()
    
    # Collect feedback on model responses
    feedback_collector = UserFeedbackCollector()
    
    # Automated retraining triggers
    if performance_tracker.accuracy_decline() > 0.05:
        trigger_retraining()
    
    # Monthly model updates with new financial data
    schedule_monthly_updates()

# Reduce batch size and enable gradient checkpointing
training_args = TrainingArguments(
    per_device_train_batch_size=1,  # Reduce from 4
    gradient_checkpointing=True,
    dataloader_pin_memory=False
)

def calculate_roi():
    """Calculate ROI for fine-tuned financial model"""
    
    # Implementation costs
    initial_setup = 15000  # Development time and resources
    ongoing_maintenance = 5000  # Annual maintenance
    
    # Benefits
    analyst_time_saved = 2000  # Hours per year
    hourly_rate = 75  # Financial analyst hourly rate
    annual_savings = analyst_time_saved * hourly_rate
    
    # ROI calculation
    roi = (annual_savings - ongoing_maintenance) / initial_setup
    payback_period = initial_setup / (annual_savings - ongoing_maintenance)
    
    return {
        "annual_savings": annual_savings,
        "roi_percentage": roi * 100,
        "payback_months": payback_period * 12
    }

roi_results = calculate_roi()
print(f"Expected ROI: {roi_results['roi_percentage']:.1f}%")
print(f"Payback period: {roi_results['payback_months']:.1f} months")