Fintech'te Yapay Zeka Uygulamaları

import pandas as pd
import numpy as np
from sklearn.ensemble import GradientBoostingClassifier, RandomForestClassifier
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.preprocessing import StandardScaler
import xgboost as xgb
import shap

class AlternativeCreditScoring:
    def __init__(self):
        self.model = None
        self.scaler = StandardScaler()
        self.feature_importance = None

    def prepare_features(self, data):
        """
        Geleneksel + alternatif veri kaynaklarından feature engineering
        """
        features = pd.DataFrame()

        # Geleneksel özellikler
        features['age'] = data['age']
        features['income'] = data['monthly_income']
        features['employment_length'] = data['employment_months']
        features['existing_loans'] = data['num_existing_loans']
        features['total_debt'] = data['total_debt_amount']

        # Alternatif veri kaynakları
        # 1. Fatura ödeme geçmişi
        features['utility_payment_score'] = self._calculate_utility_score(data)
        features['late_payment_ratio'] = data['late_payments'] / data['total_payments']

        # 2. Mobil davranış verileri
        features['app_usage_diversity'] = data['unique_apps_used']
        features['financial_app_engagement'] = data['finance_app_time_hours']
        features['avg_monthly_data_usage_gb'] = data['mobile_data_usage']

        # 3. E-ticaret aktivitesi
        features['ecommerce_transactions'] = data['online_purchases_count']
        features['avg_purchase_value'] = data['total_spent'] / (data['online_purchases_count'] + 1)
        features['payment_method_diversity'] = data['unique_payment_methods']

        # 4. Sosyal ve dijital ayak izi
        features['digital_identity_score'] = self._calculate_digital_score(data)
        features['social_connections'] = np.log1p(data['social_network_connections'])

        # Türetilmiş özellikler
        features['debt_to_income_ratio'] = features['total_debt'] / (features['income'] + 1)
        features['income_stability_score'] = self._calculate_income_stability(data)
        features['financial_literacy_score'] = self._calculate_fin_literacy(data)

        return features

    def _calculate_utility_score(self, data):
        """
        Elektrik, su, gaz faturaları ödeme performansı
        """
        on_time_payments = data['utility_on_time_payments']
        total_payments = data['utility_total_payments']

        if total_payments == 0:
            return 0.5  # Veri yok, nötr skor

        score = on_time_payments / total_payments
        # Son 3 ay ağırlıklı
        recent_score = data['utility_recent_3m_on_time'] / 3
        weighted_score = 0.6 * score + 0.4 * recent_score

        return weighted_score

    def _calculate_digital_score(self, data):
        """
        Dijital kimlik ve online varlık skoru
        """
        factors = [
            data['email_age_years'] / 10,  # Email yaşı
            min(data['social_accounts'] / 5, 1),  # Sosyal medya hesapları
            data['verified_phone'] * 0.3,  # Telefon doğrulaması
            data['verified_address'] * 0.3,  # Adres doğrulaması
            min(data['online_reviews_given'] / 20, 1) * 0.2  # Online aktivite
        ]

        return sum(factors) / len(factors)

    def _calculate_income_stability(self, data):
        """
        Gelir istikrarı skoru
        """
        if len(data['income_history']) < 3:
            return 0.5

        income_std = np.std(data['income_history'])
        income_mean = np.mean(data['income_history'])

        cv = income_std / (income_mean + 1)  # Coefficient of variation
        stability = max(0, 1 - cv)  # Düşük CV = yüksek istikrar

        return stability

    def _calculate_fin_literacy(self, data):
        """
        Finansal okuryazarlık göstergesi
        """
        indicators = [
            data['has_savings_account'] * 0.25,
            data['has_investment_account'] * 0.25,
            min(data['budgeting_app_usage_days'] / 90, 1) * 0.20,
            data['credit_card_utilization_healthy'] * 0.15,  # %30'un altı
            min(data['financial_education_hours'] / 10, 1) * 0.15
        ]

        return sum(indicators)

    def train(self, X, y):
        """
        XGBoost ile model eğitimi
        """
        # Train-test split
        X_train, X_test, y_train, y_test = train_test_split(
            X, y, test_size=0.2, random_state=42, stratify=y
        )

        # Ölçeklendirme
        X_train_scaled = self.scaler.fit_transform(X_train)
        X_test_scaled = self.scaler.transform(X_test)

        # XGBoost modeli
        self.model = xgb.XGBClassifier(
            n_estimators=300,
            max_depth=8,
            learning_rate=0.05,
            subsample=0.8,
            colsample_bytree=0.8,
            gamma=0.1,
            reg_alpha=0.1,
            reg_lambda=1.0,
            scale_pos_weight=len(y_train[y_train==0]) / len(y_train[y_train==1]),
            random_state=42
        )

        # Eğitim
        self.model.fit(
            X_train_scaled, y_train,
            eval_set=[(X_test_scaled, y_test)],
            early_stopping_rounds=50,
            verbose=False
        )

        # Feature importance
        self.feature_importance = pd.DataFrame({
            'feature': X.columns,
            'importance': self.model.feature_importances_
        }).sort_values('importance', ascending=False)

        # Model performansı
        train_score = self.model.score(X_train_scaled, y_train)
        test_score = self.model.score(X_test_scaled, y_test)

        print(f"Train Accuracy: {train_score:.4f}")
        print(f"Test Accuracy: {test_score:.4f}")

        return self

    def predict_creditworthiness(self, applicant_data):
        """
        Başvurucu için kredi değerliliği tahmini
        """
        features = self.prepare_features(applicant_data)
        features_scaled = self.scaler.transform(features)

        # Tahmin
        probability = self.model.predict_proba(features_scaled)[0][1]
        decision = self.model.predict(features_scaled)[0]

        # Kredi skoru (300-850 arası)
        credit_score = int(300 + (probability * 550))

        # Risk kategorisi
        if credit_score >= 750:
            risk_category = "Düşük Risk"
            interest_rate = 1.5
        elif credit_score >= 650:
            risk_category = "Orta Risk"
            interest_rate = 2.5
        elif credit_score >= 550:
            risk_category = "Yüksek Risk"
            interest_rate = 4.0
        else:
            risk_category = "Çok Yüksek Risk"
            interest_rate = None  # Kredi reddedilir

        # SHAP ile açıklanabilirlik
        explainer = shap.TreeExplainer(self.model)
        shap_values = explainer.shap_values(features_scaled)

        top_factors = pd.DataFrame({
            'factor': features.columns,
            'impact': shap_values[0]
        }).sort_values('impact', key=abs, ascending=False).head(5)

        result = {
            'credit_score': credit_score,
            'approval_probability': probability * 100,
            'decision': 'ONAYLANDI' if decision == 1 else 'REDDEDİLDİ',
            'risk_category': risk_category,
            'suggested_interest_rate': interest_rate,
            'top_positive_factors': top_factors[top_factors['impact'] > 0].to_dict('records'),
            'top_negative_factors': top_factors[top_factors['impact'] < 0].to_dict('records'),
            'recommendations': self._generate_recommendations(credit_score, top_factors)
        }

        return result

    def _generate_recommendations(self, score, factors):
        """
        Kredi skorunu iyileştirme önerileri
        """
        recommendations = []

        if score < 650:
            recommendations.append({
                'priority': 'Yüksek',
                'action': 'Fatura ödemelerinizi zamanında yapın',
                'impact': '+15-25 puan (6 ay içinde)'
            })

        negative_factors = factors[factors['impact'] < 0]

        for _, factor in negative_factors.iterrows():
            if 'debt_to_income' in factor['factor']:
                recommendations.append({
                    'priority': 'Yüksek',
                    'action': 'Borç/gelir oranınızı %40'ın altına indirin',
                    'impact': '+30-40 puan'
                })

            if 'late_payment' in factor['factor']:
                recommendations.append({
                    'priority': 'Orta',
                    'action': 'Son 12 ayda geç ödeme yapmayın',
                    'impact': '+20-30 puan'
                })

        return recommendations

# Kullanım örneği
scorer = AlternativeCreditScoring()

applicant = pd.DataFrame({
    'age': [32],
    'monthly_income': [15000],
    'employment_months': [48],
    'num_existing_loans': [2],
    'total_debt_amount': [125000],
    'utility_on_time_payments': [22],
    'utility_total_payments': [24],
    'utility_recent_3m_on_time': [3],
    'late_payments': [1],
    'total_payments': [24],
    'unique_apps_used': [45],
    'finance_app_time_hours': [12],
    'mobile_data_usage': [8.5],
    'online_purchases_count': [28],
    'total_spent': [42000],
    'unique_payment_methods': [4],
    'email_age_years': [8],
    'social_accounts': [5],
    'verified_phone': [1],
    'verified_address': [1],
    'online_reviews_given': [15],
    'has_savings_account': [1],
    'has_investment_account': [0],
    'budgeting_app_usage_days': [60],
    'credit_card_utilization_healthy': [1],
    'financial_education_hours': [5],
    'income_history': [[14000, 14500, 15000, 15200]]
})

result = scorer.predict_creditworthiness(applicant)
print(f"Kredi Skoru: {result['credit_score']}")
print(f"Karar: {result['decision']}")
print(f"Önerilen Faiz: %{result['suggested_interest_rate']}")

import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestRegressor
from sklearn.preprocessing import MinMaxScaler
import tensorflow as tf
from tensorflow.keras import layers
import yfinance as yf

# LSTM ile Hisse Senedi Fiyat Tahmini
class StockPricePredictor:
    def __init__(self, symbol, lookback_days=60):
        self.symbol = symbol
        self.lookback_days = lookback_days
        self.scaler = MinMaxScaler()
        self.model = None

    def fetch_data(self, start_date, end_date):
        """
        Yahoo Finance'den veri çekme
        """
        data = yf.download(self.symbol, start=start_date, end=end_date)

        # Teknik indikatörler
        data['SMA_20'] = data['Close'].rolling(window=20).mean()
        data['SMA_50'] = data['Close'].rolling(window=50).mean()
        data['RSI'] = self._calculate_rsi(data['Close'])
        data['MACD'] = self._calculate_macd(data['Close'])

        # Volume indikatörleri
        data['Volume_SMA'] = data['Volume'].rolling(window=20).mean()
        data['Volume_Ratio'] = data['Volume'] / data['Volume_SMA']

        return data.dropna()

    def _calculate_rsi(self, prices, period=14):
        delta = prices.diff()
        gain = (delta.where(delta > 0, 0)).rolling(window=period).mean()
        loss = (-delta.where(delta < 0, 0)).rolling(window=period).mean()
        rs = gain / loss
        return 100 - (100 / (1 + rs))

    def _calculate_macd(self, prices):
        exp1 = prices.ewm(span=12, adjust=False).mean()
        exp2 = prices.ewm(span=26, adjust=False).mean()
        return exp1 - exp2

    def prepare_sequences(self, data):
        """
        LSTM için zaman serisi hazırlama
        """
        features = ['Close', 'Volume', 'SMA_20', 'SMA_50', 'RSI', 'MACD']
        scaled_data = self.scaler.fit_transform(data[features])

        X, y = [], []
        for i in range(self.lookback_days, len(scaled_data)):
            X.append(scaled_data[i-self.lookback_days:i])
            y.append(scaled_data[i, 0])  # Sadece Close fiyatı

        return np.array(X), np.array(y)

    def build_lstm_model(self, input_shape):
        """
        LSTM model mimarisi
        """
        model = tf.keras.Sequential([
            layers.LSTM(128, return_sequences=True, input_shape=input_shape),
            layers.Dropout(0.2),
            layers.LSTM(64, return_sequences=True),
            layers.Dropout(0.2),
            layers.LSTM(32),
            layers.Dropout(0.2),
            layers.Dense(16, activation='relu'),
            layers.Dense(1)
        ])

        model.compile(optimizer='adam', loss='mse', metrics=['mae'])
        return model

    def train(self, data, epochs=50):
        X, y = self.prepare_sequences(data)

        self.model = self.build_lstm_model((X.shape[1], X.shape[2]))

        history = self.model.fit(
            X, y,
            epochs=epochs,
            batch_size=32,
            validation_split=0.2,
            callbacks=[
                tf.keras.callbacks.EarlyStopping(patience=10, restore_best_weights=True)
            ],
            verbose=0
        )

        return history

    def predict_next_days(self, data, days=5):
        """
        Gelecek N gün tahmini
        """
        predictions = []
        current_data = data[-self.lookback_days:].copy()

        for _ in range(days):
            features = ['Close', 'Volume', 'SMA_20', 'SMA_50', 'RSI', 'MACD']
            scaled = self.scaler.transform(current_data[features])
            X = scaled.reshape(1, self.lookback_days, len(features))

            pred_scaled = self.model.predict(X, verbose=0)[0][0]

            # Inverse transform
            pred_row = np.zeros((1, len(features)))
            pred_row[0, 0] = pred_scaled
            pred_price = self.scaler.inverse_transform(pred_row)[0, 0]

            predictions.append(pred_price)

            # Sonraki tahmin için veriyi güncelle
            new_row = current_data.iloc[-1:].copy()
            new_row['Close'] = pred_price
            current_data = pd.concat([current_data.iloc[1:], new_row])

        return predictions

# Trading Stratejisi
class AITradingStrategy:
    def __init__(self, initial_capital=100000):
        self.capital = initial_capital
        self.position = 0
        self.trades = []

    def generate_signals(self, data, predictions):
        """
        AI tahminlerine göre trading sinyalleri
        """
        current_price = data['Close'].iloc[-1]
        predicted_price = predictions[0]  # 1 gün sonrası

        price_change_pct = ((predicted_price - current_price) / current_price) * 100

        # Teknik indikatörler
        rsi = data['RSI'].iloc[-1]
        macd = data['MACD'].iloc[-1]
        sma_20 = data['SMA_20'].iloc[-1]

        # Karar algoritması
        signal = 'HOLD'
        confidence = 0

        # AL sinyali koşulları
        if (price_change_pct > 2 and
            rsi < 70 and
            current_price > sma_20 and
            macd > 0):
            signal = 'BUY'
            confidence = min(price_change_pct / 5 * 100, 100)

        # SAT sinyali koşulları
        elif (price_change_pct < -2 and
              rsi > 30 and
              macd < 0):
            signal = 'SELL'
            confidence = min(abs(price_change_pct) / 5 * 100, 100)

        return {
            'signal': signal,
            'confidence': confidence,
            'current_price': current_price,
            'predicted_price': predicted_price,
            'expected_return': price_change_pct
        }

    def execute_trade(self, signal_data):
        """
        Trade işlemini gerçekleştir
        """
        signal = signal_data['signal']
        price = signal_data['current_price']
        confidence = signal_data['confidence']

        if signal == 'BUY' and confidence > 70 and self.position == 0:
            shares = int(self.capital * 0.95 / price)  # %95 kullan
            cost = shares * price
            self.capital -= cost
            self.position = shares

            self.trades.append({
                'type': 'BUY',
                'shares': shares,
                'price': price,
                'cost': cost,
                'confidence': confidence
            })

            return f"AL: {shares} hisse @ {price:.2f} TL"

        elif signal == 'SELL' and confidence > 70 and self.position > 0:
            revenue = self.position * price
            self.capital += revenue

            profit = revenue - self.trades[-1]['cost']
            profit_pct = (profit / self.trades[-1]['cost']) * 100

            self.trades.append({
                'type': 'SELL',
                'shares': self.position,
                'price': price,
                'revenue': revenue,
                'profit': profit,
                'profit_pct': profit_pct
            })

            self.position = 0

            return f"SAT: {self.position} hisse @ {price:.2f} TL | Kar: {profit:.2f} TL ({profit_pct:.2f}%)"

        return "İşlem yapılmadı"

# Kullanım
predictor = StockPricePredictor('THYAO.IS')  # Türk Hava Yolları
data = predictor.fetch_data('2023-01-01', '2024-01-01')

predictor.train(data)
predictions = predictor.predict_next_days(data, days=5)

strategy = AITradingStrategy(initial_capital=100000)
signal = strategy.generate_signals(data, predictions)

print(f"Sinyal: {signal['signal']} (Güven: {signal['confidence']:.1f}%)")
print(f"Beklenen Getiri: {signal['expected_return']:.2f}%")

// Node.js - Robo-Advisor API
const { OpenAI } = require('openai');
const axios = require('axios');

class RoboAdvisor {
  constructor() {
    this.openai = new OpenAI({
      apiKey: process.env.OPENAI_API_KEY
    });
  }

  async assessRiskProfile(userData) {
    const prompt = `Yatırımcı profili:

Yaş: ${userData.age}
Gelir: ${userData.income} TL/ay
Yatırım Deneyimi: ${userData.experience}
Finansal Hedef: ${userData.goal}
Yatırım Süresi: ${userData.timeHorizon} yıl
Kayıp Toleransı: ${userData.lossComfort}

Bu bilgilere göre yatırımcının risk profilini değerlendir:
1. Risk seviyesi (1-10)
2. Önerilen varlık dağılımı
3. Uygun yatırım araçları`;

    const response = await this.openai.chat.completions.create({
      model: 'gpt-4',
      messages: [
        {
          role: 'system',
          content: 'Sen profesyonel bir yatırım danışmanısın.'
        },
        {
          role: 'user',
          content: prompt
        }
      ],
      temperature: 0.3
    });

    return this.parseRiskProfile(response.choices[0].message.content);
  }

  parseRiskProfile(aiResponse) {
    // AI yanıtını yapılandır
    return {
      riskScore: 7,  // 1-10
      assetAllocation: {
        stocks: 60,
        bonds: 25,
        gold: 10,
        cash: 5
      },
      recommendedProducts: [
        'Teknoloji ETF',
        'Devlet Tahvili',
        'Altın Fonu'
      ]
    };
  }

  async optimizePortfolio(currentPortfolio, riskProfile) {
    // Modern Portfolio Theory ile optimizasyon
    const targetAllocation = riskProfile.assetAllocation;
    const rebalancingActions = [];

    for (const [asset, targetPct] of Object.entries(targetAllocation)) {
      const currentPct = currentPortfolio[asset] || 0;
      const difference = targetPct - currentPct;

      if (Math.abs(difference) > 5) {  // %5'ten fazla sapma
        rebalancingActions.push({
          asset,
          action: difference > 0 ? 'AL' : 'SAT',
          amount: Math.abs(difference)
        });
      }
    }

    return {
      currentAllocation: currentPortfolio,
      targetAllocation,
      rebalancingNeeded: rebalancingActions.length > 0,
      actions: rebalancingActions
    };
  }
}

module.exports = RoboAdvisor;