Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,404 @@
-import altair as alt
-import numpy as np
-import pandas as pd
 import streamlit as st
+import pandas as pd
+import numpy as np
+
+st.set_page_config(page_title="SPK Pemilihan Cabang untuk Lokasi Coffeeshop", layout="wide")
+
+st.title("📊 Sistem Pendukung Keputusan Pemilihan Cabang untuk Lokasi Coffeeshop")
+st.markdown("Metode: AHP, TOPSIS, dan Profile Matching")
+
+# --- Step 1: Pilih Metode ---
+st.sidebar.header("⚙ Pengaturan")
+method = st.selectbox("🧠 Pilih Metode", ["None","TOPSIS", "Profile Matching", "AHP"], key="selected_method")
+
+criteria_default = "Building Area, Road Access, Distance, Rental Price"
+criteria_input = st.sidebar.text_area("Masukkan Kriteria (pisahkan dengan koma)", criteria_default)
+criteria = [c.strip() for c in criteria_input.split(",") if c.strip()]
+
+alternatives_default = "Location 1, Location 2, Location 3, Location 4"
+alternatives_input = st.sidebar.text_area("Masukkan Alternatif (pisahkan dengan koma)", alternatives_default)
+alternatives = [a.strip() for a in alternatives_input.split(",") if a.strip()]
+
+if not criteria or not alternatives:
+    st.warning("Masukkan minimal satu kriteria dan alternatif.")
+    st.stop()
+
+# ---------------------------
+if method == "AHP":
+    st.subheader("🔗 Perbandingan Berpasangan Antar Kriteria (AHP)")
+
+    pairwise_criteria_data = np.ones((len(criteria), len(criteria)))
+    for i in range(len(criteria)):
+        for j in range(i + 1, len(criteria)):
+            pairwise_criteria_data[i, j] = 1.0
+
+    pairwise_criteria_df = pd.DataFrame(pairwise_criteria_data, index=criteria, columns=criteria)
+
+    edited_pairwise_criteria_matrix = st.data_editor(
+        pairwise_criteria_df,
+        use_container_width=True,
+        key="pairwise_comparison_criteria_matrix",
+        hide_index=False,
+    )
+
+    # Reciprocity for criteria matrix
+    final_pairwise_criteria_matrix = edited_pairwise_criteria_matrix.copy()
+    for i in range(len(criteria)):
+        for j in range(i + 1, len(criteria)):
+            val = final_pairwise_criteria_matrix.iloc[i, j]
+            if val == 0:
+                val = 1e-9
+            final_pairwise_criteria_matrix.iloc[j, i] = 1 / val
+        final_pairwise_criteria_matrix.iloc[i, i] = 1.0
+
+    # Hitung bobot kriteria AHP
+    weights_ahp_criteria = pd.Series(dtype='float64')
+    if not final_pairwise_criteria_matrix.apply(pd.to_numeric, errors='coerce').isnull().values.any():
+        try:
+            numeric_criteria_matrix = final_pairwise_criteria_matrix.apply(pd.to_numeric)
+            norm_matrix = numeric_criteria_matrix / numeric_criteria_matrix.sum()
+            weights_ahp_criteria = norm_matrix.mean(axis=1)
+            weights_ahp_criteria /= weights_ahp_criteria.sum()
+            
+            st.write("🎯 Bobot Kriteria dari AHP:")
+            st.dataframe(weights_ahp_criteria.round(3).to_frame(name="Bobot AHP"))
+
+            RI = {1: 0.00, 2: 0.00, 3: 0.58, 4: 0.90, 5: 1.12, 6: 1.24, 7: 1.32, 8: 1.41, 9: 1.45, 10: 1.49}
+            n_criteria = len(criteria)
+            # Weighted Sum Vector (WSV)
+            wsv = numeric_criteria_matrix.dot(weights_ahp_criteria)
+            # λ_max manual: rata-rata dari WSV[i] / W[i]
+            lambda_max_criteria = (wsv / weights_ahp_criteria).mean()
+            # CI manual
+            CI_criteria = (lambda_max_criteria - n_criteria) / (n_criteria - 1) if n_criteria > 1 else 0
+
+            CR_criteria = np.nan
+            if n_criteria in RI and RI[n_criteria] > 0:
+                CR_criteria = CI_criteria / RI[n_criteria]
+
+            st.subheader("✅ Analisis Konsistensi Kriteria AHP")
+            st.write(f"$\\lambda_{{max}} = {lambda_max_criteria:.10f}$")
+            st.write(f"CI = {CI_criteria:.10f}")
+            if not np.isnan(CR_criteria):
+                st.write(f"CR = {CR_criteria:.10f}")
+                if CR_criteria < 0.1:
+                    st.success("Konsistensi Rasio Kriteria AHP *BAIK* (< 0.1)")
+                else:
+                    st.error("Konsistensi Rasio Kriteria AHP *BURUK* (>= 0.1). Harap sesuaikan perbandingan kriteria.")
+            else:
+                st.info("CR kriteria tidak dapat dihitung (untuk 1 kriteria atau RI tidak tersedia).")
+
+        except Exception as e:
+            st.error(f"Terjadi kesalahan saat menghitung bobot kriteria AHP: {e}")
+            st.warning("Pastikan semua nilai pada matriks perbandingan kriteria adalah numerik.")
+    else:
+        st.warning("Matriks perbandingan kriteria belum lengkap atau tidak valid.")
+
+    # --- Perbandingan berpasangan antar alternatif untuk setiap kriteria ---
+    st.subheader("🔗 Perbandingan Berpasangan Antar Alternatif untuk Setiap Kriteria (AHP)")
+
+    alternative_pairwise_matrices = {}
+    alternative_weights_per_criterion = {}
+
+    for criterion in criteria:
+        st.markdown(f"### Kriteria: *{criterion}*")
+
+        pairwise_alt_data = np.ones((len(alternatives), len(alternatives)))
+        for i in range(len(alternatives)):
+            for j in range(i + 1, len(alternatives)):
+                pairwise_alt_data[i, j] = 1.0
+
+        pairwise_alt_df = pd.DataFrame(pairwise_alt_data, index=alternatives, columns=alternatives)
+
+        st.markdown(f"Isi perbandingan berpasangan alternatif untuk *{criterion}* (misal: 3 berarti alternatif baris 3x lebih baik dari alternatif kolom terhadap {criterion}).")
+        st.markdown("Nilai akan otomatis disesuaikan secara resiprokal saat perhitungan.")
+
+        edited_pairwise_alt_matrix = st.data_editor(
+            pairwise_alt_df,
+            use_container_width=True,
+            key=f"pairwise_comparison_alternatives_matrix_{criterion}",
+            hide_index=False,
+        )
+
+        final_pairwise_alt_matrix = edited_pairwise_alt_matrix.copy()
+        for i in range(len(alternatives)):
+            for j in range(i + 1, len(alternatives)):
+                val = final_pairwise_alt_matrix.iloc[i, j]
+                if val == 0:
+                    val = 1e-9
+                final_pairwise_alt_matrix.iloc[j, i] = 1 / val
+            final_pairwise_alt_matrix.iloc[i, i] = 1.0
+
+        alternative_pairwise_matrices[criterion] = final_pairwise_alt_matrix
+
+        # Hitung bobot alternatif untuk criterion ini
+        try:
+            numeric_alt_matrix = final_pairwise_alt_matrix.apply(pd.to_numeric)
+            norm_matrix = numeric_alt_matrix / numeric_alt_matrix.sum()
+            weights_alternatives = norm_matrix.mean(axis=1)
+            weights_alternatives /= weights_alternatives.sum()
+            alternative_weights_per_criterion[criterion] = weights_alternatives
+            st.write(f"Bobot alternatif untuk kriteria *{criterion}*:")
+            st.dataframe(weights_alternatives.round(3).to_frame(name=f"Bobot alternatif ({criterion})"))
+        except Exception as e:
+            st.error(f"Error menghitung bobot alternatif pada kriteria {criterion}: {e}")
+
+elif method == "None":
+    st.subheader("Pilih Metode terlebih dahulu")
+elif method =="TOPSIS":
+    # TOPSIS 
+    st.subheader("📋 Input Nilai Alternatif terhadap Kriteria")
+    empty_data = pd.DataFrame(np.nan, index=alternatives, columns=criteria)
+    df = st.data_editor(empty_data, use_container_width=True, key="input_matrix")
+    if df.isnull().values.any():
+        st.warning("⚠ Harap lengkapi semua nilai pada tabel sebelum menjalankan perhitungan untuk TOPSIS/Profile Matching.")
+
+    criteria_default_type= {
+        "Building Area" : "benefit", 
+        "Road Access": "benefit",
+        "Distance" : "benefit",
+        "Rental Price" : "cost"
+    }
+
+    st.subheader("⚖ Bobot Kriteria (Manual)")
+    weight_dict = {}
+    cols = st.columns(len(criteria))
+    for i, c in enumerate(criteria):
+        with cols[i]:
+            weight_dict[c] = st.number_input(f"Bobot untuk '{c}' dengan rentang 1-5", min_value=0.0, max_value=10.0, value=0.0, step=0.1, key=f"weight_{c}")
+    
+    types = np.array([1 if criteria_default_type.get(c,"benefit") == "benefit" else 0 for c in criteria])
+
+    
+    weights = np.array([weight_dict[c] for c in criteria])
+    weights /= weights.sum()
+    st.write("🎯 Bobot Kriteria (Ternormalisasi):")
+        # Gabungkan ke dalam DataFrame
+    summary_df = pd.DataFrame({
+        "Kriteria": criteria,
+        "Bobot (Ternormalisasi)": weights,
+        "Tipe ": types
+    })
+    
+    # Tampilkan
+    st.write("📋 Tabel Kriteria, Bobot, dan Tipe:")
+    st.dataframe(summary_df)
+    #st.dataframe(pd.Series(weights, index=criteria, name="Bobot", ))
+
+    
+else:
+    #Profile Matching
+    st.subheader("📋 Input Nilai Alternatif terhadap Kriteria")
+    empty_data = pd.DataFrame(np.nan, index=alternatives, columns=criteria)
+    df = st.data_editor(empty_data, use_container_width=True, key="input_matrix")
+    if df.isnull().values.any():
+        st.warning("⚠ Harap lengkapi semua nilai pada tabel sebelum menjalankan perhitungan untuk TOPSIS/Profile Matching.")
+
+    # st.subheader("⚖ Bobot Kriteria (Manual)")
+    # weight_dict = {}
+    # cols = st.columns(len(criteria))
+    # for i, c in enumerate(criteria):
+    #     with cols[i]:
+    #         weight_dict[c] = st.number_input(f"Bobot untuk '{c}'", min_value=0.0, max_value=10.0, value=0.0, step=0.1, key=f"weight_{c}")
+
+    # weights = np.array([weight_dict[c] for c in criteria])
+    # weights /= weights.sum()
+    # st.write("🎯 Bobot Kriteria (Ternormalisasi):")
+    # st.dataframe(pd.Series(weights, index=criteria, name="Bobot"))
+
+    #if method == "Profile Matching":
+    st.subheader("🎯 Ideal Profile (untuk Profile Matching)")
+    ideal_profile_dict = {}
+    cols = st.columns(len(criteria))
+    for i, c in enumerate(criteria):
+        with cols[i]:
+            ideal_profile_dict[c] = st.number_input(f"Ideal '{c}' (1-5)", min_value=0, max_value=5, value=0, key=f"ideal_{c}")
+    ideal_profile = pd.Series(ideal_profile_dict, index=criteria)
+    st.write("💡 Profil Ideal:")
+    st.dataframe(ideal_profile.to_frame(name="Nilai Ideal"))
+
+    st.subheader("⚙ Pengaturan Faktor (untuk Profile Matching)")
+    core_factors_options = criteria
+    default_core_factors = [criteria[-1]] if criteria else []
+
+    selected_core_factors = st.multiselect(
+        "Pilih Kriteria Core Factor (Faktor Inti)",
+        options=core_factors_options,
+        default=default_core_factors,
+        help="Kriteria yang dianggap paling penting. Sisanya akan menjadi Secondary Factor.",
+        key="pm_core_factors"
+    )
+
+    if not selected_core_factors:
+        st.warning("Setidaknya satu Core Factor harus dipilih untuk Profile Matching.")
+        st.stop()
+
+    cf_weight = st.number_input(f"Bobot Core Factor", min_value=0.0, max_value=1.0, value=0.0, step=0.05)
+    sf_weight = 1 - cf_weight
+
+# Tombol jalankan perhitungan
+run_calc = st.button("▶ Jalankan Perhitungan")
+
+if run_calc:
+    if method == "AHP":
+        if len(alternative_weights_per_criterion) != len(criteria):
+            st.error("Perbandingan alternatif belum lengkap untuk semua kriteria. Lengkapi terlebih dahulu.")
+        elif weights_ahp_criteria.empty:
+            st.error("Bobot kriteria AHP belum terhitung dengan benar.")
+        else:
+            # Hitung skor akhir AHP per alternatif = sum bobot kriteria * bobot alternatif pada kriteria
+            final_scores_ahp = pd.Series(0.0, index=alternatives)
+            for c in criteria:
+                w_crit = weights_ahp_criteria.get(c, 0)
+                w_alts = alternative_weights_per_criterion.get(c, pd.Series(0, index=alternatives))
+                final_scores_ahp += w_crit * w_alts
+
+            st.subheader("📈 Hasil Perhitungan AHP")
+            st.write(final_scores_ahp.sort_values(ascending=False).to_frame("Skor Akhir"))
+            st.write("*Alternatif terbaik berdasarkan AHP:*")
+            st.success(final_scores_ahp.idxmax())
+
+    elif method == "TOPSIS":
+        if df.isnull().values.any():
+            st.error("Isi semua nilai alternatif terlebih dahulu.")
+        else:
+            data = df.values.astype(float)
+            w = weights
+
+            # Normalisasi
+            norm_data = data / np.sqrt((data ** 2).sum(axis=0))
+
+            # Bobot
+            weighted_data = norm_data * w
+
+            # Tentukan ideal positif dan negatif (max/min)
+            # ideal_pos = np.max(weighted_data, axis=0)
+            # ideal_neg = np.min(weighted_data, axis=0)
+            ideal_pos = np.where(types == 1, weighted_data.max(), weighted_data.min())
+            ideal_neg = np.where(types == 1, weighted_data.min(), weighted_data.max())
+
+            # Jarak ke ideal positif dan negatif
+            dist_pos = np.sqrt(((weighted_data - ideal_pos) ** 2).sum(axis=1))
+            dist_neg = np.sqrt(((weighted_data - ideal_neg) ** 2).sum(axis=1))
+
+            # Skor preferensi
+            scores_topsis = dist_neg / (dist_pos + dist_neg)
+
+            topsis_result = pd.Series(scores_topsis, index=alternatives).sort_values(ascending=False)
+
+            st.subheader("📈 Hasil Perhitungan TOPSIS")
+            st.write(topsis_result.to_frame("Skor"))
+            st.write("*Alternatif terbaik berdasarkan TOPSIS:*")
+            st.success(topsis_result.idxmax())
+
+elif method == "Profile Matching":
+    if df.isnull().values.any():
+        st.error("Isi semua nilai alternatif terlebih dahulu.")
+    else:
+        # 1. Scaling nilai ke skala 1–5
+        def scale_to_five(val):
+            if val >= 90: return 5
+            elif val >= 80: return 4
+            elif val >= 70: return 3
+            elif val >= 60: return 2
+            elif val >= 50: return 1
+            else: return 1  # default minimum
+
+        df_scaled = df.astype(float).applymap(scale_to_five)
+
+        # 2. Ambil profil ideal yang dimasukkan user (sudah dalam skala 1–5)
+        ideal_profile = pd.Series(ideal_profile_dict)
+
+        # 3. Hitung GAP
+        gaps = df_scaled.subtract(ideal_profile, axis=1)
+
+        # 4. Konversi GAP ke bobot nilai berdasarkan tabel bobot GAP
+        def gap_weight(gap):
+            gap_table = {
+                0: 5,
+                -1: 4.5, 1: 4.5,
+                -2: 4,   2: 4,
+                -3: 3.5, 3: 3.5,
+                -4: 3,   4: 3,
+                -5: 2.5, 5: 2.5,
+            }
+            return gap_table.get(int(gap), 2)  # jika di luar -5 hingga 5, berikan nilai default 2
+
+        weight_gaps = gaps.applymap(gap_weight)
+
+        # 5. Hitung nilai rata-rata core factor dan secondary factor
+        core_factors = selected_core_factors
+        secondary_factors = [c for c in criteria if c not in core_factors]
+
+        cf_scores = weight_gaps[core_factors].mean(axis=1)
+        sf_scores = weight_gaps[secondary_factors].mean(axis=1) if secondary_factors else 0
+
+        # 6. Hitung skor total berdasarkan bobot CF dan SF
+        final_scores_pm = cf_weight * cf_scores + sf_weight * sf_scores
+
+        # 7. Tampilkan hasil
+        st.subheader("📈 Hasil Perhitungan Profile Matching")
+        st.write("📏 Skala 1–5:")
+        st.dataframe(df_scaled)
+        st.write("🧮 GAP Weight:")
+        st.dataframe(weight_gaps)
+        st.write("📊 Skor Akhir:")
+        st.dataframe(final_scores_pm.sort_values(ascending=False).to_frame("Skor"))
+        st.write("*Alternatif terbaik berdasarkan Profile Matching:*")
+        st.success(final_scores_pm.idxmax())
+
+    elif method == "Profile Matching":
+        if df.isnull().values.any():
+            st.error("Isi semua nilai alternatif terlebih dahulu.")
+        else:
+            # 1. Scaling nilai ke skala 1–5
+            def scale_to_five(val):
+                if val >= 90: return 5
+                elif val >= 80: return 4
+                elif val >= 70: return 3
+                elif val >= 60: return 2
+                elif val >= 50: return 1
+                else: return 1  # default minimum
+    
+            df_scaled = df.astype(float).applymap(scale_to_five)
+
+            # 2. Ambil profil ideal yang dimasukkan user (sudah dalam skala 1–5)
+            ideal_profile = pd.Series(ideal_profile_dict)
+    
+            # 3. Hitung GAP
+            gaps = df_scaled.subtract(ideal_profile, axis=1)
+    
+            # 4. Konversi GAP ke bobot nilai berdasarkan tabel bobot GAP
+            def gap_weight(gap):
+                gap_table = {
+                    0: 5,
+                    -1: 4.5, 1: 4.5,
+                    -2: 4,   2: 4,
+                    -3: 3.5, 3: 3.5,
+                    -4: 3,   4: 3,
+                    -5: 2.5, 5: 2.5,
+                }
+                return gap_table.get(int(gap), 2)  # jika di luar -5 hingga 5, berikan nilai default 2
+    
+            weight_gaps = gaps.applymap(gap_weight)
+    
+            # 5. Hitung nilai rata-rata core factor dan secondary factor
+            core_factors = selected_core_factors
+            secondary_factors = [c for c in criteria if c not in core_factors]
 
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))
+            cf_scores = weight_gaps[core_factors].mean(axis=1)
+            sf_scores = weight_gaps[secondary_factors].mean(axis=1) if secondary_factors else 0
+    
+            # 6. Hitung skor total berdasarkan bobot CF dan SF
+            final_scores_pm = cf_weight * cf_scores + sf_weight * sf_scores
+    
+            # 7. Tampilkan hasil
+            st.subheader("📈 Hasil Perhitungan Profile Matching")
+            st.write("📏 Skala 1–5:")
+            st.dataframe(df_scaled)
+            st.write("🧮 GAP Weight:")
+            st.dataframe(weight_gaps)
+            st.write("📊 Skor Akhir:")
+            st.dataframe(final_scores_pm.sort_values(ascending=False).to_frame("Skor"))
+            st.write("*Alternatif terbaik berdasarkan Profile Matching:*")
+            st.success(final_scores_pm.idxmax())