def model_json(model): json_file = model_to_json(model) json_file = json.dumps(json_file) b64 = base64.b64encode(json_file.encode()).decode() href = f'<a href="data:file/json;base64,{b64}" download="loadForecast_model.json" ' \ f'target="_blank">Download model</a>' return href
def get_prophet_forecast(df, country="ALL", save_model=True): df_ts = df.copy() if country == "ALL" else df[df['country'] == country].copy() if len(df_ts) <= 180: return None df_month = df_ts.groupby('inv_month').sum().reset_index() df_ts['inv_date'] = pd.to_datetime(df_ts['inv_date']) df_ts.rename(columns={'inv_date': 'ds', 'value': 'y'}, inplace=True) m = Prophet(yearly_seasonality=20) m.fit(df_ts) if save_model: with open(fr'models\{country}_model.json', 'w') as fout: json.dump(model_to_json(m), fout) # Save model future = m.make_future_dataframe(periods=180, freq='D') forecast = m.predict(future) forecast['inv_month'] = forecast['ds'].apply( lambda v: date(v.year, v.month, 1).isoformat()) monthly_forecast = forecast[['inv_month', 'yhat' ]].groupby('inv_month').sum().reset_index() df_forecast = pd.merge(monthly_forecast, df_month, on='inv_month', how='left') return df_forecast
def _save_model(model, path): from prophet.serialize import model_to_json model_ser = model_to_json(model) with open(path, "w") as f: json.dump(model_ser, f)
def prophet_model(Train, Days): # make sure to get the input here, then uncomment the rest ### # HERE, convert the json that looks like this # {"income":[{income fields},{},{}], "expense":spend_dict} # to a dataframe # the you can just do this: jsonify({"predictions": yourlist}) ### k_trans_pro = Train n = len(k_trans_pro) d = Days pro_train_df = k_trans_pro[0:n - d] pro_test_df_y = k_trans_pro[n - d:] pro_test_df = k_trans_pro[n - d:].drop(['y'], axis=1) param_grid = { 'changepoint_prior_scale': [0.001, 0.01, 0.1, 0.5], 'seasonality_prior_scale': [0.01, 0.1, 1.0, 10.0], } # Generate all combinations of parameters all_params = [ dict(zip(param_grid.keys(), v)) for v in itertools.product(*param_grid.values()) ] rmses = [] # Store the RMSEs for each params here # Use cross validation to evaluate all parameters for params in all_params: m = Prophet(**params).fit(pro_train_df) # Fit model with given params df_cv = cross_validation(m, period='30 days', horizon='30 days', parallel="processes") df_p = performance_metrics(df_cv, rolling_window=1) rmses.append(df_p['rmse'].values[0]) # Find the best parameters tuning_results = pd.DataFrame(all_params) tuning_results['rmse'] = rmses best_params = all_params[np.argmin(rmses)] pro_model_tuned = Prophet(**best_params).fit(pro_train_df) with open('serialized_model.json', 'w') as fout: json.dump(model_to_json(pro_model_tuned), fout) # Save model ## Here you find the predictions ### # HERE, convert the precitions to a json doc that looks like this # { "predictions": [ {"ds": value, "yhat":value}, {"ds": value, "yhat":value}, {"ds": value, "yhat":value}, ]} # just get a list from your dataframe. # the you can just do this: jsonify({"predictions": yourlist}) return None
def _grouped_model_to_dict(self): model_dict = { attr: getattr(self, attr) for attr in GROUPED_MODEL_BASE_ATTRIBUTES } model_dict["model"] = { str(master_key): model_to_json(model) for master_key, model in self.model.items() } return model_dict
def calc(self, arg): print("impl start", flush=True) try: ds_array = [] y_array = [] for row in arg: ds_array.append(row[0]) y_array.append(row[1]) list_of_tuples = list(zip(ds_array, y_array)) df = pd.DataFrame(list_of_tuples, columns=['ds', 'y']) with suppress_stdout_stderr(): m = Prophet(daily_seasonality=True, weekly_seasonality=True, yearly_seasonality=True) m.fit(df) print("impl train end", flush=True) self._collector.collectRow(model_to_json(m)) except BaseException as ex: print("{}".format(ex), flush=True) else: print("impl finished", flush=True)
def save_model(file_name, model, r): print(f"called save_model method with parameters: file_name = %s" % file_name) file = prefix_cache + file_name r.mset({file: model_to_json(model)})
def save(self, checkpoint_file): if self.model is None: raise Exception( "Needs to call fit_eval or restore first before calling save") with open(checkpoint_file, 'w') as fout: json.dump(model_to_json(self.model), fout)
def calc(self, conf, argv1, argv2): print("Entering Python calc", flush=True) try: growth = conf['growth'] if growth is None: growth = 'linear' predict_num = conf['periods'] if predict_num is None: predict_num = 2 else: predict_num = int(predict_num) freq = conf['freq'] if freq is None: freq = 'D' uncertainty_samples = conf['uncertainty_samples'] if uncertainty_samples is None: uncertainty_samples = 1000 else: uncertainty_samples = int(uncertainty_samples) stan_i = conf['init_model'] if stan_i is not None: stan_i = self.stan_init2(json.loads(stan_i)) dimDelta = len(stan_i['delta']) #data ds_array = [] y_array = [] for row in argv1: ds_array.append(row[0]) y_array.append(row[1]) list_of_tuples = list(zip(ds_array, y_array)) df = pd.DataFrame(list_of_tuples, columns=['ds', 'y']) dataLen = len(list_of_tuples) # init model with suppress_stdout_stderr(): m = Prophet(growth=growth, uncertainty_samples=uncertainty_samples) if stan_i is not None and dataLen == dimDelta + 2: m.fit(df, init=stan_i) elif argv2 is None or argv2[0][0] is None: m.fit(df) else: init_model_str = argv2[0][0] init_model = model_from_json(init_model_str) # fit and pred m.fit(df, init=stan_init(init_model)) future = m.make_future_dataframe(periods=predict_num, freq=freq, include_history=False) pout = m.predict(future) self._collector.collectRow(model_to_json(m), pout.to_json(), json.dumps(pout.yhat.values.tolist())) except BaseException as ex: print({}.format(ex), flush=True) raise ex finally: print("Leaving Python calc", flush=True)
import pandas as pd from prophet import Prophet from prophet.serialize import model_to_json # float_precision='high' required for pd.read_csv to match precision of Rover.read_csv df = pd.read_csv('examples/example_wp_log_peyton_manning.csv', float_precision='high') m = Prophet() m.fit(df, seed=123) with open('/tmp/model.json', 'w') as fout: fout.write(model_to_json(m))