Update app.py

app.py

@@ -1,20 +1,18 @@
+I need to link the backend to frontend
+
 import gradio as gr
 import joblib
 import numpy as np
 import pandas as pd
 from propy import AAComposition
 from sklearn.preprocessing import MinMaxScaler
-from fastapi import FastAPI
-from gradio.routes import mount_gradio_app
 
-# Load trained SVM model and scaler
+# Load trained SVM model and scaler (Ensure both files exist in the Space)
 model = joblib.load("SVM.joblib")
 scaler = joblib.load("norm.joblib")
 
-# FastAPI instance
-app = FastAPI()
 
-# Selected features used in the model
+# List of features used in your model
 selected_features = [
     "A", "R", "N", "D", "C", "E", "Q", "G", "H", "I", "L", "K", "M", "F", "P", "S", "T", "W", "Y", "V",
     "AA", "AR", "AN", "AD", "AC", "AE", "AQ", "AG", "AI", "AL", "AK", "AF", "AP", "AS", "AT", "AY", "AV",
@@ -41,43 +39,47 @@ selected_features = [
 
 def extract_features(sequence):
     """Extract only the required features and normalize them."""
-    all_features = AAComposition.CalculateAADipeptideComposition(sequence)
-    feature_values = list(all_features.values())
-    feature_array = np.array(feature_values).reshape(-1, 1)[:420]  # Ensure correct shape
-    normalized_features = scaler.transform(feature_array.T).flatten()
+    # Compute all possible features
+    all_features = AAComposition.CalculateAADipeptideComposition(sequence)  # Amino Acid Composition
+    # Extract the values from the dictionary
+    feature_values = list(all_features.values())  # Extract values only
+    # Convert to NumPy array for normalization
+    feature_array = np.array(feature_values).reshape(-1, 1)
+    feature_array = feature_array[: 420]
+    # Min-Max Normalization
+    normalized_features = scaler.transform(feature_array.T)
+
+    # Reshape normalized_features back to a single dimension
+    normalized_features = normalized_features.flatten()  # Flatten array
 
-    selected_feature_dict = {
-        feature: normalized_features[i]
-        for i, feature in enumerate(selected_features)
-        if feature in all_features
-    }
+    # Create a dictionary with selected features
+    selected_feature_dict = {feature: normalized_features[i] for i, feature in enumerate(selected_features)
+                               if feature in all_features}
 
+    # Convert dictionary to dataframe
     selected_feature_df = pd.DataFrame([selected_feature_dict])
-    return selected_feature_df.to_numpy()
+
+    # Convert dataframe to numpy array
+    selected_feature_array = selected_feature_df.T.to_numpy()
+
+    return selected_feature_array
+
+
 
 def predict(sequence):
     """Predict AMP vs Non-AMP"""
     features = extract_features(sequence)
     prediction = model.predict(features.T)[0]
-    return {"prediction": "AMP" if prediction == 0 else "Non-AMP"}
+    return "AMP" if prediction == 0 else "Non-AMP"
 
-# FastAPI endpoint
-@app.post("/predict/")
-async def predict_api(request: dict):
-    sequence = request.get("sequence", "")
-    if not sequence or len(sequence) < 10 or len(sequence) > 100:
-        return {"error": "Sequence length must be between 10 and 100."}
-    return predict(sequence)
-
-# Gradio Interface (optional if you want UI access)
+# Create Gradio interface
 iface = gr.Interface(
     fn=predict,
     inputs=gr.Textbox(label="Enter Protein Sequence"),
     outputs=gr.Label(label="Prediction"),
     title="AMP Classifier",
-    description="Enter an amino acid sequence to predict AMP or Non-AMP."
+    description="Enter an amino acid sequence to predict whether it's an antimicrobial peptide (AMP) or not."
 )
 
-app = mount_gradio_app(app, iface, path="/gradio")
-
-# Run the server with: `uvicorn filename:app --host 0.0.0.0 --port 7860`
+# Launch app
+iface.launch(share=True)