Update app.py

app.py

@@ -5,11 +5,9 @@ import pandas as pd
 import matplotlib.pyplot as plt
 import seaborn as sns
 import scipy.optimize as sco
-import tensorflow as tf
-from tensorflow import keras
-from tensorflow.keras.models import Sequential
-from tensorflow.keras.layers import LSTM, Dense, Dropout
-from sklearn.preprocessing import MinMaxScaler
+import plotly.express as px
+import plotly.graph_objects as go
+from fpdf import FPDF
 
 def get_stock_data(tickers, start, end):
     data = yf.download(tickers, start=start, end=end)
@@ -46,76 +44,46 @@ def optimize_portfolio(returns, cov_matrix):
     result = sco.minimize(sharpe_ratio, init_guess, method='SLSQP', bounds=bounds, constraints=constraints)
     return result.x if result.success else None
 
-def generate_efficient_frontier(returns, cov_matrix, num_portfolios=5000):
+def simulate_monte_carlo(returns, cov_matrix, num_simulations=10000, time_horizon=252):
     num_assets = len(returns)
-    results = np.zeros((3, num_portfolios))
+    simulated_returns = np.zeros(num_simulations)
+    simulated_volatility = np.zeros(num_simulations)
     
-    for i in range(num_portfolios):
+    for i in range(num_simulations):
         weights = np.random.dirichlet(np.ones(num_assets), size=1)[0]
-        portfolio_return = np.dot(weights, returns)
-        portfolio_volatility = np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights)))
-        sharpe_ratio = portfolio_return / portfolio_volatility
-        
-        results[0, i] = portfolio_return
-        results[1, i] = portfolio_volatility
-        results[2, i] = sharpe_ratio
+        simulated_returns[i] = np.dot(weights, returns)
+        simulated_volatility[i] = np.sqrt(np.dot(weights.T, np.dot(cov_matrix, weights)))
     
-    return results
-
-def plot_correlation_heatmap(data):
-    correlation_matrix = data.corr()
-    fig, ax = plt.subplots()
-    sns.heatmap(correlation_matrix, annot=True, cmap="coolwarm", ax=ax)
-    st.pyplot(fig)
-
-def plot_moving_averages(data, stock):
-    fig, ax = plt.subplots()
-    data[stock].plot(label='Harga', ax=ax)
-    data[stock].rolling(window=50).mean().plot(label='SMA 50', ax=ax)
-    data[stock].rolling(window=200).mean().plot(label='SMA 200', ax=ax)
-    ax.legend()
-    st.pyplot(fig)
+    fig = px.scatter(x=simulated_volatility, y=simulated_returns, color=simulated_returns/simulated_volatility,
+                     labels={'x': 'Volatilitas', 'y': 'Return'},
+                     title='Simulasi Monte Carlo')
+    st.plotly_chart(fig)
 
-def simulate_dca(data, investment_amount=100):
-    investment_dates = data.index[::30]
-    dca_values = data.loc[investment_dates].mean(axis=1) * investment_amount
-    total_value = dca_values.cumsum()
-    fig, ax = plt.subplots()
-    total_value.plot(ax=ax, title='Simulasi Investasi DCA')
-    st.pyplot(fig)
-
-def predict_stock_price(data, stock, days=30):
-    st.subheader(f"Prediksi Harga Saham {stock} (LSTM Model)")
-    scaler = MinMaxScaler(feature_range=(0, 1))
-    scaled_data = scaler.fit_transform(data[stock].values.reshape(-1,1))
-    
-    X, y = [], []
-    for i in range(60, len(scaled_data) - days):
-        X.append(scaled_data[i-60:i, 0])
-        y.append(scaled_data[i:i+days, 0])
-    
-    X, y = np.array(X), np.array(y)
-    X = np.reshape(X, (X.shape[0], X.shape[1], 1))
-    
-    model = Sequential()
-    model.add(LSTM(units=50, return_sequences=True, input_shape=(X.shape[1], 1)))
-    model.add(LSTM(units=50, return_sequences=False))
-    model.add(Dense(units=25))
-    model.add(Dense(units=days))
+def stock_screener():
+    st.sidebar.header("Stock Screener")
+    pe_ratio = st.sidebar.slider("Maksimum P/E Ratio", 0, 100, 20)
+    market_cap = st.sidebar.selectbox("Market Cap", ["Small", "Mid", "Large"])
     
-    model.compile(optimizer='adam', loss='mean_squared_error')
-    model.fit(X, y, epochs=10, batch_size=16)
-    
-    predicted_prices = model.predict(X[-1].reshape(1, X.shape[1], 1))
-    predicted_prices = scaler.inverse_transform(predicted_prices)
-    
-    future_dates = pd.date_range(data.index[-1], periods=days+1)[1:]
-    
-    fig, ax = plt.subplots()
-    ax.plot(data.index, data[stock], label='Data Historis')
-    ax.plot(future_dates, predicted_prices.flatten(), label='Prediksi', linestyle='dashed')
-    ax.legend()
-    st.pyplot(fig)
+    # Simulasi data screener (contoh)
+    screener_data = pd.DataFrame({
+        'Ticker': ['AAPL', 'MSFT', 'GOOGL', 'TSLA', 'AMZN'],
+        'P/E Ratio': [30, 25, 35, 40, 28],
+        'Market Cap': ['Large', 'Large', 'Large', 'Mid', 'Large']
+    })
+    filtered_stocks = screener_data[(screener_data['P/E Ratio'] <= pe_ratio) & (screener_data['Market Cap'] == market_cap)]
+    st.sidebar.write("Saham yang memenuhi kriteria:")
+    st.sidebar.write(filtered_stocks)
+
+def export_to_pdf(stock_data):
+    pdf = FPDF()
+    pdf.add_page()
+    pdf.set_font("Arial", size=12)
+    pdf.cell(200, 10, txt="Laporan Analisis Saham", ln=True, align='C')
+    pdf.ln(10)
+    for ticker in stock_data.columns:
+        pdf.cell(200, 10, txt=f"{ticker}: {stock_data[ticker].iloc[-1]}", ln=True)
+    pdf.output("stock_report.pdf")
+    st.success("Laporan PDF telah dibuat!")
 
 st.title("Analisis Portofolio Saham Optimal (Model Markowitz)")
 
@@ -125,6 +93,7 @@ st.write("KLBF.JK, SIDO.JK, KAEF.JK, TLKM.JK, UNVR.JK")
 tickers_list = st.text_input("Masukkan ticker saham", "KLBF.JK, SIDO.JK, KAEF.JK").split(", ")
 start_date = st.date_input("Pilih tanggal mulai", pd.to_datetime("2020-01-01"))
 end_date = st.date_input("Pilih tanggal akhir", pd.to_datetime("2023-12-31"))
+stock_screener()
 
 if st.button("Analisis Portofolio"):
     stock_data = get_stock_data(tickers_list, start_date, end_date)
@@ -132,25 +101,15 @@ if st.button("Analisis Portofolio"):
         mean_returns, cov_matrix = calculate_returns(stock_data)
         optimal_weights = optimize_portfolio(mean_returns, cov_matrix)
 
-        st.subheader("Statistik Saham")
-        st.write(stock_data.describe())
-        
-        st.subheader("Heatmap Korelasi Saham")
-        plot_correlation_heatmap(stock_data)
-        
-        st.subheader("Moving Average untuk Prediksi Tren")
-        selected_stock = st.selectbox("Pilih saham untuk analisis MA", stock_data.columns)
-        plot_moving_averages(stock_data, selected_stock)
-        
-        st.subheader("Simulasi Investasi Dollar Cost Averaging (DCA)")
-        simulate_dca(stock_data)
-        
-        st.subheader("Prediksi Harga Saham dengan AI")
-        predict_stock_price(stock_data, selected_stock)
-        
+        st.subheader("Simulasi Monte Carlo")
+        simulate_monte_carlo(mean_returns, cov_matrix)
+
+        if st.button("Export to PDF"):
+            export_to_pdf(stock_data)
+            
         if optimal_weights is not None:
             st.subheader("Bobot Portofolio Optimal")
             portfolio_weights = {stock: weight for stock, weight in zip(stock_data.columns, optimal_weights)}
             st.write(portfolio_weights)
-
-
+        else:
+            st.error("Optimasi portofolio gagal. Coba dengan saham yang berbeda.")