| """ |
| IDSS — AI Use Case Prioritization untuk UMKM Kuliner |
| Streamlit app interaktif: manager bisa mengubah stakeholder, bobot, dan matriks |
| keputusan, lalu melihat hasil SAW, TOPSIS, dan Weighted Product secara real-time. |
| |
| Jalankan dengan: streamlit run app.py |
| """ |
|
|
| import numpy as np |
| import pandas as pd |
| import plotly.express as px |
| import plotly.graph_objects as go |
| import streamlit as st |
|
|
| |
| |
| |
| st.set_page_config( |
| page_title="IDSS - AI Use Case Prioritization", |
| page_icon="📊", |
| layout="wide", |
| ) |
|
|
| HIGHLIGHT_COLOR = "#f97316" |
| METHOD_COLORS = {"SAW": "#3b82f6", "TOPSIS": "#22c55e", "WP": "#a855f7"} |
|
|
| |
| |
| |
| DEFAULT_CRITERIA = pd.DataFrame( |
| [ |
| {"kode": "C1", "nama": "Business impact", "arah": "Benefit", "batas_min": None, "batas_maks": None}, |
| {"kode": "C2", "nama": "Data readiness", "arah": "Benefit", "batas_min": None, "batas_maks": None}, |
| {"kode": "C3", "nama": "Ease of adoption", "arah": "Benefit", "batas_min": None, "batas_maks": None}, |
| {"kode": "C4", "nama": "Implementation cost (juta IDR)", "arah": "Cost", "batas_min": None, "batas_maks": 20.0}, |
| {"kode": "C5", "nama": "Implementation time (minggu)", "arah": "Cost", "batas_min": None, "batas_maks": 12.0}, |
| {"kode": "C6", "nama": "Implementation risk", "arah": "Cost", "batas_min": None, "batas_maks": None}, |
| ] |
| ) |
|
|
| DEFAULT_ALTERNATIVES = pd.DataFrame( |
| [ |
| {"kode": "A1", "nama": "WhatsApp customer assistant", "C1": 4.0, "C2": 4.4, "C3": 4.8, "C4": 8, "C5": 5, "C6": 2.8}, |
| {"kode": "A2", "nama": "Demand & inventory forecasting", "C1": 4.8, "C2": 2.8, "C3": 3.1, "C4": 18, "C5": 12, "C6": 3.1}, |
| {"kode": "A3", "nama": "Automated financial recording", "C1": 4.4, "C2": 4.1, "C3": 4.0, "C4": 10, "C5": 6, "C6": 2.2}, |
| {"kode": "A4", "nama": "Marketing content generation", "C1": 3.8, "C2": 4.3, "C3": 4.5, "C4": 5, "C5": 3, "C6": 3.2}, |
| {"kode": "A5", "nama": "AI customer review analysis", "C1": 3.9, "C2": 4.8, "C3": 4.2, "C4": 7, "C5": 4, "C6": 2.6}, |
| ] |
| ) |
|
|
| DEFAULT_STAKEHOLDERS = pd.DataFrame( |
| [ |
| {"jabatan": "Coordinator", "C1": 30, "C2": 20, "C3": 15, "C4": 10, "C5": 10, "C6": 15}, |
| {"jabatan": "MSME Owner 1", "C1": 25, "C2": 15, "C3": 20, "C4": 20, "C5": 10, "C6": 10}, |
| {"jabatan": "MSME Owner 2", "C1": 25, "C2": 20, "C3": 20, "C4": 15, "C5": 10, "C6": 10}, |
| {"jabatan": "Business mentor", "C1": 30, "C2": 15, "C3": 15, "C4": 15, "C5": 10, "C6": 15}, |
| {"jabatan": "Technical team", "C1": 20, "C2": 25, "C3": 10, "C4": 15, "C5": 10, "C6": 20}, |
| ] |
| ) |
|
|
| |
| |
| |
| if "criteria" not in st.session_state: |
| st.session_state.criteria = DEFAULT_CRITERIA.copy() |
| if "alternatives" not in st.session_state: |
| st.session_state.alternatives = DEFAULT_ALTERNATIVES.copy() |
| if "stakeholders" not in st.session_state: |
| st.session_state.stakeholders = DEFAULT_STAKEHOLDERS.copy() |
|
|
|
|
| def sync_criteria_columns(): |
| """Samakan kolom kriteria di tabel alternatif & stakeholder dengan daftar kriteria terbaru.""" |
| codes = [c for c in st.session_state.criteria["kode"].dropna().tolist() if str(c).strip() != ""] |
|
|
| alt = st.session_state.alternatives.copy() |
| for c in codes: |
| if c not in alt.columns: |
| alt[c] = 0.0 |
| keep = ["kode", "nama"] + codes |
| alt = alt[[c for c in keep if c in alt.columns]] |
| st.session_state.alternatives = alt |
|
|
| sh = st.session_state.stakeholders.copy() |
| for c in codes: |
| if c not in sh.columns: |
| sh[c] = 0 |
| keep2 = ["jabatan"] + codes |
| sh = sh[[c for c in keep2 if c in sh.columns]] |
| st.session_state.stakeholders = sh |
|
|
|
|
| def reset_to_default(): |
| st.session_state.criteria = DEFAULT_CRITERIA.copy() |
| st.session_state.alternatives = DEFAULT_ALTERNATIVES.copy() |
| st.session_state.stakeholders = DEFAULT_STAKEHOLDERS.copy() |
|
|
|
|
| |
| |
| |
| def apply_feasibility(alt_df: pd.DataFrame, criteria_df: pd.DataFrame) -> pd.Series: |
| """True/False per alternatif berdasarkan batas_min / batas_maks tiap kriteria (opsional).""" |
| mask = pd.Series(True, index=alt_df.index) |
| for _, row in criteria_df.iterrows(): |
| code = row["kode"] |
| if code not in alt_df.columns: |
| continue |
| if pd.notna(row.get("batas_min")): |
| mask &= alt_df[code] >= row["batas_min"] |
| if pd.notna(row.get("batas_maks")): |
| mask &= alt_df[code] <= row["batas_maks"] |
| return mask |
|
|
|
|
| def compute_weights(stakeholder_df: pd.DataFrame, codes: list) -> tuple[pd.Series, pd.Series]: |
| """ |
| Normalisasi TIAP baris stakeholder ke total 100 dulu (biar tetap adil walau ada yang |
| salah input), baru dirata-rata antar stakeholder, lalu dinormalisasi jadi bobot total = 1. |
| Mengembalikan (bobot_final, total_poin_asli_per_stakeholder). |
| """ |
| pts = stakeholder_df[codes].astype(float) |
| row_sums = pts.sum(axis=1) |
| row_sums_safe = row_sums.replace(0, np.nan) |
| normalized_rows = pts.div(row_sums_safe, axis=0) * 100 |
| mean_points = normalized_rows.mean(axis=0) |
| weights = mean_points / mean_points.sum() |
| return weights, row_sums |
|
|
|
|
| def normalize_saw(matrix: pd.DataFrame, direction: dict) -> pd.DataFrame: |
| norm = pd.DataFrame(index=matrix.index, columns=matrix.columns, dtype=float) |
| for col in matrix.columns: |
| if direction[col] == "Benefit": |
| norm[col] = matrix[col] / matrix[col].max() |
| else: |
| norm[col] = matrix[col].min() / matrix[col] |
| return norm |
|
|
|
|
| def compute_saw(matrix: pd.DataFrame, weights: pd.Series, direction: dict): |
| norm = normalize_saw(matrix, direction) |
| weighted = norm * weights[matrix.columns] |
| scores = weighted.sum(axis=1) |
| return scores, weighted |
|
|
|
|
| def compute_topsis(matrix: pd.DataFrame, weights: pd.Series, direction: dict): |
| denom = np.sqrt((matrix ** 2).sum(axis=0)) |
| r = matrix / denom |
| v = r * weights[matrix.columns] |
|
|
| a_pos, a_neg = {}, {} |
| for col in matrix.columns: |
| if direction[col] == "Benefit": |
| a_pos[col], a_neg[col] = v[col].max(), v[col].min() |
| else: |
| a_pos[col], a_neg[col] = v[col].min(), v[col].max() |
| a_pos, a_neg = pd.Series(a_pos), pd.Series(a_neg) |
|
|
| s_pos = np.sqrt(((v - a_pos) ** 2).sum(axis=1)) |
| s_neg = np.sqrt(((v - a_neg) ** 2).sum(axis=1)) |
| closeness = s_neg / (s_pos + s_neg) |
| return closeness, v, a_pos, a_neg, s_pos, s_neg |
|
|
|
|
| def compute_wp(matrix: pd.DataFrame, weights: pd.Series, direction: dict): |
| if (matrix <= 0).any().any(): |
| return None, None, "Ada nilai \u2264 0 di matriks — WP tidak bisa dihitung (pemangkatan negatif terhadap 0/negatif tidak terdefinisi)." |
| signed_w = pd.Series( |
| {c: weights[c] if direction[c] == "Benefit" else -weights[c] for c in matrix.columns} |
| ) |
| S = (matrix ** signed_w).prod(axis=1) |
| V = S / S.sum() |
| return V, S, None |
|
|
|
|
| def ranked_bar(series: pd.Series, names: dict, winner: str, x_title: str, title: str) -> go.Figure: |
| s = series.sort_values() |
| colors = [HIGHLIGHT_COLOR if a == winner else "#93c5fd" for a in s.index] |
| labels = [f"{a} — {names.get(a, '')}" for a in s.index] |
| fig = go.Figure( |
| go.Bar( |
| x=s.values, y=labels, orientation="h", marker_color=colors, |
| text=[f"{v:.4f}" for v in s.values], textposition="outside", |
| ) |
| ) |
| fig.update_layout(title=title, xaxis_title=x_title, height=90 + 60 * len(s), margin=dict(l=10, r=10, t=60, b=10)) |
| return fig |
|
|
|
|
| |
| |
| |
| with st.sidebar: |
| st.header("⚙️ Kontrol") |
| st.caption( |
| "Nilai di semua tabel bisa diedit langsung dengan klik sel. Baris kriteria & alternatif " |
| "sudah baku (tetap); hanya tabel stakeholder yang barisnya bisa ditambah/dihapus." |
| ) |
| if st.button("🔄 Reset ke data contoh (UMKM Kuliner)", use_container_width=True): |
| reset_to_default() |
| st.rerun() |
| st.divider() |
| st.caption( |
| "Dibuat berdasarkan studi kasus *AI Use Case Prioritization for Culinary MSMEs* " |
| "(UGM). Mendukung 3 metode MCDM: **SAW**, **TOPSIS**, **Weighted Product**." |
| ) |
|
|
| st.title("📊 Intelligent Decision Support System (IDSS)") |
| st.caption("AI Use Case Prioritization — bandingkan SAW, TOPSIS, dan Weighted Product secara interaktif") |
|
|
| tab1, tab2, tab3, tab4, tab5, tab6 = st.tabs( |
| ["📋 Kriteria & Alternatif", "⚖️ Bobot Stakeholder", "📊 SAW", "📐 TOPSIS", "✖️ Weighted Product", "🏆 Dashboard Perbandingan"] |
| ) |
|
|
| |
| |
| |
| with tab1: |
| st.subheader("1. Daftar Kriteria") |
| st.caption( |
| "Kode, nama, dan arah kriteria sudah baku (tidak bisa diubah). Yang bisa diedit hanya " |
| "`batas_min` / `batas_maks` — opsional, dipakai sebagai *feasibility gate* (alternatif yang " |
| "melanggar batas akan otomatis dicoret dari perhitungan). Kosongkan kalau tidak ada batas." |
| ) |
| edited_criteria = st.data_editor( |
| st.session_state.criteria, |
| num_rows="fixed", |
| use_container_width=True, |
| key="criteria_editor", |
| column_config={ |
| "kode": st.column_config.TextColumn("Kode", disabled=True), |
| "nama": st.column_config.TextColumn("Nama Kriteria", disabled=True), |
| "arah": st.column_config.TextColumn("Arah", disabled=True), |
| "batas_min": st.column_config.NumberColumn("Batas Min (opsional)", format="%.2f"), |
| "batas_maks": st.column_config.NumberColumn("Batas Maks (opsional)", format="%.2f"), |
| }, |
| ) |
| if not edited_criteria.equals(st.session_state.criteria): |
| st.session_state.criteria = edited_criteria |
| sync_criteria_columns() |
| st.rerun() |
|
|
| criteria_df = st.session_state.criteria.dropna(subset=["kode"]).copy() |
| criteria_df = criteria_df[criteria_df["kode"].astype(str).str.strip() != ""] |
|
|
| if criteria_df["kode"].duplicated().any(): |
| st.error("Ada kode kriteria yang duplikat — perbaiki dulu sebelum lanjut.") |
| st.stop() |
| if criteria_df.empty: |
| st.error("Minimal harus ada 1 kriteria.") |
| st.stop() |
|
|
| criteria_codes = criteria_df["kode"].tolist() |
| criteria_names = dict(zip(criteria_df["kode"], criteria_df["nama"])) |
| criteria_direction = dict(zip(criteria_df["kode"], criteria_df["arah"])) |
|
|
| st.subheader("2. Matriks Keputusan (nilai mentah tiap alternatif)") |
| st.caption("Kode dan nama use case sudah baku (tidak bisa diubah). Yang bisa diedit hanya nilai C1-C6.") |
| edited_alt = st.data_editor( |
| st.session_state.alternatives, |
| num_rows="fixed", |
| use_container_width=True, |
| key="alt_editor", |
| column_config={ |
| "kode": st.column_config.TextColumn("Kode", disabled=True), |
| "nama": st.column_config.TextColumn("Nama Use Case", disabled=True), |
| **{c: st.column_config.NumberColumn(f"{c}: {criteria_names.get(c, '')}", format="%.2f") for c in criteria_codes}, |
| }, |
| ) |
| st.session_state.alternatives = edited_alt |
|
|
| alt_df = st.session_state.alternatives.dropna(subset=["kode"]).copy() |
| alt_df = alt_df[alt_df["kode"].astype(str).str.strip() != ""] |
| if alt_df["kode"].duplicated().any(): |
| st.error("Ada kode alternatif yang duplikat — perbaiki dulu sebelum lanjut.") |
| st.stop() |
| if len(alt_df) < 2: |
| st.error("Minimal harus ada 2 alternatif supaya bisa dibandingkan.") |
| st.stop() |
|
|
| alt_names = dict(zip(alt_df["kode"], alt_df["nama"])) |
| matrix_full = alt_df.set_index("kode")[criteria_codes].astype(float) |
|
|
| st.subheader("3. Feasibility Gate") |
| feasible_mask = apply_feasibility(matrix_full, criteria_df) |
| gate_view = matrix_full.copy() |
| gate_view.insert(0, "nama", [alt_names[a] for a in gate_view.index]) |
| gate_view["Status"] = np.where(feasible_mask, "✅ Lolos", "❌ Tidak lolos") |
| st.dataframe(gate_view, use_container_width=True) |
| st.caption(f"{feasible_mask.sum()}/{len(matrix_full)} alternatif lolos gate dan dipakai di perhitungan SAW/TOPSIS/WP.") |
|
|
| matrix = matrix_full.loc[feasible_mask] |
| if len(matrix) < 2: |
| st.error("Kurang dari 2 alternatif yang lolos feasibility gate — longgarkan batas_min/batas_maks dulu.") |
| st.stop() |
|
|
| |
| |
| |
| with tab2: |
| st.subheader("1. Alokasi 100 Poin per Stakeholder") |
| st.caption( |
| "Tambah/hapus baris untuk menambah/mengurangi stakeholder. Masukkan **Jabatan** dan alokasikan " |
| "poin ke tiap kriteria — total per baris **harus 100**." |
| ) |
| edited_stakeholders = st.data_editor( |
| st.session_state.stakeholders, |
| num_rows="dynamic", |
| use_container_width=True, |
| key="stakeholder_editor", |
| column_config={ |
| "jabatan": st.column_config.TextColumn("Jabatan", required=True), |
| **{c: st.column_config.NumberColumn(f"{c}: {criteria_names.get(c, '')}", min_value=0, max_value=100, step=1) for c in criteria_codes}, |
| }, |
| ) |
| st.session_state.stakeholders = edited_stakeholders |
|
|
| sh_df = st.session_state.stakeholders.dropna(subset=["jabatan"]).copy() |
| sh_df = sh_df[sh_df["jabatan"].astype(str).str.strip() != ""] |
| if sh_df.empty: |
| st.error("Minimal harus ada 1 stakeholder.") |
| st.stop() |
|
|
| weights, row_sums = compute_weights(sh_df, criteria_codes) |
|
|
| st.subheader("2. Validasi Total Poin") |
| validasi = pd.DataFrame({"Jabatan": sh_df["jabatan"].values, "Total Poin": row_sums.values}) |
| validasi["Status"] = np.where(np.isclose(validasi["Total Poin"], 100), "✅ 100", "⚠️ Bukan 100 (akan dinormalisasi otomatis)") |
| st.dataframe(validasi, use_container_width=True, hide_index=True) |
|
|
| bermasalah = validasi[~np.isclose(validasi["Total Poin"], 100)] |
| if not bermasalah.empty: |
| daftar = ", ".join(f"{r.Jabatan} ({r['Total Poin']:.0f})" for r in bermasalah.itertuples()) |
| st.warning( |
| f"Stakeholder berikut totalnya **bukan 100**: {daftar}. " |
| "Poinnya tetap dipakai tapi sudah dinormalisasi otomatis secara proporsional supaya " |
| "perhitungan tidak berhenti — sebaiknya tetap diperbaiki di tabel atas untuk akurasi." |
| ) |
| else: |
| st.success("Semua stakeholder totalnya sudah tepat 100. ✅") |
|
|
| st.subheader("3. Bobot Final per Kriteria") |
| weights_view = pd.DataFrame( |
| {"Kriteria": [f"{c}: {criteria_names[c]}" for c in criteria_codes], "Bobot": [weights[c] for c in criteria_codes]} |
| ).sort_values("Bobot", ascending=True) |
| fig_w = go.Figure( |
| go.Bar(x=weights_view["Bobot"], y=weights_view["Kriteria"], orientation="h", marker_color="#3b82f6", |
| text=[f"{v:.1%}" for v in weights_view["Bobot"]], textposition="outside") |
| ) |
| fig_w.update_layout(title="Bobot Akhir per Kriteria", xaxis_title="Bobot (proporsi dari 1.0)", |
| height=90 + 45 * len(weights_view), margin=dict(l=10, r=10, t=60, b=10)) |
| st.plotly_chart(fig_w, use_container_width=True) |
|
|
| |
| |
| |
| saw_scores, saw_weighted = compute_saw(matrix, weights, criteria_direction) |
| topsis_scores, topsis_v, topsis_apos, topsis_aneg, topsis_spos, topsis_sneg = compute_topsis(matrix, weights, criteria_direction) |
| wp_scores, wp_S, wp_error = compute_wp(matrix, weights, criteria_direction) |
|
|
| saw_winner = saw_scores.idxmax() |
| topsis_winner = topsis_scores.idxmax() |
| wp_winner = wp_scores.idxmax() if wp_scores is not None else None |
|
|
| |
| |
| |
| with tab3: |
| st.subheader("Hasil SAW (Simple Additive Weighting)") |
| st.latex(r"V_i = \sum_j w_j \cdot r_{ij}") |
|
|
| saw_table = pd.DataFrame({"nama": [alt_names[a] for a in saw_scores.index], "Skor SAW": saw_scores}) |
| saw_table = saw_table.sort_values("Skor SAW", ascending=False) |
| st.dataframe(saw_table, use_container_width=True) |
| st.success(f"🏆 Pemenang SAW: **{saw_winner} — {alt_names[saw_winner]}** (skor {saw_scores[saw_winner]:.4f})") |
|
|
| st.plotly_chart(ranked_bar(saw_scores, alt_names, saw_winner, "Skor SAW", "Ranking SAW"), use_container_width=True) |
|
|
| st.markdown("**Dekomposisi skor per kriteria**") |
| decomp = saw_weighted.copy() |
| decomp.index = [f"{a}: {alt_names[a]}" for a in decomp.index] |
| decomp_long = decomp.reset_index().melt(id_vars="index", var_name="Kriteria", value_name="Kontribusi") |
| fig_decomp = px.bar(decomp_long, x="Kontribusi", y="index", color="Kriteria", orientation="h", |
| title="Kontribusi Tiap Kriteria terhadap Skor SAW") |
| fig_decomp.update_layout(yaxis_title="", height=90 + 45 * len(decomp)) |
| st.plotly_chart(fig_decomp, use_container_width=True) |
|
|
| |
| |
| |
| with tab4: |
| st.subheader("Hasil TOPSIS") |
| st.latex(r"C_i^{*} = \frac{S_i'}{S_i^{*} + S_i'}") |
|
|
| topsis_table = pd.DataFrame( |
| { |
| "nama": [alt_names[a] for a in topsis_scores.index], |
| "Skor TOPSIS (C*)": topsis_scores, |
| "Jarak ke ideal positif (S*)": topsis_spos, |
| "Jarak ke ideal negatif (S')": topsis_sneg, |
| } |
| ).sort_values("Skor TOPSIS (C*)", ascending=False) |
| st.dataframe(topsis_table, use_container_width=True) |
| st.success(f"🏆 Pemenang TOPSIS: **{topsis_winner} — {alt_names[topsis_winner]}** (skor {topsis_scores[topsis_winner]:.4f})") |
|
|
| st.plotly_chart(ranked_bar(topsis_scores, alt_names, topsis_winner, "Skor TOPSIS (C*)", "Ranking TOPSIS"), use_container_width=True) |
|
|
| with st.expander("Lihat solusi ideal positif (A*) & negatif (A')"): |
| st.dataframe(pd.DataFrame({"A* (ideal positif)": topsis_apos, "A' (ideal negatif)": topsis_aneg}), use_container_width=True) |
|
|
| |
| |
| |
| with tab5: |
| st.subheader("Hasil Weighted Product (WP)") |
| st.latex(r"S_i = \prod_{j=1}^{n} x_{ij}^{\,w_j} \qquad V_i = \frac{S_i}{\sum_i S_i}") |
|
|
| if wp_error: |
| st.error(wp_error) |
| else: |
| wp_table = pd.DataFrame({"nama": [alt_names[a] for a in wp_scores.index], "Skor WP (V)": wp_scores, "S_i": wp_S}) |
| wp_table = wp_table.sort_values("Skor WP (V)", ascending=False) |
| st.dataframe(wp_table, use_container_width=True) |
| st.success(f"🏆 Pemenang WP: **{wp_winner} — {alt_names[wp_winner]}** (skor {wp_scores[wp_winner]:.4f})") |
|
|
| st.plotly_chart(ranked_bar(wp_scores, alt_names, wp_winner, "Skor WP (V)", "Ranking Weighted Product"), use_container_width=True) |
|
|
| |
| |
| |
| with tab6: |
| st.subheader("Dashboard Perbandingan SAW vs TOPSIS vs WP") |
| st.caption( |
| "Skor ketiga metode sama-sama berada di rentang 0-1, tapi maknanya beda " |
| "(agregat bobot×nilai vs kedekatan ke solusi ideal) — yang paling valid dibandingkan " |
| "lintas metode adalah **urutan rangking-nya**, bukan besaran angka mentahnya." |
| ) |
|
|
| comp = pd.DataFrame({"SAW": saw_scores, "TOPSIS": topsis_scores}) |
| if wp_scores is not None: |
| comp["WP"] = wp_scores |
| comp.insert(0, "nama", [alt_names[a] for a in comp.index]) |
|
|
| method_cols = [c for c in ["SAW", "TOPSIS", "WP"] if c in comp.columns] |
| rank_table = comp[method_cols].rank(ascending=False).astype(int) |
| rank_table.columns = [f"Rank_{c}" for c in rank_table.columns] |
| comp_full = pd.concat([comp, rank_table], axis=1) |
|
|
| avg_rank = rank_table.mean(axis=1).sort_values() |
| overall_best = avg_rank.index[0] |
|
|
| winners = {"SAW": saw_winner, "TOPSIS": topsis_winner} |
| if wp_winner is not None: |
| winners["WP"] = wp_winner |
| n_won = sum(1 for w in winners.values() if w == overall_best) |
|
|
| st.dataframe(comp_full.sort_values("SAW", ascending=False), use_container_width=True) |
|
|
| c1, c2 = st.columns([2, 1]) |
| with c1: |
| st.info( |
| f"**Pemenang per metode:** " + " | ".join(f"{m}: {w} ({alt_names[w]})" for m, w in winners.items()) |
| ) |
| with c2: |
| st.success( |
| f"🏆 **Terbaik keseluruhan:** {overall_best} — {alt_names[overall_best]}\n\n" |
| f"Menang di {n_won}/{len(method_cols)} metode langsung, rata-rata rank = {avg_rank[overall_best]:.2f}" |
| ) |
|
|
| |
| fig = go.Figure() |
| for m in method_cols: |
| colors = [HIGHLIGHT_COLOR if a == overall_best else METHOD_COLORS[m] for a in comp.index] |
| fig.add_trace( |
| go.Bar( |
| name=m, x=[f"{a}<br>{alt_names[a]}" for a in comp.index], y=comp[m], |
| marker_color=colors, text=[f"{v:.3f}" for v in comp[m]], textposition="outside", |
| ) |
| ) |
| fig.update_layout( |
| barmode="group", title="Skor SAW vs TOPSIS vs WP per Alternatif (oranye = terbaik keseluruhan)", |
| yaxis_title="Skor (0-1)", height=500, legend_title="Metode", |
| ) |
| st.plotly_chart(fig, use_container_width=True) |
|
|
| |
| fig_rank = go.Figure( |
| go.Bar( |
| x=avg_rank.sort_values(ascending=False).values, |
| y=[f"{a}: {alt_names[a]}" for a in avg_rank.sort_values(ascending=False).index], |
| orientation="h", |
| marker_color=[HIGHLIGHT_COLOR if a == overall_best else "#94a3b8" for a in avg_rank.sort_values(ascending=False).index], |
| text=[f"{v:.2f}" for v in avg_rank.sort_values(ascending=False).values], |
| textposition="outside", |
| ) |
| ) |
| fig_rank.update_layout(title="Rata-rata Rank Lintas 3 Metode (1 = terbaik)", xaxis_title="Rata-rata rank", |
| height=90 + 45 * len(avg_rank), xaxis_autorange="reversed") |
| st.plotly_chart(fig_rank, use_container_width=True) |
|
|
| |
| st.markdown("**Profil kriteria (nilai ternormalisasi SAW) — bonus untuk lihat kekuatan/kelemahan tiap alternatif**") |
| norm_saw = normalize_saw(matrix, criteria_direction) |
| fig_radar = go.Figure() |
| for a in norm_saw.index: |
| fig_radar.add_trace( |
| go.Scatterpolar( |
| r=norm_saw.loc[a, criteria_codes].tolist() + [norm_saw.loc[a, criteria_codes[0]]], |
| theta=criteria_codes + [criteria_codes[0]], |
| fill="toself", |
| name=f"{a}: {alt_names[a]}", |
| line_color=HIGHLIGHT_COLOR if a == overall_best else None, |
| opacity=1.0 if a == overall_best else 0.55, |
| ) |
| ) |
| fig_radar.update_layout(polar=dict(radialaxis=dict(visible=True, range=[0, 1])), height=500, |
| title="Radar Perbandingan Kriteria Antar Alternatif") |
| st.plotly_chart(fig_radar, use_container_width=True) |
|
|
| st.download_button( |
| "⬇️ Unduh hasil perbandingan (CSV)", |
| comp_full.to_csv(index=True).encode("utf-8"), |
| file_name="perbandingan_saw_topsis_wp.csv", |
| mime="text/csv", |
| ) |
|
|
