What Idea about Stock Analysis and Predicting chart ?

Introduction: In this article, we will explore how to perform stock analysis using Python. We will import and merge multiple datasets, including historical stock prices, earnings per share (EPS), and GDP data. We will then use linear regression to predict stock returns based on historical data. Finally, we will visualize the results using various libraries like pandas, matplotlib, numpy, and seaborn.

importing the necessary libraries

import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns

Import Dataframe from Excel

Now, we will read the data from Excel files and store them in pandas DataFrames:

data_set = pd.read_excel('set.xlsx',index_col=0)
data_set_eps = pd.read_excel('set_eps.xlsx',index_col=0)
data_gdpq = pd.read_excel('gdpq.xlsx',engine= 'openpyxl',index_col=0)

After importing the data, we can display the DataFrames to see what they look like:

data_set

we will see dataframe like this

data_set_eps

data_gdpq

1422 rows × 7 columns

Merging DataFrames

We will now merge the data between data_set and data_set_eps DataFrames:

min_date = data_set_eps.index.min()
max_date = data_set_eps.index.max()
date_range = (min_date, max_date)

date_range

(Timestamp('2016-01-04 00:00:00'), Timestamp('2021-11-03 00:00:00'))

data_set_eps_subset = data_set_eps.loc[data_set.index, ["PE", "EPS"]]

df1 = pd.merge(data_set, data_set_eps_subset, how="left", left_index=True, right_index=True)

data_set_eps_subset

df1

Adding GDP Data to the Merged DataFrame

Next, we will add the GDP data to the merged DataFrame

data_gdpq.index.year

Int64Index([2016, 2016, 2016, 2016, 2017, 2017, 2017, 2017, 2018, 2018, 2018,2018, 2019, 2019, 2019, 2019, 2020, 2020, 2020, 2020, 2021, 2021],
dtype='int64', name='Date')

data_gdpq.groupby(data_gdpq.index.year)['GDP'].mean()
    Date
    2016    3.647584e+12
    2017    3.872166e+12
    2018    4.092176e+12
    2019    4.224522e+12
    2020    3.924572e+12
    2021    3.997128e+12
    Name: GDP, dtype: float64

gdp_yearly = data_gdpq.groupby(data_gdpq.index.year)['GDP'].mean()

for i in range(2016,2022):
    df1.loc[str(i),'gdp'] = gdp_yearly.loc[i]

df1

Calculating and Adding Stock Return to the DataFrame

We will now calculate the daily stock return and add it to the DataFrame

df1['Return_shift'] = df1.Close.pct_change()

df1.dropna(inplace=True)

df1

df1.loc[(df1.EPS>70)& (df1.EPS<80)]

df1.loc[ (df1.EPS>35)&(df1.EPS<40)]

df1.loc[ (df1.EPS>100)]

Create label for ML training

def pe(pe):
    if pe <=20:
        return 1
    elif (pe>20)&(pe<=28):
        return 2
    elif (pe>28)&(pe<=30):
        return 3
    elif (pe > 30) & (pe <= 34):
        return 4
    elif (pe > 34) & (pe <= 38):
        return 5
    elif (pe > 38) & (pe <= 42):
        return 6
    elif pe > 42:
        return 7

def eps(eps):
    if eps <=40:
        return 1
    elif (eps>40)&(eps<=50):
        return 2
    elif (eps>50)&(eps<=60):
        return 3
    elif (eps > 60) & (eps <= 70):
        return 4
    elif (eps > 70) & (eps <= 80):
        return 5
    elif (eps > 80) & (eps <= 90):
        return 6
    elif (eps > 90) & (eps <= 100):
        return 7
    elif eps > 100 :
        return 8

def gdp(gdp):
    if gdp <=3.750000e+12:
        return 1
    elif (gdp>3.750000e+12)&(gdp<=4.000000e+12):
        return 2
    elif (gdp>4.000000e+12)&(gdp<=4.250000e+12):
        return 3
    elif eps > 4.250000e+12 :
        return 4
    
    

df1['PE_Label'] = df1['PE_y'].apply(pe)

df1['EPS_Label'] = df1['EPS'].apply(eps)

df1['GDP_Label'] = df1['gdp'].apply(gdp)

df1

Data Preparation:

First, we need to split our dataset into training and testing sets. The training set will be used to train our model, while the testing set will be used to evaluate its performance.

X = df1[['EPS','PE_y','gdp','EPS_Label', 'PE_Label','GDP_Label']]
y = df1['Return_shift']

X_train = X.iloc[:1000]
y_train = y.iloc[:1000]
X_test = X.iloc[1000:1200]
y_test = y.iloc[1000:1200]

X_train

y_train
    Date
    2016-01-05   -0.007970
    2016-01-06    0.005346
    2016-01-07   -0.027944
    2016-01-08    0.015798
    2016-01-11   -0.007780
                    ...   
    2020-01-29    0.007487
    2020-01-30   -0.000394
    2020-01-31   -0.006463
    2020-02-03   -0.011941
    2020-02-04    0.015588
    Name: Return_shift, Length: 1000, dtype: float64

X_test

Model Training and Evaluation:

Now that we have prepared our data, we can start building the linear regression model.

We will use the Scikit-learn library to create and train our model,

and then evaluate its performance using various metrics such as R-squared,

Mean Absolute Error (MAE), Mean Squared Error (MSE), and Root Mean Squared Error (RMSE).

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression

from sklearn import metrics
from sklearn.model_selection import cross_val_score



model = LinearRegression()
model.fit(X_train, y_train)

y_pred = model.predict(X_test)
print('Score = ', metrics.r2_score(y_test,y_pred))

m = model.coef_
print("coef = ",m)
b = model.intercept_
print("intercept = ",b)
print("MAE = ",  metrics.mean_absolute_error(y_test,y_pred))
print("MSE = ",  metrics.mean_squared_error(y_test,y_pred))
print("RMSE = ", np.sqrt(metrics.mean_squared_error(y_test,y_pred)))

Score =  0.016679949410685402
coef = [ 4.68128493e-05  4.35681735e-04  3.02324355e-15  2.79260864e-05
     -1.35296661e-03 -1.46159773e-03]
intercept =  -0.019300039650165336
MAE =  0.012205326313264547
MSE =  0.0003814982502499546
RMSE =  0.01953198019274939

Create report

df_report = pd.DataFrame({'Actual': y_test, 'Predict':y_pred})

df_report

df_report_example = df_report.head(20)
df_report_example.plot(kind='bar',figsize=(16,10))

(df_report+1).cumprod().plot()

test model with data split

X_live = df1.iloc[1200:]

X_live

X_live[['EPS','PE_y','gdp','EPS_Label', 'PE_Label','GDP_Label']]

X_live

live_data =X_live[['EPS','PE_y','gdp','EPS_Label', 'PE_Label','GDP_Label']]

live_data['Return_shift']=model.predict(live_data)

df_live_report = pd.DataFrame({'Actual': X_live['Return_shift'], 'Predict':live_data['Return_shift']})

df_live_report

df_live_report_exmaple = df_live_report.head(200)
df_live_report_exmaple.plot(kind='bar',figsize=(16,10))

(df_live_report_exmaple).plot()

(df_live_report_exmaple+1).cumprod().plot()

Conclusion

In this article, we demonstrated how to perform stock analysis and predict stock returns using Python. We started by importing and merging multiple datasets,

including historical stock prices, earnings per share (EPS), and GDP data. After merging the datasets and adding stock return calculations, we used linear regression to predict stock returns based on historical data.

We then visualized the results using various libraries like pandas, matplotlib, numpy, and seaborn.

The results showed that our linear regression model provided a reasonable prediction of stock returns, although it is important to note that stock market predictions are inherently uncertain and should not be solely relied upon for investment decisions.

Further improvements to the model could be achieved by incorporating additional variables, using more advanced techniques, or incorporating domain-specific knowledge.

Overall, this article serves as a foundation for further exploration into stock analysis and prediction using Python, providing valuable insights for investors and analysts looking to harness the power of data-driven decision-making.