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

# نظام متكامل للتعامل مع البيانات الصحية
import pandas as pd
import numpy as np

class HealthDataAnalyzer:
    def __init__(self, data_path):
        self.data = pd.read_csv(data_path)
    
    def clean_medical_data(self):
        # تنظيف البيانات الطبية
        self.data.dropna(inplace=True)
        self.data = self.data[self.data['age'] > 0]
        return self.data
    
    def analyze_vitals(self):
        # تحليل العلامات الحيوية
        vitals_summary = {
            'avg_heart_rate': self.data['heart_rate'].mean(),
            'avg_blood_pressure': self.data['blood_pressure'].mean(),
            'max_temperature': self.data['temperature'].max(),
            'min_oxygen_level': self.data['oxygen_level'].min()
        }
        return vitals_summary

# مثال للاستخدام
analyzer = HealthDataAnalyzer('medical_data.csv')
clean_data = analyzer.clean_medical_data()
vitals = analyzer.analyze_vitals()
print(vitals)

# نظام متكامل لتحليل الصور الطبية
import cv2
import numpy as np
from tensorflow.keras.preprocessing.image import ImageDataGenerator

class MedicalImageAnalyzer:
    def __init__(self, model_path=None):
        if model_path:
            self.model = tf.keras.models.load_model(model_path)
        else:
            self.model = self.build_model()
    
    def build_model(self):
        model = Sequential([
            Conv2D(32, (3, 3), activation='relu', input_shape=(128, 128, 3)),
            MaxPooling2D((2, 2)),
            Conv2D(64, (3, 3), activation='relu'),
            MaxPooling2D((2, 2)),
            Conv2D(128, (3, 3), activation='relu'),
            MaxPooling2D((2, 2)),
            Flatten(),
            Dense(256, activation='relu'),
            Dropout(0.5),
            Dense(128, activation='relu'),
            Dense(4, activation='softmax')  # 4 فئات: طبيعي، التهاب رئوي، سرطان، آخر
        ])
        
        model.compile(optimizer='adam',
                     loss='categorical_crossentropy',
                     metrics=['accuracy'])
        return model
    
    def preprocess_image(self, image_path):
        # تحضير الصورة الطبية
        img = cv2.imread(image_path)
        img = cv2.resize(img, (128, 128))
        img = img / 255.0  # تطبيع
        img = np.expand_dims(img, axis=0)  # إضافة بعد الدفعة
        return img
    
    def analyze_xray(self, image_path):
        # تحليل صورة أشعة سينية
        processed_img = self.preprocess_image(image_path)
        prediction = self.model.predict(processed_img)
        
        classes = ['طبيعي', 'التهاب رئوي', 'سرطان', 'حالة أخرى']
        result = classes[np.argmax(prediction)]
        confidence = np.max(prediction) * 100
        
        return {
            'diagnosis': result,
            'confidence': f'{confidence:.2f}%',
            'recommendation': self.get_recommendation(result)
        }
    
    def get_recommendation(self, diagnosis):
        recommendations = {
            'طبيعي': 'لا يوجد علامات مرضية. موعد المتابعة بعد سنة.',
            'التهاب رئوي': 'مراجعة طبيب الصدر للعلاج بالمضادات الحيوية.',
            'سرطان': 'تحويل إلى أخصائي الأوراد للمزيد من الفحوصات.',
            'حالة أخرى': 'تحويل إلى أخصائي للفحص التفصيلي.'
        }
        return recommendations.get(diagnosis, 'مراجعة الطبيب')

# نظام متقدم للتنبؤ بالأمراض
import pandas as pd
import numpy as np
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import cross_val_score, GridSearchCV

class DiseasePredictionSystem:
    def __init__(self):
        self.model = GradientBoostingClassifier()
        self.scaler = StandardScaler()
        self.feature_importance = None
    
    def load_medical_data(self, file_path):
        # تحميل البيانات الطبية
        data = pd.read_csv(file_path)
        
        # الفصل بين الميزات والنتيجة
        feature_columns = ['age', 'blood_pressure', 'cholesterol', 
                          'glucose', 'bmi', 'smoking', 'exercise']
        target_column = 'disease_risk'
        
        X = data[feature_columns]
        y = data[target_column]
        
        return X, y
    
    def preprocess_features(self, X):
        # تطبيع الميزات
        X_scaled = self.scaler.fit_transform(X)
        return X_scaled
    
    def train_model(self, X, y):
        # تقسيم البيانات
        X_train, X_test, y_train, y_test = train_test_split(
            X, y, test_size=0.2, random_state=42, stratify=y
        )
        
        # البحث عن أفضل معلمات
        param_grid = {
            'n_estimators': [50, 100, 200],
            'learning_rate': [0.01, 0.1, 0.2],
            'max_depth': [3, 5, 7]
        }
        
        grid_search = GridSearchCV(
            self.model, param_grid, cv=5, scoring='accuracy'
        )
        grid_search.fit(X_train, y_train)
        
        self.model = grid_search.best_estimator_
        self.feature_importance = self.model.feature_importances_
        
        # تقييم النموذج
        y_pred = self.model.predict(X_test)
        accuracy = accuracy_score(y_test, y_pred)
        
        return {
            'best_params': grid_search.best_params_,
            'accuracy': accuracy,
            'feature_importance': self.feature_importance
        }
    
    def predict_disease_risk(self, patient_data):
        # التنبؤ بمخاطر المرض لمريض معين
        processed_data = self.scaler.transform([patient_data])
        prediction = self.model.predict(processed_data)
        probability = self.model.predict_proba(processed_data)
        
        risk_levels = ['منخفض', 'متوسط', 'مرتفع', 'مرتفع جداً']
        
        return {
            'risk_level': risk_levels[prediction[0]],
            'probability': probability[0].max(),
            'recommendations': self.get_recommendations(prediction[0])
        }
    
    def get_recommendations(self, risk_level):
        recommendations = {
            0: ['فحص سنوي', 'متابعة طبية روتينية'],
            1: ['فحص كل 6 أشهر', 'مراقبة المؤشرات الصحية'],
            2: ['فحص فوري', 'استشارة أخصائي', 'بدء علاج وقائي'],
            3: ['تدخل طبي عاجل', 'متابعة يومية', 'علاج مكثف']
        }
        return recommendations.get(risk_level, ['استشارة طبية'])

# نظام متكامل لاكتشاف الأدوية
import numpy as np
import pandas as pd
from rdkit import Chem, DataStructs
from rdkit.Chem import AllChem, Descriptors
from rdkit.Chem.Fingerprints import FingerprintMols
from deepchem import deepchem as dc
from sklearn.ensemble import RandomForestRegressor

class DrugDiscoverySystem:
    def __init__(self):
        self.fingerprint_radius = 2
        self.fingerprint_size = 2048
        self.model = RandomForestRegressor(n_estimators=100)
    
    def load_compound_library(self, file_path):
        # تحميل مكتبة المركبات الكيميائية
        compounds = []
        activities = []
        
        data = pd.read_csv(file_path)
        for _, row in data.iterrows():
            smiles = row['smiles']
            activity = row['activity']
            
            mol = Chem.MolFromSmiles(smiles)
            if mol:
                compounds.append(mol)
                activities.append(activity)
        
        return compounds, activities
    
    def calculate_molecular_descriptors(self, mol):
        # حساب الواصفات الجزيئية
        descriptors = {
            'molecular_weight': Descriptors.MolWt(mol),
            'logp': Descriptors.MolLogP(mol),
            'hbd': Descriptors.NumHDonors(mol),
            'hba': Descriptors.NumHAcceptors(mol),
            'rotatable_bonds': Descriptors.NumRotatableBonds(mol),
            'tpsa': Descriptors.TPSA(mol)
        }
        return descriptors
    
    def generate_fingerprints(self, mol):
        # توليد بصمات جزيئية
        fp = AllChem.GetMorganFingerprintAsBitVect(
            mol, self.fingerprint_radius, nBits=self.fingerprint_size
        )
        return np.array(fp)
    
    def train_activity_model(self, compounds, activities):
        # تدريب نموذج للتنبؤ بالفعالية
        fingerprints = [self.generate_fingerprints(mol) for mol in compounds]
        X = np.array(fingerprints)
        y = np.array(activities)
        
        # تقسيم البيانات
        from sklearn.model_selection import train_test_split
        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)
        
        # التقييم
        from sklearn.metrics import mean_squared_error, r2_score
        y_pred = self.model.predict(X_test)
        mse = mean_squared_error(y_test, y_pred)
        r2 = r2_score(y_test, y_pred)
        
        return {
            'mse': mse,
            'r2_score': r2,
            'feature_importance': self.model.feature_importances_
        }
    
    def predict_compound_activity(self, smiles):
        # التنبؤ بفعالية مركب جديد
        mol = Chem.MolFromSmiles(smiles)
        if not mol:
            return {'error': 'صيغة SMILES غير صحيحة'}
        
        # حساب الواصفات
        descriptors = self.calculate_molecular_descriptors(mol)
        
        # توليد البصمة
        fingerprint = self.generate_fingerprints(mol)
        
        # التنبؤ بالفعالية
        activity_prediction = self.model.predict([fingerprint])[0]
        
        # تقييم الجزيء
        drug_likeness = self.assess_drug_likeness(descriptors)
        
        return {
            'smiles': smiles,
            'predicted_activity': activity_prediction,
            'drug_likeness': drug_likeness,
            'descriptors': descriptors,
            'recommendation': self.get_recommendation(activity_prediction, drug_likeness)
        }
    
    def assess_drug_likeness(self, descriptors):
        # تقييم مدى ملاءمة الجزيء كدواء
        score = 0
        
        # قاعدة Lipinski
        if descriptors['molecular_weight'] <= 500:
            score += 1
        if descriptors['logp'] <= 5:
            score += 1
        if descriptors['hbd'] <= 5:
            score += 1
        if descriptors['hba'] <= 10:
            score += 1
        
        # تقييم إضافي
        if descriptors['rotatable_bonds'] <= 10:
            score += 1
        if descriptors['tpsa'] <= 140:
            score += 1
        
        if score >= 5:
            return 'عالي'
        elif score >= 3:
            return 'متوسط'
        else:
            return 'منخفض'
    
    def get_recommendation(self, activity, drug_likeness):
        if activity > 0.8 and drug_likeness == 'عالي':
            return 'مرشح ممتاز لمزيد من التطوير'
        elif activity > 0.6 and drug_likeness in ['عالي', 'متوسط']:
            return 'مرشح جيد لمزيد من الدراسات'
        elif activity > 0.4:
            return 'يحتاج إلى تحسين الخصائص'
        else:
            return 'غير مرشح حاليًا'