Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,40 +1,342 @@
 import altair as alt
-import numpy as np
-import pandas as pd
 import streamlit as st
+from streamlit_option_menu import option_menu
+import streamlit.components.v1 as html
+from  PIL import Image
+import sys
+import os
+import re
+import streamlit as st
+import pandas as pd
+import numpy as np
+
+import tensorflow as tf
+# print(tf.__version__)
+
+import matplotlib.pyplot as plt
+import seaborn as sns
+from tensorflow.keras import callbacks
+from tensorflow.keras.models import Sequential
+from tensorflow.keras.layers import Conv1D, MaxPooling1D, Embedding, Dense, Dropout, GlobalMaxPooling1D
+from tensorflow.keras.preprocessing.text import Tokenizer
+from tensorflow.keras.preprocessing.sequence import pad_sequences
+from tensorflow.keras.regularizers import l2
+from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import LabelEncoder
+from imblearn.over_sampling import SMOTE
+from PIL import Image
+
+os.environ['CUDA_VISIBLE_DEVICES'] = '-1' # -1 CPU | 0 GPU
+
+# Set seed untuk reproduksibilitas
+np.random.seed(42)
+tf.random.set_seed(42)
+
+class RealTimeLogger(callbacks.Callback):
+    def __init__(self, container, epochs):
+        super().__init__()
+        self.container = container
+        self.epochs = epochs
+        
+    def on_epoch_end(self, epoch, logs=None):
+        logs = logs or {}
+        # Format log text dengan alignment
+        log_text = (
+            f"Epoch {epoch+1:03d}/{self.epochs:03d} | "
+            f"Loss: {logs.get('loss', 0):.4f} | "
+            f"Acc: {logs.get('accuracy', 0):.4f} | "
+            f"Val Loss: {logs.get('val_loss', 0):.4f} | "
+            f"Val Acc: {logs.get('val_accuracy', 0):.4f}\n"
+        )
+        
+        # Update session state
+        if 'training_logs' not in st.session_state:
+            st.session_state.training_logs = []
+            
+        st.session_state.training_logs.insert(0, log_text)
+        
+        # Update tampilan real-time
+        with self.container:
+            st.subheader("Training Logs")
+            st.code(
+                "".join(st.session_state.training_logs[-100:]),  # Batasi 100 line terakhir
+                language="log",
+                line_numbers=True
+            )
+
+def clean_text(text):
+    text = text.lower()
+    text = re.sub(r'[^a-zA-Z0-9\s]', '', text)
+    return text
+
+def load_data(file):
+    lines = file.getvalue().decode("utf-8").splitlines()
+    data, labels, bandwidth = [], [], []
+    for line in lines:
+        line = clean_text(line.strip())
+        if "fake bandwidth" in line:
+            labels.append("Fake")
+            match = re.search(r'(\d+)', line)
+            bandwidth.append(int(match.group()) if match else 0)
+        elif "genuine bandwidth" in line:
+            labels.append("Genuine")
+            match = re.search(r'(\d+)', line)
+            bandwidth.append(int(match.group()) if match else 0)
+        elif "no heavy activity" in line:
+            labels.append("No Heavy")
+            bandwidth.append(0)
+        else:
+            continue
+        data.append(line)
+    return data, labels, bandwidth
+
+def preprocess_text(texts):
+    tokenizer = Tokenizer(num_words=10000, oov_token="<OOV>")
+    tokenizer.fit_on_texts(texts)
+    sequences = tokenizer.texts_to_sequences(texts)
+    padded_sequences = pad_sequences(sequences, maxlen=100, padding='post')
+    return tokenizer, padded_sequences
+
+def build_cnn_model(input_length, num_classes=3, num_words=10000, embedding_dim=240):
+    model = Sequential([
+        # Perbaikan: Hapus parameter input_length dari Embedding
+        Embedding(num_words, embedding_dim),
+        Conv1D(256, 3, activation='relu', kernel_regularizer=l2(0.01)),
+        MaxPooling1D(3),
+        Conv1D(128, 3, activation='relu', kernel_regularizer=l2(0.01)),
+        MaxPooling1D(3),
+        Conv1D(64, 3, activation='relu', kernel_regularizer=l2(0.01)),
+        MaxPooling1D(3),
+        GlobalMaxPooling1D(),
+        Dense(128, activation='relu', kernel_regularizer=l2(0.01)),
+        Dropout(0.5),
+        Dense(num_classes, activation='softmax')
+    ])
+    model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
+    return model
+
+
+#----------------------------------------------------------------------------------------------------
+# Sidebar
+#----------------------------------------------------------------------------------------------------
+with st.sidebar:
+    choose = option_menu("Brandwidth", ["ABOUT", "CNN", "GRU", "LSTM", "COMBINE"],
+                         icons=['person-circle', 'bar-chart-steps', 'activity', 'calendar-week','transparency'],
+                         menu_icon="router", default_index=0,
+                         styles={
+                            "container": {"padding": "5!important", "background-color": "#fafafa"},
+                            "icon": {"color": "black", "font-size": "25px"}, 
+                            "nav-link": {"font-size": "16px", "text-align": "left", "margin":"0px", "--hover-color": "#eee"},
+                            "nav-link-selected": {"background-color": "#02ab21"},
+                        }
+    )
+
+#----------------------------------------------------------------------------------------------------
+# ABOUT
+#----------------------------------------------------------------------------------------------------
+# image_about = Image.open(r'/teamspace/studios/this_studio/icons/datamining.jpg')
+if choose == "ABOUT":
+
+    col1, col2 = st.columns( [0.8, 0.2])
+    with col1:             
+        st.markdown(
+        """ <style> .font {
+        font-size:35px ; color: #000000; font-weight: bold;} 
+
+        .custom-text {
+            font-size: 18px;
+            text-align: justify;
+            color: #000000;
+        }
+        </style> """, unsafe_allow_html=True)
+        st.markdown('<p class="font">ABOUT</p>', unsafe_allow_html=True)
+        
+    # with col2:  
+    #     st.markdown("## 🧠")
+
+    st.write('<p class="custom-text">Saya adalah seorang peneliti dan pengembang di bidang ilmu komputer yang memiliki fokus pada pemrosesan data dan pengklasifikasian bandwidth jaringan menggunakan pendekatan combine classification. Dalam pekerjaan saya, saya menggabungkan berbagai algoritma machine learning untuk meningkatkan akurasi dalam klasifikasi bandwidth, termasuk algoritma seperti Decision Tree, Random Forest, SVM, dan K-Nearest Neighbors., please visit website at: https://kodetr.com</p>', unsafe_allow_html=True)    
+    # st.image(image_about, width=700)
+
+#----------------------------------------------------------------------------------------------------
+# CNN
+#----------------------------------------------------------------------------------------------------
+
+elif choose == "CNN":
+
+    st.title("Klasifikasi Bandwidth dengan CNN")
+    st.write("Aplikasi ini menggunakan model CNN untuk mengklasifikasikan data bandwidth menjadi Fake, Genuine, atau No Heavy Activity")
+
+    # Upload file
+    training_file = st.file_uploader("Upload Data Training (.txt)", type=["txt"])
+    real_files = st.file_uploader("Upload Data Real (.txt)", type=["txt"], accept_multiple_files=True)
+
+    # Parameter model
+    epochs = st.number_input("Jumlah Epoch", min_value=1, value=2000)
+    batch_size = st.number_input("Ukuran Batch", min_value=1, value=32)
+
+    if st.button("Proses Data"):
+        if training_file and real_files:
+            # Memproses data training
+            try:
+                data_train, labels_train, bandwidth_train = load_data(training_file)
+                if len(data_train) == 0:
+                    st.error("Data training tidak valid atau kosong!")
+                    st.stop()
+
+                # Preprocessing
+                tokenizer, X_train = preprocess_text(data_train)
+                le = LabelEncoder()
+                labels_encoded = le.fit_transform(labels_train)
+                
+                # Split data
+                X_train, X_test, y_train, y_test, bw_train, bw_test = train_test_split(
+                    X_train, labels_encoded, bandwidth_train, 
+                    test_size=0.2, stratify=labels_encoded, random_state=42
+                )
+                
+                # SMOTE
+                smote = SMOTE(random_state=42)
+                X_train_smote, y_train_smote = smote.fit_resample(X_train, y_train)
+                
+                # Konversi ke kategorikal
+                y_train_cat = tf.keras.utils.to_categorical(y_train_smote, num_classes=3)
+                y_test_cat = tf.keras.utils.to_categorical(y_test, num_classes=3)
+                
+                if 'training_progress' not in st.session_state:
+                    st.session_state.training_progress = []
+
+                # Buat container untuk live update
+                live_container = st.empty()
+
+                # Membangun dan melatih model
+                model = build_cnn_model(X_train.shape[1])
+                early_stop = EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True)
+                reduce_lr = ReduceLROnPlateau(monitor='val_loss', patience=3, factor=0.5, verbose=1)
+ 
+                history = model.fit(
+                    X_train_smote, y_train_cat,
+                    epochs=epochs,
+                    batch_size=batch_size,
+                    validation_data=(X_test, y_test_cat),
+                    # callbacks=[early_stop, reduce_lr],
+                    # verbose=2
+                    callbacks=[
+                        EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True),
+                        ReduceLROnPlateau(monitor='val_loss', patience=3, factor=0.5, verbose=0),
+                        RealTimeLogger(live_container, epochs)
+                    ],
+                    verbose=0
+                )
+                # Tampilkan grafik training history
+                st.subheader("📈 Grafik Hasil Training")
+
+                # Buat layout 2 kolom
+                col1, col2 = st.columns(2)
+
+                with col1:
+                    # Grafik Loss
+                    fig, ax = plt.subplots(figsize=(10, 5))
+                    ax.plot(history.history['loss'], label='Training Loss', color='#FF4B4B', linewidth=2)
+                    ax.plot(history.history['val_loss'], label='Validation Loss', color='#0068C9', linewidth=2)
+                    ax.set_title('Perkembangan Loss', fontsize=14)
+                    ax.set_xlabel('Epoch', fontsize=12)
+                    ax.set_ylabel('Loss', fontsize=12)
+                    ax.grid(True, alpha=0.3)
+                    ax.legend()
+                    st.pyplot(fig)
+
+                with col2:
+                    # Grafik Accuracy
+                    fig, ax = plt.subplots(figsize=(10, 5))
+                    ax.plot(history.history['accuracy'], label='Training Accuracy', color='#00D154', linewidth=2)
+                    ax.plot(history.history['val_accuracy'], label='Validation Accuracy', color='#FF922B', linewidth=2)
+                    ax.set_title('Perkembangan Accuracy', fontsize=14)
+                    ax.set_xlabel('Epoch', fontsize=12)
+                    ax.set_ylabel('Accuracy', fontsize=12)
+                    ax.grid(True, alpha=0.3)
+                    ax.legend()
+                    st.pyplot(fig)
+
+                # Evaluasi
+                loss, acc = model.evaluate(X_test, y_test_cat, verbose=0)
+                st.success(f"Akurasi Model: {acc*100:.2f}%")
+            
+                # Memproses data real
+                data_real, labels_real, bandwidth_real = [], [], []
+                for file in real_files:
+                    d, lbl, bw = load_data(file)
+                    data_real.extend(d)
+                    labels_real.extend(lbl)
+                    bandwidth_real.extend(bw)
+
+                # Menghitung statistik
+                fake = labels_real.count('Fake')
+                genuine = labels_real.count('Genuine')
+                no_heavy = labels_real.count('No Heavy')
+                total = len(labels_real)
+
+                # Visualisasi
+                fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))
+                
+                # Pie chart
+                ax1.pie([fake, genuine, no_heavy], 
+                    labels=['Fake', 'Genuine', 'No Heavy'], 
+                    autopct='%1.1f%%')
+                ax1.set_title('Distribusi Kategori Bandwidth')
+                
+                # Bar plot bandwidth
+                avg_bw = [
+                    np.mean([bw for lbl, bw in zip(labels_real, bandwidth_real) if lbl == 'Fake'] or [0]),
+                    np.mean([bw for lbl, bw in zip(labels_real, bandwidth_real) if lbl == 'Genuine'] or [0]),
+                    0
+                ]
+                ax2.bar(['Fake', 'Genuine', 'No Heavy'], avg_bw)
+                ax2.set_title('Rata-rata Bandwidth per Kategori')
+                ax2.set_ylabel('Mbps')
+                
+                st.pyplot(fig)
+
+                # Tampilkan statistik
+                st.subheader("Statistik Data Real:")
+                st.write(f"Total Data: {total}")
+                st.write(f"Fake Bandwidth: {fake} ({fake/total*100:.2f}%)")
+                st.write(f"Genuine Bandwidth: {genuine} ({genuine/total*100:.2f}%)")
+                st.write(f"No Heavy Activity: {no_heavy} ({no_heavy/total*100:.2f}%)")
+
+            except Exception as e:
+                st.error(f"Terjadi kesalahan: {str(e)}")
+        else:
+            st.warning("Harap upload file training dan file real terlebih dahulu!")
+
+#----------------------------------------------------------------------------------------------------
+# GRU
+#----------------------------------------------------------------------------------------------------
+
+elif choose == "GRU":
+    st.title("Klasifikasi Bandwidth dengan GRU")
+
+    # st.markdown('Design GRU')
+    
+   
+
+#----------------------------------------------------------------------------------------------------
+# LSTM
+#----------------------------------------------------------------------------------------------------
+
+elif choose == "LSTM":
+    st.title("Klasifikasi Bandwidth dengan LSTM")
+
+    # st.subheader('Test 123')
+    # st.markdown('Design LSTM')
+
+
+#----------------------------------------------------------------------------------------------------
+# Combine
+#----------------------------------------------------------------------------------------------------
+
+elif choose == "COMBINE":
+    st.title("Klasifikasi Bandwidth dengan COMBINE")
 
-"""
-# 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])),
-    ))
+    # st.subheader('Test 123')
+    # st.markdown('Design LSTM')