Update app.py

app.py

@@ -2,146 +2,122 @@ import streamlit as st
 import pandas as pd
 import numpy as np
 import matplotlib.pyplot as plt
-from amazon_chronos import ChronosModel, TimeSeriesDataSet
-import tempfile
-import os
+import torch
+from chronos import ChronosPipeline
 
 class TimeSeriesForecaster:
-    def __init__(self):
-        self.model = None
-        self.dataset = None
+    def __init__(self, model_name="amazon/chronos-t5-small"):
+        self.pipeline = ChronosPipeline.from_pretrained(
+            model_name,
+            device_map="cuda" if torch.cuda.is_available() else "cpu",
+            torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32
+        )
         self.original_series = None
+        self.context = None
 
     def preprocess_data(self, df, date_column, value_column, context_length=30, prediction_length=7):
         """
-        Persiapkan data time series dari DataFrame
+        Prepare time series data from DataFrame
         """
-        # Pastikan data terurut berdasarkan tanggal
+        # Ensure data is sorted by date
         df = df.sort_values(by=date_column)
         
-        # Konversi kolom tanggal ke datetime
+        # Convert date column to datetime
         df[date_column] = pd.to_datetime(df[date_column])
         
-        # Set index ke tanggal
+        # Set index to date
         df.set_index(date_column, inplace=True)
         
-        # Ekstrak series numerik
-        time_series = df[value_column].values
+        # Extract numeric series
+        self.original_series = df[value_column].values
         
-        # Buat dataset Chronos
-        self.original_series = time_series
-        self.dataset = TimeSeriesDataSet.from_series(
-            time_series, 
-            context_length=context_length, 
-            prediction_length=prediction_length
-        )
+        # Convert to tensor
+        self.context = torch.tensor(self.original_series[-context_length:], dtype=torch.float32)
         
-        return self.dataset
-
-    def train_model(self, model_id='chronos-t5-small'):
-        """
-        Latih model Chronos
-        """
-        self.model = ChronosModel.from_pretrained(model_id)
-        self.model.fit(self.dataset)
-        return self.model
+        return self.context, context_length
 
-    def forecast(self, n_samples=100):
+    def forecast(self, context, prediction_length=7, num_samples=100):
         """
-        Lakukan prediksi
+        Perform time series forecasting
         """
-        if not self.model or not self.dataset:
-            raise ValueError("Model belum dilatih. Latih model terlebih dahulu.")
-        
-        forecasts = self.model.predict(self.dataset, num_samples=n_samples)
+        forecasts = self.pipeline.predict(context, prediction_length, num_samples=num_samples)
         return forecasts
 
-    def visualize_forecast(self, forecasts):
+    def visualize_forecast(self, context, forecasts):
         """
-        Buat visualisasi prediksi
+        Create visualization of predictions
         """
         plt.figure(figsize=(12, 6))
         
-        # Plot series asli
-        plt.plot(self.original_series, label='Data Historis', color='blue')
+        # Plot original series
+        plt.plot(range(len(self.original_series)), self.original_series, label='Historical Data', color='blue')
         
-        # Plot prediksi
-        forecast_mean = forecasts.mean(axis=0)
-        forecast_lower = np.percentile(forecasts, 10, axis=0)
-        forecast_upper = np.percentile(forecasts, 90, axis=0)
+        # Calculate forecast statistics
+        forecast_np = forecasts[0].numpy()
+        low, median, high = np.quantile(forecast_np, [0.1, 0.5, 0.9], axis=0)
         
-        forecast_start = len(self.original_series)
-        plt.plot(
-            range(forecast_start, forecast_start + len(forecast_mean)), 
-            forecast_mean, 
-            label='Prediksi Rata-rata', 
-            color='red'
-        )
-        plt.fill_between(
-            range(forecast_start, forecast_start + len(forecast_mean)), 
-            forecast_lower, 
-            forecast_upper, 
-            alpha=0.3, 
-            color='red'
-        )
+        # Plot forecast
+        forecast_index = range(len(self.original_series), len(self.original_series) + len(median))
+        plt.plot(forecast_index, median, color='red', label='Median Forecast')
+        plt.fill_between(forecast_index, low, high, color='red', alpha=0.3, label='80% Prediction Interval')
         
-        plt.title('Peramalan Time Series dengan Amazon Chronos')
-        plt.xlabel('Indeks Waktu')
-        plt.ylabel('Nilai')
+        plt.title('Time Series Forecasting with Amazon Chronos')
+        plt.xlabel('Time Index')
+        plt.ylabel('Value')
         plt.legend()
         
         return plt
 
 def main():
-    st.title('🕰️ Time Series Forecasting dengan Amazon Chronos')
+    st.title('🕰️ Time Series Forecasting with Amazon Chronos')
     
-    # Sidebar untuk upload dan konfigurasi
-    st.sidebar.header('Pengaturan Prediksi')
+    # Sidebar for upload and configuration
+    st.sidebar.header('Forecast Settings')
     
-    # Upload file CSV
+    # Upload CSV file
     uploaded_file = st.sidebar.file_uploader(
-        "Unggah File CSV", 
+        "Upload CSV File", 
         type=['csv'], 
-        help="Pastikan file CSV memiliki kolom tanggal dan nilai numerik"
+        help="Ensure CSV file has date and numeric columns"
     )
     
-    # Pilihan kolom
+    # Column selection and prediction settings
     if uploaded_file is not None:
-        # Baca CSV
+        # Read CSV
         df = pd.read_csv(uploaded_file)
         
-        # Pilih kolom
+        # Select columns
         date_column = st.sidebar.selectbox(
-            'Pilih Kolom Tanggal', 
+            'Select Date Column', 
             options=df.columns
         )
         value_column = st.sidebar.selectbox(
-            'Pilih Kolom Nilai', 
+            'Select Value Column', 
             options=[col for col in df.columns if col != date_column]
         )
         
-        # Parameter prediksi
+        # Prediction parameters
         context_length = st.sidebar.slider(
-            'Panjang Konteks', 
+            'Context Length', 
             min_value=10, 
             max_value=100, 
             value=30
         )
         prediction_length = st.sidebar.slider(
-            'Panjang Prediksi', 
+            'Prediction Length', 
             min_value=1, 
             max_value=30, 
             value=7
         )
         
-        # Tombol proses
-        if st.sidebar.button('Lakukan Prediksi'):
+        # Process button
+        if st.sidebar.button('Perform Forecast'):
             try:
-                # Inisiasi forecaster
+                # Initialize forecaster
                 forecaster = TimeSeriesForecaster()
                 
-                # Preprocessing
-                dataset = forecaster.preprocess_data(
+                # Preprocess data
+                context, _ = forecaster.preprocess_data(
                     df, 
                     date_column, 
                     value_column, 
@@ -149,33 +125,31 @@ def main():
                     prediction_length
                 )
                 
-                # Latih model
-                model = forecaster.train_model()
-                
-                # Lakukan prediksi
-                forecasts = forecaster.forecast()
+                # Perform forecasting
+                forecasts = forecaster.forecast(context, prediction_length)
                 
-                # Tampilkan hasil
-                st.subheader('Visualisasi Prediksi')
-                plt = forecaster.visualize_forecast(forecasts)
+                # Visualize results
+                st.subheader('Forecast Visualization')
+                plt = forecaster.visualize_forecast(context, forecasts)
                 st.pyplot(plt)
                 
-                # Tampilkan detail prediksi
-                forecast_mean = forecasts.mean(axis=0)
-                forecast_lower = np.percentile(forecasts, 10, axis=0)
-                forecast_upper = np.percentile(forecasts, 90, axis=0)
+                # Display forecast details
+                forecast_np = forecasts[0].numpy()
+                forecast_mean = forecast_np.mean(axis=0)
+                forecast_lower = np.percentile(forecast_np, 10, axis=0)
+                forecast_upper = np.percentile(forecast_np, 90, axis=0)
                 
                 prediction_df = pd.DataFrame({
-                    'Prediksi Rata-rata': forecast_mean,
-                    'Batas Bawah (10%)': forecast_lower,
-                    'Batas Atas (90%)': forecast_upper
+                    'Mean Forecast': forecast_mean,
+                    'Lower Bound (10%)': forecast_lower,
+                    'Upper Bound (90%)': forecast_upper
                 })
                 
-                st.subheader('Detail Prediksi')
+                st.subheader('Forecast Details')
                 st.dataframe(prediction_df)
                 
             except Exception as e:
-                st.error(f"Terjadi kesalahan: {str(e)}")
+                st.error(f"An error occurred: {str(e)}")
 
 if __name__ == '__main__':
     main()