Real Estate Investment Analysis with Ollama: REITs and Property Valuation

# Install Ollama (macOS/Linux)
curl -fsSL https://ollama.ai/install.sh | sh

# Download models optimized for numerical analysis
ollama pull llama2:13b
ollama pull codellama:13b
ollama pull mistral:7b

# Verify installation
ollama list

# requirements.txt
ollama-python==0.1.7
pandas==2.1.4
numpy==1.24.3
yfinance==0.2.18
requests==2.31.0
matplotlib==3.7.2
seaborn==0.12.2

# Install dependencies
pip install -r requirements.txt

import ollama
import yfinance as yf
import pandas as pd
from datetime import datetime, timedelta

class REITAnalyzer:
    def __init__(self, model_name="llama2:13b"):
        self.model = model_name
        self.client = ollama.Client()
    
    def fetch_reit_data(self, ticker, period="2y"):
        """Fetch comprehensive REIT financial data"""
        try:
            reit = yf.Ticker(ticker)
            
            # Get historical price data
            hist_data = reit.history(period=period)
            
            # Get financial information
            info = reit.info
            financials = reit.financials
            
            return {
                'ticker': ticker,
                'price_data': hist_data,
                'company_info': info,
                'financials': financials,
                'current_price': hist_data['Close'][-1]
            }
        except Exception as e:
            print(f"Error fetching data for {ticker}: {e}")
            return None
    
    def calculate_reit_metrics(self, reit_data):
        """Calculate key REIT performance indicators"""
        info = reit_data['company_info']
        price_data = reit_data['price_data']
        
        metrics = {
            'dividend_yield': info.get('dividendYield', 0) * 100,
            'funds_from_operations': info.get('operatingCashflow', 0),
            'price_to_book': info.get('priceToBook', 0),
            'debt_to_equity': info.get('debtToEquity', 0),
            'market_cap': info.get('marketCap', 0),
            'volatility': price_data['Close'].pct_change().std() * 100,
            'ytd_return': ((price_data['Close'][-1] / price_data['Close'][0]) - 1) * 100
        }
        
        return metrics
    
    def ai_reit_analysis(self, ticker, metrics):
        """Generate AI-powered REIT investment analysis"""
        
        prompt = f"""
        Analyze this REIT investment opportunity for {ticker}:
        
        Financial Metrics:
        - Dividend Yield: {metrics['dividend_yield']:.2f}%
        - Price-to-Book Ratio: {metrics['price_to_book']:.2f}
        - Debt-to-Equity: {metrics['debt_to_equity']:.2f}
        - Market Cap: ${metrics['market_cap']:,.0f}
        - Price Volatility: {metrics['volatility']:.2f}%
        - YTD Return: {metrics['ytd_return']:.2f}%
        
        Provide a comprehensive analysis covering:
        1. Investment grade (A, B, C, D) with reasoning
        2. Risk assessment (Low, Medium, High)
        3. Three key strengths
        4. Three main concerns
        5. Price target recommendation
        6. Portfolio allocation suggestion (0-10%)
        
        Format as structured analysis for investment decision-making.
        """
        
        try:
            response = self.client.chat(model=self.model, messages=[
                {'role': 'user', 'content': prompt}
            ])
            
            return response['message']['content']
        except Exception as e:
            return f"Analysis error: {e}"

# Example usage
analyzer = REITAnalyzer()

# Analyze multiple REITs
reit_tickers = ['VNQ', 'SCHH', 'IYR', 'FREL', 'RWR']
analysis_results = {}

for ticker in reit_tickers:
    print(f"Analyzing {ticker}...")
    
    # Fetch data
    reit_data = analyzer.fetch_reit_data(ticker)
    
    if reit_data:
        # Calculate metrics
        metrics = analyzer.calculate_reit_metrics(reit_data)
        
        # Get AI analysis
        ai_analysis = analyzer.ai_reit_analysis(ticker, metrics)
        
        analysis_results[ticker] = {
            'metrics': metrics,
            'ai_analysis': ai_analysis
        }
        
        print(f"✓ {ticker} analysis complete")

# Display results
for ticker, results in analysis_results.items():
    print(f"\n{'='*50}")
    print(f"REIT ANALYSIS: {ticker}")
    print(f"{'='*50}")
    print(results['ai_analysis'])

class REITPortfolioOptimizer:
    def __init__(self, analyzer):
        self.analyzer = analyzer
    
    def optimize_portfolio(self, reit_list, target_return=0.08, risk_tolerance="Medium"):
        """AI-driven REIT portfolio optimization"""
        
        portfolio_data = []
        
        for ticker in reit_list:
            reit_data = self.analyzer.fetch_reit_data(ticker)
            if reit_data:
                metrics = self.analyzer.calculate_reit_metrics(reit_data)
                portfolio_data.append({
                    'ticker': ticker,
                    'dividend_yield': metrics['dividend_yield'],
                    'volatility': metrics['volatility'],
                    'ytd_return': metrics['ytd_return'],
                    'market_cap': metrics['market_cap']
                })
        
        # AI portfolio optimization prompt
        optimization_prompt = f"""
        Optimize this REIT portfolio for maximum risk-adjusted returns:
        
        Available REITs:
        {pd.DataFrame(portfolio_data).to_string()}
        
        Investment Parameters:
        - Target Annual Return: {target_return*100:.1f}%
        - Risk Tolerance: {risk_tolerance}
        - Portfolio Size: $100,000
        
        Provide optimal allocation percentages for each REIT considering:
        - Correlation between holdings
        - Sector diversification
        - Geographic exposure
        - Dividend sustainability
        - Growth prospects
        
        Output format:
        TICKER: XX.X% ($X,XXX)
        Expected Portfolio Return: XX.X%
        Expected Portfolio Risk: XX.X%
        Sharpe Ratio Estimate: X.XX
        """
        
        try:
            response = self.analyzer.client.chat(
                model=self.analyzer.model,
                messages=[{'role': 'user', 'content': optimization_prompt}]
            )
            
            return response['message']['content']
        except Exception as e:
            return f"Optimization error: {e}"

# Portfolio optimization example
portfolio_optimizer = REITPortfolioOptimizer(analyzer)
reit_universe = ['VNQ', 'SCHH', 'IYR', 'FREL', 'RWR', 'VNQI', 'IFGL']

optimized_portfolio = portfolio_optimizer.optimize_portfolio(
    reit_universe, 
    target_return=0.09, 
    risk_tolerance="Medium"
)

print("AI-Optimized REIT Portfolio:")
print(optimized_portfolio)

class PropertyValuationAI:
    def __init__(self, model_name="mistral:7b"):
        self.model = model_name
        self.client = ollama.Client()
    
    def analyze_property_comps(self, subject_property, comparable_sales):
        """AI-powered comparable sales analysis"""
        
        analysis_prompt = f"""
        Perform a comprehensive comparable sales analysis for property valuation:
        
        SUBJECT PROPERTY:
        {subject_property}
        
        COMPARABLE SALES:
        {comparable_sales}
        
        Analysis Requirements:
        1. Adjust comparable sales for differences in:
           - Square footage
           - Lot size
           - Age/condition
           - Location/neighborhood
           - Amenities and features
        
        2. Calculate adjusted price per square foot for each comparable
        
        3. Weight comparables by similarity to subject property
        
        4. Provide valuation range: Low, Mid, High estimates
        
        5. Confidence level in valuation (1-10 scale)
        
        6. Key factors affecting value
        
        Present analysis in structured format suitable for appraisal report.
        """
        
        try:
            response = self.client.chat(model=self.model, messages=[
                {'role': 'user', 'content': analysis_prompt}
            ])
            
            return response['message']['content']
        except Exception as e:
            return f"Valuation analysis error: {e}"
    
    def investment_property_analysis(self, property_data, market_data):
        """Comprehensive investment property evaluation"""
        
        investment_prompt = f"""
        Analyze this investment property opportunity:
        
        PROPERTY DETAILS:
        {property_data}
        
        MARKET CONDITIONS:
        {market_data}
        
        Calculate and analyze:
        1. Cap Rate (NOI / Purchase Price)
        2. Cash-on-Cash Return
        3. Internal Rate of Return (IRR) projection
        4. Break-even analysis
        5. Sensitivity analysis for key variables
        6. Exit strategy scenarios
        
        Provide investment recommendation:
        - Buy/Hold/Pass decision
        - Maximum offer price
        - Expected annual returns
        - Risk factors
        - Investment timeline
        
        Format as executive summary for investment committee.
        """
        
        try:
            response = self.client.chat(model=self.model, messages=[
                {'role': 'user', 'content': investment_prompt}
            ])
            
            return response['message']['content']
        except Exception as e:
            return f"Investment analysis error: {e}"

# Example property valuation
valuator = PropertyValuationAI()

subject_property = """
Address: 123 Investment Lane, Austin, TX
Type: Single Family Rental
Square Feet: 2,100
Lot Size: 0.25 acres
Year Built: 2018
Bedrooms: 4
Bathrooms: 3
Garage: 2-car attached
Rent Potential: $2,800/month
Purchase Price: $485,000
"""

comparable_sales = """
Comp 1: 125 Investment Lane - $475,000, 2,050 sq ft, 2017 build
Comp 2: 127 Rental Road - $510,000, 2,200 sq ft, 2019 build  
Comp 3: 129 Income Street - $465,000, 1,950 sq ft, 2016 build
Comp 4: 131 Cash Court - $525,000, 2,300 sq ft, 2020 build
"""

market_data = """
Austin Market Conditions Q2 2025:
- Median home price: $520,000 (+8.5% YoY)
- Average rent: $2,650/month (+12% YoY)
- Vacancy rate: 4.2%
- Property tax rate: 1.8%
- Insurance: $1,200/year average
- Population growth: +2.1% annually
"""

# Generate valuation analysis
comps_analysis = valuator.analyze_property_comps(subject_property, comparable_sales)
investment_analysis = valuator.investment_property_analysis(subject_property, market_data)

print("COMPARABLE SALES ANALYSIS:")
print("=" * 50)
print(comps_analysis)

print("\n\nINVESTMENT PROPERTY ANALYSIS:")
print("=" * 50)
print(investment_analysis)

class MarketForecastingAI:
    def __init__(self, model_name="codellama:13b"):
        self.model = model_name
        self.client = ollama.Client()
    
    def market_forecast_analysis(self, economic_data, property_type="Residential"):
        """Generate market forecasts using economic indicators"""
        
        forecast_prompt = f"""
        Generate comprehensive real estate market forecast:
        
        ECONOMIC INDICATORS:
        {economic_data}
        
        PROPERTY TYPE: {property_type}
        
        Analysis Framework:
        1. Interest Rate Impact Assessment
        2. Employment Data Correlation
        3. Inflation Effects on Property Values
        4. Population Growth Influence
        5. Construction Cost Trends
        
        Forecast Deliverables:
        - 6-month price movement prediction
        - 12-month market outlook
        - 24-month strategic forecast
        - Risk scenarios (Bull/Base/Bear cases)
        - Investment timing recommendations
        
        Include confidence intervals and key assumptions.
        """
        
        try:
            response = self.client.chat(model=self.model, messages=[
                {'role': 'user', 'content': forecast_prompt}
            ])
            
            return response['message']['content']
        except Exception as e:
            return f"Forecast analysis error: {e}"

# Market forecasting example
forecaster = MarketForecastingAI()

economic_indicators = """
Current Economic Conditions (Q2 2025):
- Federal Funds Rate: 4.75%
- 30-Year Mortgage Rate: 6.85%
- Unemployment Rate: 3.8%
- Core Inflation: 2.9%
- GDP Growth: 2.4% (annualized)
- Housing Starts: 1.45M (annualized)
- Building Permits: 1.52M (annualized)
- Consumer Confidence: 108.2
- Construction Cost Index: +8.2% YoY
"""

market_forecast = forecaster.market_forecast_analysis(economic_indicators, "Residential")

print("MARKET FORECAST ANALYSIS:")
print("=" * 50)
print(market_forecast)

class DataValidationFramework:
    def __init__(self):
        self.validation_rules = {
            'price_range': (50000, 10000000),
            'sqft_range': (500, 20000),
            'lot_size_range': (0.1, 50),
            'year_built_range': (1900, 2025),
            'required_fields': ['address', 'price', 'sqft', 'bedrooms', 'bathrooms']
        }
    
    def validate_property_data(self, property_data):
        """Validate property data before AI analysis"""
        errors = []
        warnings = []
        
        # Check required fields
        for field in self.validation_rules['required_fields']:
            if field not in property_data or property_data[field] is None:
                errors.append(f"Missing required field: {field}")
        
        # Validate numeric ranges
        if 'price' in property_data:
            price = property_data['price']
            if not (self.validation_rules['price_range'][0] <= price <= self.validation_rules['price_range'][1]):
                warnings.append(f"Price ${price:,.0f} outside typical range")
        
        # Check for data consistency
        if 'sqft' in property_data and 'price' in property_data:
            price_per_sqft = property_data['price'] / property_data['sqft']
            if price_per_sqft < 50 or price_per_sqft > 1000:
                warnings.append(f"Price per sq ft ${price_per_sqft:.0f} may indicate data error")
        
        return {
            'valid': len(errors) == 0,
            'errors': errors,
            'warnings': warnings
        }

# Data validation example
validator = DataValidationFramework()

sample_property = {
    'address': '456 Oak Street, Dallas, TX',
    'price': 425000,
    'sqft': 1850,
    'bedrooms': 3,
    'bathrooms': 2,
    'year_built': 2010,
    'lot_size': 0.18
}

validation_result = validator.validate_property_data(sample_property)
print("Data Validation Results:")
print(f"Valid: {validation_result['valid']}")
if validation_result['errors']:
    print(f"Errors: {validation_result['errors']}")
if validation_result['warnings']:
    print(f"Warnings: {validation_result['warnings']}")