Create app.py

app.py

@@ -0,0 +1,360 @@
+import streamlit as st
+import yfinance as yf
+import pandas as pd
+import numpy as np
+import plotly.graph_objects as go
+from fastdtw import fastdtw
+from scipy.spatial.distance import euclidean
+import ta
+from sklearn.decomposition import PCA
+from sklearn.impute import SimpleImputer
+
+# Function to normalize the time series
+def normalize(ts):
+    return (ts - ts.min()) / (ts.max() - ts.min())
+
+# Function to calculate DTW distance
+def dtw_distance(ts1, ts2):
+    ts1_normalized = normalize(ts1)
+    ts2_normalized = normalize(ts2)
+    distance, _ = fastdtw(ts1_normalized.reshape(-1, 1), ts2_normalized.reshape(-1, 1), dist=euclidean)
+    return distance
+
+# Function to calculate correlation
+def correlation(ts1, ts2):
+    return np.corrcoef(ts1, ts2)[0, 1]
+
+# Function to find most similar patterns using DTW
+def find_most_similar_pattern_dtw(price_data_pct_change, n_days, subsequent_days):
+    current_window = price_data_pct_change[-n_days:].values
+
+    min_distances = [(float('inf'), -1), (float('inf'), -1), (float('inf'), -1)]
+    for start_index in range(len(price_data_pct_change) - 2 * n_days - subsequent_days):
+        past_window = price_data_pct_change[start_index:start_index + n_days].values
+        distance = dtw_distance(current_window, past_window)
+
+        for i, (min_distance, _) in enumerate(min_distances):
+            if distance < min_distance:
+                min_distances[i] = (distance, start_index)
+                break
+
+    return min_distances
+
+# Function to find most similar patterns using correlation
+def find_most_similar_pattern_corr(price_data_pct_change, n_days, subsequent_days, pre_days):
+    current_window = price_data_pct_change[-n_days:].values
+
+    max_correlations = [(float('-inf'), -1), (float('-inf'), -1), (float('-inf'), -1)]
+    for start_index in range(len(price_data_pct_change) - 2 * n_days - subsequent_days):
+        past_window = price_data_pct_change[start_index:start_index + n_days].values
+        corr = correlation(current_window, past_window)
+
+        for i, (max_corr, _) in enumerate(max_correlations):
+            if corr > max_corr:
+                max_correlations[i] = (corr, start_index)
+                break
+
+    return max_correlations
+
+# Add technical analysis features
+def add_ta_features(data):
+    data['trend_ichimoku_conv'] = ta.trend.ichimoku_a(data['High'], data['Low'])
+    data['trend_ema_slow'] = ta.trend.ema_indicator(data['Close'], 50)
+    data['momentum_kama'] = ta.momentum.kama(data['Close'])
+    data['trend_psar_up'] = ta.trend.psar_up(data['High'], data['Low'], data['Close'])
+    data['volume_vwap'] = ta.volume.VolumeWeightedAveragePrice(data['High'], data['Low'], data['Close'], data['Volume']).volume_weighted_average_price()
+    data['trend_ichimoku_a'] = ta.trend.ichimoku_a(data['High'], data['Low'])
+    data['volatility_kcl'] = ta.volatility.KeltnerChannel(data['High'], data['Low'], data['Close']).keltner_channel_lband()
+    data['trend_ichimoku_b'] = ta.trend.ichimoku_b(data['High'], data['Low'])
+    data['trend_ichimoku_base'] = ta.trend.ichimoku_base_line(data['High'], data['Low'])
+    data['trend_sma_fast'] = ta.trend.sma_indicator(data['Close'], 20)
+    data['volatility_dcm'] = ta.volatility.DonchianChannel(data['High'], data['Low'], data['Close']).donchian_channel_mband()
+    data['volatility_bbl'] = ta.volatility.BollingerBands(data['Close']).bollinger_lband()
+    data['volatility_bbm'] = ta.volatility.BollingerBands(data['Close']).bollinger_mavg()
+    data['volatility_kcc'] = ta.volatility.KeltnerChannel(data['High'], data['Low'], data['Close']).keltner_channel_mband()
+    data['volatility_kch'] = ta.volatility.KeltnerChannel(data['High'], data['Low'], data['Close']).keltner_channel_hband()
+    data['trend_sma_slow'] = ta.trend.sma_indicator(data['Close'], 200)
+    data['trend_ema_fast'] = ta.trend.ema_indicator(data['Close'], 20)
+    data['volatility_dch'] = ta.volatility.DonchianChannel(data['High'], data['Low'], data['Close']).donchian_channel_hband()
+    data['others_cr'] = ta.others.cumulative_return(data['Close'])
+    data['Adj Close'] = data['Close']
+    
+    return data
+
+def dtw_distance_with_ta(ts1, ts2, ts1_ta, ts2_ta, weight=0.8):
+    ts1_normalized = normalize(ts1)
+    ts2_normalized = normalize(ts2)
+    distance_pct_change, _ = fastdtw(ts1_normalized.reshape(-1, 1), ts2_normalized.reshape(-1, 1), dist=euclidean)
+
+    distance_ta, _ = fastdtw(ts1_ta, ts2_ta, dist=euclidean)
+    distance = weight * distance_pct_change + (1 - weight) * distance_ta
+    return distance
+
+def extract_and_reduce_features(data, n_components=3):
+    ta_features = data.drop(columns=['Open', 'High', 'Low', 'Close', 'Volume', 'Adj Close'])
+    
+    imputer = SimpleImputer(strategy='mean')
+    imputed_ta_features = imputer.fit_transform(ta_features)
+    
+    pca = PCA(n_components=n_components)
+    reduced_features = pca.fit_transform(imputed_ta_features)
+    return reduced_features
+
+# Streamlit app
+st.set_page_config(page_title="Pattern Recognition", layout="wide")
+st.title('Pattern Recognition in Stock Prices')
+
+# Sidebar for method selection
+selected = st.sidebar.radio("Select Method", ["DTW Pattern Recognition", "Correlation Pattern Recognition", "TA-Enhanced DTW Pattern Recognition"])
+
+# Sidebar for input parameters
+st.sidebar.header("Input Parameters")
+ticker = st.sidebar.text_input('Enter Stock Ticker', 'ASML.AS')
+start_date = st.sidebar.date_input('Start Date', pd.to_datetime('2000-01-01'))
+end_date = st.sidebar.date_input('End Date', pd.to_datetime('2023-12-30'))
+subsequent_days = st.sidebar.slider('Subsequent Days to Forecast', min_value=5, max_value=60, value=20, step=5)
+n_days_options = st.sidebar.multiselect('Days to Compare', options=[15, 20, 30, 40, 50], default=[15, 20, 40])
+pre_days = st.sidebar.slider('Days Prior to Similar Series', min_value=10, max_value=100, value=60, step=10)
+
+if 'data' not in st.session_state:
+    st.session_state.data = None
+if 'price_data_pct_change' not in st.session_state:
+    st.session_state.price_data_pct_change = None
+if 'data_with_ta' not in st.session_state:
+    st.session_state.data_with_ta = None
+if 'reduced_features' not in st.session_state:
+    st.session_state.reduced_features = None
+if 'results_dtw' not in st.session_state:
+    st.session_state.results_dtw = None
+if 'results_corr' not in st.session_state:
+    st.session_state.results_corr = None
+if 'results_ta_dtw' not in st.session_state:
+    st.session_state.results_ta_dtw = None
+
+def run_dtw():
+    min_distances = []
+    figs = []
+    for n_days in n_days_options:
+        min_distances.append(find_most_similar_pattern_dtw(st.session_state.price_data_pct_change, n_days, subsequent_days))
+
+        fig1 = go.Figure()
+        # Plot the entire stock price data
+        fig1.add_trace(go.Scatter(x=st.session_state.price_data.index, y=st.session_state.price_data, mode='lines', name='Overall stock price', line=dict(color='blue')))
+        colors = ['red', 'green', 'orange']
+        for i, (_, start_index) in enumerate(min_distances[-1]):
+            # Plot the pattern period
+            past_window_start_date = st.session_state.price_data.index[start_index]
+            past_window_end_date = st.session_state.price_data.index[start_index + n_days + subsequent_days]
+            fig1.add_trace(go.Scatter(x=st.session_state.price_data[past_window_start_date:past_window_end_date].index,
+                                      y=st.session_state.price_data[past_window_start_date:past_window_end_date],
+                                      mode='lines', name=f"Pattern {i + 1}", line=dict(color=colors[i % len(colors)])))
+
+        # Add labels and legend
+        fig1.update_layout(title=f'{ticker} Stock Price Data',
+                           xaxis_title='Date',
+                           yaxis_title='Stock Price',
+                           legend_title='Legend')
+
+        reindexed_current_window = (st.session_state.price_data_pct_change[-n_days:] + 1).cumprod() * 100
+        fig2 = go.Figure()
+        for i, (_, start_index) in enumerate(min_distances[-1]):
+            past_window = st.session_state.price_data_pct_change[start_index:start_index + n_days + subsequent_days]
+            reindexed_past_window = (past_window + 1).cumprod() * 100
+            fig2.add_trace(go.Scatter(x=list(range(n_days + subsequent_days)), y=reindexed_past_window,
+                                      mode='lines', name=f"Past window {i + 1} (with subsequent {subsequent_days} days)",
+                                      line=dict(color=colors[i % len(colors)], width=3 if i == 0 else 1)))
+
+        fig2.add_trace(go.Scatter(x=list(range(n_days)), y=reindexed_current_window, mode='lines',
+                                  name="Current window", line=dict(color='black', width=3)))
+
+        fig2.update_layout(title=f"Most similar {n_days}-day patterns in {ticker} stock price history (aligned, reindexed)",
+                           xaxis_title="Days",
+                           yaxis_title="Reindexed Price",
+                           legend_title="Legend")
+
+        figs.append((fig1, fig2))
+
+    st.session_state.results_dtw = figs
+
+def run_corr():
+    max_correlations = []
+    figs = []
+    for n_days in n_days_options:
+        max_correlations.append(find_most_similar_pattern_corr(st.session_state.price_data_pct_change, n_days, subsequent_days, pre_days))
+
+        fig1 = go.Figure()
+        # Plot the entire stock price data
+        fig1.add_trace(go.Scatter(x=st.session_state.price_data.index, y=st.session_state.price_data, mode='lines', name='Overall stock price', line=dict(color='blue')))
+        colors = ['red', 'green', 'orange']
+        for i, (_, start_index) in enumerate(max_correlations[-1]):
+            # Plot the previous period
+            past_window_start_date = st.session_state.price_data.index[start_index - pre_days]
+            past_window_end_date = st.session_state.price_data.index[start_index + n_days + subsequent_days]
+            fig1.add_trace(go.Scatter(x=st.session_state.price_data[past_window_start_date:past_window_end_date].index,
+                                      y=st.session_state.price_data[past_window_start_date:past_window_end_date],
+                                      mode='lines', name=f"Pattern {i + 1}", line=dict(color=colors[i % len(colors)])))
+
+        # Add labels and legend
+        fig1.update_layout(title=f'{ticker} Stock Price Data',
+                           xaxis_title='Date',
+                           yaxis_title='Stock Price',
+                           legend_title='Legend')
+
+        reindexed_current_window = (st.session_state.price_data_pct_change[-n_days:] + 1).cumprod() * 100
+        fig2 = go.Figure()
+        for i, (_, start_index) in enumerate(max_correlations[-1]):
+            past_window = st.session_state.price_data_pct_change[start_index:start_index + n_days + subsequent_days]
+            reindexed_past_window = (past_window + 1).cumprod() * 100
+            fig2.add_trace(go.Scatter(x=list(range(pre_days, pre_days + n_days + subsequent_days)), y=reindexed_past_window,
+                                      mode='lines', name=f"Past window {i + 1} (with subsequent {subsequent_days} days)",
+                                      line=dict(color=colors[i % len(colors)], width=3 if i == 0 else 1)))
+
+        fig2.add_trace(go.Scatter(x=list(range(pre_days, pre_days + n_days)), y=reindexed_current_window, mode='lines',
+                                  name="Current window", line=dict(color='black', width=3)))
+
+        fig2.update_layout(title=f"Most similar {n_days}-day patterns in {ticker} stock price history (aligned, reindexed with correlation)",
+                           xaxis_title="Days",
+                           yaxis_title="Reindexed Price",
+                           legend_title="Legend")
+
+        figs.append((fig1, fig2))
+
+    st.session_state.results_corr = figs
+
+def run_ta_dtw():
+    min_distance_indices = []
+    figs = []
+    for n_days in n_days_options:
+        current_window = st.session_state.price_data_pct_change[-n_days:].values
+        current_ta_window = st.session_state.reduced_features[-n_days:]
+
+        distances = [dtw_distance_with_ta(current_window, st.session_state.price_data_pct_change[start_index:start_index + n_days].values, 
+                                         current_ta_window, st.session_state.reduced_features[start_index:start_index + n_days]) 
+                     for start_index in range(len(st.session_state.price_data_pct_change) - 2 * n_days - subsequent_days)]
+
+        min_distance_indices.append(np.argsort(distances)[:3])  # find indices of 3 smallest distances
+
+        fig1 = go.Figure()
+        # Plot the entire stock price data
+        fig1.add_trace(go.Scatter(x=st.session_state.data.index, y=st.session_state.data['Close'], mode='lines', name='Overall stock price', line=dict(color='blue')))
+        colors = ['red', 'green', 'orange']
+        for i, start_index in enumerate(min_distance_indices[-1]):
+            # Plot the pattern period
+            past_window_start_date = st.session_state.data.index[start_index]
+            past_window_end_date = st.session_state.data.index[start_index + n_days + subsequent_days]
+            fig1.add_trace(go.Scatter(x=st.session_state.data['Close'][past_window_start_date:past_window_end_date].index,
+                                      y=st.session_state.data['Close'][past_window_start_date:past_window_end_date],
+                                      mode='lines', name=f"Pattern {i + 1}", line=dict(color=colors[i % len(colors)])))
+
+        # Add labels and legend
+        fig1.update_layout(title=f'{ticker} Stock Price Data',
+                           xaxis_title='Date',
+                           yaxis_title='Stock Price',
+                           legend_title='Legend')
+
+        reindexed_current_window = (st.session_state.price_data_pct_change[-n_days:] + 1).cumprod() * 100
+        fig2 = go.Figure()
+        for i, start_index in enumerate(min_distance_indices[-1]):
+            past_window = st.session_state.price_data_pct_change[start_index:start_index + n_days + subsequent_days]
+            reindexed_past_window = (past_window + 1).cumprod() * 100
+            fig2.add_trace(go.Scatter(x=list(range(n_days + subsequent_days)), y=reindexed_past_window,
+                                      mode='lines', name=f"Past window {i + 1} (with subsequent {subsequent_days} days)",
+                                      line=dict(color=colors[i % len(colors)], width=3 if i == 0 else 1)))
+
+        fig2.add_trace(go.Scatter(x=list(range(n_days)), y=reindexed_current_window, mode='lines',
+                                  name="Current window", line=dict(color='black', width=3)))
+
+        fig2.update_layout(title=f"Most similar {n_days}-day patterns in {ticker} stock price history (aligned, reindexed)",
+                           xaxis_title="Days",
+                           yaxis_title="Reindexed Price",
+                           legend_title="Legend")
+
+        figs.append((fig1, fig2))
+
+    st.session_state.results_ta_dtw = figs
+
+if st.sidebar.button('Run'):
+    st.session_state.data = yf.download(ticker, start=start_date, end=end_date)
+    if not st.session_state.data.empty:
+        st.session_state.price_data = st.session_state.data['Close']
+        st.session_state.price_data_pct_change = st.session_state.price_data.pct_change().dropna()
+        st.session_state.data_with_ta = add_ta_features(st.session_state.data)
+        st.session_state.reduced_features = extract_and_reduce_features(st.session_state.data_with_ta, n_components=2)
+
+        if selected == "DTW Pattern Recognition":
+            run_dtw()
+        elif selected == "Correlation Pattern Recognition":
+            run_corr()
+        elif selected == "TA-Enhanced DTW Pattern Recognition":
+            run_ta_dtw()
+
+# Display results and descriptions based on the selected method
+if selected == "DTW Pattern Recognition":
+    st.markdown("""
+    ### DTW Pattern Recognition
+    
+    This method uses Dynamic Time Warping (DTW) to find patterns in stock prices. DTW is an algorithm that measures similarity between two temporal sequences, which may vary in time or speed. By comparing the current pattern with historical data, it identifies periods in the past with the most similar patterns.
+
+    **How to use:**
+    1. Enter the stock ticker, start date, and end date.
+    2. Select the number of subsequent days to forecast.
+    3. Select the number of days to compare.
+    4. Click the 'Run' button.
+    
+    **Results:**
+    The left chart shows the entire stock price data with the identified patterns highlighted. The right chart shows the reindexed price patterns for comparison.
+    """)
+    if st.session_state.results_dtw:
+        for fig1, fig2 in st.session_state.results_dtw:
+            col1, col2 = st.columns(2)
+            with col1:
+                st.plotly_chart(fig1)
+            with col2:
+                st.plotly_chart(fig2)
+
+elif selected == "Correlation Pattern Recognition":
+    st.markdown("""
+    ### Correlation Pattern Recognition
+    
+    This method calculates the correlation between the current stock price pattern and historical patterns. Correlation measures how closely two time series move together. Higher correlation values indicate more similar patterns.
+
+    **How to use:**
+    1. Enter the stock ticker, start date, and end date.
+    2. Select the number of subsequent days to forecast.
+    3. Select the number of days to compare.
+    4. Select the number of days prior to the similar series.
+    5. Click the 'Run' button.
+    
+    **Results:**
+    The left chart shows the entire stock price data with the identified patterns highlighted. The right chart shows the reindexed price patterns for comparison.
+    """)
+    if st.session_state.results_corr:
+        for fig1, fig2 in st.session_state.results_corr:
+            col1, col2 = st.columns(2)
+            with col1:
+                st.plotly_chart(fig1)
+            with col2:
+                st.plotly_chart(fig2)
+
+elif selected == "TA-Enhanced DTW Pattern Recognition":
+    st.markdown("""
+    ### TA-Enhanced DTW Pattern Recognition
+    
+    This method combines technical analysis (TA) features with DTW to enhance pattern recognition. It integrates various TA indicators into the time series data and uses DTW to find the most similar historical patterns, providing a more comprehensive analysis.
+
+    **How to use:**
+    1. Enter the stock ticker, start date, and end date.
+    2. Select the number of subsequent days to forecast.
+    3. Select the number of days to compare.
+    4. Click the 'Run' button.
+    
+    **Results:**
+    The left chart shows the entire stock price data with the identified patterns highlighted. The right chart shows the reindexed price patterns for comparison.
+    """)
+    if st.session_state.results_ta_dtw:
+        for fig1, fig2 in st.session_state.results_ta_dtw:
+            col1, col2 = st.columns(2)
+            with col1:
+                st.plotly_chart(fig1)
+            with col2:
+                st.plotly_chart(fig2)