def run():
journal = ledger.read_journal("./secret/ledger.dat")
last_post = None
amount = 0
for post in journal.query(""):
if last_post == None or post.date == last_post.date:
if str(post.amount.commodity) != "£":
continue
amount = amount + post.amount
else:
print post.date, ",", amount
amount = 0
last_post = post
df = pd.read_csv('./testing.csv')
df['y'] = np.multiply(100, df['y'])
m = Prophet()
m.fit(df);
forecast = m.predict(future)
forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail()
m.plot(forecast);
m.plot_components(forecast);
df.head()
df['x'] = pd.to_datetime(df['Date'], format='%m/%d/%Y %I:%M:%S %p')
df['x2'] = df['x'].dt.strftime('%Y-%m-%d')
data = pd.DataFrame(df['x2'].value_counts(sort=False).reset_index())
data.columns = ['ds', 'y']
crimes = data.sort_values(by='ds')
crimes.reset_index(inplace=True)
# create a Prophet model
m = Prophet()
# fit the dataframe to the Prophet model
m.fit(crimes)
# create a new period to forecast
future = m.make_future_dataframe(periods=365)
future.head()
# making the forecast
forecast = m.predict(future)
# plotting the forecast
fig1 = m.plot(forecast)
fig2 = m.plot_components(forecast)
x=bikerides['ds'],
y=bikerides['rain'],
name='Rain',
))
if temp_con == True:
fig.add_trace(
go.Scatter(
x=bikerides['ds'],
y=bikerides['temp'],
name='Temp',
))
st.write(fig)
st.write(m.plot(forecast))
st.write(m.plot_components(forecast))
st.write(getPerformanceMetrics(m).mean())
st.header('Forecasting Rides')
period = st.slider(
'Forecast Periods in days',
1,
365,
)
st.write("Forecast Periods ", period, " days")
# We must create a data frame holding dates for our forecast. The periods # parameter counts days as long as the frequency is 'D' for the day. Let's # do a 180 day forecast, approximately half a year.
future = m.make_future_dataframe(periods=period, freq='D')
def compare_models(data, variable, test_size):
test_split = len(data) - test_size
# simple model using mean electricity use by month, weekday and hour
data_train = data[:test_split][[variable]]
data_train_grouped = (data_train[[variable]].groupby([
data_train.index.month, data_train.index.weekday, data_train.index.hour
]).mean())
data_train_grouped.index.names = ["month", "weekday", "hour"]
data_test = pd.DataFrame(
data={
"month": data[test_split:].index.month,
"weekday": data[test_split:].index.weekday,
"hour": data[test_split:].index.hour,
},
index=data[test_split:].index,
)
mean_grouped_predictions = data_test.join(data_train_grouped,
how="left",
on=["month", "weekday",
"hour"])[variable]
# preparing data for prophet
df = data[variable].reset_index(level=0)
df.columns = ["ds", "y"]
df_train = df[:test_split]
df_test = df[test_split:]
m_simple = Prophet()
m_simple.fit(df_train)
future_simple = m_simple.make_future_dataframe(periods=test_size, freq="H")
forecast_simple = m_simple.predict(future_simple)
# limiting low predictions to zero
forecast_simple["yhat"] = np.where(forecast_simple["yhat"] < 0, 0,
forecast_simple["yhat"])
forecast_simple["yhat_lower"] = np.where(forecast_simple["yhat_lower"] < 0,
0, forecast_simple["yhat_lower"])
forecast_simple["yhat_upper"] = np.where(forecast_simple["yhat_upper"] < 0,
0, forecast_simple["yhat_upper"])
global forecast_plot_simple
global component_plot_simple
forecast_plot_simple = m_simple.plot(forecast_simple)
component_plot_simple = m_simple.plot_components(forecast_simple)
# using inbuilt holidays because this automatically applies to predictions also
m_holiday = Prophet()
m_holiday.add_country_holidays(country_name="FRA")
m_holiday.fit(df_train)
future_holiday = m_holiday.make_future_dataframe(periods=test_size,
freq="H")
forecast_holiday = m_holiday.predict(future_holiday)
# limiting low predictions to zero
forecast_holiday["yhat"] = np.where(forecast_holiday["yhat"] < 0, 0,
forecast_holiday["yhat"])
forecast_holiday["yhat_lower"] = np.where(
forecast_holiday["yhat_lower"] < 0, 0, forecast_holiday["yhat_lower"])
forecast_holiday["yhat_upper"] = np.where(
forecast_holiday["yhat_upper"] < 0, 0, forecast_holiday["yhat_upper"])
global forecast_plot_holiday
global component_plot_holiday
forecast_plot_holiday = m_holiday.plot(forecast_holiday)
component_plot_holiday = m_holiday.plot_components(forecast_holiday)
m_temp = Prophet()
m_temp.add_regressor("temperature")
m_temp.add_regressor("temperature2")
m_temp.add_regressor("temperature_lag")
m_temp.add_regressor("temperature2_lag")
df_train["temperature"] = data["temperature"][:test_split].to_numpy()
df_train["temperature2"] = df_train["temperature"]**2
df_train["temperature_lag"] = df_train["temperature"].shift(
1, fill_value=df_train["temperature"].mean())
df_train["temperature2_lag"] = df_train["temperature2"].shift(
1, fill_value=df_train["temperature"].mean()**2)
m_temp.fit(df_train)
future_temp = m_temp.make_future_dataframe(periods=test_size, freq="H")
future_temp["temperature"] = data["temperature"][-len(future_temp
):].to_numpy()
future_temp["temperature2"] = future_temp["temperature"]**2
future_temp["temperature_lag"] = future_temp["temperature"].shift(
1, fill_value=future_temp["temperature"].mean())
future_temp["temperature2_lag"] = future_temp["temperature2"].shift(
1, fill_value=future_temp["temperature"].mean()**2)
forecast_temp = m_temp.predict(future_temp)
# limiting low predictions to zero
forecast_temp["yhat"] = np.where(forecast_temp["yhat"] < 0, 0,
forecast_temp["yhat"])
forecast_temp["yhat_lower"] = np.where(forecast_temp["yhat_lower"] < 0, 0,
forecast_temp["yhat_lower"])
forecast_temp["yhat_upper"] = np.where(forecast_temp["yhat_upper"] < 0, 0,
forecast_temp["yhat_upper"])
global forecast_plot_temp
global component_plot_temp
forecast_plot_temp = m_temp.plot(forecast_temp)
component_plot_temp = m_temp.plot_components(forecast_temp)
# calculate rmse
df_test.y.describe()
print(
"Mean RMSE: ",
mean_squared_error(df_test.y, np.repeat(df_train.y.mean(),
len(df_test))),
)
print("Mean grouped RMSE: ",
mean_squared_error(df_test.y, mean_grouped_predictions))
print(
"Simple Prophet: ",
mean_squared_error(df_test.y, forecast_simple.yhat[test_split:]),
)
print(
"Holiday Prophet: ",
mean_squared_error(df_test.y, forecast_holiday.yhat[test_split:]),
)
print(
"Temperature Prophet: ",
mean_squared_error(df_test.y, forecast_temp.yhat[test_split:]),
)
model_fit = mod.fit(disp=0)
ret = pd.DataFrame(model_fit.predict())
f, axarr = plt.subplots(1, sharex=True)
arg.y.plot(color='b', linestyle='-', ax=axarr)
ret.plot(color='r', linestyle='--', ax=axarr)
plt.show()
if __name__ == "__main__":
data = pd.read_csv(INPUT_FILE_PATH)
data["y"] = data["1"] + data["2"] + data["3"] + data["4"] + data[
"5"] + data["6"]
train_data = pd.DataFrame([data['ds'], data['y']]).T.sort_values(by="ds")
# max 369 min 42
m = Prophet(seasonality_mode='multiplicative',
changepoint_prior_scale=100,
interval_width=1) # Default growth='linear'
m.fit(train_data)
future = m.make_future_dataframe(periods=1, freq='w')
forecast = m.predict(future)
fig1 = m.plot(forecast, uncertainty=False)
plt.show()
train_data.index = train_data["ds"]
train_data = train_data["y"]
print("Predict Value : {}".format(math.floor(
forecast.yhat[-1:].values[0])))
#3: PREPARING THE DATA
chicago_prophet = chicago_df.resample('M').size().reset_index()
print(chicago_prophet)
chicago_prophet.columns = ['Date', 'Crime Count']
chicago_prophet_df = pd.DataFrame(chicago_prophet)
print(chicago_prophet_df)
#4: MAKE PREDICTIONS
print(chicago_prophet_df.columns)
chicago_prophet_df_final = chicago_prophet_df.rename(columns={
'Date': 'ds',
'Crime Count': 'y'
})
print(chicago_prophet_df_final)
m = Prophet()
m.fit(chicago_prophet_df_final)
# Forcasting into the future
future = m.make_future_dataframe(periods=365)
forecast = m.predict(future)
print(forecast)
figure = m.plot(forecast, xlabel='Date', ylabel='Crime Rate')
figure3 = m.plot_components(forecast)
organic_df = df[df['type']=='organic']
organic_df
plt.figure(figsize=(20,5))
plt.plot(organic_df['Date'], organic_df['AveragePrice'])
plt.xticks([])
organic_df = organic_df.rename(columns={'Date':'ds', 'AveragePrice':'y'})
m = Prophet()
m.fit(organic_df)
future = m.make_future_dataframe(periods=365)
forecast = m.predict(future)
figure = m.plot(forecast, xlabel='Date', ylabel='Price')
decomposed_figure = m.plot_components(forecast)
"""##Price Prediction with Conventional Type"""
conventional_df = df[df['type']=='conventional']
conventional_df
plt.figure(figsize=(20,5))
plt.plot(conventional_df['Date'], conventional_df['AveragePrice'])
plt.xticks([])
conventional_df = conventional_df.rename(columns={'Date':'ds', 'AveragePrice':'y'})
m = Prophet()
confirmed.drop(confirmed[confirmed.y == 0].index, inplace=True)
length = int(confirmed.shape[0] * 0.80)
#Split to Train set and test set
train_set = confirmed.iloc[:length]
test_set = confirmed.iloc[length:]
model = Prophet(interval_width=0.95)
model.fit(train_set)
#predict 20 days
future = model.make_future_dataframe(periods=30)
forecast = model.predict(future)
#plot
confirmed_forecast_plot = model.plot(forecast)
forecast_components = model.plot_components(forecast)
#Prepare
test_forecast = forecast[forecast.index >= length]
test_score = test_forecast.set_index('ds')[['yhat']].join(
test_set.set_index('ds').y).reset_index()
#Drop zero Values
test_score.dropna(inplace=True)
from sklearn.metrics import mean_squared_error, mean_absolute_error
print('MAE:', mean_absolute_error(test_score.yhat, test_score.y))
print('RMSE:', np.sqrt(mean_squared_error(test_score.yhat, test_score.y)))
def grid_search_worker(event, context={}):
# Time series model settings
parameter_list = event['parameters']
parameters = {}
for key in parameter_list:
# Special case for holidays, because it is a json string
if key == 'holidays':
holidays_dict = json.loads(event['data'][key])
continue
parameters[key] = event['data'][key]
forecast = event['forecast']
print('=====Parameters=======')
print(parameters)
# Read the dataset from S3 bucket
df = read_csv_s3(parameters['dataset'])
# df = pd.read_csv("./datasets/prophet/example_wp_log_peyton_manning.csv")
# Transfer holiday to data frame
if holidays_dict is not None:
parameters['holidays'] = pd.DataFrame({
'holiday':
holidays_dict['holiday'],
'ds':
pd.to_datetime(holidays_dict['ds']),
'lower_window':
holidays_dict['lower_window'],
'upper_window':
holidays_dict['upper_window'],
})
# Fit the model
df['cap'] = parameters['cap']
df['floor'] = parameters['floor']
model = Prophet(
growth=parameters['growth'],
changepoint_prior_scale=parameters['changepoint_prior_scale'],
holidays=parameters['holidays'],
holidays_prior_scale=parameters['holidays_prior_scale'],
seasonality_mode=parameters['seasonality_mode'],
interval_width=parameters['interval_width'])
model.add_seasonality(name='yearly',
period=365,
fourier_order=parameters['fourier_order'],
prior_scale=parameters['seasonality_prior_scale'])
model.add_country_holidays(country_name=parameters['country_holidays'])
# Truncate the time series
df.loc[(df['ds'] <= parameters['left_bound']) &
(df['ds'] >= parameters['right_bound']), 'y'] = None
print("=====Fit the Model=======")
model.fit(df)
if forecast == 0:
# Cross validation the model
print("=====Cross Validation=======")
average_metric = cross_validation_worker(model, parameters['initial'],
parameters['period'],
parameters['horizon'],
parameters['metric'])
print("Metric {0}: {1}".format(parameters['metric'], average_metric))
return {'average_metric': average_metric, 'event': event}
else:
future = model.make_future_dataframe(periods=int(forecast))
forecast = model.predict(future)
time_series = model.plot(forecast)
components = model.plot_components(forecast)
time_series.savefig(local_repo + '/time_series.png')
upload_csv_s3(local_repo + '/time_series.png')
components.savefig(local_repo + '/components.png')
upload_csv_s3(local_repo + '/components.png')
return "Graphs are uploaded to S3"
def main():
st.header('Online Stock Price Ticker')
# yfiance 실행
symbol = st.text_input(
'심볼 입력 : '
) # 이렇게 하면 밑에 심볼을 포맷으로 해놓은것에 유저가 입력할때마다 들어가서 보고싶은 회사의 주식을 볼수 있음
# symbol = 'MSFT' # MSFT 는 마이크로 소프트 # 내가 보고싶은 종목(회사)를 바꾸고 싶으면 여기를 바꾸면 됨
data = yf.Ticker(symbol)
today = datetime.now().date().isoformat(
) # 연월일 만 가져올땐 date(), 시분초만 가져올땐 time() # isoformat는 숫자들을 문자열로
print(today)
df = data.history(start='2010-06-01', end='2021-03-22')
st.dataframe(df)
st.subheader('종가') # 종가 차트 그리기
st.line_chart(df['Close'])
st.subheader('거래량') # 거래량 차트 그리기
st.line_chart(df['Volume'])
# yfiance 라이브러리만의 정보
# data.info # 내가 보는 회사의 정보들을 알려줌
# data.calendar
# data.major_holders # 대주주가 누구인가를 알수 있음
# data.institutional_holders # 어떤사람들이 주식 가지고 있는지 알수 있음
# data.recommendations # 어느기관이 샀는지 시간별로 알수 있음
# data.dividends # 배당금 정보 알 수 있음
div_df = data.dividends
st.dataframe(div_df.resample('Y').sum()) # 배당금 각 연도별로 알수있다 # resample !!
new_df = div_df.reset_index(
) # 지금 현재 날짜를 인덱스 번호로 해서 컬럼으로 만든다 # 그래서 연도별 배당금을 알수있다 차트로 # 이렇게 바꾸면 이따가 prophet에도 쉽게 사용가능 하다
new_df['Year'] = new_df['Date'].dt.year
# 배당금을 차트로
fig = plt.figure()
plt.bar(new_df['Year'], new_df['Dividends'])
st.pyplot(fig)
# 여러 주식 데이터를 한번에 보여주기
favorites = ['msft', 'tsla', 'nvda', 'aapl', 'amzn'] # 이거를 심볼로 놔도됨
f_df = pd.DataFrame() # 각각의 종가(Close)들을 비어있는 데이터프레임에 넣어서 보여주고 싶을 때
for stock in favorites:
f_df[stock] = yf.Ticker(stock).history(
start='2010-01-01', end=today)['Close'] # 변수로 저장해서 2-3줄로도 가능
# 비어있던 f_df에 stock라고 만든 컬럼에 이값들을 넣어달라
st.dataframe(f_df)
# 위에것을 한번에 차트 나타내라
st.line_chart(f_df) # 이런부분 멀티셀렉트로 하면 좋을 것 같다
# API 호출을 위한 라이브러리 임폴트 하고 와야해
# 구글에 주소 가져올때 했었음
# pip install requests 이거 설치하면 이제 불러올수 있고 stocktwits 주소 넣으면 됨
res = requests.get(
'https://api.stocktwits.com/api/2/streams/symbol/{}.json'.format(
symbol)
) # 원하는 회사의 데이터를 보고 싶을 때 # 이렇게 만들었으면 맨 위에 text_input 만들어서 보게 할수도 있음
# json 형식이므로 , .json()
res_data = res.json() # 리스트와 딕셔너리 형태로 불러옴
# 파이썬의 딕셔너리와 리스트이 조합으로 사용가능
#st.write(res_data)
for message in res_data['messages']:
# message 키에 있는 내용들 가져와서
#st.write(message) # 메세지 30개의 전체 내용들을 볼수 있음
col1, col2 = st.beta_columns([1, 4]) # 1 : 4의 비율로 보여달라
with col1:
st.image(message['user']['avatar_url'])
with col2:
st.write('유저 이름 : ' + message['user']['username'])
st.write('트윗 내용 : ' + message['body'])
st.write('올린 시간 : ' + message['created_at'])
# st.image( message['user']['avatar_url'] ) # col, with 빼고 포문에 이것만 넣으면 다 한줄에 그냥 볼수있고 위에처럼 바꾸면 예쁘게 정리한모습으로 볼수 있음
# st.write( message['user']['username'] )
# st.write( message['body'] )
# st.write( message['created_at'] )
# 여기서 부터는 프로펫 !!!
p_df = df.reset_index()
p_df.rename(columns={'Data': 'ds', 'Close': 'y'}, inplace=True)
# st.dataframe(p_df)
# 이제 예측가능 !
m = Prophet()
m.fit(p_df)
future = m.make_future_dataframe(periods=365) # 1년치 데이터를 만들어 놓고
forecast = m.predict(future) # >>> 예측해달라
st.dataframe(forecast)
# 위에 차트 그려라
fig1 = m.plot(forecast)
st.pyplot(fig1)
fig2 = m.plot_components(forecast)
st.pyplot(fig2)
#otherwise similar to sk-learn
predictions = model.predict(future_timestamps)
#let's take a look at our model's predictions
print(predictions.head())
#now we observe a lot of data from this, again to learn more you should learn about ARIMA
#but here are some important take aways
#ds: the datestamp
#yhat: what statistics calls the forecasted value for y as time ds
#yhat_lower: lower bounds of our forecast at ds
#yhat_upper: upper bounds of our forecast at ds
#conviently, Prophet has built in ploting abilities
#which will plot what it believe to be important things
model.plot(predictions, uncertainty=True)
plt.ylabel('Monthly Number of Airline Passengers')
plt.xlabel('Date')
plt.show()
#the black dots are the observed values from the training set
#the thick blue line is yhat
#and the light blue is the area between yhat_upper and yhat_lower
#and also, wow that is some serious predictive power!
#another cool feature is that Prophet can easily show you what it is using to build it's model
#or in other words, the components of the model
model.plot_components(predictions)
plt.show()
from fbprophet import Prophet
# import matplotlib.pyplot as plt
# get_ipython().run_line_magic('matplotlib', 'inline')
# 读入数据集
train = pd.read_csv('./train.csv')
print(train.head())
print(train.tail())
train['Datetime'] = pd.to_datetime(train.Datetime, format='%d-%m-%Y %H:%M')
train.index = train.Datetime
print(train.head())
train.drop(['ID', 'Datetime'], axis=1, inplace=True)
print(train.head())
daily_train = train.resample('D').sum()
daily_train['ds'] = daily_train.index
daily_train['y'] = daily_train.Count
daily_train.drop(['Count'], axis=1, inplace=True)
print(daily_train.head())
m = Prophet(yearly_seasonality=True, seasonality_prior_scale=0.1)
m.fit(daily_train)
future = m.make_future_dataframe(periods=213)
forcast = m.predict(future)
print(forcast)
m.plot(forcast)
m.plot_components(forcast)
holidays = pd.concat(
(easter, samsung_preorder, samsung_launch, apple_preorder, apple_launch,
black_friday, cyber_monday, thanksgiving, christmas, independence_day))
# Define and fit the model
m = Prophet(holidays=holidays,
daily_seasonality=True,
yearly_seasonality=6,
changepoint_range=0.9,
changepoint_prior_scale=0.01)
# changepoints = ['2018-01-01']
# m.add_country_holidays(country_name = 'US')
m.train_holiday_names
m.fit(df)
# Create a dataframe to hold predictions
future = m.make_future_dataframe(periods=243)
future.tail()
# Make predictions
forecast = m.predict(future)
forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail(31)
forecast.to_csv('jan_aug_forecast.csv')
# Plot forecasts
fig = m.plot(forecast)
add_changepoints_to_plot(fig.gca(), m, forecast)
# Plot forecast components
m.plot_components(forecast)
import matplotlib.pyplot as plt
# 读入数据集
df = pd.read_csv('./train.csv')
df['Datetime'] = pd.to_datetime(df.Datetime, format='%d-%m-%Y %H:%M')
df.index = df.Datetime
df.drop(['ID', 'Datetime'], axis=1, inplace=True)
# 按天聚合
daily_df = df.resample('D').sum()
# 将时间顺序列名修改符合Prophet要求
daily_df['ds'] = daily_df.index
daily_df['y'] = daily_df.Count
daily_df.drop('Count', axis=1, inplace=True)
print(daily_df.head())
# 拟合Prophet模型
model = Prophet(yearly_seasonality=True, seasonality_prior_scale=0.1)
model.fit(daily_df)
# 预测未来七个月（213天）
future = model.make_future_dataframe(periods=213)
forcast = model.predict(future)
# print(forcast)
# 查看预测各成份
model.plot_components(forcast)
# 绘制预测
model.plot(forcast)
plt.show()
#print(forecast1[['ds','yhat','yhat_lower','yhat_upper']])
#%%
## This works and retained the dataframe type
forecast2 = np.exp(forecast1[['yhat','yhat_lower','yhat_upper']])
## Now merge to bring the ds back into the df
## Without the "on" keyword the join key is implicitly the index which is what we're doing here
forecast2 = forecast2.join(forecast1['ds'], how='inner')
#%%
## This works
## This will create a plot that includes Forecasted, C.I.'s, and Actual values
m.plot(forecast)
#%%
## Save a copy of the plot
fig = m.plot(forecast)
fig.savefig("/home/steve/forecast_raw.jpeg")
#%%
## I think it is unecessary to review exponentiated components
## Plus the complexity of joining forecast2 with forecast1
m.plot_components(forecast1);
#%%
## It was necessary, in the fill_between, to use a datetime index associated with
## the first parameter of the function.
## This necessitated converting the existing ds datetime element to an index
import pandas as pd
import numpy as np
from fbprophet import Prophet
# Prep the dataset
data = pd.read_csv("/home/dusty/Econ8310/DataSets/chicagoBusRiders.csv")
route3 = data[data.route=='3'][['date','rides']]
route3.date = pd.to_datetime(route3.date, infer_datetime_format=True)
route3.columns = [['ds', 'y']]
# Initialize Prophet instance and fit to data
m = Prophet()
m.fit(route3)
# Create timeline for 1 year in future, then generate predictions based on that timeline
future = m.make_future_dataframe(periods=365)
forecast = m.predict(future)
# Create plots of forecast and truth, as well as component breakdowns of the trends
plt = m.plot(forecast)
plt.show()
comp = m.plot_components(forecast)
comp.show()
def show_trend(df,
name='Ontario',
typeToVis="contracted",
n_changepoints=2,
startDate=None,
returnForcast=False,
typeOfFit='linear'):
"""
Show trend of log10(@variable) using fbprophet package.
@ncov_df <pd.DataFrame>: the clean data
@variable <str>: variable name to analyse
- if Confirmed, use Infected + Recovered + Deaths
@n_changepoints <int>: max number of change pointsimport matplotlib.pyplot as plt
from fbprophet import Prophet
from fbprophet.plot import add_changepoints_to_plot
import numpy as np
import pandas as pd
from datetime import date, timedelta
@kwargs: keword arguments of select_area()
"""
# get only typeToVis and convert the data to log
# note that we are replacing anything with inf - -inf to 0 there are nans basically
# or the crit points of log
if startDate == None:
df = df[typeToVis]
else:
# split the date comming in
splitDate = startDate.split('-')
int(splitDate[2]), int(splitDate[1]), int(splitDate[0])
# create a time index
startDate = date(int(splitDate[0]), int(splitDate[1]),
int(splitDate[2]))
endDate = date.today()
df = df.loc[startDate:endDate, typeToVis]
if typeOfFit == 'linear':
df = np.log10(df).replace([np.inf, -np.inf], 0)
# massage the date to be placed in fbprophet
# the data frame must contain coloumn with "ds" and "y"
# these are string dates and values respectively
dfProphetIn = pd.DataFrame({'ds': df.index, 'y': df}).reset_index()
dfProphetIn = dfProphetIn.drop(columns='date')
if typeOfFit == 'logistic':
dfProphetIn['cap'] = 15000
#dfProphetIn.tail()
# fbprophet
# note that the growth in linear here because we transformed the data into log scale
# pipeline is as follows:
# model generation ---> model fit ----> model generate future ----> forecast
if typeOfFit == 'linear':
model = Prophet(growth="linear",
daily_seasonality=False,
n_changepoints=n_changepoints)
else:
model = Prophet(growth="logistic",
daily_seasonality=False,
n_changepoints=n_changepoints)
model.fit(dfProphetIn)
future = model.make_future_dataframe(periods=3)
if typeOfFit == 'logistic':
future['cap'] = 15000
forecast = model.predict(future)
# Printing the change points of the model
print(model.changepoints)
# Create figure
# plot the model using prophet
fig = model.plot(forecast)
_ = add_changepoints_to_plot(fig.gca(), model, forecast)
plt.title(f"{name} log10({typeToVis}) over time and change points")
plt.ylabel(f"log10(the number of cases)")
plt.xlabel("")
plt.show()
if returnForcast:
return forecast
from fbprophet import Prophet
import pandas as pd
df = pd.read_csv('./Datasets/Google_Stock_Price_Train.csv')
open_data = df.groupby('Date').sum()['Open'].reset_index()
open_data.columns = ['ds', 'y'] # renaming the columns as required by model
open_data['ds'] = pd.to_datetime(open_data['ds']) # formating date to required form to feed to the model
m = Prophet(interval_width = 0.96)
m.fit(open_data)
future_predict = m.make_future_dataframe(periods = 50)
my_forecast = m.predict(future_predict)
predicted_data = my_forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']]
#############################################################################
# graphical visualization
import matplotlib
matplotlib.use('Agg')
fig = m.plot(predicted_data)
fig.savefig('./v2.eps', format = 'eps')
)
else:
st.markdown(
f"# PARABÉNS! Você está no caminho certo para fechar {today_year} com as contas em dia!"
)
st.write("\nA previsão solicitada se encontra a seguir:")
st.header("Receitas")
fcst['mes'] = fcst.ds.apply(lambda x: pd.to_datetime(x).month)
fcst['ano'] = fcst.ds.apply(lambda x: pd.to_datetime(x).year)
st.table(fcst[['mes', 'ano', 'yhat']].rename(columns={
'mes': 'Mês',
'ano': 'Ano',
'yhat': 'Receita prevista'
}).tail(n_periods))
fig = m1.plot(fcst)
st.pyplot(fig)
st.header("Despesas")
fcst2['mes'] = fcst2.ds.apply(lambda x: pd.to_datetime(x).month)
fcst2['ano'] = fcst2.ds.apply(lambda x: pd.to_datetime(x).year)
st.table(fcst2[['mes', 'ano',
'yhat']].rename(columns={
'mes': 'Mês',
'ano': 'Ano',
'yhat': 'Receita prevista'
}).tail(n_periods))
fig2 = m2.plot(fcst2)
st.pyplot(fig2)
if column == 'prn' or column == 'epoch_time' or column=='index':
continue
if column == 'sv_clock_bias' or column == 'sv_clock_drift' or column == 'sv_clock_drift_rate' or column == 'mean_motion' or column == 'essentricity' or column == 'sqrt_semi_major_axis' or column == 'OMEGA' or column == 'inclination' or column == 'omega' or column == 'OMEGA_dot' or column == 'inclination_rate' or column == 'codes' or column == 'gps_week' or column == 'l2_p_data_flag' or column == 'sv_accuracy' or column == 'sv_health' or column == 'tgd' or column == 'fit_interval':
df_m = pd.DataFrame()
df_m['ds'] = df_prn['epoch_time']
df_m['y'] = df_prn[column]
model = Prophet()
model.fit(df_m)
future = model.make_future_dataframe(periods=days_to_predict, freq='H')
forecast=model.predict(future)
df_predicted[column] = forecast['yhat']
path_img = 'img/'+column+'.png'
model.plot(forecast).savefig('img/'+column+'.png')
#model.plot(forecast)
#print('RMSE: %f' % np.sqrt(np.mean((forecast.loc[:df_m['y'].size-1, 'yhat']-df_m['y'])**2)) )
mse = mean_absolute_percentage_error(forecast.loc[:df_m['y'].size-1, 'yhat'],df_m['y'])
#print("MSE: "+str(mse))
avg_acc = avg_acc + mse
del df_m
if column == 'iode' or column == 'correction_radius_sine' or column == 'correction_latitude_cosine' or column == 't_tx' or column == 'correction_latitude_sine' or column == 'correction_inclination_cosine' or column == 'correction_radius_cosine' or column == 'mean_anomaly' or column == 'correction_inclination_sine':
df_m = pd.DataFrame()
df_m['ds'] = df_prn['epoch_time']
df_m['y'] = df_prn[column]
model = Prophet(changepoint_prior_scale=0.5)
model.fit(df_m)
def fit(self, ts_df: pd.DataFrame, target_col: str, cv: Optional[int], time_col: str) -> object:
"""
Fits the model to the data
:param ts_df The time series data to be used for fitting the model
:type ts_df pd.DataFrame
:param target_col The column name of the target time series that needs to be modeled.
All other columns will be considered as exogenous variables (if applicable to method)
:type target_col str
:param cv: Number of folds to use for cross validation.
Number of observations in the Validation set for each fold = forecast period
If None, a single fold is used
:type cv Optional[int]
:param time_col: Name of the time column in the dataset (needed by Prophet)
Time column can also be the index, in which case, this would be the name of the index
:type time_col str
:rtype object
"""
# use all available threads/cores
self.time_col = time_col
self.original_target_col = target_col
self.original_preds = [x for x in list(ts_df) if x not in [self.original_target_col]]
if len(self.original_preds) == 0:
self.univariate = True
else:
self.univariate = False
# print(f"Prophet Is Univariate: {self.univariate}")
ts_df = copy.deepcopy(ts_df)
##### if you are going to use matplotlib with prophet data, it gives an error unless you do this.
pd.plotting.register_matplotlib_converters()
#### You have to import Prophet if you are going to build a Prophet model #############
actual = 'y'
timecol = 'ds'
data = self.prep_col_names_for_prophet(ts_df=ts_df, test=False)
if self.univariate:
dft = data[[timecol, actual]]
else:
dft = data[[timecol, actual] + self.original_preds]
##### For most Financial time series data, 80% conf interval is enough...
if self.verbose >= 1:
print(' Fit-Predict data (shape=%s) with Confidence Interval = %0.2f...' % (dft.shape, self.conf_int))
### Make Sure you lower your desired interval width from the normal 95% to a more realistic 80%
start_time = time.time()
if self.univariate is False:
for name in self.original_preds:
self.model.add_regressor(name)
print(" Starting Prophet Fit")
if self.seasonality:
prophet_seasonality, prophet_period, fourier_order, prior_scale = get_prophet_seasonality(
self.time_interval, self.seasonal_period)
self.model.add_seasonality(name=prophet_seasonality,
period=prophet_period, fourier_order=fourier_order, prior_scale= prior_scale)
print(' Adding %s seasonality to Prophet with period=%d, fourier_order=%d and prior_scale=%0.2f' %(
prophet_seasonality, prophet_period, fourier_order, prior_scale))
else:
print(' No seasonality assumed since seasonality flag is set to False')
if type(dft) == dask.dataframe.core.DataFrame:
num_obs = dft.shape[0].compute()
else:
num_obs = dft.shape[0]
### Creating a new way to skip cross validation when trying to run auto-ts multiple times. ###
if cv == 0:
cv_in = 0
else:
cv_in = copy.deepcopy(cv)
NFOLDS = self.get_num_folds_from_cv(cv)
#########################################################################################
# NOTE: This change to the FB recommendation will cause the cv folds from facebook to
# be incompatible with the folds from the other models (in terms of periods of evaluation
# as well as number of observations in each period). Hence the final comparison will
# be biased since it will not compare the same folds.
# The original implementation was giving issues under certain conditions, hence this change
# to FB recommendation has been made as a temporary (short term) fix.
# The root cause issue will need to be fixed eventually at a later point.
#########################################################################################
### Prophet's Time Interval translates into frequency based on the following pandas date_range alias:
# Link: https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html#timeseries-offset-aliases
## This is done using the get_prophet_time_interval() function later.
if self.time_interval in self.list_of_valid_time_ints:
time_int = copy.deepcopy(self.time_interval)
else:
time_int = self.get_prophet_time_interval(for_cv=False)
# First Fold -->
# Train Set: 0:initial
# Test Set: initial:(initial+horizon)
# Second Fold -->
# Train Set: (period):(initial+period)
# Test Set: (initial+period):(initial+horizon+ period)
# Format: '850 D'
print(" Starting Prophet Cross Validation")
################################################################################
if self.forecast_period <= 5:
#### Set a minimum of 5 for the number of rows in test!
self.forecast_period = 5
### In case the number of forecast_period is too high, just reduce it so it can fit into num_obs
if NFOLDS*self.forecast_period > num_obs:
self.forecast_period = int(num_obs/(NFOLDS+1))
print('Lowering forecast period to %d to enable cross_validation' %self.forecast_period)
###########################################################################################
#cv = GapWalkForward(n_splits=NFOLDS, gap_size=0, test_size=self.forecast_period)
max_trainsize = len(dft) - self.forecast_period
try:
cv = TimeSeriesSplit(n_splits=NFOLDS, test_size=self.forecast_period) ### this works only sklearn v 0.0.24]
except:
cv = TimeSeriesSplit(n_splits=NFOLDS, max_train_size = max_trainsize)
y_preds = pd.DataFrame()
print('Max. iterations using expanding window cross validation = %d' %NFOLDS)
start_time = time.time()
rmse_folds = []
norm_rmse_folds = []
forecast_df_folds = []
concatenated = pd.DataFrame()
extra_concatenated = pd.DataFrame()
if type(dft) == dask.dataframe.core.DataFrame:
dft = dft.head(len(dft)) ### this converts dask into a pandas dataframe
if cv_in == 0:
print('Skipping cross validation steps since cross_validation = %s' %cv_in)
model = Prophet(growth="linear")
kwargs = {'iter':1e2} ## this limits iterations and hence speeds up prophet
else:
for fold_number, (train_index, test_index) in enumerate(cv.split(dft)):
dftx = dft.head(len(train_index)+len(test_index))
train_fold = dftx.head(len(train_index)) ## now train will be the first segment of dftx
test_fold = dftx.tail(len(test_index)) ### now test will be right after train in dftx
horizon = len(test_fold)
print(f"\nFold Number: {fold_number+1} --> Train Shape: {train_fold.shape[0]} Test Shape: {test_fold.shape[0]}")
#########################################
#### Define the model with fold data ####
#########################################
model = Prophet(growth="linear")
############################################
#### Fit the model with train_fold data ####
############################################
kwargs = {'iter':1e2} ## this limits iterations and hence speeds up prophet
model.fit(train_fold, **kwargs)
#################################################
#### Predict using model with test_fold data ####
#################################################
future_period = model.make_future_dataframe(freq=time_int, periods=horizon)
forecast_df = model.predict(future_period)
### Now compare the actuals with predictions ######
y_pred = forecast_df['yhat'][-horizon:]
concatenated = pd.DataFrame(np.c_[test_fold[actual].values,
y_pred.values], columns=['original', 'predicted'],index=test_fold.index)
if fold_number == 0:
extra_concatenated = copy.deepcopy(concatenated)
else:
extra_concatenated = extra_concatenated.append(concatenated)
rmse_fold, rmse_norm = print_dynamic_rmse(concatenated['original'].values, concatenated['predicted'].values,
concatenated['original'].values)
print('Cross Validation window: %d completed' %(fold_number+1,))
rmse_folds.append(rmse_fold)
norm_rmse_folds.append(rmse_norm)
######################################################
### This is where you consolidate the CV results #####
######################################################
fig = model.plot(forecast_df)
#rmse_mean = np.mean(rmse_folds)
#print('Average CV RMSE over %d windows (macro) = %0.5f' %(fold_number+1,rmse_mean))
#cv_micro = np.sqrt(mean_squared_error(y_trues.values, y_preds.values))
#print('Average CV RMSE of all predictions (micro) = %0.5f' %cv_micro)
try:
print_ts_model_stats(extra_concatenated['original'], extra_concatenated['predicted'], "Prophet")
except:
print('Error: Not able to plot Prophet CV results')
forecast_df_folds = extra_concatenated['predicted'].values
#print(" End of Prophet Cross Validation")
print('Time Taken = %0.0f seconds' %((time.time()-start_time)))
#### Now you need to fit Prophet on the whole train data set ##########
dftx = dft.head(len(dft))
model = Prophet(growth="linear")
self.model = model
self.model.fit(dftx, **kwargs)
print(" End of Prophet Fit")
#num_obs_folds = df_cv.groupby('cutoff')['ds'].count()
# https://stackoverflow.com/questions/54405704/check-if-all-values-in-dataframe-column-are-the-same
#a = num_obs_folds.to_numpy()
#all_equal = (a[0] == a).all()
#if not all_equal:
#print("WARNING: All folds did not have the same number of observations in the validation sets.")
#print("Num Test Obs Per fold")
#print(num_obs_folds)
#rmse_folds = []
#norm_rmse_folds = []
#forecast_df_folds = []
#df_cv_grouped = df_cv.groupby('cutoff')
#for (_, loop_df) in df_cv_grouped:
# rmse, norm_rmse = print_dynamic_rmse(loop_df['y'], loop_df['yhat'], dft['y'])
# rmse_folds.append(rmse)
# norm_rmse_folds.append(norm_rmse)
# forecast_df_folds.append(loop_df)
# print(f"RMSE Folds: {rmse_folds}")
# print(f"Norm RMSE Folds: {norm_rmse_folds}")
# print(f"Forecast DF folds: {forecast_df_folds}")
# forecast = self.predict(simple=False, return_train_preds=True)
# #### We are going to plot Prophet's forecasts differently since it is better
# dfa = plot_prophet(dft, forecast);
# # Prophet makes Incredible Predictions Charts!
# ### There can't be anything simpler than this to make Forecasts!
# #self.model.plot(forecast); # make sure to add semi-colon in the end to avoid plotting twice
# # Also their Trend, Seasonality Charts are Spot On!
# try:
# self.model.plot_components(forecast)
# except:
# print('Error in FB Prophet components forecast. Continuing...')
#rmse, norm_rmse = print_dynamic_rmse(dfa['y'], dfa['yhat'], dfa['y'])
#return self.model, forecast, rmse, norm_rmse
return self.model, forecast_df_folds, rmse_folds, norm_rmse_folds
avocado_df = avocado_df.sort_values("Date")
plt.plot(avocado_df["Date"], avocado_df["AveragePrice"])
sns.countplot(y="region", data=avocado_df)
sns.countplot(y="year", data=avocado_df)
avocado_prophet = avocado_df[["Date", "AveragePrice"]]
avocado_prophet.columns = ["ds", "y"]
m = Prophet()
m.fit(avocado_prophet)
future = m.make_future_dataframe(periods=365)
forecast = m.predict(future)
m.plot(forecast,
xlabel="Date",
ylabel="Average Price of Avocado",
figsize=(10, 10))
m.plot_components(forecast)
avocado_df["region"]
### REGION SPECIFIC ###
avocado_df = avocado_df[avocado_df["region"] == "California"]
avocado_df = avocado_df.sort_values("Date")
plt.plot(avocado_df["Date"], avocado_df["AveragePrice"])
sns.countplot(y="year", data=avocado_df)
avocado_prophet = avocado_df[["Date", "AveragePrice"]]
avocado_prophet.columns = ["ds", "y"]
# Prophet Model
data01_model = Prophet(interval_width=0.95)
data01 = data01.rename(columns={'M_Y': 'ds', 'Qty': 'y'})
data01_model.fit(data01)
data_forecast = data01_model.make_future_dataframe(periods=12, freq='W')
data_forecast_pred = data01_model.predict(data_forecast)
import matplotlib.pyplot as plt
plt.figure(figsize=(18, 6))
data01_model.plot(data_forecast_pred, xlabel='Date', ylabel='Qty')
plt.title('Qty Forecast')
#fig = px.line(data01, x='ds', y='y')
#fig.show()
#
#data.info()
data01['ds'] = pd.to_datetime(data01['ds'], format='%Y-%m-%d').dt.date
data01.info()
fdata = data01[['ds', 'y']]
fdata.set_index('ds', inplace=True)
import pandas as pd
import numpy as np
from fbprophet import Prophet
df = pd.read_csv('./examples/example_wp_R.csv')
df['y'] = np.log(df['y'])
df['cap'] = 8.5
m = Prophet(growth='logistic')
m.fit(df)
future = m.make_future_dataframe(periods=2)
future['cap'] = 8.5
forecast = m.predict(future)
print(forecast)
m.plot(forecast)
from matplotlib import pyplot as plt
plt.show()
def predict_each_satellite(prn):
print(prn)
df_temp = pd.DataFrame()
avg_acc = 0.0
df_prn = df_final.loc[df_final['prn'] == prn].reset_index()
df_expect2 = df_expect.loc[df_expect['prn'] == prn].reset_index()
future = pd.DataFrame()
future['ds'] = df_expect2['epoch_time']
#print(future)
df_m = pd.DataFrame()
df_m['ds'] = df_prn['epoch_time']
df_m['y'] = df_prn['epoch_time']
model = Prophet()
model.fit(df_m)
#future = model.make_future_dataframe(periods=30, freq='H')
df_temp['prn'] = prn
df_temp['epoch_time'] = df_expect2['epoch_time']
df_temp['prn'] = prn
for column in list(df_prn.columns.values):
#print('--------column--------- :'+ str(column))
if column == 'prn' or column == 'epoch_time' or column == 'index':
continue
if column == 'sv_clock_bias' or column == 'sv_clock_drift' or column == 'sv_clock_drift_rate' or column == 'mean_motion' or column == 'essentricity' or column == 'sqrt_semi_major_axis' or column == 'OMEGA' or column == 'inclination' or column == 'omega' or column == 'OMEGA_dot' or column == 'inclination_rate' or column == 'codes' or column == 'gps_week' or column == 'l2_p_data_flag' or column == 'sv_accuracy' or column == 'sv_health' or column == 'tgd' or column == 'fit_interval':
df_m = pd.DataFrame()
df_m['ds'] = df_prn['epoch_time']
df_m['y'] = df_prn[column]
model = Prophet()
model.fit(df_m)
forecast = model.predict(future)
model.plot(forecast)
#print('RMSE: %f' % (np.sqrt(np.mean((forecast.loc[:df2['y'].size-1, 'yhat']-df2['y'])**2))/np.abs(np.max(forecast.loc[:df2['y'].size-1, 'yhat']-df2['y']))))
mse = mean_absolute_percentage_error(forecast['yhat'],
df_expect2[column])
#print("MSE: "+str(mse))
avg_acc = avg_acc + mse
df_temp[column] = forecast['yhat']
del df_m
if column == 'iode' or column == 'correction_radius_sine' or column == 'correction_latitude_cosine' or column == 't_tx' or column == 'correction_latitude_sine' or column == 'correction_inclination_cosine' or column == 'correction_radius_cosine' or column == 'mean_anomaly' or column == 'correction_inclination_sine':
df_m = pd.DataFrame()
df_m['ds'] = df_prn['epoch_time']
df_m['y'] = df_prn[column]
model = Prophet(changepoint_prior_scale=0.5)
model.fit(df_m)
forecast = model.predict(future)
model.plot(forecast)
#print('RMSE: %f' % (np.sqrt(np.mean((forecast.loc[:df2['y'].size-1, 'yhat']-df2['y'])**2))/np.abs(np.max(forecast.loc[:df2['y'].size-1, 'yhat']-df2['y']))))
mse = mean_absolute_percentage_error(forecast['yhat'],
df_expect2[column])
#print("MSE: "+str(mse))
avg_acc = avg_acc + mse
df_temp[column] = forecast['yhat']
del df_m
if column == 'time_of_ephemeris' or column == 'iodc':
df_m = pd.DataFrame()
df_m['ds'] = df_prn['epoch_time']
df_m['y'] = df_prn[column]
model = Prophet(changepoint_prior_scale=1.0)
model.fit(df_m)
forecast = model.predict(future)
model.plot(forecast)
#model.plot(forecast)
#print('RMSE: %f' % (np.sqrt(np.mean((forecast.loc[:df2['y'].size-1, 'yhat']-df2['y'])**2))/np.abs(np.max(forecast.loc[:df2['y'].size-1, 'yhat']-df2['y']))))
mse = mean_absolute_percentage_error(forecast['yhat'],
df_expect2[column])
#print("MSE: "+str(mse))
avg_acc = avg_acc + mse
df_temp[column] = forecast['yhat']
del df_m
#df_predicted = df_predicted.append(df_temp, ignore_index=True)
print(df_temp.shape)
print(" PRN : " + str(prn) + " acc : " + str(avg_acc / 30))
return (df_temp, avg_acc, prn)
fig = fig = px.line(d_test, x='ds', y='y')#memvisualisasi data yang digunakan sebagai data test fig.show() fig = fig = px.line(d_train, x='ds', y='y')#memvisualisasi data yang digunakan sebagai data train fig.show() """#membuat model prophet tanpa melalukan tune pada seasonality parameter""" m = Prophet( interval_width=0.95,) # the Prophet class (model) m.fit(d_train) # fit the model using all data future = m.make_future_dataframe(periods=(1336),freq='H',) #we need to specify the number of days in future prediction = m.predict(future) m.plot(prediction)# seperti yang dapat dilihat confident dari model berusaha melakukan fit tetapi model belum dapat mengikuti seasonality dr data set import statsmodels.api as sm sm.graphics.tsa.plot_acf(d_train['y'].values.squeeze(),lags=162) plt.ylim(-1,1) plt.xlim(72,75) plt.show() """# membuat model dengan melakukan tune pada parameter modelnya parameter yang akan sangat berdampak adalah parameter seasonality disini seperti berdasarkan yang kita lihat dari preproses untuk melihat tren dan seasonality dari dataset dataset memiliki seasonality selama 2 hari sekali, 1 bulan sekali dan 2 bulan sekali hal itu juga di tunjukan berdasarkan autocorelasion dari datanya """ m = Prophet( interval_width=0.95, weekly_seasonality=False,daily_seasonality=False,changepoint_prior_scale=0.07) # the Prophet class (model) m.add_seasonality(name='daily',period=2,fourier_order=4,prior_scale=20,mode='additive') m.add_seasonality(name='monthly',period=29.5,fourier_order=100,prior_scale=15,mode='additive') m.add_seasonality(name='weekly',period=7,fourier_order=20,prior_scale=6,mode='additive')
df.columns.values[0] #log-transform the y variable #to linearize a relationship #simplify the number and complexity of interaction terms df['y'] = np.log(df['y']) df.head() type(df['ds'][0]) #------------------------------# m = Prophet() m.fit(df) #Select the days to make a new dataframe future = model.make_future_dataframe(periods=50) #This is the prediction, literally speaking forecast = m.predict(future) forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail() #Plot the results %matplotlib inline c = m.plot(forecast); #Plot the components m.plot_components(forecast); #------------------------------#
if (Year_End_Train == Year) & (Month == Month_End_Train + 1):
split_index = index
break
data_train = data.iloc[:split_index]
for index in range(data_train.shape[0]):
data_train.at[index, 'y'] = np.log(data_train.loc[index, 'y'])
data_test = data.iloc[split_index:]
predict_length = (data_test.shape[0])
#%% Model training and prediction
model = Prophet(daily_seasonality=True)
model.fit(data_train)
predictor = model.make_future_dataframe(periods=predict_length)
data_prediction = model.predict(predictor)
#%% Plot result
plt.figure()
model.plot(data_prediction)
data_test.set_index('ds', inplace=True)
for index in range(data_prediction.shape[0]):
data_prediction.at[index, 'yhat'] = np.exp(data_prediction.loc[index,
'yhat'])
data_prediction.index = list(data['ds'])
data_prediction = data_prediction.drop(['ds'], axis=1).tail(predict_length)
fig, ax1 = plt.subplots(figsize=(10, 8))
ax1.plot(data_test['y'], label='True Price')
ax1.plot(data_prediction['yhat'], 'r-', label='Predicted Price')
ax1.legend()
import pandas as pd
from fbprophet import Prophet
import matplotlib.pyplot as plt
df = pd.read_csv('../data/GOOGL.csv')
df.columns = ['ds', 'Open', 'High', 'Low', 'Close', 'Adj Close', 'y']
model = Prophet()
model.fit(df)
future = model.make_future_dataframe(periods=100)
forecast = model.predict(future)
fig1 = model.plot(forecast)
fig2 = model.plot_components(forecast)
plt.show()
how ='left',left_index=True, right_index=True)
# In[78]:
#set ds as index
prophet_pred = prophet_pred.reset_index('ds')
# In[79]:
#plot prophet yhat, yhat_lower, and yhat_upper
pro.plot(prophet_pred)
plt.savefig(r'/home/songy4/Documents/prophet_log_range.png')
# In[80]:
pro.plot_components(prophet_pred)
plt.savefig(r'/home/songy4/Documents/prophet_components.png')
# In[81]:
#calculate rmse, mse errors and mean value
office = office.rename(columns={'Order Date': 'ds', 'Sales': 'y'})
office_model = Prophet(interval_width=0.95)
office_model.fit(office)
# In[73]:
furniture_forecast = furniture_model.make_future_dataframe(periods=36,
freq='MS')
furniture_forecast = furniture_model.predict(furniture_forecast)
# In[74]:
office_forecast = office_model.make_future_dataframe(periods=36, freq='MS')
office_forecast = office_model.predict(office_forecast)
plt.figure(figsize=(18, 6))
furniture_model.plot(furniture_forecast, xlabel='Date', ylabel='Sales')
plt.title('Furniture Sales')
# In[75]:
plt.figure(figsize=(18, 6))
office_model.plot(office_forecast, xlabel='Date', ylabel='Sales')
plt.title('Office Supplies Sales')
# # Compare Forecasts
# We already have the forecasts for three years for these two categories into the future. We will now join them together to compare their future forecasts.
# In[76]:
furniture_names = [
'furniture_%s' % column for column in furniture_forecast.columns
print(forecast['yhat_upper'][0:5])
#%%
## This works and retained the dataframe type
forecast2 = np.exp(forecast1[['yhat','yhat_lower','yhat_upper']])
## Now merge to bring the ds back into the df
## Without the "on" keyword the join key is implicitly the index
forecast2 = forecast2.join(forecast1['ds'], how='inner')
print(forecast1)
#%%
## This works
## This will create a plot that includes Forecasted, C.I.'s, and Actual values
m.plot(forecast2)
#%%
## I think it is unecessary to review exponentiated components
## Plus the complexity of joining forecast2 with forecast1
m.plot_components(forecast1);
#%%
## It was necessary, in the fill_between, to use a datetime index associated with
## the first parameter of the function.
## This necessitated converting the existing ds datetime element to an index
pplt.subplots(figsize=(30,10))
forecast2.set_index('ds',inplace=True)
pplt.plot(view_hour['distinct_freq_sum'], label='Original', color='black');
pplt.plot(forecast2.yhat, color='red', label='Forecast');
def main():
st.header("Online Stock Price Ticker")
# symbol = st.text_input('심볼 입력 : ')
symbol = 'AMZN'
data = yf.Ticker(symbol)
today = datetime.now().date().isoformat() #문자열로
print(today)
#------------------------------------------------------
df = data.history(start='2010-06-01', end=today)
st.dataframe(df)
# --------------------Close차트 -----------------
st.subheader('종가')
st.line_chart(df['Close'])
#------------------------------------------------
st.subheader('거래량')
st.line_chart(df['Volume'])
# yfinace의 라이브러리만의 정보
# data.info
# data.calendar
# data.major_holders
# data.institutional_holders
# data.recommendations
div_df = data.dividends #배당금정보
st.dataframe(div_df.resample('Y').sum())
new_df = div_df.reset_index()
new_df['Year'] = new_df['Date'].dt.year
st.dataframe(new_df)
fig = plt.figure()
plt.bar(new_df['Year'], new_df['Dividends'])
st.pyplot(fig)
# 여러주식 한번에 보여주기
favorites = ['msft', 'aapl', 'amzn', 'tsla', 'nvda']
f_df = pd.DataFrame()
for stock in favorites:
f_df[stock] = yf.Ticker(stock).history(start='2010-01-01',
end=today)['Close']
st.dataframe(f_df)
# 차트그리기
st.line_chart(f_df)
#=============================stocktwits===================================
# 스탁 트윗 API 호출
res = requests.get(
'https://api.stocktwits.com/api/2/streams/symbol/{}.json'.format(
symbol))
# json 형식이므로 .json()이용
res_data = res.json()
# 파이썬의 딕셔너리와 리스트로 활용
# st.write(res_data)
for massage in res_data['messages']:
col1, col2 = st.beta_columns([1, 4]) #영역 잡기(비율)
with col1:
st.image(massage['user']['avatar_url']) #아바타 사진
with col2:
st.write('유저이름 : ' + massage['user']['username'])
st.write('트윗 내용 : ' + massage['body'])
st.write('올린 시간 : ' + massage['created_at'])
p_df = df.reset_index()
p_df.rename(columns={'Date': 'ds', 'Close': 'y'}, inplace=True)
st.dataframe(p_df)
#예측 가능
m = Prophet()
m.fit(p_df)
future = m.make_future_dataframe(periods=365)
forecast = m.predict(future)
st.dataframe(forecast)
fig1 = m.plot(forecast)
st.pyplot(fig1)
fig2 = m.plot_components(forecast)
st.pyplot(fig2)
pass
#print(forecast1[['ds','yhat','yhat_lower','yhat_upper']])
#%%
## This works and retained the dataframe type
forecast2 = np.exp(forecast1[['yhat','yhat_lower','yhat_upper']])
## Now merge to bring the ds back into the df
## Without the "on" keyword the join key is implicitly the index which is what we're doing here
forecast2 = forecast2.join(forecast1['ds'], how='inner')
#%%
## This works
## This will create a plot that includes Forecasted, C.I.'s, and Actual values
m.plot(forecast1)
#%%
## I think it is unecessary to review exponentiated components
## Plus the complexity of joining forecast2 with forecast1
m.plot_components(forecast1);
#%%
## It was necessary, in the fill_between, to use a datetime index associated with
## the first parameter of the function.
## This necessitated converting the existing ds datetime element to an index
pplt.subplots(figsize=(30,10))
forecast2.set_index('ds',inplace=True)
## If using the view_hour data it will be REQUIRED to exponentiate the forecasts (i.e., forecast2)
pplt.plot(view_hour['distinct_freq_sum'], label='Original', color='black');
daily_train["ds"] = daily_train.index
daily_train["y"] = daily_train.Count #设置为ds、y的保留字
print(daily_train.head())
daily_train.drop(["Count"], axis=1, inplace=True)
print(daily_train.head())
#拟合Prophet模型并做训练
model = Prophet(yearly_seasonality=True,
daily_seasonality=True,
seasonality_prior_scale=0.1)
model.fit(daily_train)
#预测未来7个月，213天
future = model.make_future_dataframe(periods=213)
forecast = model.predict(future)
print(forecast)
model.plot(forecast)
#查看各个成分
model.plot_components(forecast)
# 对节假日建模
# 将节日看成是一个正态分布，把活动期间当做波峰，lower_window 以及upper_window 的窗口作为扩散
chinese_seasons = pd.DataFrame({
'holiday':
'chinese_season',
'ds':
pd.to_datetime([
'2012-01-01', '2012-05-01', '2012-10-01', '2013-01-01', '2013-05-01',
'2013-10-01', '2014-01-01', '2014-05-01', '2014-10-01', '2015-01-01',
'2015-05-01', '2015-10-01'
]),
'lower_window':