Update api.py

api.py

@@ -1,70 +1,84 @@
 import numpy as np
 import pandas as pd
-import torch
-import torch.nn as nn
-import torch.optim as optim
-from sklearn.model_selection import train_test_split
-from sklearn.metrics import accuracy_score
+import gradio as gr
+import pickle
 
-class PlacementModel(nn.Module):
-    def __init__(self, input_size, hidden_size, output_size):
-        super(PlacementModel, self).__init__()
-        self.fc1 = nn.Linear(input_size, hidden_size)
-        self.fc2 = nn.Linear(hidden_size, output_size)
+# Load trained models
+with open('rf_hacathon_fullstk.pkl', 'rb') as f1:
+    rf_fullstk = pickle.load(f1)
+with open('rf_hacathon_prodengg.pkl', 'rb') as f2:
+    rf_prodengg = pickle.load(f2)
+with open('rf_hacathon_mkt.pkl', 'rb') as f3:
+    rf_mkt = pickle.load(f3)
 
-    def forward(self, x):
-        x = torch.relu(self.fc1(x))
-        x = self.fc2(x)
-        return x
 
-# Load and preprocess data
-df = pd.read_csv("Placement (2).csv")
-df = df.drop(columns=["sl_no","stream","ssc_p","ssc_b","hsc_p","hsc_b","etest_p"])
-df['internship'] = df['internship'].map({'Yes':1,'No':0})
-df['status'] = df['status'].map({'Placed':1,'Not Placed':0})
+# Define input and output functions for Gradio
+def predict_placement(option, degree_p, internship, DSA, java, management,
+                      leadership, communication, sales):
+    if option == "Fullstack":
+        new_data = pd.DataFrame(
+            {
+                'degree_p': degree_p,
+                'internship': internship,
+                'DSA': DSA,
+                'java': java,
+            },
+            index=[0])
+        prediction = rf_fullstk.predict(new_data)
+        probability = rf_fullstk.predict_proba(new_data)[0][1]
+    elif option == "Marketing":
+        new_data = pd.DataFrame(
+            {
+                'degree_p': degree_p,
+                'internship': internship,
+                'management': management,
+                'leadership': leadership,
+            },
+            index=[0])
+        prediction = rf_mkt.predict(new_data)
+        probability = rf_mkt.predict_proba(new_data)[0][1]
 
-X_fullstk = df.drop(['status','management','leadership','communication','sales'], axis=1)
-y = df['status']
+    elif option == "Production Engineer":
+        new_data = pd.DataFrame(
+            {
+                'degree_p': degree_p,
+                'internship': internship,
+                'communication': communication,
+                'sales': sales,
+            },
+            index=[0])
+        prediction = rf_prodengg.predict(new_data)
+        probability = rf_prodengg.predict_proba(new_data)[0][1]
 
-X_train_fullstk, X_test_fullstk, y_train, y_test = train_test_split(X_fullstk, y, test_size=0.20, random_state=42)
+    else:
+        return "Invalid option"
 
-# Define model hyperparameters
-input_size = X_fullstk.shape[1]
-hidden_size = 128
-output_size = 2
-learning_rate = 0.01
-epochs = 100
+    if prediction == 1:
+        return f"{probability:.2f}"
+    else:
+        return f"{probability:.2f}"
 
-# Initialize model
-model = PlacementModel(input_size, hidden_size, output_size)
-criterion = nn.CrossEntropyLoss()
-optimizer = optim.Adam(model.parameters(), lr=learning_rate)
 
-# Train model
-for epoch in range(epochs):
-    inputs = torch.tensor(X_train_fullstk.values, dtype=torch.float32)
-    labels = torch.tensor(y_train.values, dtype=torch.long)
+# Create Gradio interface
+iface = gr.Interface(
+    fn=predict_placement,
+    inputs=[
+        gr.inputs.Dropdown(["Fullstack", "Marketing", "Production Engineer"],
+                           label="Select Option"),
+        gr.inputs.Number(label="Degree Percentage"),
+        gr.inputs.Number(label="Internship"),
+        gr.inputs.Checkbox(label="DSA"),
+        gr.inputs.Checkbox(label="Java"),
+        gr.inputs.Checkbox(label="Management"),
+        gr.inputs.Checkbox(label="Leadership"),
+        gr.inputs.Checkbox(label="Communication"),
+        gr.inputs.Checkbox(label="Sales"),
+    ],
+    outputs=gr.outputs.Textbox(label="Placement Prediction"),
+    title="Placement Prediction",
+    description=
+    "Predict the chances of placement for different job roles using machine learning models.",
+)
 
-    optimizer.zero_grad()
-
-    outputs = model(inputs)
-    loss = criterion(outputs, labels)
-    loss.backward()
-    optimizer.step()
-
-    if epoch % 10 == 0:
-        print(f'Epoch [{epoch+1}/{epochs}], Loss: {loss.item():.4f}')
-
-# Evaluate model
-with torch.no_grad():
-    inputs = torch.tensor(X_test_fullstk.values, dtype=torch.float32)
-    labels = torch.tensor(y_test.values, dtype=torch.long)
-
-    outputs = model(inputs)
-    _, predicted = torch.max(outputs.data, 1)
-    accuracy = accuracy_score(labels, predicted)
-
-    print(f'Test Accuracy: {accuracy:.4f}')
-
-# Save model
-torch.save(model.state_dict(), 'placement_model.pth')
+# Launch Gradio app
+iface.launch(share=True)