Sağlık Sektöründe Yapay Zeka Uygulamaları

import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.preprocessing.image import ImageDataGenerator
import numpy as np

# CNN Modeli Oluşturma
def create_chest_xray_model(input_shape=(224, 224, 3), num_classes=3):
    """
    Akciğer röntgeni analizi için CNN modeli
    Sınıflar: Normal, Pnömoni, COVID-19
    """
    model = models.Sequential([
        # Convolutional Blocks
        layers.Conv2D(32, (3, 3), activation='relu', input_shape=input_shape),
        layers.MaxPooling2D((2, 2)),
        layers.BatchNormalization(),

        layers.Conv2D(64, (3, 3), activation='relu'),
        layers.MaxPooling2D((2, 2)),
        layers.BatchNormalization(),

        layers.Conv2D(128, (3, 3), activation='relu'),
        layers.MaxPooling2D((2, 2)),
        layers.BatchNormalization(),

        layers.Conv2D(256, (3, 3), activation='relu'),
        layers.MaxPooling2D((2, 2)),
        layers.BatchNormalization(),

        # Dense Layers
        layers.Flatten(),
        layers.Dense(512, activation='relu'),
        layers.Dropout(0.5),
        layers.Dense(256, activation='relu'),
        layers.Dropout(0.3),
        layers.Dense(num_classes, activation='softmax')
    ])

    model.compile(
        optimizer='adam',
        loss='categorical_crossentropy',
        metrics=['accuracy', tf.keras.metrics.Precision(),
                 tf.keras.metrics.Recall()]
    )

    return model

# Transfer Learning ile ResNet50
def create_transfer_learning_model():
    """
    Pre-trained ResNet50 ile transfer learning
    """
    base_model = tf.keras.applications.ResNet50(
        weights='imagenet',
        include_top=False,
        input_shape=(224, 224, 3)
    )

    # İlk katmanları dondur
    base_model.trainable = False

    model = models.Sequential([
        base_model,
        layers.GlobalAveragePooling2D(),
        layers.Dense(256, activation='relu'),
        layers.Dropout(0.5),
        layers.Dense(3, activation='softmax')
    ])

    model.compile(
        optimizer=tf.keras.optimizers.Adam(learning_rate=0.0001),
        loss='categorical_crossentropy',
        metrics=['accuracy']
    )

    return model

# Data Augmentation
train_datagen = ImageDataGenerator(
    rescale=1./255,
    rotation_range=20,
    width_shift_range=0.2,
    height_shift_range=0.2,
    horizontal_flip=True,
    zoom_range=0.2,
    fill_mode='nearest'
)

test_datagen = ImageDataGenerator(rescale=1./255)

# Model Eğitimi
model = create_transfer_learning_model()

history = model.fit(
    train_generator,
    epochs=50,
    validation_data=validation_generator,
    callbacks=[
        tf.keras.callbacks.EarlyStopping(patience=10, restore_best_weights=True),
        tf.keras.callbacks.ReduceLROnPlateau(factor=0.5, patience=5)
    ]
)

# Tahmin ve Görselleştirme
def predict_xray(image_path, model):
    """
    Röntgen görüntüsü analizi
    """
    from tensorflow.keras.preprocessing import image
    import matplotlib.pyplot as plt

    img = image.load_img(image_path, target_size=(224, 224))
    img_array = image.img_to_array(img)
    img_array = np.expand_dims(img_array, axis=0)
    img_array /= 255.0

    predictions = model.predict(img_array)
    class_names = ['Normal', 'Pnömoni', 'COVID-19']

    predicted_class = class_names[np.argmax(predictions)]
    confidence = np.max(predictions) * 100

    print(f"Teşhis: {predicted_class}")
    print(f"Güven: {confidence:.2f}%")

    # Tüm sınıf olasılıkları
    for i, class_name in enumerate(class_names):
        print(f"{class_name}: {predictions[0][i]*100:.2f}%")

    return predicted_class, confidence

# Grad-CAM ile Görselleştirme
def make_gradcam_heatmap(img_array, model, last_conv_layer_name):
    """
    Model kararını görselleştir
    """
    grad_model = tf.keras.models.Model(
        [model.inputs],
        [model.get_layer(last_conv_layer_name).output, model.output]
    )

    with tf.GradientTape() as tape:
        conv_outputs, predictions = grad_model(img_array)
        class_idx = tf.argmax(predictions[0])
        class_channel = predictions[:, class_idx]

    grads = tape.gradient(class_channel, conv_outputs)
    pooled_grads = tf.reduce_mean(grads, axis=(0, 1, 2))

    conv_outputs = conv_outputs[0]
    heatmap = conv_outputs @ pooled_grads[..., tf.newaxis]
    heatmap = tf.squeeze(heatmap)
    heatmap = tf.maximum(heatmap, 0) / tf.math.reduce_max(heatmap)

    return heatmap.numpy()

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

# Diyabet Risk Tahmini
class DiabetesRiskPredictor:
    def __init__(self):
        self.model = None
        self.scaler = StandardScaler()
        self.feature_names = None

    def prepare_features(self, data):
        """
        Hasta verilerinden özellik çıkarma
        """
        features = pd.DataFrame()

        # Demografik özellikler
        features['age'] = data['age']
        features['gender'] = data['gender'].map({'Erkek': 1, 'Kadın': 0})
        features['bmi'] = data['weight'] / (data['height'] / 100) ** 2

        # Vital bulgular
        features['systolic_bp'] = data['systolic_bp']
        features['diastolic_bp'] = data['diastolic_bp']
        features['heart_rate'] = data['heart_rate']

        # Laboratuvar sonuçları
        features['glucose_fasting'] = data['glucose_fasting']
        features['hba1c'] = data['hba1c']
        features['cholesterol_total'] = data['cholesterol_total']
        features['hdl'] = data['hdl']
        features['ldl'] = data['ldl']
        features['triglycerides'] = data['triglycerides']

        # Lifestyle faktörleri
        features['smoking'] = data['smoking'].map({'Evet': 1, 'Hayır': 0})
        features['exercise_hours_week'] = data['exercise_hours_week']
        features['family_history'] = data['family_history'].map({'Evet': 1, 'Hayır': 0})

        # Türetilmiş özellikler
        features['bp_ratio'] = features['systolic_bp'] / features['diastolic_bp']
        features['cholesterol_ratio'] = features['total_cholesterol'] / features['hdl']
        features['age_bmi_interaction'] = features['age'] * features['bmi']

        return features

    def train(self, X, y):
        """
        Model eğitimi
        """
        self.feature_names = X.columns.tolist()

        # XGBoost modeli
        self.model = xgb.XGBClassifier(
            n_estimators=200,
            max_depth=6,
            learning_rate=0.05,
            subsample=0.8,
            colsample_bytree=0.8,
            random_state=42,
            scale_pos_weight=len(y[y==0]) / len(y[y==1])  # Dengesiz veri için
        )

        # Veriyi ölçeklendir
        X_scaled = self.scaler.fit_transform(X)

        # Modeli eğit
        self.model.fit(X_scaled, y)

        return self

    def predict_risk(self, patient_data):
        """
        Hasta için diyabet riski tahmini
        """
        features = self.prepare_features(patient_data)
        features_scaled = self.scaler.transform(features)

        # Tahmin
        risk_probability = self.model.predict_proba(features_scaled)[0][1]
        risk_class = self.model.predict(features_scaled)[0]

        # Risk kategorisi
        if risk_probability < 0.3:
            risk_level = "Düşük"
        elif risk_probability < 0.6:
            risk_level = "Orta"
        else:
            risk_level = "Yüksek"

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

        # En önemli faktörler
        feature_importance = pd.DataFrame({
            'Feature': self.feature_names,
            'SHAP': np.abs(shap_values[0])
        }).sort_values('SHAP', ascending=False)

        result = {
            'risk_probability': risk_probability * 100,
            'risk_level': risk_level,
            'risk_class': 'Diyabet Riski Var' if risk_class == 1 else 'Düşük Risk',
            'top_risk_factors': feature_importance.head(5).to_dict('records')
        }

        return result

    def generate_recommendations(self, risk_result, patient_data):
        """
        Risk bazlı öneriler
        """
        recommendations = []

        if risk_result['risk_probability'] > 60:
            recommendations.append({
                'priority': 'Yüksek',
                'recommendation': 'Endokrinoloji konsültasyonu gerekli',
                'action': 'En kısa sürede doktor randevusu alın'
            })

        # Özellik bazlı öneriler
        for factor in risk_result['top_risk_factors']:
            feature = factor['Feature']

            if feature == 'bmi' and patient_data['bmi'].values[0] > 30:
                recommendations.append({
                    'priority': 'Orta',
                    'recommendation': 'Kilo yönetimi programı',
                    'action': 'BMI değerinizi 25'in altına indirmeyi hedefleyin'
                })

            if feature == 'glucose_fasting' and patient_data['glucose_fasting'].values[0] > 100:
                recommendations.append({
                    'priority': 'Yüksek',
                    'recommendation': 'Açlık kan şekeri yüksek',
                    'action': 'HbA1c testi yaptırın ve karbonhidrat alımını azaltın'
                })

            if feature == 'exercise_hours_week' and patient_data['exercise_hours_week'].values[0] < 2:
                recommendations.append({
                    'priority': 'Orta',
                    'recommendation': 'Fiziksel aktivite artırımı',
                    'action': 'Haftada en az 150 dakika orta şiddette egzersiz yapın'
                })

        return recommendations

# Kullanım
predictor = DiabetesRiskPredictor()

# Örnek hasta verisi
patient = pd.DataFrame({
    'age': [45],
    'gender': ['Erkek'],
    'height': [175],
    'weight': [92],
    'systolic_bp': [145],
    'diastolic_bp': [92],
    'heart_rate': [78],
    'glucose_fasting': [115],
    'hba1c': [5.9],
    'cholesterol_total': [220],
    'hdl': [38],
    'ldl': [145],
    'triglycerides': [185],
    'smoking': ['Hayır'],
    'exercise_hours_week': [1],
    'family_history': ['Evet']
})

# Risk tahmini
risk = predictor.predict_risk(patient)
print(f"Diyabet Risk Olasılığı: {risk['risk_probability']:.1f}%")
print(f"Risk Seviyesi: {risk['risk_level']}")

# Öneriler
recommendations = predictor.generate_recommendations(risk, patient)
for rec in recommendations:
    print(f"[{rec['priority']}] {rec['recommendation']}: {rec['action']}")

from rdkit import Chem
from rdkit.Chem import AllChem, Descriptors
import torch
import torch.nn as nn
from transformers import AutoModel, AutoTokenizer

# Moleküler Özellik Çıkarma
class MolecularFeatureExtractor:
    def __init__(self):
        self.fingerprint_size = 2048

    def smiles_to_features(self, smiles):
        """
        SMILES stringinden moleküler özellikler
        """
        mol = Chem.MolFromSmiles(smiles)

        if mol is None:
            return None

        # Morgan Fingerprint
        fingerprint = AllChem.GetMorganFingerprintAsBitVect(
            mol, radius=2, nBits=self.fingerprint_size
        )

        # Moleküler descriptorlar
        features = {
            'molecular_weight': Descriptors.MolWt(mol),
            'logp': Descriptors.MolLogP(mol),
            'h_donors': Descriptors.NumHDonors(mol),
            'h_acceptors': Descriptors.NumHAcceptors(mol),
            'rotatable_bonds': Descriptors.NumRotatableBonds(mol),
            'aromatic_rings': Descriptors.NumAromaticRings(mol),
            'tpsa': Descriptors.TPSA(mol),  # Topological polar surface area
            'lipinski_pass': self.check_lipinski(mol)
        }

        return {
            'fingerprint': list(fingerprint),
            'descriptors': features
        }

    def check_lipinski(self, mol):
        """
        Lipinski's Rule of Five kontrolü (ilaç benzerliliği)
        """
        mw = Descriptors.MolWt(mol)
        logp = Descriptors.MolLogP(mol)
        hbd = Descriptors.NumHDonors(mol)
        hba = Descriptors.NumHAcceptors(mol)

        conditions = [
            mw <= 500,
            logp <= 5,
            hbd <= 5,
            hba <= 10
        ]

        return sum(conditions) >= 3  # En az 3 koşul sağlanmalı

# İlaç-Hedef Etkileşim Tahmini
class DrugTargetInteractionPredictor(nn.Module):
    def __init__(self, drug_dim=2048, protein_dim=1024, hidden_dim=512):
        super().__init__()

        self.drug_encoder = nn.Sequential(
            nn.Linear(drug_dim, hidden_dim),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(hidden_dim, 256)
        )

        self.protein_encoder = nn.Sequential(
            nn.Linear(protein_dim, hidden_dim),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(hidden_dim, 256)
        )

        self.interaction_predictor = nn.Sequential(
            nn.Linear(512, 256),
            nn.ReLU(),
            nn.Dropout(0.2),
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Linear(128, 1),
            nn.Sigmoid()
        )

    def forward(self, drug_features, protein_features):
        drug_encoded = self.drug_encoder(drug_features)
        protein_encoded = self.protein_encoder(protein_features)

        combined = torch.cat([drug_encoded, protein_encoded], dim=1)
        interaction_score = self.interaction_predictor(combined)

        return interaction_score

# Yan Etki Tahmini
def predict_side_effects(smiles, model):
    """
    Molekül yapısından potansiyel yan etkileri tahmin et
    """
    extractor = MolecularFeatureExtractor()
    features = extractor.smiles_to_features(smiles)

    if features is None:
        return {'error': 'Invalid SMILES'}

    # Lipinski kontrolü
    if not features['descriptors']['lipinski_pass']:
        warnings = ['Molekül ilaç benzerliliği kurallarını ihlal ediyor']
    else:
        warnings = []

    # TPSA bazlı BBB tahmini
    tpsa = features['descriptors']['tpsa']
    bbb_penetration = tpsa < 90  # Blood-brain barrier

    side_effects = {
        'cns_effects': bbb_penetration,
        'cardiovascular': features['descriptors']['logp'] > 5,
        'hepatotoxicity': features['descriptors']['molecular_weight'] > 500,
        'warnings': warnings
    }

    return side_effects

// Node.js - Hasta İzleme Sistemi
const express = require('express');
const { OpenAI } = require('openai');

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

    this.vitalThresholds = {
      heartRate: { min: 60, max: 100, critical: 120 },
      bloodPressure: {
        systolic: { min: 90, max: 140, critical: 180 },
        diastolic: { min: 60, max: 90, critical: 120 }
      },
      oxygenSaturation: { min: 95, critical: 90 },
      temperature: { min: 36.5, max: 37.5, critical: 39 }
    };
  }

  async analyzeVitalSigns(patientData) {
    const { heartRate, bloodPressure, oxygenSat, temperature } = patientData;
    const alerts = [];

    // Anomali tespiti
    if (heartRate > this.vitalThresholds.heartRate.critical) {
      alerts.push({
        severity: 'CRITICAL',
        type: 'Taşikardi',
        value: heartRate,
        recommendation: 'Acil kardiyoloji konsültasyonu'
      });
    }

    if (oxygenSat < this.vitalThresholds.oxygenSaturation.critical) {
      alerts.push({
        severity: 'CRITICAL',
        type: 'Hipoksi',
        value: oxygenSat,
        recommendation: 'Oksijen desteği başlatılmalı'
      });
    }

    // GPT-4 ile trend analizi
    const trendAnalysis = await this.analyzeTrends(patientData);

    return {
      status: alerts.length > 0 ? 'ALERT' : 'NORMAL',
      alerts,
      trends: trendAnalysis,
      timestamp: new Date()
    };
  }

  async analyzeTrends(patientData) {
    const prompt = `Hasta vital bulgu verileri:

Son 24 saat:
- Kalp atışı: ${patientData.heartRateHistory.join(', ')}
- Tansiyon: ${patientData.bpHistory.join(', ')}
- Oksijen satürasyonu: ${patientData.oxygenHistory.join(', ')}

Hasta geçmişi: ${patientData.medicalHistory}

Bu verilere göre:
1. Vital bulgularda trend var mı?
2. Potansiyel komplikasyon riski var mı?
3. Hangi önlemler alınmalı?`;

    const response = await this.openai.chat.completions.create({
      model: 'gpt-4',
      messages: [
        {
          role: 'system',
          content: 'Sen uzman bir dahiliye doktorusun. Hasta verilerini analiz edip klinik öneriler sunuyorsun.'
        },
        {
          role: 'user',
          content: prompt
        }
      ],
      temperature: 0.3
    });

    return response.choices[0].message.content;
  }

  async generateHealthReport(patientId, period = '7days') {
    // Hasta verilerini çek
    const data = await this.getPatientData(patientId, period);

    const report = {
      patientId,
      period,
      summary: {
        avgHeartRate: this.calculateAverage(data.heartRate),
        avgBP: {
          systolic: this.calculateAverage(data.systolicBP),
          diastolic: this.calculateAverage(data.diastolicBP)
        },
        minOxygenSat: Math.min(...data.oxygenSat),
        alertCount: data.alerts.length
      },
      trends: await this.detectTrends(data),
      recommendations: await this.generateRecommendations(data)
    };

    return report;
  }
}

// Sağlık Chatbot
class HealthcareAssistant {
  constructor() {
    this.openai = new OpenAI({
      apiKey: process.env.OPENAI_API_KEY
    });
  }

  async chat(userMessage, context = {}) {
    const systemPrompt = `Sen hastalarla konuşan bir sağlık asistanısın.

Görevlerin:
1. Genel sağlık sorularını yanıtla
2. İlaç hatırlatıcıları yap
3. Semptomlara göre triage yap (aciliyet değerlendir)
4. Randevu ve ilaç takibi

ÖNEMLİ:
- Kesin teşhis koyma
- İlaç reçete etme
- Acil durumlarda 112'yi ara
- Tıbbi konularda doktora yönlendir`;

    const messages = [
      { role: 'system', content: systemPrompt },
      ...context.history || [],
      { role: 'user', content: userMessage }
    ];

    const response = await this.openai.chat.completions.create({
      model: 'gpt-4',
      messages,
      functions: [
        {
          name: 'check_symptoms',
          description: 'Semptomları değerlendir ve aciliyet belirle',
          parameters: {
            type: 'object',
            properties: {
              symptoms: {
                type: 'array',
                items: { type: 'string' }
              },
              severity: {
                type: 'string',
                enum: ['low', 'medium', 'high', 'emergency']
              }
            }
          }
        },
        {
          name: 'schedule_appointment',
          description: 'Doktor randevusu oluştur',
          parameters: {
            type: 'object',
            properties: {
              department: { type: 'string' },
              preferredDate: { type: 'string' },
              reason: { type: 'string' }
            }
          }
        }
      ],
      function_call: 'auto'
    });

    return response.choices[0];
  }
}

module.exports = { PatientMonitoringSystem, HealthcareAssistant };