Bitcoin Halving Cycle Analysis: Ollama AI Predicts 2024-2028 Price Movements

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

# Pull models for analysis
ollama pull llama3.1:70b
ollama pull codellama:34b
ollama pull mistral:7b

# Verify installation
ollama list

# requirements.txt
import subprocess
import json
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import yfinance as yf
from datetime import datetime, timedelta
import requests

# Install required packages
subprocess.run(["pip", "install", "pandas", "numpy", "matplotlib", "yfinance", "requests"])

import requests
import json

class OllamaAnalyzer:
    def __init__(self, base_url="http://localhost:11434"):
        self.base_url = base_url
        self.model = "llama3.1:70b"
    
    def analyze_halving_data(self, data, query):
        """Send Bitcoin data to Ollama for analysis"""
        payload = {
            "model": self.model,
            "prompt": f"Analyze this Bitcoin halving data: {data}\n\nQuery: {query}",
            "stream": False
        }
        
        response = requests.post(f"{self.base_url}/api/generate", json=payload)
        return response.json()['response']
    
    def predict_price_targets(self, current_price, historical_cycles):
        """Generate price predictions based on historical patterns"""
        prompt = f"""
        Bitcoin Current Price: ${current_price:,.2f}
        Historical Cycle Data: {historical_cycles}
        
        Calculate 2024-2028 price targets using:
        1. Average cycle ROI with diminishing returns
        2. Market cap considerations
        3. Adoption curve analysis
        
        Provide specific price targets with confidence intervals.
        """
        
        return self.analyze_halving_data("", prompt)

# Initialize analyzer
analyzer = OllamaAnalyzer()

def get_halving_data():
    """Fetch Bitcoin price data for all halving periods"""
    
    # Halving dates
    halving_dates = {
        'first': '2012-11-28',
        'second': '2016-07-09', 
        'third': '2020-05-11',
        'fourth': '2024-04-19'
    }
    
    halving_data = {}
    
    for name, date in halving_dates.items():
        # Get 2 years before and after each halving
        start_date = (datetime.strptime(date, '%Y-%m-%d') - timedelta(days=730)).strftime('%Y-%m-%d')
        end_date = (datetime.strptime(date, '%Y-%m-%d') + timedelta(days=730)).strftime('%Y-%m-%d')
        
        # Download price data
        btc_data = yf.download('BTC-USD', start=start_date, end=end_date)
        
        halving_data[name] = {
            'date': date,
            'data': btc_data,
            'pre_halving_low': btc_data['Low'].min(),
            'post_halving_high': btc_data['High'].max()
        }
    
    return halving_data

# Fetch data
historical_data = get_halving_data()
print("Historical halving data collected successfully")

def analyze_cycle_patterns(historical_data, analyzer):
    """Use Ollama to identify patterns in halving cycles"""
    
    pattern_analysis = {}
    
    for cycle_name, cycle_data in historical_data.items():
        # Prepare data summary for Ollama
        data_summary = {
            'halving_date': cycle_data['date'],
            'pre_halving_low': cycle_data['pre_halving_low'],
            'post_halving_high': cycle_data['post_halving_high'],
            'cycle_roi': ((cycle_data['post_halving_high'] / cycle_data['pre_halving_low']) - 1) * 100
        }
        
        # Query Ollama for pattern analysis
        query = f"""
        Analyze this Bitcoin halving cycle pattern:
        
        1. Identify pre-halving accumulation phases
        2. Calculate post-halving momentum periods  
        3. Determine optimal entry/exit timeframes
        4. Compare to previous cycles for trend analysis
        
        Focus on actionable trading insights.
        """
        
        analysis = analyzer.analyze_halving_data(data_summary, query)
        pattern_analysis[cycle_name] = analysis
        
        print(f"✅ {cycle_name.title()} halving analysis complete")
    
    return pattern_analysis

# Run pattern analysis
cycle_patterns = analyze_cycle_patterns(historical_data, analyzer)

def calculate_diminishing_returns():
    """Calculate ROI decline rate across halving cycles"""
    
    cycle_rois = [
        {'cycle': 1, 'year': 2012, 'roi': 584.83},  # 58,483%
        {'cycle': 2, 'year': 2016, 'roi': 119.62},  # 11,962% 
        {'cycle': 3, 'year': 2020, 'roi': 21.10},   # 2,110%
        {'cycle': 4, 'year': 2024, 'roi': None}     # TBD
    ]
    
    # Calculate decline rate
    decline_rates = []
    for i in range(1, len(cycle_rois)-1):
        current_roi = cycle_rois[i]['roi']
        previous_roi = cycle_rois[i-1]['roi']
        decline_rate = (previous_roi - current_roi) / previous_roi
        decline_rates.append(decline_rate)
    
    average_decline = np.mean(decline_rates)
    
    # Predict 2024 cycle ROI
    last_roi = cycle_rois[2]['roi']  # 2020 cycle
    predicted_2024_roi = last_roi * (1 - average_decline)
    
    return {
        'average_decline_rate': average_decline,
        'predicted_2024_roi': predicted_2024_roi,
        'historical_data': cycle_rois
    }

diminishing_returns = calculate_diminishing_returns()
print(f"Average ROI decline rate: {diminishing_returns['average_decline_rate']:.2%}")
print(f"Predicted 2024 cycle ROI: {diminishing_returns['predicted_2024_roi']:.1f}x")

def current_market_analysis(analyzer):
    """Analyze current Bitcoin market conditions"""
    
    # Get current Bitcoin price
    btc_current = yf.download('BTC-USD', period='1d')
    current_price = btc_current['Close'].iloc[-1]
    
    # Market metrics
    market_data = {
        'current_price': current_price,
        'halving_date': '2024-04-19',
        'days_since_halving': (datetime.now() - datetime(2024, 4, 19)).days,
        'market_cap': current_price * 19.7e6,  # Approximate circulating supply
        'previous_ath': 73000,  # March 2024 high
        'cycle_low': 15476     # 2022 bear market low
    }
    
    # Ollama analysis
    analysis_query = """
    Based on this Bitcoin market data, analyze:
    
    1. Current cycle stage (early/mid/late)
    2. Comparison to previous halving timelines
    3. Market structure differences from past cycles
    4. Institutional adoption impact
    5. Macro environment considerations
    
    Provide specific insights for the 2024-2028 prediction.
    """
    
    current_analysis = analyzer.analyze_halving_data(market_data, analysis_query)
    
    return {
        'market_data': market_data,
        'ollama_analysis': current_analysis
    }

# Run current market analysis
current_market = current_market_analysis(analyzer)
print(f"Current Bitcoin Price: ${current_market['market_data']['current_price']:,.2f}")

def calculate_price_targets(current_price, diminishing_returns, analyzer):
    """Calculate Bitcoin price targets for 2024-2028"""
    
    # Base scenarios using diminishing returns model
    conservative_roi = diminishing_returns['predicted_2024_roi'] * 0.5  # 50% of predicted
    base_case_roi = diminishing_returns['predicted_2024_roi']           # Full predicted
    optimistic_roi = diminishing_returns['predicted_2024_roi'] * 1.5   # 150% of predicted
    
    # Calculate price targets
    cycle_low = 15476  # 2022 bear market low
    
    targets = {
        'conservative': {
            'peak_price': cycle_low * conservative_roi,
            'probability': '60%',
            'timeline': 'Q2 2025 - Q4 2025'
        },
        'base_case': {
            'peak_price': cycle_low * base_case_roi,
            'probability': '40%', 
            'timeline': 'Q1 2026 - Q3 2026'
        },
        'optimistic': {
            'peak_price': cycle_low * optimistic_roi,
            'probability': '20%',
            'timeline': 'Q4 2025 - Q2 2026'
        }
    }
    
    # Ollama validation
    validation_query = f"""
    Validate these Bitcoin price targets for 2024-2028:
    
    Conservative: ${targets['conservative']['peak_price']:,.0f}
    Base Case: ${targets['base_case']['peak_price']:,.0f}  
    Optimistic: ${targets['optimistic']['peak_price']:,.0f}
    
    Consider:
    1. Market cap implications at each level
    2. Historical resistance zones
    3. Adoption curve sustainability
    4. Macro environment constraints
    
    Adjust targets if necessary and explain reasoning.
    """
    
    validation = analyzer.analyze_halving_data("", validation_query)
    
    return {
        'targets': targets,
        'validation': validation
    }

# Calculate price targets
price_targets = calculate_price_targets(
    current_market['market_data']['current_price'],
    diminishing_returns, 
    analyzer
)

# Display results
print("\n2024-2028 Bitcoin Price Targets:")
for scenario, data in price_targets['targets'].items():
    print(f"{scenario.title()}: ${data['peak_price']:,.0f} ({data['probability']} probability)")

def risk_assessment(price_targets, analyzer):
    """Analyze risks and confidence intervals for predictions"""
    
    risk_factors = [
        "Regulatory changes in major markets",
        "Macro economic recession impact", 
        "Cryptocurrency adoption slowdown",
        "Technical scalability challenges",
        "Institutional selling pressure",
        "Alternative cryptocurrency competition"
    ]
    
    # Ollama risk analysis
    risk_query = f"""
    Assess these risks for Bitcoin 2024-2028 predictions:
    
    Risk Factors: {risk_factors}
    Price Targets: {price_targets['targets']}
    
    For each risk:
    1. Impact probability (High/Medium/Low)
    2. Price impact if realized (-X% to +X%)
    3. Mitigation strategies for investors
    4. Early warning indicators to monitor
    
    Provide confidence intervals for each price target.
    """
    
    risk_analysis = analyzer.analyze_halving_data("", risk_query)
    
    # Calculate confidence intervals
    confidence_intervals = {}
    for scenario, data in price_targets['targets'].items():
        base_price = data['peak_price']
        
        # Apply risk adjustments
        lower_bound = base_price * 0.7  # 30% downside
        upper_bound = base_price * 1.3  # 30% upside
        
        confidence_intervals[scenario] = {
            'target': base_price,
            'range': f"${lower_bound:,.0f} - ${upper_bound:,.0f}",
            'confidence': '68%'  # 1 standard deviation
        }
    
    return {
        'risk_analysis': risk_analysis,
        'confidence_intervals': confidence_intervals
    }

# Run risk assessment  
risk_data = risk_assessment(price_targets, analyzer)

def create_trading_strategy(cycle_patterns, price_targets):
    """Design trading strategy for 2024-2028 cycle"""
    
    strategy = {
        'accumulation_phase': {
            'timeframe': '2024 Q2 - 2025 Q1',
            'entry_zones': [
                {'price_range': '$45,000 - $55,000', 'allocation': '40%'},
                {'price_range': '$35,000 - $45,000', 'allocation': '35%'},
                {'price_range': '$25,000 - $35,000', 'allocation': '25%'}
            ],
            'triggers': [
                'Monthly close above 20-week moving average',
                'On-chain metrics showing accumulation',
                'Decreased exchange inflows'
            ]
        },
        'distribution_phase': {
            'timeframe': '2025 Q3 - 2026 Q2', 
            'exit_zones': [
                {'price_range': '$150,000 - $200,000', 'allocation': '30%'},
                {'price_range': '$200,000 - $300,000', 'allocation': '40%'},
                {'price_range': '$300,000+', 'allocation': '30%'}
            ],
            'triggers': [
                'Weekly RSI above 85 for 3+ weeks',
                'Euphoric social sentiment indicators',
                'Mainstream media peak coverage'
            ]
        }
    }
    
    return strategy

trading_strategy = create_trading_strategy(cycle_patterns, price_targets)
print("✅ Trading strategy framework created")

def portfolio_allocation_models():
    """Create different allocation models based on risk tolerance"""
    
    models = {
        'conservative': {
            'bitcoin_allocation': '5-10%',
            'entry_method': 'Dollar-cost averaging over 12 months',
            'exit_strategy': 'Gradual selling starting at 300% gains',
            'risk_management': 'Stop loss at -50% from purchase price'
        },
        'moderate': {
            'bitcoin_allocation': '15-25%', 
            'entry_method': 'Lump sum on technical confirmations',
            'exit_strategy': 'Target-based selling at price milestones',
            'risk_management': 'Trailing stop loss at -30%'
        },
        'aggressive': {
            'bitcoin_allocation': '30-50%',
            'entry_method': 'Leveraged positions with strict rules',
            'exit_strategy': 'Hold until cycle peak indicators',
            'risk_management': 'Position sizing with 2% risk per trade'
        }
    }
    
    return models

allocation_models = portfolio_allocation_models()

def setup_monitoring_framework():
    """Create monitoring system for prediction accuracy"""
    
    key_metrics = {
        'price_metrics': [
            'Daily/weekly close prices',
            'Moving average relationships', 
            'Support/resistance levels',
            'Volume patterns'
        ],
        'on_chain_metrics': [
            'Network hash rate',
            'Transaction volume', 
            'Exchange inflows/outflows',
            'Long-term holder behavior'
        ],
        'market_sentiment': [
            'Fear & Greed Index',
            'Social media mentions',
            'Google Trends data',
            'Institutional flows'
        ],
        'macro_indicators': [
            'DXY (Dollar Index)',
            'Gold prices',
            'Stock market performance', 
            'Interest rates'
        ]
    }
    
    # Automated alerts
    alerts = {
        'prediction_validation': 'Weekly comparison vs targets',
        'risk_factors': 'Monthly risk assessment updates',
        'strategy_adjustments': 'Quarterly strategy reviews'
    }
    
    return {
        'metrics': key_metrics,
        'alerts': alerts
    }

monitoring_framework = setup_monitoring_framework()

def track_prediction_accuracy():
    """Monitor how predictions perform against reality"""
    
    tracking_system = {
        'monthly_reviews': {
            'price_vs_target': 'Compare actual vs predicted prices',
            'timeline_accuracy': 'Validate predicted timeframes', 
            'risk_factor_monitoring': 'Track identified risks'
        },
        'quarterly_adjustments': {
            'model_refinement': 'Update predictions based on new data',
            'strategy_optimization': 'Adjust trading rules if needed',
            'risk_reassessment': 'Update confidence intervals'
        },
        'annual_evaluation': {
            'overall_accuracy': 'Full cycle performance review',
            'lessons_learned': 'Document insights for future cycles',
            'methodology_improvements': 'Enhance analysis framework'
        }
    }
    
    return tracking_system

accuracy_tracking = track_prediction_accuracy()

def create_crypto_modelfile():
    """Create specialized Ollama model for Bitcoin analysis"""
    
    modelfile_content = """
FROM llama3.1:70b

PARAMETER temperature 0.1
PARAMETER top_p 0.9
PARAMETER repeat_penalty 1.1

SYSTEM You are a Bitcoin halving cycle expert with deep knowledge of:
- Historical price patterns and cycle analysis
- On-chain metrics and their implications  
- Market psychology and sentiment analysis
- Risk management and portfolio theory
- Technical analysis and trading strategies

Always provide:
1. Specific numerical targets with confidence levels
2. Risk-adjusted recommendations
3. Historical context and comparisons
4. Actionable insights for traders/investors
5. Clear reasoning for all conclusions

Focus on practical, actionable advice rather than general information.
"""
    
    # Save modelfile
    with open('Modelfile.bitcoin', 'w') as f:
        f.write(modelfile_content)
    
    # Create custom model
    import subprocess
    subprocess.run(['ollama', 'create', 'bitcoin-analyst', '-f', 'Modelfile.bitcoin'])
    
    return "bitcoin-analyst"

# Create specialized model
custom_model = create_crypto_modelfile()
print(f"✅ Custom model '{custom_model}' created for Bitcoin analysis")

def ensemble_predictions(price_targets):
    """Use multiple Ollama models for ensemble predictions"""
    
    models = ['llama3.1:70b', 'mistral:7b', 'bitcoin-analyst']
    ensemble_results = {}
    
    for model in models:
        analyzer_instance = OllamaAnalyzer()
        analyzer_instance.model = model
        
        prediction_query = f"""
        Given current Bitcoin market conditions and historical halving data,
        predict the 2024-2028 cycle peak price.
        
        Provide:
        1. Single peak price target
        2. Timeline for peak (quarter/year)
        3. Confidence level (1-10)
        4. Key factors supporting prediction
        
        Be specific and quantitative.
        """
        
        result = analyzer_instance.analyze_halving_data("", prediction_query)
        ensemble_results[model] = result
    
    return ensemble_results

# Run ensemble analysis
ensemble_predictions_data = ensemble_predictions(price_targets)