تطوير الذكاء الاصطناعي للتمويل

# البرنامج الكامل للتعامل مع البيانات المالية
import pandas as pd

def analyze_financial_data(file_path):
    # قراءة البيانات المالية
    data = pd.read_csv(file_path)
    
    # تحليل أساسي
    summary = {
        'total_transactions': len(data),
        'average_amount': data['amount'].mean(),
        'max_amount': data['amount'].max(),
        'min_amount': data['amount'].min()
    }
    
    return summary

# مثال للاستخدام
data_summary = analyze_financial_data('transactions.csv')
for key, value in data_summary.items():
    print(f"{key}: {value}")

# نموذج متقدم لكشف الاحتيال
import numpy as np
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split

class FraudDetectionModel:
    def __init__(self):
        self.scaler = StandardScaler()
        self.model = RandomForestClassifier(n_estimators=100)
    
    def prepare_features(self, data):
        # تطبيع البيانات
        features = ['amount', 'frequency', 'time_since_last']
        X = data[features]
        X_scaled = self.scaler.fit_transform(X)
        return X_scaled
    
    def train(self, X, y):
        X_train, X_test, y_train, y_test = train_test_split(
            X, y, test_size=0.2, random_state=42
        )
        self.model.fit(X_train, y_train)
        
        # حساب الدقة
        accuracy = self.model.score(X_test, y_test)
        return accuracy
    
    def predict(self, transaction):
        features = self.prepare_features(transaction)
        prediction = self.model.predict(features)
        return prediction

# مثال للاستخدام
model = FraudDetectionModel()
# ... تدريب النموذج على البيانات

# نظام تداول خوارزمي متكامل
import yfinance as yf
from datetime import datetime, timedelta
import pandas as pd

class AlgorithmicTradingSystem:
    def __init__(self, symbol, initial_capital=100000):
        self.symbol = symbol
        self.capital = initial_capital
        self.positions = 0
        self.trades = []
    
    def fetch_data(self, start_date, end_date):
        stock = yf.Ticker(self.symbol)
        data = stock.history(start=start_date, end=end_date)
        return data
    
    def calculate_indicators(self, data):
        # حساب المؤشرات الفنية
        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'])
        return data
    
    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
        rsi = 100 - (100 / (1 + rs))
        return rsi
    
    def generate_signals(self, data):
        signals = []
        for i in range(1, len(data)):
            if data['SMA_20'].iloc[i] > data['SMA_50'].iloc[i] and data['RSI'].iloc[i] < 70:
                signals.append(('BUY', data.index[i], data['Close'].iloc[i]))
            elif data['SMA_20'].iloc[i] < data['SMA_50'].iloc[i] and data['RSI'].iloc[i] > 30:
                signals.append(('SELL', data.index[i], data['Close'].iloc[i]))
        return signals
    
    def execute_trades(self, signals):
        for signal in signals:
            action, date, price = signal
            if action == 'BUY' and self.capital > price * 100:
                shares = 100
                self.positions += shares
                self.capital -= shares * price
                self.trades.append(('BUY', date, price, shares))
            elif action == 'SELL' and self.positions >= 100:
                shares = 100
                self.positions -= shares
                self.capital += shares * price
                self.trades.append(('SELL', date, price, shares))
        
        return self.trades

# نظام متقدم لتقييم الجدارة الائتمانية
import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.model_selection import GridSearchCV, cross_val_score

class CreditScoringSystem:
    def __init__(self):
        self.model = RandomForestClassifier(n_estimators=100, random_state=42)
        self.scaler = StandardScaler()
        self.label_encoders = {}
    
    def preprocess_data(self, df):
        # نسخ البيانات
        data = df.copy()
        
        # معالجة البيانات الناقصة
        for col in data.columns:
            if data[col].dtype == 'object':
                data[col].fillna(data[col].mode()[0], inplace=True)
            else:
                data[col].fillna(data[col].median(), inplace=True)
        
        # ترميز المتغيرات الفئوية
        categorical_cols = data.select_dtypes(include=['object']).columns
        for col in categorical_cols:
            le = LabelEncoder()
            data[col] = le.fit_transform(data[col])
            self.label_encoders[col] = le
        
        return data
    
    def engineer_features(self, data):
        # إنشاء ميزات جديدة
        if 'income' in data.columns and 'debt' in data.columns:
            data['debt_to_income'] = data['debt'] / data['income']
        
        if 'age' in data.columns:
            data['age_group'] = pd.cut(
                data['age'], 
                bins=[0, 25, 35, 45, 55, 65, 100],
                labels=['18-25', '26-35', '36-45', '46-55', '56-65', '65+']
            )
        
        return data
    
    def train_model(self, X_train, y_train):
        # تطبيع البيانات
        X_train_scaled = self.scaler.fit_transform(X_train)
        
        # البحث عن أفضل معلمات
        param_grid = {
            'n_estimators': [50, 100, 200],
            'max_depth': [5, 10, 20, None],
            'min_samples_split': [2, 5, 10]
        }
        
        grid_search = GridSearchCV(
            self.model, param_grid, cv=5, scoring='accuracy'
        )
        grid_search.fit(X_train_scaled, y_train)
        
        self.model = grid_search.best_estimator_
        return grid_search.best_score_, grid_search.best_params_
    
    def evaluate_model(self, X_test, y_test):
        X_test_scaled = self.scaler.transform(X_test)
        predictions = self.model.predict(X_test_scaled)
        
        # حساب المقاييس
        from sklearn.metrics import (
            accuracy_score, precision_score, recall_score, 
            f1_score, roc_auc_score, confusion_matrix
        )
        
        metrics = {
            'accuracy': accuracy_score(y_test, predictions),
            'precision': precision_score(y_test, predictions),
            'recall': recall_score(y_test, predictions),
            'f1_score': f1_score(y_test, predictions),
            'roc_auc': roc_auc_score(y_test, predictions)
        }
        
        return metrics
    
    def predict_credit_score(self, customer_data):
        # معالجة بيانات العميل
        processed_data = self.preprocess_data(customer_data)
        
        # تطبيق الميزات
        featured_data = self.engineer_features(processed_data)
        
        # تحويل البيانات
        X = self.scaler.transform(featured_data)
        
        # التنبؤ
        prediction = self.model.predict(X)
        probability = self.model.predict_proba(X)
        
        return {
            'prediction': 'مؤهل' if prediction[0] == 1 else 'غير مؤهل',
            'probability': probability[0][1],
            'confidence': 'عالية' if probability[0].max() > 0.8 else 'متوسطة'
        }