small change

app.py

@@ -1,203 +1,205 @@
-import gradio as gr
-import torch
-import joblib
-import pandas as pd
-import numpy as np
-from scipy.spatial.distance import cosine
-from pathlib import Path
-import os
-
-# Define the model architecture (same as in training)
-class AESModel(torch.nn.Module):
-    def __init__(self, input_dim, hidden_dim=512, num_layers=3, dropout=0.4):
-        super(AESModel, self).__init__()
-        self.input_layer = torch.nn.Sequential(
-            torch.nn.Linear(input_dim, hidden_dim),
-            torch.nn.BatchNorm1d(hidden_dim),
-            torch.nn.ReLU(),
-            torch.nn.Dropout(dropout)
-        )
-        self.hidden_layers = torch.nn.ModuleList()
-        for _ in range(num_layers - 1):
-            self.hidden_layers.append(torch.nn.Sequential(
-                torch.nn.Linear(hidden_dim, hidden_dim),
-                torch.nn.BatchNorm1d(hidden_dim),
-                torch.nn.ReLU(),
-                torch.nn.Dropout(dropout)
-            ))
-        self.output_layer = torch.nn.Sequential(
-            torch.nn.Linear(hidden_dim, 1),
-            torch.nn.Sigmoid()
-        )
-
-    def forward(self, x):
-        x = self.input_layer(x)
-        for layer in self.hidden_layers:
-            x = layer(x)
-        return self.output_layer(x) * 4
-
-# Load the saved model and components
-def load_components(model_dir='./final'):
-    try:
-        # Use CPU for Hugging Face Spaces deployment
-        device = torch.device('cpu')
-        
-        model_data = torch.load(f'{model_dir}/final_aes_model.pt', map_location='cpu', weights_only=False)
-        preprocessor = joblib.load(f'{model_dir}/preprocessor.pkl')
-        jawaban_essay = pd.read_pickle(f'{model_dir}/jawaban_essay.pkl')
-        training_config = joblib.load(f'{model_dir}/training_config.pkl')
-
-        model = AESModel(
-            input_dim=training_config['model_architecture']['input_dim'],
-            hidden_dim=training_config['model_architecture']['hidden_dim'],
-            num_layers=training_config['model_architecture']['num_layers'],
-            dropout=training_config['model_architecture']['dropout']
-        )
-        model.load_state_dict(model_data['model_state_dict'])
-        model.to(device)
-        model.eval()
-
-        return model, preprocessor, jawaban_essay, device
-    except Exception as e:
-        print(f"Error loading model components: {e}")
-        return None, None, None, None
-
-# Prediction function that returns multiple outputs
-def predict_score(question_code, student_answer, model, preprocessor, jawaban_essay, device):
-    try:
-        question_code = int(question_code)
-        processed_text = preprocessor.preprocess_text(student_answer)
-
-        # Get the answer key for this question
-        kunci_jawaban = jawaban_essay[jawaban_essay['Kode'] == question_code]
-        if len(kunci_jawaban) == 0:
-            return "Error: Question code not found", "", "", ""
-
-        question_text = kunci_jawaban['Pertanyaan'].values[0]
-        key_answer = kunci_jawaban['Jawaban'].values[0]
-
-        # Extract features
-        linguistic_features = preprocessor.extract_linguistic_features(processed_text)
-        embedding = preprocessor.get_sbert_embedding(processed_text)
-        embedding_kunci = preprocessor.get_sbert_embedding(kunci_jawaban['processed_kunci_jawaban'].values[0])
-        similarity = 1 - cosine(embedding, embedding_kunci)
-
-        # Prepare feature vector
-        features = {
-            **{f'sbert_{i}': val for i, val in enumerate(embedding)},
-            **{f'ling_{k}': v for k, v in linguistic_features.items()},
-            'similarity': similarity
-        }
-        feature_values = np.array(list(features.values())).astype(np.float32).reshape(1, -1)
-
-        # Make prediction
-        with torch.no_grad():
-            input_tensor = torch.FloatTensor(feature_values).to(device)
-            prediction = model(input_tensor).item()
-            prediction = min(max(prediction, 0), 4)
-            prediction = round(prediction, 2)
-
-        return (f"Predicted Score: {prediction:.2f}/4.00",
-                f"Pertanyaan: {question_text}",
-                f"Kunci Jawaban: {key_answer}",
-                f"Similarity dengan Kunci Jawaban: {similarity:.3f}")
-    except Exception as e:
-        return f"Error: {str(e)}", "", "", ""
-
-# Load components once at startup
-print("Loading model components...")
-model, preprocessor, jawaban_essay, device = load_components()
-
-if model is not None:
-    print("Model components loaded successfully!")
-else:
-    print("Failed to load model components. Running in demo mode.")
-
-# Create Gradio interface with multiple outputs
-def gradio_predict(question_code, student_answer):
-    if model is None or preprocessor is None:
-        return ("Error: Model not loaded", "Model tidak dapat dimuat", "", "")
-    return predict_score(question_code, student_answer, model, preprocessor, jawaban_essay, device)
-
-# Check if components are loaded before creating interface
-if jawaban_essay is not None:
-    # List of available question codes and their questions
-    question_info = [(f"{row['Kode']} - {row['Pertanyaan'][:50]}...", row['Kode'])
-                     for _, row in jawaban_essay.iterrows()]
-else:
-    # Fallback question info for demo
-    question_info = [("Demo - Model tidak dapat dimuat", 1)]
-
-# Create the Gradio app with enhanced display
-with gr.Blocks(title="Auto-Scoring Essay Indonesia", theme=gr.themes.Soft()) as app:
-    gr.Markdown("# 🎓 Sistem Auto-Scoring Essay Bahasa Indonesia")
-    gr.Markdown("Pilih pertanyaan dan masukkan jawaban siswa untuk mendapatkan prediksi nilai otomatis menggunakan AI.")
-    
-    if model is None:
-        gr.Markdown("⚠️ **Model sedang dimuat atau tidak tersedia. Silakan coba lagi nanti.**")
-
-    with gr.Row():
-        with gr.Column():
-            question_input = gr.Dropdown(
-                label="📝 Pilih Pertanyaan",
-                choices=[info[0] for info in question_info],
-                value=question_info[0][0] if question_info else None
-            )
-            actual_code = gr.Textbox(visible=False)  # Hidden field to store actual code
-            answer_input = gr.Textbox(
-                label="✍️ Jawaban Siswa",
-                placeholder="Masukkan jawaban siswa di sini...",
-                lines=8,
-                max_lines=15
-            )
-            submit_btn = gr.Button("🔍 Prediksi Nilai", variant="primary", size="lg")
-
-        with gr.Column():
-            output_score = gr.Textbox(label="📊 Hasil Prediksi", interactive=False)
-            output_question = gr.Textbox(label="❓ Detail Pertanyaan", interactive=False)
-            output_key = gr.Textbox(label="🔑 Kunci Jawaban", interactive=False)
-            output_similarity = gr.Textbox(label="📈 Similarity Score", interactive=False)
-
-    # Function to update hidden code when question selection changes
-    def update_code(question_choice):
-        for info in question_info:
-            if info[0] == question_choice:
-                return info[1]
-        return question_info[0][1] if question_info else 1
-
-    question_input.change(update_code, inputs=question_input, outputs=actual_code)
-
-    submit_btn.click(
-        fn=gradio_predict,
-        inputs=[actual_code, answer_input],
-        outputs=[output_score, output_question, output_key, output_similarity]
-    )
-
-    # Add some examples if model is loaded
-    if jawaban_essay is not None and len(question_info) > 0:
-        gr.Markdown("## 💡 Contoh Jawaban")
-        examples = [
-            [question_info[0][0], "Ancaman keamanan jaringan meliputi malware seperti virus dan trojan, serangan DDoS yang dapat melumpuhkan server, serta upaya phishing untuk mencuri data pribadi."],
-            [question_info[0][0], "Kebocoran data, penyusupan akun, penghapusan data, spam dan phising merupakan ancaman utama dalam keamanan jaringan komputer."],
-        ]
-        
-        if len(question_info) > 1:
-            examples.append([
-                question_info[1][0],
-                "Jaringan komputer adalah kumpulan komputer yang terhubung untuk berbagi sumber daya seperti file, printer, dan koneksi internet."
-            ])
-            
-        gr.Examples(
-            examples=examples,
-            inputs=[question_input, answer_input],
-            outputs=[output_score, output_question, output_key, output_similarity],
-            fn=gradio_predict,
-            cache_examples=False
-        )
-    
-    gr.Markdown("---")
-    gr.Markdown("*Sistem ini menggunakan AI untuk memberikan penilaian otomatis pada essay berbahasa Indonesia.*")
-
-# Launch the app
-if __name__ == "__main__":
-    app.launch()
+import gradio as gr
+import torch
+import joblib
+import pandas as pd
+import numpy as np
+from scipy.spatial.distance import cosine
+from pathlib import Path
+import os
+
+# Define the model architecture (same as in training)
+class AESModel(torch.nn.Module):
+    def __init__(self, input_dim, hidden_dim=512, num_layers=3, dropout=0.4):
+        super(AESModel, self).__init__()
+        self.input_layer = torch.nn.Sequential(
+            torch.nn.Linear(input_dim, hidden_dim),
+            torch.nn.BatchNorm1d(hidden_dim),
+            torch.nn.ReLU(),
+            torch.nn.Dropout(dropout)
+        )
+        self.hidden_layers = torch.nn.ModuleList()
+        for _ in range(num_layers - 1):
+            self.hidden_layers.append(torch.nn.Sequential(
+                torch.nn.Linear(hidden_dim, hidden_dim),
+                torch.nn.BatchNorm1d(hidden_dim),
+                torch.nn.ReLU(),
+                torch.nn.Dropout(dropout)
+            ))
+        self.output_layer = torch.nn.Sequential(
+            torch.nn.Linear(hidden_dim, 1),
+            torch.nn.Sigmoid()
+        )
+
+    def forward(self, x):
+        x = self.input_layer(x)
+        for layer in self.hidden_layers:
+            x = layer(x)
+        return self.output_layer(x) * 4
+
+# Load the saved model and components
+def load_components(model_dir='./final'):
+    try:
+        # Use CPU for Hugging Face Spaces deployment
+        device = torch.device('cpu')
+        
+        model_data = torch.load(f'{model_dir}/final_aes_model.pt', map_location='cpu', weights_only=False)
+        preprocessor = joblib.load(f'{model_dir}/preprocessor.pkl')
+        jawaban_essay = pd.read_pickle(f'{model_dir}/jawaban_essay.pkl')
+        training_config = joblib.load(f'{model_dir}/training_config.pkl')
+
+        model = AESModel(
+            input_dim=training_config['model_architecture']['input_dim'],
+            hidden_dim=training_config['model_architecture']['hidden_dim'],
+            num_layers=training_config['model_architecture']['num_layers'],
+            dropout=training_config['model_architecture']['dropout']
+        )
+        model.load_state_dict(model_data['model_state_dict'])
+        model.to(device)
+        model.eval()
+
+        return model, preprocessor, jawaban_essay, device
+    except Exception as e:
+        print(f"Error loading model components: {e}")
+        return None, None, None, None
+
+# Prediction function that returns multiple outputs
+def predict_score(question_code, student_answer, model, preprocessor, jawaban_essay, device):
+    try:
+        question_code = int(question_code)
+        processed_text = preprocessor.preprocess_text(student_answer)
+
+        # Get the answer key for this question
+        kunci_jawaban = jawaban_essay[jawaban_essay['Kode'] == question_code]
+        if len(kunci_jawaban) == 0:
+            return "Error: Question code not found", "", "", ""
+
+        question_text = kunci_jawaban['Pertanyaan'].values[0]
+        key_answer = kunci_jawaban['Jawaban'].values[0]
+
+        # Extract features
+        linguistic_features = preprocessor.extract_linguistic_features(processed_text)
+        embedding = preprocessor.get_sbert_embedding(processed_text)
+        embedding_kunci = preprocessor.get_sbert_embedding(kunci_jawaban['processed_kunci_jawaban'].values[0])
+        similarity = 1 - cosine(embedding, embedding_kunci)
+
+        # Prepare feature vector
+        features = {
+            **{f'sbert_{i}': val for i, val in enumerate(embedding)},
+            **{f'ling_{k}': v for k, v in linguistic_features.items()},
+            'similarity': similarity
+        }
+        feature_values = np.array(list(features.values())).astype(np.float32).reshape(1, -1)
+
+        # Make prediction
+        with torch.no_grad():
+            input_tensor = torch.FloatTensor(feature_values).to(device)
+            prediction = model(input_tensor).item()
+            prediction = min(max(prediction, 0), 4)
+            prediction = round(prediction, 2)
+
+        return (f"Predicted Score: {prediction:.2f}/4.00",
+                f"Pertanyaan: {question_text}",
+                f"Kunci Jawaban: {key_answer}",
+                f"Similarity dengan Kunci Jawaban: {similarity:.3f}")
+    except Exception as e:
+        return f"Error: {str(e)}", "", "", ""
+
+# Load components once at startup
+print("Loading model components...")
+model, preprocessor, jawaban_essay, device = load_components()
+
+if model is not None:
+    print("Model components loaded successfully!")
+else:
+    print("Failed to load model components. Running in demo mode.")
+
+# Create Gradio interface with multiple outputs
+def gradio_predict(question_code, student_answer):
+    if model is None or preprocessor is None:
+        return ("Error: Model not loaded", "Model tidak dapat dimuat", "", "")
+    return predict_score(question_code, student_answer, model, preprocessor, jawaban_essay, device)
+
+# Check if components are loaded before creating interface
+if jawaban_essay is not None:
+    # List of available question codes and their questions
+    question_info = [(f"{row['Kode']} - {row['Pertanyaan'][:50]}...", row['Kode'])
+                     for _, row in jawaban_essay.iterrows()]
+else:
+    # Fallback question info for demo
+    question_info = [("Demo - Model tidak dapat dimuat", 1)]
+
+# Create the Gradio app with enhanced display
+with gr.Blocks(title="Auto-Scoring Essay Indonesia", theme=gr.themes.Soft()) as app:
+    gr.Markdown("# 🎓 Sistem Auto-Scoring Essay Bahasa Indonesia")
+    gr.Markdown("Pilih pertanyaan dan masukkan jawaban siswa untuk mendapatkan prediksi nilai otomatis menggunakan AI.")
+    
+    if model is None:
+        gr.Markdown("⚠️ **Model sedang dimuat atau tidak tersedia. Silakan coba lagi nanti.**")
+
+    with gr.Row():
+        with gr.Column():
+            question_input = gr.Dropdown(
+                label="📝 Pilih Pertanyaan",
+                choices=[info[0] for info in question_info],
+                value=question_info[0][0] if question_info else None
+            )
+            actual_code = gr.Textbox(visible=False)  # Hidden field to store actual code
+            answer_input = gr.Textbox(
+                label="✍️ Jawaban Siswa",
+                placeholder="Masukkan jawaban siswa di sini...",
+                lines=8,
+                max_lines=15
+            )
+            submit_btn = gr.Button("🔍 Prediksi Nilai", variant="primary", size="lg")
+
+        with gr.Column():
+            output_score = gr.Textbox(label="📊 Hasil Prediksi", interactive=False)
+            output_question = gr.Textbox(label="❓ Detail Pertanyaan", interactive=False)
+            output_key = gr.Textbox(label="🔑 Kunci Jawaban", interactive=False)
+            output_similarity = gr.Textbox(label="📈 Similarity Score", interactive=False)
+
+    # Function to update hidden code when question selection changes
+    def update_code(question_choice):
+        for info in question_info:
+            if info[0] == question_choice:
+                return info[1]
+        return question_info[0][1] if question_info else 1
+
+    question_input.change(update_code, inputs=question_input, outputs=actual_code)
+
+    submit_btn.click(
+        fn=gradio_predict,
+        inputs=[actual_code, answer_input],
+        outputs=[output_score, output_question, output_key, output_similarity]
+    )
+
+    # Add some examples if model is loaded
+    if jawaban_essay is not None and len(question_info) > 0:
+        gr.Markdown("## 💡 Contoh Jawaban")
+        examples = [
+            [question_info[0][0], "Ancaman keamanan jaringan meliputi malware seperti virus dan trojan, serangan DDoS yang dapat melumpuhkan server, serta upaya phishing untuk mencuri data pribadi."],
+            [question_info[0][0], "Kebocoran data, penyusupan akun, penghapusan data, spam dan phising merupakan ancaman utama dalam keamanan jaringan komputer."],
+        ]
+        
+        if len(question_info) > 1:
+            examples.append([
+                question_info[1][0],
+                "Jaringan komputer adalah kumpulan komputer yang terhubung untuk berbagi sumber daya seperti file, printer, dan koneksi internet."
+            ])
+            
+        gr.Examples(
+            examples=examples,
+            inputs=[question_input, answer_input],
+            outputs=[output_score, output_question, output_key, output_similarity],
+            fn=gradio_predict,
+            cache_examples=False
+        )
+    
+    gr.Markdown("---")
+    gr.Markdown("*Sistem ini menggunakan AI untuk memberikan penilaian otomatis pada essay berbahasa Indonesia.*")
+
+
+# Launch the app
+if __name__ == "__main__":
+    print(torch.__version__)
+    app.launch()