six

app.py

@@ -2,9 +2,8 @@ import streamlit as st
 import pandas as pd
 import pickle
 import numpy as np
-from sklearn.feature_extraction.text import TfidfVectorizer
-from sklearn.multioutput import MultiOutputClassifier
 import os
+from datetime import datetime
 
 # Konfigurasi halaman
 st.set_page_config(
@@ -13,23 +12,27 @@ st.set_page_config(
     layout="wide"
 )
 
-# Fungsi untuk memuat model dan vectorizer
-@st.cache_resource
+# Judul aplikasi
+st.title("🍽️ Sistem Prediksi Alergen Makanan")
+st.markdown("---")
+
+# Cache untuk memuat model
+@st.cache_data
 def load_models():
-    """Memuat semua model dan TF-IDF vectorizer"""
+    """Memuat semua model dan vectorizer yang tersimpan"""
     models = {}
     model_files = {
-        'XGBoost': 'saved_models/XGBoost_model.pkl',
-        'KNN': 'saved_models/KNN_model.pkl',
-        'Random Forest': 'saved_models/Random Forest_model.pkl'
+        "XGBoost": "models/XGBoost_model.pkl",
+        "KNN": "models/KNN_model.pkl", 
+        "Random Forest": "models/Random Forest_model.pkl"
     }
     
-    # Load TF-IDF Vectorizer
+    # Load TF-IDF vectorizer
     try:
-        with open('saved_models/tfidf_vectorizer.pkl', 'rb') as f:
+        with open('models/tfidf_vectorizer.pkl', 'rb') as f:
             tfidf_vectorizer = pickle.load(f)
     except FileNotFoundError:
-        st.error("❌ TF-IDF Vectorizer tidak ditemukan! Pastikan file 'saved_models/tfidf_vectorizer.pkl' tersedia.")
+        st.error("❌ TF-IDF vectorizer tidak ditemukan! Pastikan file 'models/tfidf_vectorizer.pkl' ada.")
         return None, None
     
     # Load models
@@ -44,188 +47,176 @@ def load_models():
 
 # Fungsi prediksi
 def predict_allergens(text, model, vectorizer):
-    """Melakukan prediksi alergen berdasarkan teks input"""
-    # Transform text menggunakan TF-IDF
-    text_tfidf = vectorizer.transform([text])
+    """Melakukan prediksi alergen dari teks input"""
+    # Transform text menggunakan TF-IDF vectorizer
+    text_vector = vectorizer.transform([text])
     
     # Prediksi
-    prediction = model.predict(text_tfidf)
-    prediction_proba = model.predict_proba(text_tfidf)
+    prediction = model.predict(text_vector)
+    prediction_proba = model.predict_proba(text_vector)
     
     return prediction[0], prediction_proba
 
+# Load models
+models, tfidf_vectorizer = load_models()
+
+if models is None or tfidf_vectorizer is None:
+    st.stop()
+
+# Sidebar untuk pemilihan model
+st.sidebar.header("⚙️ Pengaturan")
+selected_model = st.sidebar.selectbox(
+    "Pilih Model:",
+    list(models.keys()),
+    help="Pilih model machine learning untuk prediksi"
+)
+
 # Label alergen
-ALLERGEN_LABELS = ['Susu', 'Kacang', 'Telur', 'Makanan Laut', 'Gandum']
-ALLERGEN_EMOJIS = ['🥛', '🥜', '🥚', '🦐', '🌾']
+allergen_labels = ['Susu', 'Kacang', 'Telur', 'Makanan Laut', 'Gandum']
+allergen_emojis = ['🥛', '🥜', '🥚', '🦐', '🌾']
 
-def main():
-    st.title("🍽️ Sistem Prediksi Alergen Makanan")
-    st.markdown("---")
-    
-    # Load models
-    models, tfidf_vectorizer = load_models()
-    
-    if models is None or tfidf_vectorizer is None:
-        st.stop()
-    
-    # Sidebar untuk konfigurasi
-    st.sidebar.header("⚙️ Konfigurasi")
-    
-    # Pilihan model
-    available_models = list(models.keys())
-    if available_models:
-        selected_model = st.sidebar.selectbox(
-            "Pilih Model:",
-            available_models,
-            help="Pilih model machine learning untuk prediksi"
-        )
-    else:
-        st.error("❌ Tidak ada model yang tersedia!")
-        st.stop()
-    
-    # Threshold untuk prediksi
-    threshold = st.sidebar.slider(
-        "Threshold Prediksi:",
-        min_value=0.1,
-        max_value=0.9,
-        value=0.5,
-        step=0.1,
-        help="Nilai ambang batas untuk menentukan prediksi positif"
+# Main interface
+col1, col2 = st.columns([2, 1])
+
+with col1:
+    st.header("📝 Input Teks Makanan")
+    
+    # Text input
+    user_input = st.text_area(
+        "Masukkan deskripsi makanan atau ingredients:",
+        placeholder="Contoh: nasi goreng dengan telur, udang, dan kacang tanah",
+        height=100
     )
     
-    # Main interface
-    col1, col2 = st.columns([2, 1])
-    
-    with col1:
-        st.header("📝 Input Makanan")
-        
-        # Text input
-        food_text = st.text_area(
-            "Masukkan deskripsi makanan atau bahan-bahan:",
-            placeholder="Contoh: nasi goreng dengan telur, udang, dan kecap manis",
-            height=150,
-            help="Masukkan deskripsi makanan atau daftar bahan-bahan yang ingin diprediksi"
-        )
-        
-        # Tombol prediksi
-        predict_button = st.button("🔍 Prediksi Alergen", type="primary")
-        
-        # Contoh input
-        st.subheader("💡 Contoh Input:")
-        examples = [
-            "nasi goreng dengan telur dan kecap manis",
-            "roti gandum dengan selai kacang",
-            "sup seafood dengan udang dan cumi",
-            "kue coklat dengan susu dan mentega",
-            "salad buah dengan yogurt"
-        ]
-        
-        for i, example in enumerate(examples):
-            if st.button(f"📋 {example}", key=f"example_{i}"):
-                st.session_state.food_text = example
-                st.rerun()
-        
-        # Update text area jika ada contoh yang dipilih
-        if 'food_text' in st.session_state:
-            food_text = st.session_state.food_text
-    
-    with col2:
-        st.header("ℹ️ Informasi Model")
-        
-        if selected_model in models:
-            st.success(f"✅ Model aktif: **{selected_model}**")
-            
-            # Informasi tentang alergen
-            st.subheader("🏷️ Alergen yang Diprediksi:")
-            for emoji, label in zip(ALLERGEN_EMOJIS, ALLERGEN_LABELS):
-                st.write(f"{emoji} {label}")
-    
-    # Hasil prediksi
-    if predict_button and food_text.strip():
-        st.markdown("---")
-        st.header("📊 Hasil Prediksi")
+    # Contoh input
+    st.subheader("💡 Contoh Input:")
+    examples = [
+        "pizza dengan keju mozzarella dan seafood",
+        "roti gandum dengan selai kacang",
+        "cake coklat dengan butter dan telur",
+        "sup tom yum dengan udang dan cumi",
+        "mie instan rasa ayam"
+    ]
+    
+    example_cols = st.columns(len(examples))
+    for i, example in enumerate(examples):
+        if example_cols[i].button(f"Contoh {i+1}", help=example):
+            user_input = example
+            st.rerun()
+
+with col2:
+    st.header("ℹ️ Informasi Model")
+    if selected_model in models:
+        st.success(f"✅ Model {selected_model} siap digunakan")
+        st.info(f"📊 Jumlah label: {len(allergen_labels)}")
         
-        with st.spinner("Sedang memproses prediksi..."):
+        # Model info
+        model_info = {
+            "XGBoost": "Gradient Boosting yang efisien",
+            "KNN": "K-Nearest Neighbors",
+            "Random Forest": "Ensemble dari decision trees"
+        }
+        st.write(f"**Deskripsi:** {model_info.get(selected_model, 'Model machine learning')}")
+
+# Prediksi
+if st.button("🔍 Prediksi Alergen", type="primary", use_container_width=True):
+    if user_input.strip():
+        with st.spinner("Sedang melakukan prediksi..."):
             try:
-                # Dapatkan prediksi
-                predictions, probabilities = predict_allergens(
-                    food_text, 
+                # Prediksi
+                prediction, prediction_proba = predict_allergens(
+                    user_input, 
                     models[selected_model], 
                     tfidf_vectorizer
                 )
                 
-                # Tampilkan hasil dalam bentuk kolom
-                result_cols = st.columns(len(ALLERGEN_LABELS))
+                st.markdown("---")
+                st.header("📊 Hasil Prediksi")
                 
-                detected_allergens = []
+                # Hasil prediksi dalam bentuk metrics
+                st.subheader("🎯 Deteksi Alergen")
                 
-                for i, (col, label, emoji) in enumerate(zip(result_cols, ALLERGEN_LABELS, ALLERGEN_EMOJIS)):
-                    with col:
-                        # Ambil probabilitas untuk label ini
-                        if hasattr(models[selected_model], 'predict_proba'):
-                            try:
-                                proba = probabilities[i][0][1] if len(probabilities[i][0]) > 1 else probabilities[i][0][0]
-                            except:
-                                proba = 0.5  # Default jika error
-                        else:
-                            proba = predictions[i]
-                        
-                        # Tentukan status berdasarkan threshold
-                        is_detected = predictions[i] == 1 or proba >= threshold
-                        
-                        if is_detected:
-                            st.error(f"{emoji} **{label}**\n\n⚠️ TERDETEKSI\n\n({proba:.2%})")
+                # Buat columns untuk menampilkan hasil
+                cols = st.columns(len(allergen_labels))
+                
+                detected_allergens = []
+                for i, (label, emoji) in enumerate(zip(allergen_labels, allergen_emojis)):
+                    with cols[i]:
+                        if prediction[i] == 1:
+                            st.success(f"{emoji} **{label}**\n\n✅ **TERDETEKSI**")
                             detected_allergens.append(label)
                         else:
-                            st.success(f"{emoji} **{label}**\n\n✅ AMAN\n\n({proba:.2%})")
-                
-                # Ringkasan hasil
-                st.subheader("📋 Ringkasan Hasil")
+                            st.info(f"{emoji} **{label}**\n\n❌ Tidak terdeteksi")
                 
+                # Ringkasan
+                st.subheader("📋 Ringkasan")
                 if detected_allergens:
-                    st.warning(f"⚠️ **PERINGATAN ALERGEN TERDETEKSI:**")
-                    for allergen in detected_allergens:
-                        st.write(f"• {allergen}")
-                    
-                    st.info("💡 **Saran:** Hindari makanan ini jika Anda memiliki alergi terhadap bahan-bahan yang terdeteksi.")
+                    st.warning(f"⚠️ **Alergen terdeteksi:** {', '.join(detected_allergens)}")
+                    st.write("**Rekomendasi:** Harap berhati-hati jika Anda memiliki alergi terhadap bahan-bahan tersebut.")
                 else:
-                    st.success("✅ **TIDAK ADA ALERGEN TERDETEKSI**")
-                    st.info("💡 Makanan ini kemungkinan aman dari alergen yang diprediksi oleh sistem.")
+                    st.success("✅ **Tidak ada alergen utama yang terdeteksi**")
+                    st.write("**Catatan:** Selalu periksa label produk untuk memastikan keamanan.")
                 
-                # Detail teknis (collapsible)
-                with st.expander("🔧 Detail Teknis"):
-                    st.write(f"**Model yang digunakan:** {selected_model}")
-                    st.write(f"**Threshold:** {threshold}")
-                    st.write(f"**Input text:** {food_text}")
+                # Probability scores (jika tersedia)
+                try:
+                    st.subheader("📈 Tingkat Kepercayaan")
+                    prob_data = []
+                    
+                    for i, (label, emoji) in enumerate(zip(allergen_labels, allergen_emojis)):
+                        # Ambil probabilitas untuk kelas positif (indeks 1)
+                        if hasattr(prediction_proba[i], 'shape') and len(prediction_proba[i][0]) > 1:
+                            prob = prediction_proba[i][0][1]  # Probabilitas kelas 1 (positif)
+                        else:
+                            prob = 0.5  # Default jika tidak ada probabilitas
+                        
+                        prob_data.append({
+                            'Alergen': f"{emoji} {label}",
+                            'Probabilitas': prob,
+                            'Persentase': f"{prob*100:.1f}%"
+                        })
+                    
+                    prob_df = pd.DataFrame(prob_data)
                     
-                    # Tabel detail probabilitas
-                    detail_df = pd.DataFrame({
-                        'Alergen': ALLERGEN_LABELS,
-                        'Prediksi': ['Ya' if p == 1 else 'Tidak' for p in predictions],
-                        'Probabilitas': [f"{(probabilities[i][0][1] if len(probabilities[i][0]) > 1 else probabilities[i][0][0]):.2%}" 
-                                       if hasattr(models[selected_model], 'predict_proba') else f"{p:.0%}" 
-                                       for i, p in enumerate(predictions)]
-                    })
-                    st.dataframe(detail_df, use_container_width=True)
+                    # Progress bars
+                    for _, row in prob_df.iterrows():
+                        st.write(f"**{row['Alergen']}**")
+                        st.progress(row['Probabilitas'])
+                        st.write(f"Kepercayaan: {row['Persentase']}")
+                        st.write("")
+                
+                except Exception as e:
+                    st.info("💡 Tingkat kepercayaan tidak tersedia untuk model ini")
+                
+                # Timestamp
+                st.markdown("---")
+                st.caption(f"Prediksi dilakukan pada: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
                 
             except Exception as e:
                 st.error(f"❌ Terjadi kesalahan saat prediksi: {str(e)}")
-                st.write("Pastikan model dan vectorizer telah dimuat dengan benar.")
-    
-    elif predict_button and not food_text.strip():
-        st.warning("⚠️ Silakan masukkan deskripsi makanan terlebih dahulu!")
-    
-    # Footer
-    st.markdown("---")
-    st.markdown(
-        """
-        <div style='text-align: center; color: gray;'>
-        🔬 Sistem Prediksi Alergen Makanan menggunakan Machine Learning<br>
-        ⚠️ Hasil prediksi bersifat estimasi. Selalu konsultasikan dengan ahli gizi untuk keputusan medis.
-        </div>
-        """, 
-        unsafe_allow_html=True
-    )
+                st.write("Pastikan semua file model sudah tersedia dan format input benar.")
+    else:
+        st.warning("⚠️ Silakan masukkan teks untuk prediksi!")
+
+# Footer
+st.markdown("---")
+st.markdown("""
+### 📌 Catatan Penting:
+- Sistem ini adalah alat bantu dan tidak menggantikan konsultasi medis profesional
+- Selalu periksa label produk dan konsultasikan dengan dokter untuk alergi yang serius
+- Akurasi prediksi tergantung pada kualitas data training dan input yang diberikan
+""")
+
+# Informasi tambahan di sidebar
+st.sidebar.markdown("---")
+st.sidebar.header("📋 Informasi Alergen")
+st.sidebar.markdown("""
+**Alergen yang dideteksi:**
+- 🥛 **Susu**: Produk dairy, keju, yogurt
+- 🥜 **Kacang**: Kacang tanah, almond, dll
+- 🥚 **Telur**: Telur ayam dan produk turunannya
+- 🦐 **Makanan Laut**: Udang, ikan, kerang
+- 🌾 **Gandum**: Tepung terigu, roti, pasta
+""")
 
-if __name__ == "__main__":
-    main()
+st.sidebar.markdown("---")
+st.sidebar.info("💡 **Tips:** Semakin detail deskripsi makanan yang Anda berikan, semakin akurat hasil prediksinya.")

requirements.txt

@@ -3,4 +3,4 @@ pandas
 scikit-learn
 xgboost
 numpy
-pickle-mixin
+pickle