AI in Healthcare: Revolutionizing Medicine and Medical Practice

import pydicom
import cv2
import numpy as np
from tensorflow.keras.models import load_model

def analyze_chest_xray(image_path):
    """
    Analyze chest X-ray for pneumonia detection
    """
    # Load pre-trained model
    model = load_model('chest_xray_model.h5')

    # Read and preprocess DICOM image
    dcm = pydicom.dcmread(image_path)
    image_array = dcm.pixel_array

    # Normalize image
    image_array = cv2.normalize(image_array, None, 0, 1, cv2.NORM_MINMAX)
    image_array = cv2.resize(image_array, (224, 224))

    # Expand dimensions for model input
    image_array = np.expand_dims(image_array, axis=[0, -1])

    # Make prediction
    prediction = model.predict(image_array)
    probability = prediction[0][0]

    return {
        'prediction': 'Pneumonia' if probability > 0.5 else 'Normal',
        'confidence': probability if probability > 0.5 else 1 - probability
    }

# Example usage
result = analyze_chest_xray('chest_xray.dcm')
print(f"Diagnosis: {result['prediction']} (Confidence: {result['confidence']:.2f})")

from tensorflow.keras.applications import MobileNetV2
from tensorflow.keras.layers import Dense, GlobalAveragePooling2D
from tensorflow.keras.models import Model

def create_skin_cancer_classifier(num_classes=7):
    """
    Create a skin lesion classifier using transfer learning
    """
    # Load MobileNetV2 base model
    base_model = MobileNetV2(weights='imagenet', include_top=False,
                            input_shape=(224, 224, 3))

    # Freeze base model layers
    for layer in base_model.layers:
        layer.trainable = False

    # Add classification head
    x = base_model.output
    x = GlobalAveragePooling2D()(x)
    x = Dense(1024, activation='relu')(x)
    predictions = Dense(num_classes, activation='softmax')(x)

    model = Model(inputs=base_model.input, outputs=predictions)

    model.compile(optimizer='adam',
                  loss='categorical_crossentropy',
                  metrics=['accuracy', 'AUC'])

    return model

# Model classes for skin cancer
ISIC_CLASSES = {
    0: 'Actinic keratoses',
    1: 'Basal cell carcinoma',
    2: 'Benign keratosis',
    3: 'Dermatofibroma',
    4: 'Melanocytic nevi',
    5: 'Melanoma',
    6: 'Vascular lesions'
}

import rdkit
from rdkit import Chem
from sklearn.ensemble import RandomForestRegressor
import pandas as pd

def predict_drug_activity(smiles, model_features):
    """
    Predict molecular activity using ML
    """
    # Convert SMILES to molecular descriptors
    mol = Chem.MolFromSmiles(smiles)

    if mol is None:
        raise ValueError("Invalid SMILES string")

    # Calculate molecular fingerprints
    fp = Chem.GetMorganFingerprintAsBitVect(mol, 2, nBits=2048)

    # Convert to feature array
    features = np.array([int(bit) for bit in fp.ToBitString()])

    # Load pre-trained model and predict
    model = RandomForestRegressor.load('drug_activity_model.pkl')
    activity = model.predict([features])[0]

    return activity

# Example usage
smiles_string = "CC(=O)OC1=CC=CC=C1C(=O)O"  # Aspirin
predicted_activity = predict_drug_activity(smiles_string, model_features)
print(f"Predicted activity: {predicted_activity:.4f}")

def virtual_screening(library_path, target_model, num_candidates=1000):
    """
    Perform virtual screening on compound library
    """
    # Load compound library
    compounds_df = pd.read_csv(library_path)

    predictions = []

    for idx, row in compounds_df.iterrows():
        try:
            activity = predict_drug_activity(row['smiles'], target_model)
            predictions.append({
                'compound_id': row['compound_id'],
                'smiles': row['smiles'],
                'predicted_activity': activity
            })
        except:
            continue

    # Sort by predicted activity (higher is better)
    predictions_df = pd.DataFrame(predictions)
    top_candidates = predictions_df.nlargest(num_candidates, 'predicted_activity')

    return top_candidates

# Perform virtual screening
top_hits = virtual_screening('compound_library.csv', drug_target_model, 100)
print("Top 100 candidate compounds:")
print(top_hits.head())

import numpy as np
from sklearn.decomposition import PCA

def analyze_genetic_variants(variant_data, phenotype_labels):
    """
    Analyze genetic variants for disease association
    """
    # Perform PCA on genotype data
    pca = PCA(n_components=50)
    genetic_pca = pca.fit_transform(variant_data)

    explained_variance = np.sum(pca.explained_variance_ratio_)
    print(f"Explained variance with 50 PCs: {explained_variance:.3f}")

    # Train classifier for disease prediction
    from sklearn.ensemble import GradientBoostingClassifier

    gb_classifier = GradientBoostingClassifier(n_estimators=100,
                                               learning_rate=0.1,
                                               max_depth=5)

    gb_classifier.fit(genetic_pca, phenotype_labels)

    # Get most important features
    feature_importance = pca.inverse_transform(gb_classifier.feature_importances_)

    return gb_classifier, feature_importance

# Example: Disease risk prediction
genetic_data = load_genotypes('genotype_matrix.npy')
disease_labels = load_phenotypes('disease_phenotypes.npy')

model, important_variants = analyze_genetic_variants(genetic_data, disease_labels)

from sklearn.preprocessing import StandardScaler
from sklearn.neural_network import MLPRegressor

def predict_treatment_response(patient_features, treatment_type):
    """
    Predict treatment response using ML
    """
    # Scale features
    scaler = StandardScaler()
    patient_features_scaled = scaler.fit_transform([patient_features])

    # Load appropriate model for treatment type
    if treatment_type == 'chemotherapy':
        model = MLPRegressor(hidden_layer_sizes=(100, 50), max_iter=500)
        # Load trained model
        model = joblib.load('chemotherapy_response_model.pkl')

    elif treatment_type == 'immunotherapy':
        model = MLPRegressor(hidden_layer_sizes=(150, 75, 25), max_iter=500)
        model = joblib.load('immunotherapy_response_model.pkl')

    # Predict response probability
    response_probability = model.predict_proba(patient_features_scaled)[0][1]

    return response_probability

# Example prediction
patient_age = 65
tumor_size = 3.2
gene_expression_profile = [0.8, 0.3, 0.9, 0.2, 0.6]  # Simplified

patient_features = [patient_age, tumor_size] + gene_expression_profile
response_prob = predict_treatment_response(patient_features, 'chemotherapy')

print(f"Treatment response probability: {response_prob:.2f}")

import pandas as pd
from datetime import datetime
from sklearn.ensemble import RandomForestRegressor

def optimize_bed_allocation(hospital_data, prediction_hours=24):
    """
    Predict bed occupancy and optimize allocation
    """
    # Prepare time series features
    hospital_data['hour'] = hospital_data['date'].dt.hour
    hospital_data['day_of_week'] = hospital_data['date'].dt.dayofweek
    hospital_data['month'] = hospital_data['date'].dt.month

    features = ['hour', 'day_of_week', 'month', 'current_occupancy', 'staff_count', 'emergency_cases']

    X = hospital_data[features]
    y = hospital_data['bed_occupancy_rate']

    # Train prediction model
    model = RandomForestRegressor(n_estimators=100, random_state=42)
    model.fit(X, y)

    # Feature importance
    importance_df = pd.DataFrame({
        'feature': features,
        'importance': model.feature_importances_
    }).sort_values('importance', ascending=False)

    print("Feature Importances:")
    print(importance_df)

    # Predict future occupancy for optimization
    future_predictions = []
    for hour in range(prediction_hours):
        # Create prediction features (simplified)
        pred_features = {
            'hour': (datetime.now().hour + hour) % 24,
            'day_of_week': datetime.now().weekday(),
            'month': datetime.now().month,
            'current_occupancy': 0.7,  # Current occupancy
            'staff_count': 45,
            'emergency_cases': 12
        }

        pred_df = pd.DataFrame([pred_features])
        prediction = model.predict(pred_df)[0]
        future_predictions.append(prediction)

    return future_predictions

# Example resource optimization
occupancy_predictions = optimize_bed_allocation(hospital_occupancy_data, 24)
print("24-hour occupancy predictions:", occupancy_predictions[:6])

class ClinicalDecisionSupport:
    def __init__(self):
        self.models = self.load_medical_models()
        self.knowledge_base = self.load_medical_knowledge()

    def load_medical_models(self):
        """Load various diagnostic and treatment models"""
        models = {
            'heart_disease': joblib.load('heart_disease_risk_model.pkl'),
            'diabetes': joblib.load('diabetes_prediction_model.pkl'),
            'pneumonia': joblib.load('pneumonia_detection_model.pkl')
        }
        return models

    def assess_patient_condition(self, patient_data, condition):
        """
        Assess patient for specific medical condition
        """
        model = self.models[condition]

        # Extract relevant features
        features = self.extract_features_for_condition(patient_data, condition)

        # Make prediction
        risk_score = model.predict_proba([features])[0][1]

        # Generate recommendations based on score
        recommendations = self.generate_recommendations(condition, risk_score)

        return {
            'condition': condition,
            'risk_score': risk_score,
            'recommendations': recommendations,
            'follow_up_tests': self.suggest_follow_up_tests(condition, patient_data)
        }

    def generate_recommendations(self, condition, risk_score):
        """Generate personalized medical recommendations"""
        if risk_score > 0.8:
            return ["Immediate consultation recommended", "Further diagnostic testing"]
        elif risk_score > 0.5:
            return ["Schedule appointment within 1 week", "Monitor symptoms closely"]
        else:
            return ["Continue regular check-ups", "Maintain healthy lifestyle"]

    def suggest_follow_up_tests(self, condition, patient_data):
        """Suggest appropriate follow-up tests"""
        base_tests = ["Complete Blood Count (CBC)", "Basic Metabolic Panel"]

        if condition == 'heart_disease':
            base_tests.extend(["ECG", "Echocardiogram", "Stress Test"])
        elif condition == 'diabetes':
            base_tests.extend(["HbA1c", "Fasting Glucose", "Oral Glucose Tolerance Test"])

        return base_tests

# Example clinical decision support
cds = ClinicalDecisionSupport()

patient = {
    'age': 55,
    'blood_pressure': 145,
    'cholesterol': 240,
    'smoking_status': 1,
    'family_history': 1,
    'chest_pain': 1
}

assessment = cds.assess_patient_condition(patient, 'heart_disease')
print("Heart disease assessment:")
print(f"Risk score: {assessment['risk_score']:.2f}")
print("Recommendations:")
for rec in assessment['recommendations']:
    print(f"- {rec}")

def audit_model_fairness(model, test_data, sensitive_attributes):
    """
    Audit AI model for fairness across protected groups
    """
    results = {}

    for attribute in sensitive_attributes:
        print(f"\nAnalyzing fairness for {attribute}:")

        # Calculate metrics by group
        group_metrics = {}

        for group_value in test_data[attribute].unique():
            group_data = test_data[test_data[attribute] == group_value]

            predictions = model.predict(group_data.drop('target', axis=1))
            actuals = group_data['target']

            tp = ((predictions == 1) & (actuals == 1)).sum()
            fp = ((predictions == 1) & (actuals == 0)).sum()
            fn = ((predictions == 0) & (actuals == 1)).sum()
            tn = ((predictions == 0) & (actuals == 0)).sum()

            sensitivity = tp / (tp + fn) if (tp + fn) > 0 else 0
            specificity = tn / (tn + fp) if (tn + fp) > 0 else 0

            group_metrics[group_value] = {
                'sensitivity': sensitivity,
                'specificity': specificity,
                'sample_size': len(group_data)
            }

        results[attribute] = group_metrics

    # Check for disparities
    for attribute, metrics in results.items():
        sensitivities = [m['sensitivity'] for m in metrics.values()]
        max_sens = max(sensitivities)
        min_sens = min(sensitivities)

        if max_sens - min_sens > 0.1:  # 10% disparity threshold
            print(f"⚠️ Fairness concern for {attribute}: Sensitivity range {min_sens:.2f} - {max_sens:.2f}")

    return results

# Example fairness audit
fairness_results = audit_model_fairness(
    diabetes_model,
    test_patients_with_demographics,
    ['gender', 'ethnicity', 'age_group']
)