def predict_and_plot(self): print("PREDICTING") self.df_new.head() # this model will apply repeatedly until the positiveness value reaches to 100. # this while loop will do that and calculate the number of iteration required # then it will decide the number of days(decide according to the iteration count) needed to job fit while (self.value <= 100): self.days = self.days + 7 self.future = self.m.make_future_dataframe(periods=self.days) self.future.tail() forecast = self.m.predict(self.future) forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail() f_cast = forecast['yhat'].tail(1) f_cast = f_cast.tolist() self.value = f_cast[0] print("Days: {}--- Positive value:{}".format( self.days, self.value)) self.m.plot(forecast) #plotting the data self.m.plot_components(forecast) #plotting the data py.init_notebook_mode() # initialize the notebook mode fig = plot_plotly(self.m, forecast) # This returns a plotly Figure py.iplot(fig) print("Number of days to fit the job: {} Days".format(self.days)) self.remove_temp_files()
def predict(): pytrend = TrendReq(timeout=(10,25), hl='en-US', tz=360) pytrend.build_payload(kw_list=keywords, timeframe='today 5-y', geo=c_code) five_years = pytrend.interest_over_time().reset_index() if five_years[keywords].sum().values[0] < 5: return 'not enough data', 'not enough data', 'not enough data', 'not enough data', 'not enough data' else: #five_years = five_years[five_years.isPartial == 'False'] five_years = five_years[:-1] five_years.drop('isPartial', axis=1, inplace=True) five_years.columns = ['ds', 'y'] temp = five_years.copy() temp['cap'] = temp['y'].max() temp['floor'] = temp['y'].min() m = Prophet() fit = m.fit(temp) periods = 90 future = m.make_future_dataframe(periods=periods) future["floor"] = temp['y'].min() future["cap"] = temp["y"].max() forecast = m.predict(future) fig = plot_plotly(m, forecast) fig.update_layout(template='plotly_white',title='{} "{}" Interest Prediction'.format(country,keywords[0]), xaxis={'title':'Date'}, yaxis={'title':'Intrest & Prediction'}) fig.update_traces(line_color="#F66162", selector=dict(line_color='#0072B2')) fig.update_traces(marker_color="royalblue", selector=dict(marker_color='black')) comp = plot_components_plotly(m, forecast) comp.update_layout(template='plotly_white',title='{} "{}" Seasonality Prediction'.format(country,keywords[0]),yaxis={'title':'Prediction'}) comp.update_traces(line_color="#F66162", selector=dict(line_color='#0072B2')) comp.update_traces(marker_color="royalblue", selector=dict(marker_color='black')) return fig, comp, forecast, periods, pytrend
def do_prophet(): n_days = 7 # Predict forecast with Prophet. df_train = df[['Date','Close']] df_train = df_train.rename(columns={"Date": "ds", "Close": "y"}) m = Prophet() m.fit(df_train) future = m.make_future_dataframe(periods=n_days) forecast = m.predict(future) # Show and plot forecast st.subheader('Forecast data') st.write(forecast.tail()) st.subheader(f'시세 예측 그래프: {n_days} 일') test = m.plot(forecast) # st.write(test) fig1 = plot_plotly(m, forecast) # st.write('그렸어야해..') # st.plotly_chart(forecast) st.plotly_chart(fig1) # st.write("Forecast components") # fig2 = m.plot_components(forecast) # st.write(fig2) st.success("시세 예측 완료!") st.balloons()
def plot_forecast( self, title="Forecast", template="plotly_white", yaxis_title="Number of individuals", output_image=False, width=800, height=600, scale=2, output_figure=False, ): fig = plot_plotly(self.m, self.forecast) fig.update_layout( title=title, yaxis_title=yaxis_title, template=template, title_x=0.5, ) if output_image: return Image( fig.to_image(format="png", width=width, height=height, scale=scale)) if output_figure: return fig return fig.show()
def run_forecast(category, state, seasonality, periods, uncertainty_samples, years): t0 = time.time() col = f"('{category}', '{state}')" df = walmart[["date", col]].rename(columns={"date": "ds", col: "y"}) m, forecast = run_prophet( df, weekly_seasonality=seasonality, periods=periods, uncertainty_samples=uncertainty_samples, start=years[0], end=years[1], ) # Plot figures margin = dict(l=30, r=30, t=80, b=30) fig_forecast = plot_plotly(m, forecast).update_layout( title="Forecasting with Prophet", width=None, height=None, margin=margin, ) fig_components = plot_components_plotly(m, forecast).update_layout( title="Seasonal Components", width=None, height=None, margin=margin) t1 = time.time() print(f"Training and Inference time: {t1-t0:.2f}s.") return fig_forecast, fig_components
def indiadeaths(): df = pd.read_csv("Indiajuly21.csv", parse_dates=['Date'], dayfirst=True) df = df[['Date', 'State/UnionTerritory', 'Cured', 'Deaths', 'Confirmed']] df.columns = ['date', 'state', 'cured', 'deaths', 'confirmed'] today = df[df.date == '2020-07-24'] df2 = df.groupby(['date'])['confirmed', 'deaths', 'cured', ].sum().reset_index() #making columns for daily new cases df2['new_confirmed'] = df2.confirmed.diff() df2['new_deaths'] = df2.deaths.diff() df2['new_cured'] = df2.cured.diff() #taking dates from 15th March df2 = df2.iloc[64:] #Statewise new confirmed df['new_confirmed'] = df.groupby(['state'])['confirmed'].diff() df['new_deaths'] = df.groupby(['state'])['deaths'].diff() df['new_cured'] = df.groupby(['state'])['cured'].diff() df3 = df2[['date', 'deaths']] #Renaming column names according to fb prophet df3.columns = ['ds', 'y'] m = Prophet() m.fit(df3) future = m.make_future_dataframe(periods=10) forecast = m.predict(future) fig = plot_plotly(m, forecast) # This returns a plotly Figure fig.update_layout( title_text='<b>Covid-19 Total deaths cases Forecast<b>', title_x=0.5, paper_bgcolor='LightCoral', plot_bgcolor="LightCoral", ) fig.show() return render_template("indiastatistics.html")
def update_predictions(ticker): dict_timelines = portfoliomanager.download_stock_timelines([ticker]) df_timeline_with_future, m = portfoliomanager.predict_future(dict_timelines[ticker]) fig_future = plot_plotly(m, df_timeline_with_future) fig_components = plot_components_plotly(m, df_timeline_with_future) return fig_future, fig_components
def show_graph(self, model, forecast): ''' model = Prophet object forecast = Dataframe. Result of the model.predict(future) ''' fig = plot_plotly(model, forecast) py.iplot(fig)
def plotter_prophet(model, frcst): fig = plot_plotly(model, frcst, figsize=(900, 600), xlabel='Time period', ylabel='Price') fig.update_layout(hovermode='x') fig.show()
def prediction(self, period): self.model.fit(self.prophet_df) future = self.model.make_future_dataframe(periods=period) # Eliminate weekend from future dataframe future['day'] = future['ds'].dt.weekday future = future[future['day'] <= 4] forecast = self.model.predict(future) fig = plot_plotly(self.model, forecast) fig2 = self.model.plot_components(forecast) fig3 = self.model.plot(forecast) a = add_changepoints_to_plot(fig3.gca(), self.model, forecast) return (fig, fig2, fig3)
def prophet_prediction(row, zip_code, retirement_date='2029'): # if os.path.exists('pickles/{}_forecast.pkl'.format(zip_code)): # with open("pickles/{}_model.pkl".format(zip_code), 'rb') as f: # unpickler = pickle.Unpickler(f) # m = unpickler.load() m = Prophet(seasonality_mode='multiplicative') row = row[(row['ds'] > '2009')] m.fit(row) forecast = pd.read_pickle('pickles/{}_forecast.pkl'.format(zip_code)) print(forecast.dtypes) forecast = forecast[(forecast['ds'] > '2009') & (forecast['ds'] < str(retirement_date))] return plot_plotly(m, forecast)
def model_from_coin(coin, base, growth, changepoints, changepoint_range, seasonality_mode, seasonality_prior_scale, holidays_prior_scale, changepoint_prior_scale, interval_width): df = pd.DataFrame() df["ds"] = base["DATE_INFO"] df["y"] = base["CLOSE"] if growth == 'logistic': df["cap"] = float(max(base["CLOSE"])) m = Prophet(growth=growth, changepoints=changepoints, changepoint_range=changepoint_range, yearly_seasonality=False, weekly_seasonality=False, daily_seasonality=False, seasonality_mode=seasonality_mode, seasonality_prior_scale=seasonality_prior_scale, holidays_prior_scale=holidays_prior_scale, changepoint_prior_scale=changepoint_prior_scale, interval_width=interval_width).add_country_holidays( country_name='US').add_seasonality( name='bimonthly', period=365.25 / 6, fourier_order=5).add_seasonality(name='yearly', period=365.25, fourier_order=3) m.fit(df) future = m.make_future_dataframe(periods=int(365 / 2)) if growth == 'logistic': future["cap"] = float(max(base["CLOSE"])) forecast = m.predict(future) logging.info("Going to detect_anomalies") forecasted = detect_anomalies(forecast, df) logging.info("Saving graph for {}".format(coin)) fig = plot_plotly(m, forecast) # This returns a plotly Figure #plio.write_html(fig, '/appdata/graph_{}.html'.format(coin), include_plotlyjs=True) plot_anomalies(forecasted).save('/appdata/graph_{}.html'.format(coin)) logging.info("Graph for {} saved".format(coin)) now = datetime.datetime.now() resultdf = forecast[forecast['ds'] == pd.Timestamp( now.year, now.month, now.day)][[ 'ds', 'yhat', 'yhat_lower', 'yhat_upper' ]] return resultdf
def predict(df, days): prophet = Prophet() prophet.fit(df) future = prophet.make_future_dataframe(periods=days) forecast = prophet.predict(future) df_forecast = forecast[["ds", "yhat", "yhat_lower", "yhat_upper"]].set_index("ds") df_forecast = df_forecast.round(0) # fig_forecast = prophet.plot(forecast) fig_forecast = plot_plotly(prophet, forecast) return df_forecast
def main_gui(self): st.image('cl.jpg') st.title('COVID-19 LUXEMBOURG') st.subheader('Last 5 days') st.table(self.data.tail()) self.plot_data('Cases', 'Total Cases') self.plot_data('Deaths', 'Total Deaths') self.plot_data('Recovered', 'Total Recoveries') st.subheader('Future Cases (Predictions)') fig = plot_plotly(self.model, self.prediction) fig.update_layout(width = 700, height = 500) st.plotly_chart(fig) st.text('Source: https://github.com/CSSEGISandData/COVID-19')
def predict(): temp = p_df.copy() temp['cap'] = temp['y'].max() temp['floor'] = temp['y'].min() m = Prophet() fit = m.fit(temp) periods = 90 future = m.make_future_dataframe(periods=periods) future["floor"] = temp['y'].min() future["cap"] = temp["y"].max() forecast = m.predict(future) fig = plot_plotly(m, forecast) fig.update_layout( title='{} CBD Oil Intrest Prediction'.format(country), xaxis={'title': 'Date'}, yaxis={'title': 'Intrest Prediction'}) return fig, forecast, periods
def fit_predict_prophet(df1, city): """Subset for city column and rename Passengers columns""" df1 = df1[df1['city'] == city] df1 = df1.rename(columns={'PASSENGERS': 'y'}) size = int(len(df1) * 0.7) train, test = df1[['ds','y']][0:size], df1[['ds','y']][size:len(df1)] # train_exog, test_exog = df1[0:size], df1[size:len(df1)] """Reset Index for both training and testing set""" train.reset_index(inplace=True) test.reset_index(inplace=True) start=len(train) end=len(train)+len(test)-1 # endog = train_exog['y'] # exog = train_exog[['temperature_mean']] """Prophet Modeling and Fit""" Model = pr(daily_seasonality = False, yearly_seasonality = True, weekly_seasonality = False, seasonality_mode = 'multiplicative', interval_width = 0.90, changepoint_range = 0.8) Model.fit(train) """Forecast and Plot Model""" forecast = Model.predict(pd.DataFrame(df1.reset_index()['ds'][start-1:end])) forecast.head() Model.plot(forecast, uncertainty=True) """Plot Fbprophet Using plotly""" from fbprophet.plot import plot_plotly import plotly.offline as py py.init_notebook_mode() """This returns a plotly Figure""" fig = plot_plotly(Model, forecast) """Calculate Root Mean Squared""" rms = sqrt(mean_squared_error(test['y'], forecast.loc[:, 'yhat'])) print(rms) return fig
def create_forecasts(value): #dataframe for fbprophet prediction/visualization fb_df = df[df['Geographic_Area'] == 'Total'][['Date', value]] fb_df.columns = ['ds', 'y'] #removing any non-numerical characters fb_df['y'] = fb_df['y'].apply(lambda x: int(re.sub('[^0-9]', '', str(x)))) #removing weekends fb_df_weekdays = fb_df[fb_df['ds'].dt.dayofweek < 5] #fitting the fbprophet model prophet = Prophet() prophet.fit(fb_df_weekdays) #making dataframe of future dates, 30 days into future future = prophet.make_future_dataframe(periods=30) future_weekdays = future[future['ds'].dt.dayofweek < 5] #generating forecast for future dates forecast = prophet.predict(future_weekdays) #dictionary of title options based on radio items feature to be used in app callbacks for fb prophet section title_options = { 'Daily Cases': 'New Cases Per Day', 'Total\xa0 Confirmed Cases': 'Total Confirmed Cases', 'Recovered by Region': 'Recovered Patients', 'Still infectious by Region': 'Active Cases', 'Number of Deaths': 'Number of Deaths' } #plotting forecast fig1 = plot_plotly(prophet, forecast) fig1.update_layout(paper_bgcolor=colors['background'], plot_bgcolor=colors['background'], font={'color': colors['text']}, xaxis={'title': 'Date'}, yaxis={'title': title_options[value]}, width=1000) fig1.update_traces(marker={'color': 'LightSkyBlue'}) return fig1
def plot_fbprophet_forecasting(df, dates, days_in_future, feature): k = df[df['Country/Region'] == 'India'].loc[:, '1/22/20':] india_values = k.values.tolist()[0] data = pd.DataFrame(columns=['ds', 'y']) data['ds'] = dates data['y'] = india_values pd.set_option('float_format', '{:f}'.format) model_prophet = fbprophet.Prophet() model_prophet.fit(data) future = model_prophet.make_future_dataframe(periods=days_in_future) prop_forecast = model_prophet.predict(future) forecast = prop_forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail(days_in_future) print(forecast) fig = plot_plotly(model_prophet, prop_forecast) fig = model_prophet.plot(prop_forecast, xlabel='Date', ylabel='{}'.format(feature)) fig.show()
def make_forecast(selection): """Takes a name from the selection and makes a forecast plot.""" if selection == CASES: cumulative_series_name = "cumulative_cases" title = "Daily Cases" x_label = "Cases" if selection == DEATHS: cumulative_series_name = "cumulative_deaths" title = "Daily Deaths" x_label = "Deaths" if selection == RECOVERIES: cumulative_series_name = "cumulative_recoveries" title = "Daily Recoveries" x_label = "Recoveries" prophet_df = ( df[cumulative_series_name] .diff() .dropna() .to_frame() .reset_index() .rename(columns={"date": "ds", cumulative_series_name: "y"}) ) model = Prophet() model.fit(prophet_df) future = model.make_future_dataframe(periods=90) forecast = model.predict(future) fig = plot_plotly(model, forecast) fig.update_layout( title=title, yaxis_title=x_label, xaxis_title="Date", ) return fig
def make_forecast(selection): """Takes a name from the selection and makes a forecast plot.""" if selection == PRODUCT_A: cumulative_series_name = "cumulative_cases" title = "Forecast Product A" x_label = "Prices" if selection == PRODUCT_B: cumulative_series_name = "cumulative_deaths" title = "Forecast Product B" x_label = "Prices" if selection == PRODUCT_C: cumulative_series_name = "cumulative_recoveries" title = "Forecast Product C" x_label = "Prices" prophet_df = (df[cumulative_series_name].diff().dropna().to_frame(). reset_index().rename(columns={ "date": "ds", cumulative_series_name: "y" })) model = Prophet() model.fit(prophet_df) future = model.make_future_dataframe(periods=90) forecast = model.predict(future) fig = plot_plotly(model, forecast) fig.update_layout( title=title, yaxis_title=x_label, xaxis_title="Date", ) return fig
def predict_n_days(required_data, start_date, end_date, company_symbol): number_of_days = input( 'How many days in the future you want to predict? : ') required_data[['ds', 'y']] = required_data[['Date', 'Close']] df = required_data[['ds', 'y']] m = Prophet(weekly_seasonality=False, yearly_seasonality=True, daily_seasonality=True, n_changepoints=15) m.fit(df) future = m.make_future_dataframe(periods=int(number_of_days)) forecast = m.predict(future) fig = plot_plotly( m, forecast, xlabel= f'Trained model from {start_date} to {end_date} and predicted {number_of_days} days in the future', ylabel=f'Closing price of {company_symbol} ', figsize=(1800, 800)) fig.update_layout(showlegend=True) plot(fig, filename=f'{company_symbol}_predict_{number_of_days}_days_graph.html')
def karcured(): df = pd.read_csv("onlykarnatakajune3.csv", parse_dates=['Date'], dayfirst=True) df = df[['Date', 'State/UnionTerritory', 'Cured', 'Deaths', 'Confirmed']] df.columns = ['date', 'state', 'cured', 'deaths', 'confirmed'] #df.isna().sum() today = df[df.date == '2020-07-24'] df2 = df.groupby(['date'])['confirmed', 'deaths', 'cured', ].sum().reset_index() #making columns for daily new cases df2['new_confirmed'] = df2.confirmed.diff() df2['new_deaths'] = df2.deaths.diff() df2['new_cured'] = df2.cured.diff() #taking dates from 15th March df2 = df2.iloc[122:] #Statewise new confirmed df['new_confirmed'] = df.groupby(['state'])['confirmed'].diff() df['new_deaths'] = df.groupby(['state'])['deaths'].diff() df['new_cured'] = df.groupby(['state'])['cured'].diff() df3 = df2[['date', 'cured']] #Renaming column names according to fb prophet df3.columns = ['ds', 'y'] m = Prophet() m.fit(df3) future = m.make_future_dataframe(periods=10) forecast = m.predict(future) #forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail(31) fig = plot_plotly(m, forecast) # This returns a plotly Figure fig.update_layout( title_text='<b>Covid-19 Total Recovery cases Forecast in karnataka<b>', title_x=0.5, paper_bgcolor='LightGreen', plot_bgcolor="LightGreen", ) fig.show() return render_template("karnataka.html")
def iterate(): folder_path = "../convert_data/idle_res_us_timestamp" for filename in os.listdir(folder_path): if filename.endswith(".csv"): df = pd.read_csv(folder_path + "/" + filename, names=[ "ds", "bandwidth_up", "bandwidth_down", "connections", "ports", "ips" ]) df['ds'] = df['ds'].apply( lambda x: time.strftime('%Y-%m-%d %H:%M:%S', time.gmtime(x))) df.head() m = Prophet(changepoint_prior_scale=0.01, interval_width=0.95) for col in df.columns: if col != "ds": subdf = df[['ds', col]].dropna() subdf = subdf.rename(columns={'ds': 'ds', col: 'y'}) m.fit(subdf) break future = m.make_future_dataframe(periods=1) future.tail() forecast = m.predict(future) forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail() m.plot_components(forecast).savefig( filename.split('.')[0] + '.png') # fig = plot_plotly(m, forecast) # This returns a plotly Figure file_name_html = filename.split('.')[0] + ".html" py.plot(fig, filename=file_name_html)
dataset[dataset.Country == 'China'].groupby( 'Date')['Confirmed'].sum().reset_index()).rename(columns={ 'Date': 'ds', 'Confirmed': 'y' }) confirmed_training_dataset.head() prophet = Prophet(yearly_seasonality=False, weekly_seasonality=False, daily_seasonality=True, seasonality_mode='additive') prophet.fit(confirmed_training_dataset) future = prophet.make_future_dataframe(periods=7) confirmed_forecast = prophet.predict(future) fig = plot_plotly(prophet, confirmed_forecast) annotations = [] annotations.append( dict(xref='paper', yref='paper', x=0.0, y=1.05, xanchor='left', yanchor='bottom', text='确诊人数预测', font=dict(family='Arial', size=30, color='rgb(37,37,37)'), showarrow=False)) fig.update_layout(annotations=annotations) prophet = Prophet(yearly_seasonality=False, weekly_seasonality=False,
df3 = df2[['date', 'confirmed']] #Renaming column names according to fb prophet df3.columns = ['ds', 'y'] #model m = Prophet() #fitting the model m.fit(df3) #forecast future = m.make_future_dataframe(periods=20) forecast = m.predict(future) from fbprophet.plot import plot_plotly fig4 = plot_plotly(m, forecast) # This returns a plotly Figure fig4.update_layout( autosize=False, width=750, height=800, title_text='<b>Covid-19 Total cases Forecast<b>', title_x=0.5, paper_bgcolor='snow', plot_bgcolor="snow", ) maha = df[df.state == 'Maharashtra'] maha = maha[['date', 'confirmed']] maha.columns = ['ds', 'y'] p = Prophet() p.fit(maha)
<div style="font-family: 'Suez One';font-size:70px; background-color:white; color:black"><center>Covid-19 Global Predictor</center></div> ''',unsafe_allow_html=True ) st.header(" ") st.header("Region-wise predictions") option1 = st.selectbox("Country",countries) option2 = st.number_input("Forecast period in days",min_value=1,max_value=30) option3 = st.selectbox("Select the forecasted variable",list(type_of_analysis.keys())) if( len(option1) != 0): m=Prophet(seasonality_mode='additive',yearly_seasonality=True,weekly_seasonality=True,daily_seasonality=True) #,growth='logistic' data=df[df['location']==option1][['date',type_of_analysis[option3]]].rename(columns={"date":"ds",type_of_analysis[option3]:"y"}) #data['floor']=0 #data['cap']=data['y'].max()+data['y'].mean() m.fit(data) future=m.make_future_dataframe(periods=option2) #future['floor']=0 #future['cap']=data['y'].max()+data['y'].mean() forecast = m.predict(future) fig=plot_plotly(m, forecast) fig.update_layout( title="Forecasting", xaxis_title="Date", yaxis_title=option3) st.plotly_chart(fig,config = {'displayModeBar': False}) cross_validation_results = cross_validation(m,initial='100 days',horizon="50 days") #horizon='5 days' #, initial='210 days', period='15 days', performance_metrics_results = performance_metrics(cross_validation_results) st.write(performance_metrics_results)
year = [1977, 1989, 1996, 1997, 2006, 2011, 2018] speed = [62136, 173736, 27000, 122000, 58536, 209000, 343180] plt.plot(year, speed, color='red') plt.xlabel('Year Launched') plt.ylabel('Fastest Speed Recorded (km/h)') plt.title('Fastest Spacecrafts Launched in the Last 50 Years') #create a dataframe for manipulation data = [['1977-09-05', 62136], ['1989-10-18', 173736], ['2011-08-05', 209000], ['2018-08-12', 343180]] df = pd.DataFrame(data, columns = ['ds', 'y']) #use fbprophet to predict groth m = Prophet() m.fit(df) future = m.make_future_dataframe(periods=365*243) future.tail(n=10) forecast = m.predict(future) forecast.tail(n=3) py.init_notebook_mode() fig = plot_plotly(m, forecast) # This returns a plotly Figure py.iplot(fig) m.plot_components(forecast) y = travelTime(50034460) timeConver(y)
data2 = (data2['Price'].dropna().to_frame().reset_index().rename(columns={ "index": "ds", 'Price': "y" })) windows = st.sidebar.slider('prediction window', min_value=80, max_value=250, value=90, step=1) model = Prophet() model.fit(data2) future = model.make_future_dataframe(periods=windows) forecast = model.predict(future) fig = plot_plotly(model, forecast) fig.update_layout( title='title', yaxis_title=asset, xaxis_title="Date", ) st.write("# Forecast Prices") st.plotly_chart(fig) ########################################## model.plot_components(forecast) #plt.title("Global Products") plt.legend() st.pyplot()
m.fit(df_train) future = m.make_future_dataframe(periods=periode) forecast = m.predict(future) return forecast #Visualisasi Ramalan #selectbox untuk tampilkan plot st.subheader("Tampilkan Visualisasi Awal") check_1 = st.checkbox('tampilkan canddle stick') check_2 = st.checkbox('tampilkan grafik garis') if check_1: plot_data_awal_canddlestick(df) if check_2: plot_data_awal_linechart(df) st.subheader("Ramalan") check_3 = st.checkbox('Lakukan Training') if check_3: hasil_training = forecast_stock(df) st.write(hasil_training.tail()) st.subheader("Tampilkan Visualisasi Ramalan") check_4 = st.checkbox("Visualisasi 1") if check_4: st.plotly_chart(plot_plotly(m, hasil_training))
df_treino = df_valores[['Date', 'Close']] #renomear colunas df_treino = df_treino.rename(columns={"Date": 'ds', 'Close': 'y'}) modelo = Prophet() modelo.fit(df_treino) futuro = modelo.make_future_dataframe(periods=n_dias, freq='B') previsao = modelo.predict(futuro) st.subheader('Previsão') st.write(previsao[['ds', 'yhat','yhat_lower','yhat_upper' ]].tail(n_dias)) #grafico grafico1 = plot_plotly(modelo, previsao) st.plotly_chart(grafico1) #grafico2 grafico2 = plot_components_plotly(modelo, previsao) st.plotly_chart(grafico2)