AI-Assisted Financial Analysis

# =====================================================
# AI-Assisted Financial Analysis — Lab 1
# Automated Financial Ratio Calculation
# =====================================================

import pandas as pd
import numpy as np

# --------------------------------------------------
# Step 1: Create sample financial data for Indian companies
# --------------------------------------------------
data = {
    'Company': ['TCS', 'Infosys', 'Reliance', 'HDFC Bank', 'Tata Steel', 'HUL'],
    # Balance Sheet items (in ₹ Crores)
    'Current_Assets': [45000, 38000, 185000, 520000, 48000, 8200],
    'Current_Liabilities': [22000, 18000, 125000, 470000, 32000, 4100],
    'Inventory': [500, 300, 25000, 0, 15000, 2100],
    'Total_Assets': [120000, 95000, 850000, 2100000, 180000, 25000],
    'Total_Debt': [2500, 4500, 250000, 950000, 70000, 500],
    'Shareholders_Equity': [95000, 78000, 450000, 250000, 55000, 6500],
    # Income Statement items (in ₹ Crores)
    'Revenue': [225000, 165000, 850000, 200000, 230000, 55000],
    'Net_Income': [44000, 28000, 70000, 45000, 8000, 9000],
    'EBIT': [54000, 35000, 105000, 55000, 15000, 12000],
    'Interest_Expense': [600, 500, 16000, 30000, 4500, 80],
    'EBITDA': [58000, 38000, 130000, 65000, 22000, 13000],
}

df = pd.DataFrame(data)

# --------------------------------------------------
# Step 2: Calculate Financial Ratios
# --------------------------------------------------

# Liquidity Ratios
df['Current_Ratio'] = df['Current_Assets'] / df['Current_Liabilities']
df['Quick_Ratio'] = (df['Current_Assets'] - df['Inventory']) / df['Current_Liabilities']

# Profitability Ratios
df['Net_Profit_Margin'] = (df['Net_Income'] / df['Revenue']) * 100
df['ROE'] = (df['Net_Income'] / df['Shareholders_Equity']) * 100  # Return on Equity
df['ROA'] = (df['Net_Income'] / df['Total_Assets']) * 100   # Return on Assets
df['ROCE'] = (df['EBIT'] / (df['Total_Assets'] - df['Current_Liabilities'])) * 100

# Leverage Ratios
df['Debt_to_Equity'] = df['Total_Debt'] / df['Shareholders_Equity']
df['Interest_Coverage'] = df['EBIT'] / df['Interest_Expense']
df['Debt_to_EBITDA'] = df['Total_Debt'] / df['EBITDA']

# Efficiency Ratios
df['Asset_Turnover'] = df['Revenue'] / df['Total_Assets']

# --------------------------------------------------
# Step 3: Display Results
# --------------------------------------------------
ratio_cols = ['Company', 'Current_Ratio', 'Quick_Ratio',
              'Net_Profit_Margin', 'ROE', 'ROA', 'ROCE',
              'Debt_to_Equity', 'Interest_Coverage', 'Asset_Turnover']

print(df[ratio_cols].to_string(index=False, float_format="%.2f"))

# Classify companies based on financial health scoring

def classify_health(row):
    """Classify a company's financial health based on key ratios."""
    score = 0
    
    # Current Ratio scoring (ideal: 1.5 - 3.0)
    if 1.5 <= row['Current_Ratio'] <= 3.0:
        score += 2
    elif row['Current_Ratio'] >= 1.0:
        score += 1
    
    # D/E Ratio scoring (lower is better)
    if row['Debt_to_Equity'] < 0.5:
        score += 2
    elif row['Debt_to_Equity'] < 1.0:
        score += 1
    
    # ROE scoring (higher is better)
    if row['ROE'] > 15:
        score += 2
    elif row['ROE'] > 10:
        score += 1
    
    # Interest Coverage scoring
    if row['Interest_Coverage'] > 5:
        score += 2
    elif row['Interest_Coverage'] > 3:
        score += 1
    
    # Classify based on total score
    if score >= 7:
        return '🟢 Excellent'
    elif score >= 5:
        return '🟡 Good'
    elif score >= 3:
        return '🟠 Average'
    else:
        return '🔴 Poor'

df['Health_Rating'] = df.apply(classify_health, axis=1)
print(df[['Company', 'Health_Rating']].to_string(index=False))

# =====================================================
# AI-Assisted Financial Analysis — Lab 2A
# Z-Score Based Anomaly Detection
# =====================================================

import pandas as pd
import numpy as np

# Sample financial data for 10 Indian companies
data = {
    'Company': ['TCS', 'Infosys', 'Wipro', 'HCL Tech', 'Tech Mahindra',
                'Mphasis', 'LTIMindtree', 'Persistent', 'Coforge', 'SuspectCorp'],
    'Net_Profit_Margin': [19.5, 17.0, 12.5, 14.8, 11.2,
                           16.5, 14.2, 13.8, 10.5, 42.0],   # SuspectCorp: 42%!
    'Revenue_Growth': [8.5, 7.2, 6.8, 9.1, 8.0,
                        15.2, 12.5, 18.0, 22.0, 95.0],  # SuspectCorp: 95%!
    'Receivables_to_Revenue': [0.22, 0.25, 0.20, 0.28, 0.24,
                                 0.21, 0.23, 0.19, 0.26, 0.65], # SuspectCorp: 65%
    'Cash_Flow_to_Net_Income': [1.05, 1.10, 0.95, 1.02, 0.98,
                                  1.08, 0.92, 1.01, 0.88, 0.30],  # SuspectCorp: 0.30!
}

df = pd.DataFrame(data)

# --------------------------------------------------
# Z-Score Calculation
# --------------------------------------------------
numeric_cols = ['Net_Profit_Margin', 'Revenue_Growth',
                 'Receivables_to_Revenue', 'Cash_Flow_to_Net_Income']

print("🔍 Z-Score Anomaly Detection (Threshold: |Z| > 2)")
print("=" * 60)

for col in numeric_cols:
    mean_val = df[col].mean()
    std_val = df[col].std()
    df[f'{col}_ZScore'] = (df[col] - mean_val) / std_val
    
    # Flag anomalies
    anomalies = df[df[f'{col}_ZScore'].abs() > 2]
    if len(anomalies) > 0:
        print(f"\n⚠️ ANOMALY in {col}:")
        for _, row in anomalies.iterrows():
            print(f"   🚨 {row['Company']}: Value={row[col]:.2f}, Z-Score={row[f'{col}_ZScore']:.2f}")

# =====================================================
# AI-Assisted Financial Analysis — Lab 2B
# Isolation Forest for Anomaly Detection
# =====================================================

from sklearn.ensemble import IsolationForest
import pandas as pd
import numpy as np

# Use the same data from Lab 2A
# (assuming df is already loaded with the 10 companies)

# Prepare features for Isolation Forest
features = df[['Net_Profit_Margin', 'Revenue_Growth',
                'Receivables_to_Revenue', 'Cash_Flow_to_Net_Income']]

# Train Isolation Forest
iso_forest = IsolationForest(
    contamination=0.1,    # Expect ~10% anomalies
    random_state=42,
    n_estimators=100
)
df['Anomaly_Score'] = iso_forest.fit_predict(features)
df['Anomaly_Label'] = df['Anomaly_Score'].map({1: 'Normal', -1: '🚨 ANOMALY'})

# Display results
print("🌲 Isolation Forest Results:")
print("=" * 50)
print(df[['Company', 'Anomaly_Label']].to_string(index=False))

# =====================================================
# Benford's Law Analysis for Financial Data
# =====================================================

def benfords_law_check(values, label="Data"):
    """Check if data follows Benford's Law distribution."""
    # Expected Benford's Law distribution
    benford_expected = {
        1: 30.1, 2: 17.6, 3: 12.5, 4: 9.7, 5: 7.9,
        6: 6.7, 7: 5.8, 8: 5.1, 9: 4.6
    }
    
    # Get leading digits
    leading_digits = [int(str(abs(int(float(v))))[0]) for v in values if float(v) != 0]
    total = len(leading_digits)
    
    print(f"\n📊 Benford's Law Analysis: {label}")
    print("=" * 45)
    print(f"{'Digit':<8}{'Expected':<12}{'Actual':<12}{'Deviation'}")
    print("-" * 45)
    
    for d in range(1, 10):
        actual_pct = (leading_digits.count(d) / total) * 100
        expected_pct = benford_expected[d]
        deviation = abs(actual_pct - expected_pct)
        flag = "⚠️" if deviation > 5 else "✅"
        print(f"{d:<8}{expected_pct:>6.1f}%{'':5}{actual_pct:>6.1f}%{'':4}{flag} ({deviation:.1f}%)")

# Example: Test with revenue figures
revenues = [225000, 165000, 85000, 76000, 45000,
             38000, 23000, 18000, 12000, 9500,
             8500, 7200, 5800, 4500, 3200,
             2800, 1500, 1200, 980, 650]
benfords_law_check(revenues, "Company Revenues")

# =====================================================
# AI-Assisted Financial Analysis — Lab 3
# Credit Risk Prediction with Machine Learning
# =====================================================

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import (classification_report,
                              accuracy_score, confusion_matrix)

# --------------------------------------------------
# Step 1: Generate Synthetic Credit Risk Dataset
# (In practice, use real data from RBI, CRISIL, or
#  company annual reports)
# --------------------------------------------------
np.random.seed(42)
n_companies = 500

# Generate financial features
data = {
    'current_ratio': np.random.uniform(0.5, 4.0, n_companies),
    'debt_to_equity': np.random.uniform(0.0, 5.0, n_companies),
    'interest_coverage': np.random.uniform(0.5, 20.0, n_companies),
    'net_margin': np.random.uniform(-10.0, 25.0, n_companies),
    'roe': np.random.uniform(-15.0, 40.0, n_companies),
    'asset_turnover': np.random.uniform(0.1, 3.0, n_companies),
}

df = pd.DataFrame(data)

# Create target variable: Default (1) or Not Default (0)
# Companies with high debt, low coverage, negative margins → more likely to default
default_prob = (0.3 * (df['debt_to_equity'] / 5.0) +
                 0.25 * (1 - df['interest_coverage'] / 20.0) +
                 0.25 * (1 - df['net_margin'] / 25.0) +
                 0.2 * (1 - df['current_ratio'] / 4.0))

df['default'] = (default_prob > np.random.uniform(0.2, 0.6, n_companies)).astype(int)

print(f"Dataset: {n_companies} companies")
print(f"Defaults: {df['default'].sum()} ({df['default'].mean()*100:.1f}%)")
print(f"Non-Defaults: {(df['default']==0).sum()} ({(1-df['default'].mean())*100:.1f}%)")

# --------------------------------------------------
# Step 2: Split Data into Train and Test Sets
# --------------------------------------------------
X = df.drop('default', axis=1)
y = df['default']

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)
print(f"\nTrain: {len(X_train)} companies | Test: {len(X_test)} companies")

# --------------------------------------------------
# Step 3: Scale Features
# --------------------------------------------------
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# --------------------------------------------------
# Step 4: Train Models
# --------------------------------------------------
# Model 1: Logistic Regression
lr_model = LogisticRegression(random_state=42)
lr_model.fit(X_train_scaled, y_train)
lr_pred = lr_model.predict(X_test_scaled)

# Model 2: Random Forest
rf_model = RandomForestClassifier(n_estimators=100, random_state=42)
rf_model.fit(X_train, y_train)  # RF doesn't need scaling
rf_pred = rf_model.predict(X_test)

# --------------------------------------------------
# Step 5: Evaluate Models
# --------------------------------------------------
print("\n" + "=" * 50)
print("📊 MODEL COMPARISON")
print("=" * 50)
print(f"Logistic Regression Accuracy: {accuracy_score(y_test, lr_pred)*100:.1f}%")
print(f"Random Forest Accuracy:       {accuracy_score(y_test, rf_pred)*100:.1f}%")

print("\n📋 Random Forest Classification Report:")
print(classification_report(y_test, rf_pred,
    target_names=['Non-Default', 'Default']))

# Feature Importance from Random Forest
importance = pd.Series(
    rf_model.feature_importances_, index=X.columns
).sort_values(ascending=True)

print("🔑 Feature Importance (Credit Risk Model):")
print("=" * 45)
for feat, imp in importance.items():
    bar = '█' * int(imp * 50)
    print(f"{feat:>20} {bar} {imp*100:.1f}%")

# Predict credit risk for a NEW company
new_company = pd.DataFrame({
    'current_ratio': [0.8],        # ⚠️ Low liquidity
    'debt_to_equity': [3.5],        # ⚠️ High leverage
    'interest_coverage': [1.2],    # ⚠️ Barely covering interest
    'net_margin': [-2.5],          # 🔴 Negative margin!
    'roe': [-8.0],                  # 🔴 Negative return
    'asset_turnover': [0.4],        # ⚠️ Low efficiency
})

# Get prediction and probability
prediction = rf_model.predict(new_company)[0]
probability = rf_model.predict_proba(new_company)[0]

risk_label = "🔴 HIGH RISK — DEFAULT LIKELY" if prediction == 1 else "🟢 LOW RISK — NON-DEFAULT"

print("=" * 50)
print("📊 CREDIT RISK PREDICTION FOR NEW COMPANY")
print("=" * 50)
print(f"Prediction: {risk_label}")
print(f"Probability of Non-Default: {probability[0]*100:.1f}%")
print(f"Probability of Default:     {probability[1]*100:.1f}%")
print("=" * 50)