Upload 4 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+labeled_severity.csv filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,113 @@
+import torch
+from transformers import AutoModelForSequenceClassification, AutoTokenizer
+import requests
+import gradio as gr
+
+# Define device
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+print(f"🚀 Device: {device}")
+
+# Load the pre-trained model and tokenizer from the Hugging Face directory where the model is saved
+model_name = "Fredaaaaaa/hybrid_model"  # Update this to the correct model path
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+text_model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=4)
+text_model.to(device)
+
+# Function to fetch drug features from an external API (e.g., PubChem)
+def get_drug_features(drug1, drug2):
+    # You can modify this function to fetch additional features based on your API choice.
+    api_url = f'https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/{drug1}/property/SMILES,Pharmacology,Toxicity,Mechanism-of-action,Route-of-elimination,Metabolism/JSON'
+    response = requests.get(api_url)
+    
+    if response.status_code == 200:
+        data = response.json()
+        drug_features = {
+            'SMILES': data['PropertyTable']['Properties'][0].get('SMILES', 'No data'),
+            'pharmacology': data['PropertyTable']['Properties'][0].get('Pharmacology', 'No data'),
+            'toxicity': data['PropertyTable']['Properties'][0].get('Toxicity', 'No data'),
+            'mechanism-of-action': data['PropertyTable']['Properties'][0].get('Mechanism-of-action', 'No data'),
+            'route-of-elimination': data['PropertyTable']['Properties'][0].get('Route-of-elimination', 'No data'),
+            'metabolism': data['PropertyTable']['Properties'][0].get('Metabolism', 'No data'),
+        }
+        return drug_features
+    else:
+        return None  # If no data is returned, handle the missing values gracefully
+
+# Define the Hybrid Model (already trained)
+class HybridModel(torch.nn.Module):
+    def __init__(self, text_model, input_size, dropout_rate=0.3):
+        super(HybridModel, self).__init__()
+        self.text_model = text_model
+        self.fc1 = torch.nn.Linear(input_size, 128)  # Fully connected layer for drug features
+        self.fc2 = torch.nn.Linear(128, 64)         # Additional fully connected layer
+        self.fc3 = torch.nn.Linear(64, 4)           # Output layer (4 classes for severity)
+        self.dropout = torch.nn.Dropout(dropout_rate)
+
+    def forward(self, input_ids, attention_mask, drug_features):
+        # Process the text data (interaction description) through BioBERT
+        text_outputs = self.text_model(input_ids=input_ids, attention_mask=attention_mask)
+        text_features = text_outputs.logits  # Shape: (batch_size, num_labels)
+
+        # Pass the drug features through the fully connected layers
+        x = torch.relu(self.fc1(drug_features))
+        x = self.dropout(x)
+        x = torch.relu(self.fc2(x))
+        x = self.fc3(x)
+
+        # Combine the features from the text and drug inputs
+        combined = text_features + x
+        return combined
+
+# Initialize the model
+hybrid_model = HybridModel(text_model, input_size=3)  # Example size, adjust based on your data
+hybrid_model.to(device)
+
+# Function to process the input and predict severity
+def predict_severity(drug1, drug2):
+    # Fetch drug features from external API
+    drug_features = get_drug_features(drug1, drug2)
+
+    if not drug_features:
+        return "Error: Could not fetch drug features from the API."
+
+    # Preprocess text data (interaction description)
+    interaction_description = f"{drug1} interacts with {drug2}"  # Example interaction description
+    inputs = tokenizer(interaction_description, return_tensors="pt", padding=True, truncation=True, max_length=128)
+    input_ids = inputs['input_ids'].to(device)
+    attention_mask = inputs['attention_mask'].to(device)
+
+    # Process drug features (SMILES, pharmacology, toxicity, etc.)
+    drug_feature_values = [drug_features['SMILES'], drug_features['pharmacology'], drug_features['toxicity']]
+    
+    # Convert to numerical features (handle strings gracefully)
+    numerical_features = []
+    for feature in drug_feature_values:
+        if isinstance(feature, str):  # If the feature is a string, convert it to a dummy number or handle it
+            numerical_features.append(0)  # Placeholder value for missing data
+        else:
+            numerical_features.append(feature)
+
+    drug_features_tensor = torch.tensor(numerical_features, dtype=torch.float32).unsqueeze(0).to(device)
+
+    # Run the model to get predictions
+    hybrid_model.eval()
+    with torch.no_grad():
+        outputs = hybrid_model(input_ids, attention_mask, drug_features_tensor)
+    
+    # Get the predicted class
+    prediction = torch.argmax(outputs, dim=1).item()
+
+    # Map the predicted class index to the severity label
+    severity_labels = ["No interaction", "Mild", "Moderate", "Severe"]
+    return severity_labels[prediction]
+
+# Gradio Interface
+interface = gr.Interface(
+    fn=predict_severity,
+    inputs=[gr.Textbox(label="Drug 1"), gr.Textbox(label="Drug 2")],
+    outputs="text",
+    live=True
+)
+
+# Launch the interface
+interface.launch()

hybrid_model.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:75567f724f1ddab1d748f5190031f11ff2b6cf532333801683ec44293a276dc4
+size 401914674

labeled_severity.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:78f825bb07033ce4bbf16d4f58a756e2e113934a3f8274d298312c359a65edb9
+size 31877277

requirements.txt

@@ -0,0 +1,3 @@
+transformers
+torch
+gradio