Update app.py

app.py

@@ -4,6 +4,10 @@ import gradio as gr
 
 SPD = Table.read_table('Student_Performance_Data.csv')
 
+# =========================
+# SHARED FEATURE ENGINEERING
+# =========================
+
 def study_effectiveness(study_time, absences, parental_support, tutoring):
     return (study_time * 1.5) + (parental_support * 2) + (tutoring * 3) - (absences * 0.7)
 
@@ -17,6 +21,166 @@ effectiveness_scores = SPD.apply(
 
 SPD = SPD.with_column('StudyEffectiveness', effectiveness_scores)
 
+# =========================================================
+# DECISION TREE MODEL (EXACT CODE YOU PROVIDED)
+# =========================================================
+
+def predict_pass(study_time, absences, parental_support, tutoring, extracurricular, sports, music, volunteering, effectiveness):
+
+    if effectiveness >= 18:
+        return True
+
+    elif effectiveness >= 14:
+        if absences <= 18:
+            return True
+        else:
+            return False
+
+    elif effectiveness >= 10:
+        if study_time >= 10 and absences <= 12:
+            return True
+        elif tutoring == 1 and parental_support >= 3:
+            return True
+        else:
+            return False
+
+    elif effectiveness >= 6:
+        if study_time >= 12 and absences < 8:
+            return True
+        elif extracurricular == 1 or sports == 1 or music == 1 or volunteering == 1:
+            if absences < 12 and parental_support >= 2:
+                return True
+            else:
+                return False
+        else:
+            return False
+
+    else:
+        return False
+
+
+predicted = SPD.apply(
+    predict_pass,
+    'StudyTimeWeekly',
+    'Absences',
+    'ParentalSupport',
+    'Tutoring',
+    'Extracurricular',
+    'Sports',
+    'Music',
+    'Volunteering',
+    'StudyEffectiveness'
+)
+
+
+def actual_pass(grade):
+    if grade == 4:
+        return False
+    else:
+        return True
+
+
+true_labels = SPD.apply(actual_pass, 'GradeClass')
+
+correct = predicted == true_labels
+accuracy_tree = sum(correct) / len(correct)
+
+SPD = SPD.with_columns(
+    'predicted_pass', predicted,
+    'true_pass', true_labels,
+    'correct', correct
+)
+
+# =========================================================
+# KNN MODEL (EXACT CODE YOU PROVIDED)
+# =========================================================
+
+def pass_fail(x):
+    if x == 4:
+        return 0
+    else:
+        return 1
+
+passes_knn = SPD.apply(pass_fail, 'GradeClass')
+SPD = SPD.with_column('PassFail', passes_knn)
+
+data = SPD.select(
+    'Age',
+    'Gender',
+    'Ethnicity',
+    'ParentalEducation',
+    'StudyTimeWeekly',
+    'Absences',
+    'Tutoring',
+    'ParentalSupport',
+    'Extracurricular',
+    'Sports',
+    'Music',
+    'Volunteering',
+    'StudyEffectiveness',
+    'PassFail'
+)
+
+np.random.seed(1)
+shuffled = data.sample(with_replacement=False)
+size = int(data.num_rows * 0.8)
+
+train = shuffled.take(np.arange(size))
+test = shuffled.take(np.arange(size, data.num_rows))
+
+
+def distance(r1, r2):
+    total = 0
+    total += (r1.item('Age') - r2.item('Age'))**2
+    total += (r1.item('Gender') - r2.item('Gender'))**2
+    total += (r1.item('Ethnicity') - r2.item('Ethnicity'))**2
+    total += (r1.item('ParentalEducation') - r2.item('ParentalEducation'))**2
+    total += (r1.item('StudyTimeWeekly') - r2.item('StudyTimeWeekly'))**2
+    total += (r1.item('Absences') - r2.item('Absences'))**2
+    total += (r1.item('Tutoring') - r2.item('Tutoring'))**2
+    total += (r1.item('ParentalSupport') - r2.item('ParentalSupport'))**2
+    total += (r1.item('Extracurricular') - r2.item('Extracurricular'))**2
+    total += (r1.item('Sports') - r2.item('Sports'))**2
+    total += (r1.item('Music') - r2.item('Music'))**2
+    total += (r1.item('Volunteering') - r2.item('Volunteering'))**2
+    total += (r1.item('StudyEffectiveness') - r2.item('StudyEffectiveness'))**2
+    return np.sqrt(total)
+
+
+def knn(test_row, k):
+    dists = make_array()
+
+    for i in np.arange(train.num_rows):
+        row = train.row(i)
+        d = distance(test_row, row)
+        dists = np.append(dists, d)
+
+    temp = train.with_column('Distance', dists)
+    nearest = temp.sort('Distance').take(np.arange(k))
+    total = np.sum(nearest.column('PassFail'))
+
+    if total > k / 2:
+        return 1
+    else:
+        return 0
+
+
+k = 5
+
+predictions_knn = make_array()
+
+for i in np.arange(test.num_rows):
+    row = test.row(i)
+    p = knn(row, k)
+    predictions_knn = np.append(predictions_knn, p)
+
+actual = test.column('PassFail')
+accuracy_knn = np.mean(predictions_knn == actual)
+
+# =========================================================
+# NEURAL NETWORK MODEL (EXACT CODE YOU PROVIDED)
+# =========================================================
+
 def pass_or_fail(grade):
     if grade == 4:
         return 0
@@ -29,7 +193,7 @@ SPD = SPD.with_column('Pass', passes)
 X = []
 
 for i in np.arange(SPD.num_rows):
-    X.append([
+    row = [
         SPD.column('StudyTimeWeekly').item(i) / 20,
         SPD.column('Absences').item(i) / 30,
         SPD.column('Tutoring').item(i),
@@ -39,67 +203,186 @@ for i in np.arange(SPD.num_rows):
         SPD.column('Music').item(i),
         SPD.column('Volunteering').item(i),
         SPD.column('StudyEffectiveness').item(i) / 40
-    ])
+    ]
+    X.append(row)
 
 X = np.array(X)
 y = np.array(SPD.column('Pass'))
 
 np.random.seed(1)
+
 W1 = np.random.normal(0, 1, (9, 16))
 W2 = np.random.normal(0, 1, (16, 1))
 
+
 def sigmoid(x):
     return 1 / (1 + np.exp(-x))
 
+
 for i in range(20000):
     hidden = sigmoid(np.dot(X, W1))
     output = sigmoid(np.dot(hidden, W2))
+
     error = y.reshape(len(y), 1) - output
+
     output_change = error * output * (1 - output)
+
     hidden_error = np.dot(output_change, W2.T)
     hidden_change = hidden_error * hidden * (1 - hidden)
-    W2 += 0.001 * np.dot(hidden.T, output_change)
-    W1 += 0.001 * np.dot(X.T, hidden_change)
+
+    W2 = W2 + 0.001 * np.dot(hidden.T, output_change)
+    W1 = W1 + 0.001 * np.dot(X.T, hidden_change)
 
 hidden = sigmoid(np.dot(X, W1))
 output = sigmoid(np.dot(hidden, W2))
+
 predictions = output > 0.5
-accuracy_nn = np.mean(predictions.flatten() == y)
-
-def predict(student_time, absences, tutoring, parental_support, extracurricular, sports, music, volunteering):
-    study_effect = (student_time * 1.5) + (parental_support * 2) + (tutoring * 3) - (absences * 0.7)
-
-    x = np.array([
-        student_time / 20,
-        absences / 30,
-        tutoring,
-        parental_support / 4,
-        extracurricular,
-        sports,
-        music,
-        volunteering,
-        study_effect / 40
-    ])
-
-    hidden = sigmoid(np.dot(x, W1))
-    output = sigmoid(np.dot(hidden, W2))
+correct = predictions.flatten() == y
+
+accuracy_nn = np.mean(correct)
+
+# =========================================================
+# GRADIO PREDICTION FUNCTION
+# =========================================================
+
+def predict_model(
+    model_choice,
+    student_time,
+    absences,
+    tutoring,
+    parental_support,
+    extracurricular,
+    sports,
+    music,
+    volunteering
+):
+
+    study_effect = (
+        (student_time * 1.5)
+        + (parental_support * 2)
+        + (tutoring * 3)
+        - (absences * 0.7)
+    )
+
+    # =====================
+    # DECISION TREE
+    # =====================
+    if model_choice == "Decision Tree":
 
-    result = "PASS" if output[0] > 0.5 else "FAIL"
-    confidence = float(output[0])
+        result = predict_pass(
+            student_time,
+            absences,
+            parental_support,
+            tutoring,
+            extracurricular,
+            sports,
+            music,
+            volunteering,
+            study_effect
+        )
 
-    return result, round(confidence, 4)
+        prediction = "PASS" if result else "FAIL"
+
+        return prediction, round(float(accuracy_tree), 4)
+
+    # =====================
+    # KNN
+    # =====================
+    elif model_choice == "KNN":
+
+        test_row = Table().with_columns(
+            'Age', [17],
+            'Gender', [0],
+            'Ethnicity', [0],
+            'ParentalEducation', [2],
+            'StudyTimeWeekly', [student_time],
+            'Absences', [absences],
+            'Tutoring', [int(tutoring)],
+            'ParentalSupport', [parental_support],
+            'Extracurricular', [int(extracurricular)],
+            'Sports', [int(sports)],
+            'Music', [int(music)],
+            'Volunteering', [int(volunteering)],
+            'StudyEffectiveness', [study_effect],
+            'PassFail', [0]
+        ).row(0)
+
+        result = knn(test_row, k)
+
+        prediction = "PASS" if result == 1 else "FAIL"
+
+        return prediction, round(float(accuracy_knn), 4)
+
+    # =====================
+    # NEURAL NETWORK
+    # =====================
+    elif model_choice == "Neural Network":
+
+        x = np.array([
+            student_time / 20,
+            absences / 30,
+            tutoring,
+            parental_support / 4,
+            extracurricular,
+            sports,
+            music,
+            volunteering,
+            study_effect / 40
+        ])
+
+        hidden = sigmoid(np.dot(x, W1))
+        output = sigmoid(np.dot(hidden, W2))
+
+        prediction = "PASS" if output[0] > 0.5 else "FAIL"
+
+        return prediction, round(float(output[0]), 4)
+
+# =========================================================
+# GRADIO UI
+# =========================================================
 
 theme = gr.themes.Soft()
 
 with gr.Blocks(theme=theme) as app:
+
     gr.Markdown("# Student Performance Predictor")
-    gr.Markdown("Predict whether a student will pass or fail based on academic behavior and activities.")
+
+    gr.Markdown(
+        "Select a machine learning model and predict whether a student will pass or fail."
+    )
 
     with gr.Row():
+
         with gr.Column():
-            student_time = gr.Slider(0, 20, value=10, label="Study Time Weekly")
-            absences = gr.Slider(0, 30, value=5, label="Absences")
-            parental_support = gr.Slider(0, 4, value=2, step=1, label="Parental Support")
+
+            model_choice = gr.Dropdown(
+                choices=[
+                    "Decision Tree",
+                    "KNN",
+                    "Neural Network"
+                ],
+                value="Neural Network",
+                label="Select Model"
+            )
+
+            student_time = gr.Slider(
+                0, 20,
+                value=10,
+                label="Study Time Weekly"
+            )
+
+            absences = gr.Slider(
+                0, 30,
+                value=5,
+                label="Absences"
+            )
+
+            parental_support = gr.Slider(
+                0, 4,
+                value=2,
+                step=1,
+                label="Parental Support"
+            )
 
             tutoring = gr.Checkbox(label="Tutoring")
             extracurricular = gr.Checkbox(label="Extracurricular Activities")
@@ -107,18 +390,43 @@ with gr.Blocks(theme=theme) as app:
             music = gr.Checkbox(label="Music")
             volunteering = gr.Checkbox(label="Volunteering")
 
-            btn = gr.Button("Predict", variant="primary")
+            btn = gr.Button(
+                "Predict",
+                variant="primary"
+            )
 
         with gr.Column():
+
             result = gr.Textbox(label="Prediction")
-            confidence = gr.Number(label="Confidence Score")
+
+            confidence = gr.Number(
+                label="Confidence / Accuracy"
+            )
 
     btn.click(
-        predict,
-        inputs=[student_time, absences, tutoring, parental_support, extracurricular, sports, music, volunteering],
-        outputs=[result, confidence]
+        predict_model,
+        inputs=[
+            model_choice,
+            student_time,
+            absences,
+            tutoring,
+            parental_support,
+            extracurricular,
+            sports,
+            music,
+            volunteering
+        ],
+        outputs=[
+            result,
+            confidence
+        ]
     )
 
-    gr.Markdown(f"Model training accuracy: {accuracy_nn:.3f}")
+    gr.Markdown(f"""
+### Model Training Accuracy
+- Decision Tree: {accuracy_tree:.3f}
+- KNN: {accuracy_knn:.3f}
+- Neural Network: {accuracy_nn:.3f}
+""")
 
 app.launch()