AI in Healthcare: Applications and Revolutionizing the Industry

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import numpy as np

# Simplified CNN architecture for medical image classification
def create_medical_cnn(input_shape, num_classes):
    model = keras.Sequential([
        layers.Conv2D(32, (3, 3), activation='relu', input_shape=input_shape),
        layers.MaxPooling2D((2, 2)),
        layers.Conv2D(64, (3, 3), activation='relu'),
        layers.MaxPooling2D((2, 2)),
        layers.Conv2D(128, (3, 3), activation='relu'),
        layers.MaxPooling2D((2, 2)),
        layers.Flatten(),
        layers.Dense(128, activation='relu'),
        layers.Dropout(0.5),
        layers.Dense(num_classes, activation='softmax')
    ])
    
    model.compile(
        optimizer='adam',
        loss='categorical_crossentropy',
        metrics=['accuracy']
    )
    return model

# Example usage with synthetic medical imaging data
input_shape = (224, 224, 3)  # Standard medical image dimensions
num_classes = 5  # Number of disease categories

model = create_medical_cnn(input_shape, num_classes)
model.summary()

import pandas as pd
import numpy as np
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report

# Load patient vital signs data
data = pd.read_csv('patient_vitals.csv')

# Feature engineering for predictive model
features = ['heart_rate', 'blood_pressure', 'respiratory_rate', 'temperature', 'oxygen_saturation']
X = data[features]
y = data['deterioration_within_24h']

# Train-test split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Random Forest model for deterioration prediction
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# Evaluate model performance
y_pred = model.predict(X_test)
print(classification_report(y_test, y_pred))

import deepchem as dc
from deepchem.models import GraphConvModel
from deepchem.feat import ConvMolFeaturizer
from deepchem.splits import RandomSplitter
import numpy as np

# Load molecular dataset
dataset = dc.utils.save.load_from_disk('drug_candidates.csv')

# Featurize molecules for graph convolutional network
featurizer = ConvMolFeaturizer()
features = featurizer.featurize(dataset.mols)

# Split data for training and validation
splitter = RandomSplitter()
train_dataset, valid_dataset, test_dataset = splitter.train_valid_test_split(
    dataset, frac_train=0.8, frac_valid=0.1, frac_test=0.1
)

# Create and train Graph Convolutional Network
model = GraphConvModel(
    n_tasks=1,  # Single task: drug efficacy prediction
    mode='regression',
    dropout=0.2,
    batch_size=64
)

# Train the model
model.fit(train_dataset, nb_epoch=50)

# Evaluate performance
metric = dc.metrics.Metric(dc.metrics.r2_score)
train_score = model.evaluate(train_dataset, [metric])
valid_score = model.evaluate(valid_dataset, [metric])

print(f"Training R²: {train_score[0]['r2_score']:.4f}")
print(f"Validation R²: {valid_score[0]['r2_score']:.4f}")

import numpy as np
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.preprocessing import StandardScaler

# Load genomic data and treatment outcomes
genomic_data = np.load('patient_genomes.npy')  # Shape: (n_samples, n_genes)
treatment_outcomes = np.load('treatment_outcomes.npy')

# Preprocess data
scaler = StandardScaler()
scaled_genomic_data = scaler.fit_transform(genomic_data)

# Train model to predict treatment response
model = GradientBoostingClassifier(n_estimators=100, max_depth=3)
model.fit(scaled_genomic_data, treatment_outcomes)

# Predict optimal treatment for new patient
new_patient_genome = np.load('new_patient_genome.npy')
scaled_new_patient = scaler.transform([new_patient_genome])
predicted_response = model.predict(scaled_new_patient)

print(f"Predicted treatment response: {predicted_response[0]}")

import openai
from typing import Dict, List

# Configure OpenAI API
openai.api_key = 'your-api-key'

def extract_medical_entities(conversation: str) -> Dict[str, List[str]]:
    """
    Extract medical entities from physician-patient conversation
    """
    response = openai.ChatCompletion.create(
        model="gpt-4",
        messages=[
            {"role": "system", "content": "You are a medical documentation specialist. Extract and categorize medical entities from conversations."},
            {"role": "user", "content": f"Extract medical entities from this conversation: {conversation}"}
        ],
        temperature=0
    )
    
    # Parse response for medical entities
    entities = response.choices[0].message.content
    
    # Simplified entity extraction logic
    return {
        "diagnoses": ["hypertension", "diabetes"],
        "medications": ["metformin", "lisinopril"],
        "symptoms": ["fatigue", "frequent urination"],
        "follow_up": ["blood work", "dietary changes"]
    }

# Example usage
conversation = """
Patient: Doctor, I've been feeling very tired lately and I'm urinating more frequently.
Physician: How long has this been going on?
Patient: About two weeks now.
Physician: Any other symptoms?
Patient: I've also been unusually thirsty.
Physician: Let's run some blood work and check your glucose levels.
"""

entities = extract_medical_entities(conversation)
print(entities)

from sklearn.metrics import confusion_matrix, classification_report
import numpy as np

def evaluate_model_fairness(y_true, y_pred, sensitive_attribute):
    """
    Evaluate model performance across different demographic groups
    """
    # Calculate overall performance
    overall_metrics = classification_report(y_true, y_pred, output_dict=True)
    
    # Calculate performance by demographic group
    unique_groups = np.unique(sensitive_attribute)
    group_metrics = {}
    
    for group in unique_groups:
        group_mask = sensitive_attribute == group
        group_y_true = y_true[group_mask]
        group_y_pred = y_pred[group_mask]
        
        group_metrics[str(group)] = classification_report(
            group_y_true, group_y_pred, output_dict=True
        )
    
    return {
        "overall": overall_metrics,
        "by_group": group_metrics
    }

# Example usage with synthetic data
y_true = np.random.randint(0, 2, 1000)
y_pred = np.random.randint(0, 2, 1000)
sensitive_attribute = np.random.choice(['group_A', 'group_B', 'group_C'], 1000)

fairness_metrics = evaluate_model_fairness(y_true, y_pred, sensitive_attribute)
print(fairness_metrics)

import shap
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

# Load breast cancer dataset
data = load_breast_cancer()
X_train, X_test, y_train, y_test = train_test_split(
    data.data, data.target, test_size=0.2, random_state=42
)

# Train Random Forest model
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# Use SHAP for model interpretability
explainer = shap.TreeExplainer(model)
shap_values = explainer.shap_values(X_test)

# Visualize feature importance
shap.summary_plot(shap_values, X_test, feature_names=data.feature_names)