Create app.py

app.py

@@ -0,0 +1,318 @@
+import streamlit as st
+import yfinance as yf
+import pandas as pd
+import numpy as np
+from pykalman import KalmanFilter
+import plotly.graph_objs as go
+import networkx as nx
+
+# Streamlit app setup
+st.set_page_config(layout="wide")
+
+st.title("Herding Behaviour Analysis in Cryptocurrency Markets")
+
+st.markdown(
+    """
+    This app analyzes herding behavior in cryptocurrency markets by examining price movements and correlations.
+    You can specify the cryptocurrency pairs, time period, and other parameters for the analysis.
+    The app includes various analyses such as price reindexing, Kalman Filter estimation of a common factor, 
+    CSSD and CSAD calculations, rolling CSSD and CSAD, and network visualization of correlations.
+    """
+)
+
+st.sidebar.header("How to use")
+st.sidebar.write(
+    """
+    1. Select the cryptocurrency pairs.
+    2. Choose the time period.
+    3. Set additional parameters for the analyses.
+    4. Click 'Run Analysis' to see the results.
+    """
+)
+
+# User inputs in the sidebar
+tickers = st.sidebar.text_area("Asset Symbol (Crypto-Pair or Stock Ticker) (comma-separated)", value="BTC-USD,ETH-USD,BNB-USD,ADA-USD,SOL-USD,DOT-USD,DOGE-USD,AVAX-USD,MATIC-USD,LTC-USD,LUNA1-USD,LINK-USD,ALGO-USD,ATOM-USD,FTT-USD,TRX-USD,ETC-USD,FIL-USD,XMR-USD,XLM-USD").split(",")
+start_date = st.sidebar.date_input("Start Date", value=pd.to_datetime("2020-01-01"))
+end_date = st.sidebar.date_input("End Date", value=pd.to_datetime("2025-01-01"))
+market_index = st.sidebar.text_input("Market Index Ticker", value="BTC-USD")
+run_button = st.sidebar.button("Run Analysis")
+
+if run_button:
+    # Include market index in the tickers list if not already present
+    if market_index not in tickers:
+        tickers.append(market_index)
+
+    # Fetching cryptocurrency data
+    data = yf.download(tickers, start=start_date, end=end_date)['Close']
+
+    # Clean the data by filling or dropping NaN and infinite values
+    data = data.fillna(method='ffill').dropna()
+    data = data.replace([np.inf, -np.inf], np.nan).dropna()
+
+    # Reindexing prices to start at 0
+    st.markdown("#### Cryptocurrency Prices Reindexed to Start at 0")
+    st.markdown("This analysis reindexes cryptocurrency prices to start at 0, making it easier to compare their relative movements over time.")
+    
+    data_reindexed = data.apply(lambda x: x / x.iloc[0])
+    fig = go.Figure()
+
+    for ticker in tickers:
+        fig.add_trace(go.Scatter(x=data_reindexed.index, y=data_reindexed[ticker], mode='lines', name=ticker))
+
+    fig.update_layout(
+        title="Cryptocurrency Prices Reindexed to Start at 0",
+        xaxis_title="Date",
+        yaxis_title="Reindexed Price",
+        template="plotly_dark"
+    )
+    st.plotly_chart(fig, use_container_width=True)
+
+    # Calculating daily returns
+    returns = data.pct_change().dropna()
+
+    # Ensure no inf or NaN values in returns
+    returns = returns.replace([np.inf, -np.inf], np.nan).dropna()
+
+    # Kalman Filter: Estimating a common factor
+    st.markdown("#### Kalman Filter: Estimated Common Factor and Cryptocurrency Returns")
+    st.markdown("This analysis uses the Kalman Filter to estimate a common factor influencing all cryptocurrency returns. It compares individual cryptocurrency returns to the estimated common factor.")
+
+    st.markdown("The Kalman Filter operates based on the following state-space model:")
+
+    st.latex(r"""
+    \text{State Equation:} \quad \mathbf{x}_t = \mathbf{A} \mathbf{x}_{t-1} + \mathbf{w}_t
+    """)
+
+    st.latex(r"""
+    \text{Observation Equation:} \quad \mathbf{y}_t = \mathbf{H} \mathbf{x}_t + \mathbf{v}_t
+    """)
+
+    st.markdown("Where:")
+    st.markdown(r"""
+    \begin{itemize}
+    \item \(\mathbf{x}_t\) is the state vector (the common factor we are estimating).
+    \item \(\mathbf{A}\) is the state transition matrix (set to the identity matrix \(\mathbf{I}\)).
+    \item \(\mathbf{w}_t\) is the process noise (with covariance \(\mathbf{Q}\)).
+    \item \(\mathbf{y}_t\) is the observation vector (cryptocurrency returns).
+    \item \(\mathbf{H}\) is the observation matrix (set to a vector of ones).
+    \item \(\mathbf{v}_t\) is the observation noise (with covariance \(\mathbf{R}\)).
+    \end{itemize}
+    """)
+
+    st.markdown("The Kalman Filter recursively estimates the state vector \(\mathbf{x}_t\) using the observed cryptocurrency returns \(\mathbf{y}_t\). The estimated common factor is then compared to individual cryptocurrency returns.")
+    
+    st.markdown("""
+    The steps to derive the common factor are:
+    1. **Initialization:** Start with an initial estimate of the state vector \(\mathbf{x}_0\) and the initial covariance.
+    2. **Prediction:** Use the state equation to predict the state vector at the next time step.
+    3. **Update:** Use the observation equation and the actual observed returns to update the estimate of the state vector.
+
+    This process repeats for each time step, producing an estimated common factor that influences all cryptocurrency returns.
+    """)
+
+    st.markdown("""
+    **How to Interpret the Results:**
+
+    - **Estimated Common Factor:** This represents the underlying factor that influences all the cryptocurrency returns. If the common factor is high, it indicates that most cryptocurrencies are experiencing high returns. Conversely, if the common factor is low, it indicates that most cryptocurrencies are experiencing low returns.
+    - **Individual Cryptocurrency Returns vs. Common Factor:** By comparing the individual cryptocurrency returns to the estimated common factor, you can identify which cryptocurrencies are moving with the market trend and which are moving independently.
+    - **Deviation from the Common Factor:** Cryptocurrencies that deviate significantly from the common factor may be influenced by specific news or events, whereas cryptocurrencies that closely follow the common factor are more influenced by market-wide factors.
+
+    By observing these comparisons, you can gain insights into the behavior of individual cryptocurrencies relative to the market and identify potential outliers or trend-followers.
+    """)
+
+    observations = returns.values
+    initial_state_mean = np.zeros(1)  
+    kf = KalmanFilter(
+        transition_matrices=np.eye(1),
+        observation_matrices=np.ones((len(tickers), 1)),
+        initial_state_mean=initial_state_mean,
+        observation_covariance=np.eye(len(tickers)),
+        transition_covariance=np.eye(1)
+    )
+
+    state_means, state_covariances = kf.em(observations).filter(observations)
+    fig = go.Figure()
+
+    for i, ticker in enumerate(tickers):
+        fig.add_trace(go.Scatter(x=returns.index, y=observations[:, i], mode='lines', name=f'{ticker} Returns'))
+
+    fig.add_trace(go.Scatter(x=returns.index, y=state_means[:, 0], mode='lines', name='Estimated Common Factor', line=dict(color='red', width=4)))
+    fig.update_layout(
+        title='Kalman Filter: Estimated Common Factor and Cryptocurrency Returns',
+        xaxis_title='Date',
+        yaxis_title='Returns',
+        template='plotly_dark'
+    )
+    st.plotly_chart(fig, use_container_width=True)
+
+    # CSSD and CSAD calculations
+    st.markdown("#### CSSD and CSAD Calculations")
+    st.markdown("This analysis calculates the Cross-Sectional Standard Deviation (CSSD) and Cross-Sectional Absolute Deviation (CSAD) of cryptocurrency returns. These metrics help to identify herding behavior in the market.")
+
+    st.markdown("The formulas for CSSD and CSAD are as follows:")
+
+    st.markdown("**CSSD (Cross-Sectional Standard Deviation):**")
+    st.latex(r"\text{CSSD}_t = \sqrt{\frac{\sum_{i=1}^{N} (R_{i,t} - \overline{R}_t)^2}{N - 1}}")
+
+    st.markdown("""
+    Where:
+    - \(R_{i,t}\) is the return of cryptocurrency \(i\) at time \(t\).
+    - \(\overline{R}_t\) is the average return of all cryptocurrencies at time \(t\).
+    - \(N\) is the number of cryptocurrencies.
+    """)
+
+    st.markdown("**CSAD (Cross-Sectional Absolute Deviation):**")
+    st.latex(r"\text{CSAD}_t = \frac{\sum_{i=1}^{N} |R_{i,t} - \overline{R}_t|}{N}")
+
+    st.markdown("""
+    Where:
+    - \(R_{i,t}\) is the return of cryptocurrency \(i\) at time \(t\).
+    - \(\overline{R}_t\) is the average return of all cryptocurrencies at time \(t\).
+    - \(N\) is the number of cryptocurrencies.
+    """)
+
+    st.markdown("These metrics help to identify herding behavior by measuring the dispersion of individual cryptocurrency returns around the market return.")
+
+    st.markdown("""
+    **How to Interpret the Results:**
+
+    - **CSSD (Cross-Sectional Standard Deviation):** A higher CSSD indicates greater dispersion of individual cryptocurrency returns around the market return, suggesting less herding behavior. Conversely, a lower CSSD indicates that cryptocurrency returns are more closely clustered around the market return, suggesting more herding behavior.
+    - **CSAD (Cross-Sectional Absolute Deviation):** A higher CSAD also indicates greater dispersion of individual cryptocurrency returns around the market return, suggesting less herding behavior. A lower CSAD suggests more herding behavior as cryptocurrency returns are more closely clustered around the market return.
+
+    By observing the trends in CSSD and CSAD over time, you can identify periods of increased or decreased herding behavior in the market.
+    """)
+
+    market_return = returns[market_index]
+    returns = returns.drop(columns=[market_index])
+
+    def calculate_cssd(returns, market_return):
+        cssd = np.sqrt(((returns - market_return[:, None]) ** 2).sum(axis=1) / (returns.shape[1] - 1))
+        return cssd
+
+    def calculate_csad(returns, market_return):
+        csad = (np.abs(returns - market_return[:, None]).sum(axis=1)) / returns.shape[1]
+        return csad
+
+    cssd = calculate_cssd(returns.values, market_return.values)
+    csad = calculate_csad(returns.values, market_return.values)
+
+    # Rolling CSSD and CSAD calculations
+    window_size = 30
+
+    def rolling_csad(stock_returns, market_returns, window):
+        csad_values = []
+        for i in range(len(stock_returns) - window + 1):
+            window_data = stock_returns.iloc[i:i+window]
+            window_market = market_returns[i:i+window].mean()
+            N = len(window_data.columns)
+            csad = (1 / N) * np.sum(np.abs(window_data.sub(window_market, axis=0)).mean(axis=1))
+            csad_values.append(csad)
+        return pd.Series(csad_values, index=stock_returns.index[window-1:])
+
+    def rolling_cssd(stock_returns, market_returns, window):
+        cssd_values = []
+        for i in range(len(stock_returns) - window + 1):
+            window_data = stock_returns.iloc[i:i+window]
+            window_market = market_returns[i:i+window].mean()
+            N = len(window_data.columns)
+            cssd = np.sqrt((1 / (N - 1)) * np.sum(np.square(window_data.sub(window_market, axis=0)).mean(axis=1)))
+            cssd_values.append(cssd)
+        return pd.Series(cssd_values, index=stock_returns.index[window-1:])
+
+    rolling_csad_values = rolling_csad(returns, market_return, window_size)
+    rolling_cssd_values = rolling_cssd(returns, market_return, window_size)
+
+    fig = go.Figure()
+    fig.add_trace(go.Scatter(x=returns.index, y=cssd, mode='lines', name='CSSD', line=dict(color='blue')))
+    fig.add_trace(go.Scatter(x=returns.index, y=csad, mode='lines', name='CSAD', line=dict(color='red')))
+    fig.add_trace(go.Scatter(x=rolling_csad_values.index, y=rolling_csad_values, mode='lines', name='Rolling CSAD (30 days)', line=dict(color='orange')))
+    fig.add_trace(go.Scatter(x=rolling_cssd_values.index, y=rolling_cssd_values, mode='lines', name='Rolling CSSD (30 days)', line=dict(color='green')))
+    fig.update_layout(
+        title='CSSD, CSAD, Rolling CSAD, and Rolling CSSD over Time',
+        xaxis_title='Date',
+        yaxis_title='Value',
+        template='plotly_dark'
+    )
+    st.plotly_chart(fig, use_container_width=True)
+
+    # Network visualization of cryptocurrency correlations
+    st.markdown("#### Network Visualization of Cryptocurrency Correlations")
+    st.markdown("This analysis visualizes the correlations between cryptocurrencies as a network. Cryptocurrencies are connected by edges if their correlation exceeds a threshold.")
+    st.markdown("""
+    **How to Interpret the Results:**
+
+    - **Nodes:** Each node represents a cryptocurrency. The position of the nodes is determined by a spring layout algorithm, which places highly connected nodes closer together.
+    - **Edges:** An edge (or line) between two nodes indicates that the correlation between the two cryptocurrencies exceeds the specified threshold (0.5 in this case).
+    - **Edge Thickness:** The thickness of the edge represents the strength of the correlation. Thicker edges indicate higher correlations.
+    - **Cluster Formation:** Groups of nodes that are densely connected to each other represent clusters of cryptocurrencies that move together. This can indicate sector-specific movements or broader market trends.
+    - **Isolated Nodes:** Nodes that are not connected to others suggest that those cryptocurrencies do not have strong correlations with the rest of the market within the given threshold.
+
+    By examining this network, you can identify groups of cryptocurrencies that tend to move together, which may reflect sector-specific behavior or broader market dynamics. This can provide insights into the structure of the market and potential areas of risk or opportunity.
+    """)
+    
+    years = data.index.year.unique()
+
+    def plot_network_for_year(data_for_year, year):
+        corr_matrix = data_for_year.corr()
+        G = nx.Graph()
+
+        for ticker in tickers:
+            G.add_node(ticker)
+
+        threshold = 0.5
+        for i in range(len(tickers)):
+            for j in range(i+1, len(tickers)):
+                if abs(corr_matrix.iloc[i, j]) > threshold:
+                    G.add_edge(tickers[i], tickers[j], weight=corr_matrix.iloc[i, j])
+
+        pos = nx.spring_layout(G)
+        edge_trace = []
+
+        for edge in G.edges(data=True):
+            x0, y0 = pos[edge[0]]
+            x1, y1 = pos[edge[1]]
+            trace = go.Scatter(
+                x=[x0, x1, None],
+                y=[y0, y1, None],
+                line=dict(width=2, color='blue'),
+                hoverinfo='none',
+                mode='lines'
+            )
+            edge_trace.append(trace)
+
+        node_trace = go.Scatter(
+            x=[pos[node][0] for node in G.nodes()],
+            y=[pos[node][1] for node in G.nodes()],
+            text=[node for node in G.nodes()],
+            mode='markers+text',
+            textposition='top center',
+            hoverinfo='text',
+            marker=dict(
+                size=10,
+                color='red',
+            )
+        )
+
+        layout = go.Layout(
+            title=f'Cryptocurrency Correlation Network for {year}',
+            showlegend=False,
+            hovermode='closest',
+            margin=dict(b=20, l=5, r=5, t=40),
+            xaxis=dict(showgrid=False, zeroline=False, showticklabels=False),
+            yaxis=dict(showgrid=False, zeroline=False, showticklabels=False)
+        )
+
+        fig = go.Figure(data=edge_trace + [node_trace], layout=layout)
+        st.plotly_chart(fig, use_container_width=True)
+
+    for year in years:
+        data_for_year = data[data.index.year == year]
+        plot_network_for_year(data_for_year, year)
+
+hide_streamlit_style = """
+<style>
+#MainMenu {visibility: hidden;}
+footer {visibility: hidden;}
+</style>
+"""
+st.markdown(hide_streamlit_style, unsafe_allow_html=True)