Duplicate from MichaelBurry/Error_

Co-authored-by: Burry <MichaelBurry@users.noreply.huggingface.co>

.gitattributes

@@ -0,0 +1,3 @@
+data_and_sp500.csv filter=lfs diff=lfs merge=lfs -text
+correlation_matrix.csv filter=lfs diff=lfs merge=lfs -text
+us-shareprices-daily.csv filter=lfs diff=lfs merge=lfs -text

README.md

@@ -0,0 +1,13 @@
+---
+title: Cse6242 Dataminers
+emoji: 📚
+colorFrom: pink
+colorTo: pink
+sdk: streamlit
+sdk_version: 1.10.0
+app_file: app.py
+pinned: false
+duplicated_from: MichaelBurry/Error_
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,283 @@
+import streamlit as st
+from datetime import date, timedelta
+#from rest_api.fetch_data import (get_symbol_data)
+import pandas as pd
+from PIL import Image
+import time
+
+from plots import (
+    beta,
+    basic_portfolio,
+    # display_portfolio_return,
+    display_heat_map,
+    #circle_packing,
+    ER,
+    buble_interactive
+)
+
+### Koi
+from ef import(
+    ef_viz
+)
+def risk_str(num):
+    if num >=5 and num <15:
+        return 'Low Risk Aversion'
+    elif num >= 15 and num <25:
+        return 'Medium Risk Aversion'
+    elif num >= 25 and num <=35:
+        return 'High Risk Aversion'
+#### Koi
+        
+from sharp_ratio import(
+    cumulative_return,
+    
+    sharp_ratio_func
+)
+
+from arima import (
+    # get_model_accuracy,
+    arima_chart
+)
+
+
+        
+def load_heading():
+    """The function that displays the heading.
+        Provides instructions to the user
+    """
+    with st.container():
+        st.title('Dataminers')
+        header = st.subheader('This App performs historical portfolio analysis and future analysis ')
+        st.subheader('Please read the instructions carefully and enjoy!')
+        # st.text('This is some text.')
+
+
+def get_choices():
+    """Prompts the dialog to get the All Choices.
+    Returns:
+        An object of choices and an object of combined dataframes.
+    """
+    choices = {}
+    #tab1, tab2, tab3, tab4, tab5 = st.tabs(["Tickers", "Quantity", "Benchmark","Risk Free Return","Risk Aversion"])
+
+    tickers = st.sidebar.text_input('Enter stock tickers.', 'GOOG,AA,AVGO,AMD')
+
+    # Set the weights
+    weights_str = st.sidebar.text_input('Enter the investment quantities', '50,30,25,25')
+
+    benchmark = st.sidebar.selectbox(
+        'Select your ideal benchmark of return',
+        ('SP500', 'AOK', 'IXIC'))
+    if benchmark == 'IXIC':
+        st.sidebar.warning("You have selected a volatile benchmark.")
+    elif benchmark == 'SP500':
+        st.sidebar.success('You have selected a balanced benchmark')
+    elif benchmark == 'AOK':
+        st.sidebar.success('You have selected a conservative benchmark')
+
+    ### koi
+    rf = st.sidebar.number_input('Enter current rate of risk free return', min_value=0.001, max_value=1.00, value=0.041)
+
+
+    #A_coef_map = 
+    A_coef = st.sidebar.slider('Enter The Coefficient of Risk Aversion', min_value=5, max_value=35, value=30, step=5)
+
+    if A_coef > 20:
+        st.sidebar.success("You have selected a "+ risk_str(A_coef) +" investing style")
+        investing_style = 'Conservative'
+    elif A_coef >10 and A_coef <= 20:
+        st.sidebar.success("You have selected a "+risk_str(A_coef) +" investing style")
+        investing_style = 'Balanced'
+    elif A_coef <= 10:
+        st.sidebar.warning("You have selected a "+ risk_str(A_coef) +" investing style")
+        investing_style = 'Risky'
+
+    # Every form must have a submit button.
+    submitted = st.sidebar.button("Calculate")
+
+    symbols = []
+    reset = False
+
+    # Reusable Error Button DRY!
+    #def reset_app(error):
+    #    st.sidebar.write(f"{error}!")
+    #    st.sidebar.write(f"Check The Syntax")
+    #    reset = st.sidebar.button("RESET APP")
+
+    if submitted:
+        #with st.spinner('Running the calculations...'):
+        #    time.sleep(8)
+        #    st.success('Done!')
+        # convert  strings to lists
+        tickers_list = tickers.split(",")
+        weights_list = weights_str.split(",")
+        #crypto_symbols_list = crypto_symbols.split(",")
+        # Create the Symbols List
+        symbols.extend(tickers_list)
+        #symbols.extend(crypto_symbols_list)
+        # Convert Weights To Decimals
+        weights = []
+        for item in weights_list:
+            weights.append(float(item))
+
+        if reset:
+        #    # Clears all singleton caches:
+            #tickers = st.sidebar.selectbox('Enter 11 stock symbols.', ('GOOG','D','AAP','BLK'))
+        #    crypto_symbols = st.sidebar.text_input('Enter 2 crypto symbols only as below', 'BTC-USD,ETH-USD')
+            #weights_str = st.sidebar.text_input('Enter The Investment Weights', '0.3,0.3 ,0.3')
+
+            st.experimental_singleton.clear()
+
+
+        else:
+            # Submit an object with choices
+            choices = {
+
+                'symbols': symbols,
+                'weights': weights,
+                'benchmark': benchmark,
+                'investing_style': investing_style,
+                'risk-free-rate': rf,
+                'A-coef': A_coef
+
+            }
+            # Load combined_df
+            data = pd.read_csv('data_and_sp500.csv')
+            combined_df = data[tickers_list]
+            raw_data=pd.read_csv('us-shareprices-daily.csv', sep=';')
+            # return object of objects
+            return {
+                'choices': choices,
+                'combined_df': combined_df,
+                'data': data,
+                'raw_data':raw_data
+            }
+
+
+def run():
+    """The main function for running the script."""
+
+    load_heading()
+    choices = get_choices()
+    if choices:
+        st.success('''** Selected Tickers **''')     
+        buble_interactive(choices['data'],choices['choices'])
+        st.header('Tickers Beta')
+        """
+        The Capital Asset Pricing Model (CAPM) utilizes a formula to enable the application to calculate
+risk, return, and variability of return with respect to a benchmark. The application uses this
+benchmark, currently S&P 500 annual rate of return, to calculate the return of a stock using
+Figure 2 in Appendix A. Elements such as beta can be calculated using the formula in Appendix
+A Figure 1. The beta variable will serve as a variable to be used for calculating the variability of
+the stock with respect to the benchmark. This variability factor will prove useful for a variety of
+calculations such as understanding market risk and return. If the beta is equal to 1.0, the stock
+price is correlated with the market. When beta is smaller than 1.0, the stock is less volatile than
+the market. If beta is greater than 1.0, the stock is more volatile than the market.
+The CAPM model was run for 9 stocks, using 10-year daily historical data for initial test analysis.
+With this initial analysis, beta was calculated to determine the stock’s risk by measuring the
+price changes to the benchmark. By using CAPM model, annual expected return and portfolio
+return is calculated. The model results can be found in Appendix A.
+        """
+        
+        beta(choices['data'], choices['choices'])
+        ER(choices['data'], choices['choices'])
+        ##### EDIT HERE ##### koi
+        st.header('CAPM Model and the Efficient Frontier')
+        """
+    CAPM model measures systematic risks, however many of it's functions have unrealistic assumptions and rely heavily on a linear interpretation 
+    of the risks vs. returns relationship. It is better to use CAPM model in conjunction with the Efficient Frontier to better
+    graphically depict volatility (a measure of investment risk) for the defined rate of return. \n
+    Below we map the linear Utility function from the CAPM economic model along with the Efficient Frontier
+    Each circle depicted above is a variation of the portfolio with the same input asset, only different weights. 
+    Portfolios with higher volatilities have a yellower shade of hue, while portfolios with a higher return have a larger radius. \n
+    As you input different porfolio assets, take note of how diversification can improve a portfolio's risk versus reward profile.
+        """
+        ef_viz(choices['data'],choices['choices'])
+        """
+    There are in fact two components of the Efficient Frontier: the Efficient Frontier curve itself and the Minimum Variance Frontier. 
+    The lower curve, which is also the Minimum Variance Frontier will contain assets in the portfolio 
+    that has the lowest volatility. If our portfolio contains "safer" assets such as Governmental Bonds, the further to the right 
+    of the lower curve we will see a portfolio that contains only these "safe" assets, the portfolios on 
+    this curve, in theory, will have diminishing returns.\n
+    The upper curve, which is also the Efficient Frontier, contains portfolios that have marginally increasing returns as the risks 
+    increases. In theory, we want to pick a portfolio on this curve, as these portfolios contain more balanced weights of assets 
+    with acceptable trade-offs between risks and returns. \n
+    If an investor is more comfortable with investment risks, they can pick a portfolio on the right side of the Efficient Frontier. 
+    Whereas, a conservative investor might want to pick a portfolio from the left side of the Efficient Frontier. \n
+    Take notes of the assets' Betas and how that changes the shape of the curve as well. \n 
+    How does the shape of the curve change when 
+    the assets are of similar Beta vs when they are all different?\n 
+    Note the behavior of the curve when the portfolio contains only assets with Betas higher than 1 vs. when Betas are lower than 1.\n  
+
+        """
+        ##### ##### Koi
+        # Creates the title for streamlit
+        st.subheader('Portfolio Historical Normalized Cumulative Returns')
+        """
+Cumulative Returns:\n 
+The cumulative return of an asset is calculated by subtracting the original price paid from the current profit or loss. This answers the question, 
+what is the return on my initial investment?\n 
+The graph below shows the historical normalized cumulative returns for each of the chosen assets for the entire time period of the available data. 
+The default line chart shows tickers AA, AMD, AVGO, and GOOG and we can see that all have a positive cumulative return over the period of the available data. 
+Any of these assets purchased on the starting day and sold on the ending day for the period would have earned a return on their investment.\n
+This chart can also be used to analyze the correlation of the returns of the chosen assets over the displayed period. 
+Any segments of the line charts that show cumulative returns with similarly or oppositely angled segments can be considered to have some level of 
+correlation during those periods. 
+        """
+        basic_portfolio(choices['combined_df'])
+        """
+Negative Correlations (1): \n
+Occur for assets whose cumulative returns move in opposite directions. When one goes up the other goes down and vice versa. 
+These negatively correlated assets would offer some level of diversification protection to each other. 
+Perfectly negatively correlated stocks are sort of the goal, but unlikely to be common. 
+In most cases finding some level of negatively correlated stocks, should offer some level of diversification protection to your portfolio. 
+The amount of protection depends upon the calculated metric. Our tool includes some CAPM analysis, which attempts to relate the risk and return 
+and the correlation of assets to determine the expected portfolio returns versus the combined, hopefully reduced, risk.\n
+
+Positive Correlations (2):\n 
+Occur for assets whose cumulative returns move in concert. When one goes up the other also goes up and vice versa. 
+These positively correlated assets would not offer much or any diversification protection to each other.\n 
+        """
+        im = Image.open('1vs2.png')
+        col1, col2, col3 = st.columns([1,6,1])
+
+        with col1:
+            st.write("")
+    
+        with col2:
+            st.image(im, caption='Trends of Assets Correlations',use_column_width='auto')
+    
+        with col3:
+            st.write("")
+            
+            # Creates the title for streamlit
+        st.subheader('Heatmap Showing Correlation Of Assets')
+        """
+Heatmap: \n
+The Heat map shows the overall correlation of each asset to the other assets. Notice that the middle diagonal row is filled in with all 1’s. 
+That is because they are all perfectly correlated with themselves. A value of 1 equates to perfect correlation, -1 equates to perfect negative correlation, 
+and 0 equates to no correlation with values in between being relative to their distance from the extremes. A correlation value of .5 would mean 
+the asset moves half as much in the same direction as the correlated asset.  A values of -0.5 would mean it moves half as much in the opposite direction 
+as the correlated asset. \n
+The Heat map shows the correlation coefficient or value for each asset over the entire period to each other asset. 
+It also depicts the color of the intersection as darker for less correlation and lighter for more correlation, which could be either positive or negative. 
+The legend on the right indicates the absolute level of correlation for each color, again positive or negative associated to each color.\n 
+        """
+        
+        display_heat_map(choices['data'],choices['choices'])
+        #display_portfolio_return(choices['combined_df'], choices['choices'])
+        
+        cumulative_return(choices['combined_df'], choices['choices'])
+        sharp_ratio_func(choices['raw_data'], choices['choices'])
+
+        '''
+ARIMA:\n
+        '''
+
+        arima_chart(choices['choices']['symbols'])
+
+        
+
+if __name__ == "__main__":
+    run()
+

arima.py

@@ -0,0 +1,64 @@
+import pandas as pd
+from datetime import datetime
+from datetime import timedelta
+import numpy as np
+import statsmodels.api as sm
+
+import plotly.express as px
+import plotly.graph_objects as go
+
+import warnings
+warnings.filterwarnings("ignore")
+
+# from sklearn.metrics import mean_squared_error
+
+df = pd.read_csv('us-shareprices-daily.csv', sep=';')
+
+def get_model_accuracy(data, ticker_symbol):
+    
+    stock_data = data[data['Ticker'] == ticker_symbol]
+
+
+    # get MSE for testing data using 85/15 split for chosen stock symbol
+
+    train_data, test_data = stock_data[0:int(len(stock_data)*0.85)], stock_data[int(len(stock_data)*0.85):]
+    training_data = train_data['Close'].values
+    test_data = test_data['Close'].values
+    history = [x for x in training_data]
+    model_predictions = []
+    N_test_observations = len(test_data)
+    for time_point in range(N_test_observations):
+        model = sm.tsa.statespace.SARIMAX(history, order=(1,1,1))
+        model_fit = model.fit(disp=0)
+        output = model_fit.forecast()
+        yhat = output[0]
+        model_predictions.append(yhat)
+        true_test_value = test_data[time_point]
+        history.append(true_test_value)
+
+    MSE_error = mean_squared_error(test_data, model_predictions)
+    return 'Testing Mean Squared Error is {}'.format(MSE_error)
+
+
+def arima_chart(tickers):
+    df = pd.read_csv('data_and_sp500.csv')
+    df = df[['Date']+tickers]
+    fig = px.line(df, x='Date', y=df.columns)
+
+    for ticker in tickers:
+        x = np.array(df['Date'])
+        y = np.array(df[ticker])
+        ticker_df = pd.concat([df['Date'], df[ticker]], axis=1)
+
+        model = sm.tsa.statespace.SARIMAX(ticker_df[ticker], order=(21,1,7))
+        model_fit = model.fit(disp=-1)
+        # print(model_fit.summary())
+        forecast = model_fit.forecast(7, alpha=0.05)#.predict(start=1259, end=1289)
+        begin_date = datetime.strptime('2021-10-22', '%Y-%m-%d')
+        forecast_dates = [begin_date+timedelta(days=i-1258) for i in forecast.index]
+        fig.add_trace(go.Scatter(x=forecast_dates, y=forecast.to_list(),
+                                    mode='lines',
+                                    name='{} forecast'.format(ticker)))
+
+    fig.update_xaxes(range=[begin_date-timedelta(days=120), begin_date+timedelta(days=10)])
+    st.plotly_chart(fig, use_container_width=True) 

betas.py

@@ -0,0 +1,74 @@
+import pandas as pd
+import numpy as np
+import datetime as dt
+import pandas_datareader as pdr
+from datetime import datetime
+
+
+
+def convert_simFin2(path):
+    df = pd.read_csv(path, sep=';')
+    stocks = df.pivot(index="Date", columns="Ticker", values="Adj. Close")
+    return stocks
+
+def log_of_returns2(stocks):
+    log_returns = np.log(stocks/stocks.shift())
+    return log_returns
+
+
+
+
+
+# Code to Calculate and output Betas
+# Read in Stock csv data and convert to have each Ticker as a column.
+#df = pd.read_csv('D:/SimFinData/us-shareprices-daily.csv', sep=';')
+#stocks = df.pivot(index="Date", columns="Ticker", values="Adj. Close")
+#stocks
+#start = min(df['Date'])
+#end = max(df['Date'])
+#logRet = np.log(stocks/stocks.shift())
+
+
+#SP500 = pdr.get_data_yahoo("^GSPC", start)
+#IXIC = pdr.get_data_yahoo("^IXIC", start)
+#AOK = pdr.get_data_yahoo("AOK", start)
+
+#SP500['SP500'] = SP500['Adj Close']
+#IXIC['IXIC'] = IXIC['Adj Close']
+#AOK['AOK'] = AOK['Adj Close']
+
+#spAC = np.log(SP500['SP500']/SP500['SP500'].shift())
+#spAC = spAC.loc[spAC.index <= end]
+
+#ixicAC = np.log(IXIC['IXIC']/IXIC['IXIC'].shift())
+#ixicAC = ixicAC.loc[ixicAC.index <= end]
+
+#aokAC = np.log(AOK['AOK']/AOK['AOK'].shift())
+#aokAC = aokAC.loc[aokAC.index <= end]
+
+#sp500B = logRet.join(spAC)
+#ixicB = logRet.join(ixicAC)
+#aokB = logRet.join(aokAC)
+
+#sp5Cov = sp500B.cov()
+#ixicCov = ixicB.cov()
+#aokCov = aokB.cov()
+
+#sp500Var = sp500B['SP500'].var()
+#ixicVar = ixicB['IXIC'].var()
+#aokVar = aokB['AOK'].var()
+
+#sp500Beta = sp5Cov.loc['SP500']/sp500Var
+#ixicBeta = ixicCov.loc['IXIC']/ixicVar
+#aokBeta = aokCov.loc['AOK']/aokVar
+
+#betas = pd.concat([sp500Beta,ixicBeta,aokBeta], axis=1)
+
+#betas['Ticker'] = betas.index
+
+#betas = betas[['Ticker','SP500','IXIC','AOK']]
+
+#betas.to_csv (r'betas.csv', index = None, header=True)
+
+
+

correlation.py

@@ -0,0 +1,31 @@
+import pandas as pd
+import numpy as np
+import datetime as dt
+import pandas_datareader as pdr
+
+# Read in Stock csv data and convert to have each Ticker as a column.
+#df = pd.read_csv('us-shareprices-daily.csv', sep=';')
+#stocks = df.pivot(index="Date", columns="Ticker", values="Adj. Close")
+#logRet = np.log(stocks/stocks.shift())
+
+# Calculate the Correlation Coefficient for all Stocks
+#stocksCorr = logRet.corr()
+
+# Output to csv
+#stocksCorr.to_csv (r'correlation_matrix.csv', index = None, header=True)
+
+# Enter path of SimFin Data to convert to format for Calculations
+def convert_simFin(path):
+    df = pd.read_csv(path, sep=';')
+    stocks = df.pivot(index="Date", columns="Ticker", values="Adj. Close")
+    return stocks
+
+# Calculate Log returns of the Formatted Stocks
+def log_of_returns(stocks):
+    log_returns = np.log(stocks/stocks.shift())
+    return log_returns
+
+# Enter Log returns of Stocks to Calculate the Correlation Matrix.
+def correlation_matrix(lr):
+    return lr.corr()
+    

correlation_matrix.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a2eb8bf375aa94290f54caa2d0dd2e73e5b3139607599e979cc580885a84bd0b
+size 169323527

data_and_sp500.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6e14ce41ef63008499438d16624d25f42b1f2defb2a86521d06ddf4d0dbc4960
+size 18749516

ef.py

@@ -0,0 +1,193 @@
+import pandas as pd
+import numpy as np
+from datetime import datetime as dt
+from pypfopt.efficient_frontier import EfficientFrontier
+import streamlit as st
+import plotly.graph_objects as go
+import plotly.express as px
+from PIL import Image
+
+### START AND RUN STREAMLIT
+#https://docs.streamlit.io/library/get-started/installation
+
+def ef_viz(stock_df,choices):
+    #st.write("EF Visualization KOI EDITS")
+    # st.header('CAPM Model and the Efficient Frontier')
+    
+    symbols, weights, benchmark, investing_style, rf, A_coef  = choices.values()
+    tickers = symbols
+    
+    #tickers.append('sp500')
+    #st.write(tickers)
+    #st.write(stock_df)
+    
+    # Yearly returns for individual companies
+    #https://stackoverflow.com/questions/69284773/unable-to-resample-the-pandas-with-date-column-typeerror-only-valid-with-dateti
+    stock_dff = stock_df.copy()
+    stock_dff['Date'] = pd.to_datetime(stock_dff['Date'])
+
+
+    # ind_er_df = stock_dff.set_index('Date')
+    #st.write(stock_dff.columns)
+    ind_er_df = stock_dff.resample('Y', on = 'Date').last().pct_change().mean()
+    ind_er = ind_er_df[tickers]
+    #st.write(ind_er)
+    ann_sd = stock_df[tickers].pct_change().apply(lambda x: np.log(1+x)).std().apply(lambda x: x*np.sqrt(250))
+    assets = pd.concat([ind_er, ann_sd], axis=1) # Creating a table for visualising returns and volatility of assets
+    assets.columns = ['Returns', 'Volatility']
+    assets
+    #st.write(assets)
+    ln_pct_change = stock_df[tickers].pct_change().apply(lambda x: np.log(1+x))[1:]
+    #Cov Matrix
+    cov_matrix =ln_pct_change.cov()
+
+    ## CREATE PORFOLIOS WEIGHTS 
+    p_ret = [] # Define an empty array for portfolio returns
+    p_vol = [] # Define an empty array for portfolio volatility
+    p_weights = [] # Define an empty array for asset weights
+
+    num_assets = len(tickers)
+    num_portfolios = 1000
+
+    for portfolio in range(num_portfolios):
+        weights = np.random.random(num_assets)
+        weights = weights/np.sum(weights)
+        p_weights.append(weights)
+        returns = np.dot(weights, ind_er) # Returns are the product of individual expected returns of asset and its 
+                                        # weights 
+        p_ret.append(returns)
+        var = cov_matrix.mul(weights, axis=0).mul(weights, axis=1).sum().sum()# Portfolio Variance
+        sd = np.sqrt(var) # Daily standard deviation
+        ann_sd = sd*np.sqrt(250) # Annual standard deviation = volatility
+        p_vol.append(ann_sd)
+        
+    data = {'Returns':p_ret, 'Volatility':p_vol}
+
+    for counter, symbol in enumerate(stock_df[tickers].columns.tolist()):
+        #print(counter, symbol)
+        data[symbol] = [w[counter] for w in p_weights]
+        
+    port_ef_df  = pd.DataFrame(data)
+    port_ef_df['Vol'] = port_ef_df['Volatility']
+    
+    ## NEEDS INPUT INSTEAD OF HARD CODE
+    #a = 5 #the coefficient of risk aversion is A. If an invest is less risk averse A is small. We assume 25 < A < 35. 
+    #rf = 0.041
+    
+    min_vol_port = port_ef_df.iloc[port_ef_df['Volatility'].idxmin()]
+    optimal_risky_port = port_ef_df.iloc[((port_ef_df['Returns']-rf)/port_ef_df['Volatility']).idxmax()]
+
+    ### Make DF and data string for when hover over data points
+    def make_op_df(df, tickers):
+        new = {}
+        op_str = str()
+        new['Returns'] = df[0]
+        new['Volatility'] = df[1]
+        
+        for i in range(0,len(tickers)):
+            new[tickers[i]]= df[i+2]
+            op_str += str(tickers[i]) + ': ' + str(round(df[i+2],4)) + '<br>'
+
+        return pd.DataFrame(new, index=[0]), op_str
+
+    op_df, op_str = make_op_df(optimal_risky_port, tickers)
+
+    def make_port_str(df, tickers):
+        port_str_lst = []
+        for i in range(0,len(df)):
+            temp = str()
+            for u in range(0,len(tickers)):
+                temp += str(tickers[u])+ ': ' + str(round(df[tickers[u]][i],4)) + '<br>'
+            port_str_lst.append(temp)
+
+        return port_str_lst
+
+    port_str_lst = make_port_str(port_ef_df, tickers)   
+
+    ## CREATE CAPM LINE #https://www.youtube.com/watch?v=JWx2wcrSGkk
+    cal_x = []
+    cal_y = []
+    utl = []
+    
+
+
+    for er in np.linspace(rf, max(data['Returns'])+rf,20):
+        sd = (er - rf)/ ((optimal_risky_port[0] - rf)/ optimal_risky_port[1])
+        u = er - 0.5*A_coef*(sd**2)
+        cal_x.append(sd)
+        cal_y.append(er)
+        utl.append(u)
+    
+    data2 = {'Utility':utl, 'cal_x':cal_x, 'cal_y':cal_y}
+
+    utl_df  = pd.DataFrame(data2)
+    
+    ## Create Figure
+    fig3 = go.Figure()
+
+    #https://plotly.com/python/colorscales/
+    fig3.add_trace(go.Scatter(x=port_ef_df['Volatility'], y=port_ef_df['Returns'], hovertemplate='Volatility: %{x} <br>Returns: %{y} <br>%{text}',\
+                                text= port_str_lst, mode='markers', \
+                                marker=dict(color=port_ef_df['Volatility'],  colorbar=dict(title="Volatility"), \
+                                size=port_ef_df['Returns']*50, cmax=max(port_ef_df['Volatility']),\
+                                cmin=min(port_ef_df['Volatility'])),name='Portfolio'))
+                                #, mode='markers', size=port_ef_df['Returns'], \
+                                    #size_max=30, color=port_ef_df['Vol']))
+    fig3.add_trace(go.Scatter(x=utl_df['cal_x'], y=utl_df['cal_y'], mode='lines', line = dict(color='rgba(11,156,49,1)'),name='Ultility Function',\
+                                hovertemplate='Volatility: %{x} <br>Returns: %{y}')) #))
+
+    fig3.add_trace(go.Scatter(x=op_df['Volatility'], y=op_df['Returns'], mode='markers', \
+                        marker=dict(color= 'rgba(11,156,49,1)', size=30),\
+                        hovertemplate='Volatility: %{x} <br>Returns: %{y} <br>%{text}',\
+                        text=[op_str]))
+    ### HOVER TEMPLATE # https://plotly.com/python/hover-text-and-formatting/
+            
+   
+#     ### SAVE IN CASE CANNOT FIGURE OUT THE HOVER TEMPLATE
+#     fig2 = px.scatter(op_df, 'Volatility', 'Returns')
+#     fig2.update_traces(marker=dict(color= 'rgba(11,156,49,1)', size=35))
+
+#     fig1 = px.line(utl_df, x="cal_x", y="cal_y")
+#     #fig1.update_traces(line=dict(color = 'rgba(11,156,49,1)'))
+    
+#     fig = px.scatter(port_ef_df, 'Volatility', 'Returns', size='Returns', size_max=30, color='Vol')
+# #https://stackoverflow.com/questions/59057881/python-plotly-how-to-customize-hover-template-on-with-what-information-to-show
+# #https://stackoverflow.com/questions/65124833/plotly-how-to-combine-scatter-and-line-plots-using-plotly-express
+
+#     #data3 = 
+#     fig3.data = [fig2.data,fig1.data,fig.data]
+#     #fig3.update_traces(line=dict(color = 'rgba(11,156,49,1)'))
+#     ####
+
+    fig3.update_layout(showlegend=False)#, legend_title_text = "Contestant")
+    fig3.update_xaxes(title_text="Volatility")
+    fig3.update_yaxes(title_text="Portfolio Return Rates")
+
+    st.plotly_chart(fig3, use_container_width=True) 
+
+    #st.write(op_str)
+    op_df = op_df.style.set_properties(**{'color':'green'})
+    st.subheader('Optimal Returns vs Volatility and Portfolio weights')
+    col1, col2, col3 = st.columns([1,6,1])
+    with col1:
+        st.write("")
+
+    with col2:
+        st.write(op_df)
+
+    with col3:
+        st.write("")
+    
+    im = Image.open('EFvsMinvar.png')
+    st.subheader('Understand the Efficient Frontier')
+    col1, col2, col3 = st.columns([1,6,1])
+
+    with col1:
+        st.write("")
+
+    with col2:
+        st.image(im, caption='Elements of the Efficient Frontier',use_column_width='auto')
+
+    with col3:
+        st.write("")
+    

plots.py

@@ -0,0 +1,220 @@
+import pandas as pd
+import seaborn as sns
+import streamlit as st
+import matplotlib.pyplot as plt
+import numpy as np
+import altair as alt
+import plotly.express as px
+
+
+def beta(stock_df, choices):
+    symbols, weights, benchmark, investing_style, rf, A_coef  = choices.values()
+    tickers = symbols
+    tickers.append(benchmark)
+    #print(tickers)
+    quantity = weights
+    selected_stocks = stock_df[tickers]
+    # calculating daily return
+    # loops through each stocks
+    # loops through each row belonging to the stock
+    # calculates the percentage change from previous day
+    # sets the value of first row to zero since there is no previous value
+    df_stocks = selected_stocks.copy()
+
+    for i in selected_stocks.columns[1:]:
+        for j in range(1, len(selected_stocks)):
+            df_stocks[i][j] = ((selected_stocks[i][j] - selected_stocks[i][j - 1]) / selected_stocks[i][j - 1]) * 100
+        df_stocks[i][0] = 0
+    # calculate Beta and alpha for a single stock
+    # used sp500 as a benchmark
+    # used polyfit to calculate beta
+    beta_list = []
+    alpha_list = []
+    stocks_daily_return = df_stocks
+    for i in stocks_daily_return.columns:
+        if i != 'Date' and i != benchmark:
+            # stocks_daily_return.plot(kind = 'scatter', x = 'A', y = i)
+            b, a = np.polyfit(stocks_daily_return[benchmark], stocks_daily_return[i], 1)
+            # plt.plot(stocks_daily_return['sp500'], b * stocks_daily_return['sp500'] + a, '-', color = 'r')
+            beta_list.append(round(b, 2))
+            alpha_list.append(round(a, 2))
+            # plt.show()
+    # Formats the results
+    symbols.remove(benchmark)
+    beta = {'Assets': symbols, 'Beta': beta_list}
+    alpha = {'Assets': symbols, 'Alpha': alpha_list}
+    # Creates a header for streamlit
+    st.subheader('Beta and Alpha of Assets Compared to S&P500 index')
+    col1, col2 = st.columns(2)
+
+    with col1:
+        st.dataframe(beta)
+    with col2:
+        st.dataframe(alpha)
+
+
+def ER(stock_df, choices):
+    symbols, weights, benchmark, investing_style, rf, A_coef  = choices.values()
+    symbols_ =symbols.copy()
+    tickers = symbols
+    tickers.append(benchmark)
+    #print(tickers)
+    quantity = weights
+    selected_stocks = stock_df[tickers]
+    # calculating daily return
+    # loops through each stocks
+    # loops through each row belonging to the stock
+    # calculates the percentage change from previous day
+    # sets the value of first row to zero since there is no previous value
+    df_stocks = selected_stocks.copy()
+
+    for i in selected_stocks.columns[1:]:
+        for j in range(1, len(selected_stocks)):
+            df_stocks[i][j] = ((selected_stocks[i][j] - selected_stocks[i][j - 1]) / selected_stocks[i][j - 1]) * 100
+        df_stocks[i][0] = 0
+    beta = {}
+    alpha = {}
+    stocks_daily_return = df_stocks
+    # print(df_stocks)
+
+    for i in stocks_daily_return.columns:
+        if i != 'Date' and i != benchmark:
+            # stocks_daily_return.plot(kind = 'scatter', x = 'A', y = i)
+            b, a = np.polyfit(stocks_daily_return[benchmark], stocks_daily_return[i], 1)
+            # plt.plot(stocks_daily_return['sp500'], b * stocks_daily_return['sp500'] + a, '-', color = 'r')
+            beta[i] = round(b, 2)
+            alpha[i] = round(a, 2)
+            # plt.show()
+
+    # calculating camp for a stock
+    keys = list(beta.keys())
+    ER_ = []
+    # rf = 0 assuming risk-free rate of 0
+    rf = 0
+    # rm - annualize retun
+    rm = stocks_daily_return[benchmark].mean() * 252
+    for i in keys:
+        ER_.append( round(rf + (beta[i] * (rm - rf)), 2))
+
+    #for i in keys:
+    #    print('Expected Return based on CAPM for {} is {}%'.format(i, ER_[i]))
+    #print(ER)
+    symbols.remove(benchmark)
+    #st.subheader('Expected Annual Return Based on CAPM Model')
+
+    Expected_return = {'Assets': symbols_, 'Expected Annual Return': ER_}
+    # Creates a header for streamlit
+    #st.dataframe(Expected_return)
+
+    
+    # calculate expected return for the portfolio
+    # portfolio weights assume equal
+    portfolio_weights = []
+    current_cash_value = 0
+    total_portfolio_value = 0
+    cash_value_stocks =[]
+    for i in range(len(tickers) ):
+        stocks_name = tickers[i]
+        current_cash_value = selected_stocks[stocks_name].iloc[-1]
+        stocks_quantity = quantity[i]
+        cash_value = stocks_quantity * current_cash_value
+        cash_value_stocks.append(cash_value)
+        total_portfolio_value += cash_value
+        portfolio_weights.append(cash_value)
+    #print(portfolio_weights)
+    portfolio_weights = (portfolio_weights / total_portfolio_value)*100
+    ER_portfolio= []
+    ER_portfolio = sum(list(ER_) * portfolio_weights)/100
+    #print(ER_portfolio)
+
+    #st.subheader('Expected Portfolio Return Based on CAPM Model')
+    # Creates a header for streamlit
+    #st.write('Expected Portfolio Return is:', ER_portfolio)
+    Bar_output = Expected_return.copy()
+    Bar_output['Assets'].append('Portfolio')
+    Bar_output['Expected Annual Return'].append(ER_portfolio)
+    fig = px.bar(Bar_output, x='Assets', y="Expected Annual Return",color='Assets') 
+    #fig.update_layout(title_text = 'Annual Expected Return of the Assets and Portfolio',title_x=0.458)
+    st.subheader('Annual Expected Return of the Assets and Portfolio')
+    st.plotly_chart(fig, use_container_width=True)
+    
+    return beta, cash_value_stocks
+
+def basic_portfolio(stock_df):
+    """Uses the stock dataframe to graph the normalized historical cumulative returns of each asset.
+    """
+    # Calculates the daily returns of the inputted dataframe
+    daily_return = stock_df.dropna().pct_change()
+    # Calculates the cumulative return of the previously calculated daily return
+    cumulative_return = (1 + daily_return).cumprod()
+
+    
+    # Graphs the cumulative returns
+    st.line_chart(cumulative_return)
+
+
+def display_heat_map(stock_df,choices):
+    symbols, weights, benchmark, investing_style, rf, A_coef  = choices.values()
+    selected_stocks = stock_df[symbols]
+    # Calcuilates the correlation of the assets in the portfolio
+    price_correlation = selected_stocks.corr()
+
+    
+    # Generates a figure for the heatmap
+    fig, ax = plt.subplots()
+    fig = px.imshow(price_correlation,text_auto=True, aspect="auto")
+    # Displays the heatmap on streamlit
+    st.write(fig)
+   
+
+#def display_portfolio_return(stock_df, choices):
+    """Uses the stock dataframe and the chosen weights from choices to calculate and graph the historical cumulative portfolio return.
+    """
+#    symbols, weights, investment = choices.values()
+
+    # Calculates the daily percentage returns of the 
+#    daily_returns = stock_df.pct_change().dropna()
+    # Applies the weights of each asset to the portfolio
+#    portfolio_returns = daily_returns.dot(weights)
+    # Calculates the cumulative weighted portfolio return
+#    cumulative_returns = (1 + portfolio_returns).cumprod()
+    # Calculates the cumulative profit using the cumulative portfolio return
+#    cumulative_profit = investment * cumulative_returns
+
+    # Graphs the result, and displays it with a header on streamlit
+#    st.subheader('Portfolio Historical Cumulative Returns Based On Inputs!')
+#    st.line_chart(cumulative_profit)
+def buble_interactive(stock_df,choices):
+    symbols, weights, benchmark, investing_style, rf, A_coef  = choices.values()
+    beta,cash_value_weights  = ER(stock_df,choices)
+    my_list = []
+    my_colors = []
+    for i in beta.values():
+        my_list.append(i)
+        if i < 0.3:
+            my_colors.append("Conservative")
+        if i >= 0.3 and i <= 1.1:
+            my_colors.append("Moderate Risk")
+        if i > 1.1:
+            my_colors.append("Risky")
+    
+    df_final =pd.DataFrame()
+    df_final['ticker'] = symbols
+    df_final['quantities'] = weights
+    df_final['cash_value']  =cash_value_weights
+    df_final['Beta'] = my_list
+    df_final['Risk'] = my_colors
+   
+    fig = px.scatter(
+    df_final,
+    x="quantities",
+    y="Beta",
+    size="cash_value",
+    color="Risk",
+    hover_name="ticker",
+    log_x=True,
+    size_max=60,
+    )
+    fig.update_layout(title= benchmark +"Benchmark - Beta of Stock Ticker to Quantity")
+    # -- Input the Plotly chart to the Streamlit interface
+    st.plotly_chart(fig, use_container_width=True)   

requirements.txt

@@ -0,0 +1,11 @@
+streamlit
+matplotlib
+folium
+pandas
+seaborn
+numpy
+plotly
+pyportfolioopt
+Pillow
+statsmodels
+sklearn

sharp_ratio.py

@@ -0,0 +1,146 @@
+import pandas as pd
+import numpy as np
+from datetime import datetime
+import streamlit as st
+import matplotlib.pyplot as plt
+import plotly.express as px
+#import plotly.graph_objects as go
+
+
+def cumulative_return(stocks,choices):
+    symbols, weights, investing_style, benchmark, rf, A_coef = choices.values()
+    
+    #tkers = sorted(set(stocks['Ticker'].unique()))
+    #preprocess
+    #stocks = stocks.pivot(index="Date", columns="Ticker", values="Adj. Close")
+    tkers = symbols.copy()
+    logRet = np.log(stocks/stocks.shift())
+    log_returns = np.log(stocks/stocks.shift())
+    tickers_list = symbols.copy()
+    weights_list = weights.copy()
+    ##
+    stock_port = {}
+    for e in tickers_list: stock_port[e] = 0
+    # Convert Weights to Floats and Sum
+    weights = [float(x) for x in weights_list]
+    s = sum(weights)
+    # Calc Weight Proportions
+    new_weights = []
+    for i in weights: new_weights.append(i/s)
+    # Assign Weights to Ticker Dict
+    i = 0
+    for e in stock_port:
+        stock_port[e] = new_weights[i]
+        i += 1
+    
+    port = dict.fromkeys(tkers, 0)
+    port.update(stock_port)
+    
+    portfolio_dict = port
+    
+    for e in portfolio_dict:
+        tmp = 0
+        if portfolio_dict[e] > tmp:
+            tmp = portfolio_dict[e]
+            tick = e
+    list_ =[]        
+    for e in tickers_list:
+        if e not in list_:
+            list_.append(e)
+
+    df = stocks[list_]
+    df = df/df.iloc[0]
+    df.reset_index(inplace=True)
+    df=pd.DataFrame(df)
+    print(df)
+    fig = px.line(df, x='Date' ,y=df.columns[1:,])
+    
+    
+    #layout reference = https://linuxtut.com/en/b13e3e721519c2842cc9/
+    fig.update_layout(
+        xaxis=dict(
+        rangeselector=dict(
+                buttons=list([
+                    dict(count=1,
+                         label="1m",
+                         step="month",
+                         stepmode="backward"),
+                    dict(count=6,
+                         label="6m",
+                         step="month",
+                         stepmode="backward"),
+                    dict(count=1,
+                         label="YTD",
+                         step="year",
+                         stepmode="todate"),
+                    dict(count=1,
+                         label="1y",
+                         step="year",
+                         stepmode="backward"),
+                    dict(step="all")
+                ])
+            ),
+            rangeslider=dict(
+                visible=True
+            ),
+            type="date"
+        )
+    )
+    fig.update_layout(xaxis=dict(rangeselector = dict(font = dict( color = "black"))))
+    st.subheader('Portfolio Historical Normalized Cumulative Returns')
+
+    st.plotly_chart(fig, use_container_width=True)
+    
+def sharp_ratio_func(stocks,choices):
+    symbols, weights, investing_style, benchmark, rf, A_coef = choices.values()
+    logRet,tickers_list,weights_list = preprocess(stocks,choices)
+    tkers = sorted(set(stocks['Ticker'].unique()))
+
+    stocks = stocks.pivot(index="Date", columns="Ticker", values="Adj. Close")
+        
+    stock_port = {}
+    for e in tickers_list: stock_port[e] = 0
+    # Convert Weights to Floats and Sum    
+    weights = [float(x) for x in weights_list]
+    s = sum(weights)
+    # Calc Weight Proportions
+    new_weights = []
+    for i in weights: new_weights.append(i/s)
+    # Assign Weights to Ticker Dict
+    i = 0
+    for e in stock_port:
+        stock_port[e] = new_weights[i]
+        i += 1
+        
+    port = dict.fromkeys(tkers, 0)
+    port.update(stock_port)
+        
+    portfolio_dict = port
+            
+    sharp_ratio_list = []
+    for ticker in symbols:
+        logRet = np.log(stocks/stocks.shift())
+        stk = dict.fromkeys(tkers, 0)
+        stkTicker = {ticker:1}
+        stk.update(stkTicker)
+        ttlStk = np.sum(logRet*stk, axis=1)
+        stock_sharpe_ratio = ttlStk.mean() / ttlStk.std()
+        sharp_ratio_list.append(stock_sharpe_ratio)
+            
+    sharp_ratio = {'Assets': symbols, 'Sharpe Ratio': sharp_ratio_list}
+        
+        # Portfolio sharp Ratio Calculation
+    logRet = np.log(stocks/stocks.shift())
+    portfolio = dict.fromkeys(tkers, 0)
+    portfolio.update(portfolio_dict)
+    totalPortfolio = np.sum(logRet*portfolio, axis=1)
+    portfolio_sharpe_ratio = totalPortfolio.mean() / totalPortfolio.std()
+        
+    sharp_ratio['Assets'].append('Portfolio')
+    sharp_ratio['Sharpe Ratio'].append(portfolio_sharpe_ratio)
+    
+    fig = px.bar(sharp_ratio, x='Assets', y="Sharpe Ratio",color='Assets') 
+    fig.update_layout(title_text = 'Sharpe Ratio of the Assets and Portfolio',
+                        title_x=0.458)
+    st.plotly_chart(fig, use_container_width=True)
+        

us-shareprices-daily.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:104d6137243993225d2098604004dc3bbbfe5e9411afd8f8d8da5447ff6e7c04
+size 220037366