def add_traces(self): self.fig.add_trace( Scatter(x=self.x, y=self.lower, line_color='rgb(220, 220, 220)', showlegend=False, mode='lines', name='Нижняя граница (95%-й интервал)')) self.fig.add_trace( Scatter(x=self.x, y=self.y, name='Прогноз', mode='lines', line=dict(color=self.colors[0]), showlegend=True)) self.fig.add_trace( Scatter(x=self.x, y=self.upper, fill='tonexty', fillcolor='rgba(250, 250, 250, 0.4)', line_color='rgb(220, 220, 220)', showlegend=False, mode='lines', name='Верхняя граница (95%-й интервал)')) return self
def get_figure(edges, nodes): edge_trace = Scatter(x=[x for x, _ in edges], y=[x for _, x in edges], line=dict(width=0.5, color='#888'), hoverinfo='none', mode='lines') node_trace = Scatter(x=[x[0] for x in nodes.values()], y=[x[1] for x in nodes.values()], customdata=[(x, y[3]) for x, y in nodes.items()], text=[x[3] for x in nodes.values()], mode='markers', hoverinfo='text', marker=dict(showscale=False, color=[x[2] for x in nodes.values()], size=15)) figure = Figure( data=[edge_trace, node_trace], layout=Layout(showlegend=False, hovermode='closest', margin=dict(b=20, l=5, r=5, t=40), xaxis=dict(showgrid=False, zeroline=False, showticklabels=False), yaxis=dict(showgrid=False, zeroline=False, showticklabels=True), paper_bgcolor='rgba(0,0,0,0)', plot_bgcolor='rgba(0,0,0,0)'), ) return figure
def countries_shifted_scatters(self, countries: list, column: str, threshold: int = 100, mode: str = None, showlegend: bool=True) -> Figure: countries_df = self.countries_dataframe(countries=countries, column=column, threshold=threshold) countries_df.dropna(axis="index", how="all", inplace=True) countries_df = countries_df.apply(lambda x: Series(x.dropna().values)) engine = inflect.engine() fig = Figure() for country in countries: fig.add_trace( Scatter( x=countries_df.index, y=countries_df[country], name=country, mode=mode, line_color=self.color.get(country, "black"), opacity=0.9, showlegend=showlegend, ) ) fig.update_layout(yaxis_type="log") fig.update_layout(title_text="Days since \"{}\" column above {} {}".format(column, threshold, engine.plural_noun("occurence", threshold))) return fig
def main(): # Data File Name and file path filename = 'us-counties.csv' filepath = os.path.join('./data/raw', filename) # Import data into DataFrame and rename columns df = read_csv(filepath, dtype={'fips': str}) df.columns = ['date', 'county', 'state', 'zip', 'cases', 'deaths'] print(df.dtypes) print(f'Number of total cases: {df.cases.sum()}') print(f'Number of total deaths: {df.deaths.sum()}') # Extract Year, Month and Date and place in separate columns df['year'] = DatetimeIndex(df.date, yearfirst=True).year df['month'] = DatetimeIndex(df.date, yearfirst=True).month_name() # States and Counties states = df.state.unique() counties = df.county.unique() # Sum of Grouped Dats grp_dates = df.groupby(['date', 'state'])['cases', 'deaths'].sum() print(grp_dates.sum()) # Plot Scatter plot of Cases vs Deaths renderers.default = 'browser' fig = Figure(data=Scatter(x=df.cases, y=df.deaths, mode='markers')) fig.show() return
def countries_scatters(self, countries: list, column: str, mode: str=None, showlegend: bool=True) -> Figure: fig = Figure() ratio_re = re.compile(r"(?x: \b Ratio \b )") daily_re = re.compile(r"(?x: \b Daily \b )") if ratio_re.search(column) is not None: fig.update_layout(yaxis=dict(tickformat="%.format.%3f")) for country in countries: country_df = self.main_df.loc[[country]].reset_index(level=0, drop=True) if daily_re.search(column) is not None: country_df = country_df[1:] fig.add_trace( Scatter( x=country_df.index, y=country_df[column], name=country, mode=mode, line_color=self.color.get(country, "black"), opacity=0.9, showlegend=showlegend, ) ) fig.update_layout(title_text=column) return fig
def compare_models(labels_of_models, accuracies, losses): global MODELS_DIR for i in range(0, len(labels_of_models)): labels_of_models[i] = labels_of_models[i].replace(MODELS_DIR, '') labels_of_models[i] = labels_of_models[i].replace('/', '') labels_of_models[i] = labels_of_models[i].replace('cnn_', '') labels_of_models[i] = labels_of_models[i].replace('.model', '') figure = make_subplots(rows=1, cols=2) figure.add_trace( Scatter(x=labels_of_models, y=accuracies, name='Accuracies', mode='lines'), row=1, col=1) figure.add_trace( Scatter(x=labels_of_models, y=losses, name='Losses', mode='lines'), row=1, col=2) figure.update_layout(title_text='Best LR and BS {lr : bs}') figure.show()
def _plot_line(xs, ys_population, title, path=''): max_colour, mean_colour, std_colour, transparent = 'rgb(0, 132, 180)', 'rgb(0, 172, 237)', 'rgba(29, 202, 255, 0.2)', 'rgba(0, 0, 0, 0)' ys = torch.tensor(ys_population, dtype=torch.float32) ys_min, ys_max, ys_mean, ys_std = ys.min(1)[0].squeeze(), ys.max( 1)[0].squeeze(), ys.mean(1).squeeze(), ys.std(1).squeeze() ys_upper, ys_lower = ys_mean + ys_std, ys_mean - ys_std trace_max = Scatter(x=xs, y=ys_max.numpy(), line=Line(color=max_colour, dash='dash'), name='Max') trace_upper = Scatter(x=xs, y=ys_upper.numpy(), line=Line(color=transparent), name='+1 Std. Dev.', showlegend=False) trace_mean = Scatter(x=xs, y=ys_mean.numpy(), fill='tonexty', fillcolor=std_colour, line=Line(color=mean_colour), name='Mean') trace_lower = Scatter(x=xs, y=ys_lower.numpy(), fill='tonexty', fillcolor=std_colour, line=Line(color=transparent), name='-1 Std. Dev.', showlegend=False) trace_min = Scatter(x=xs, y=ys_min.numpy(), line=Line(color=max_colour, dash='dash'), name='Min') plotly.offline.plot( { 'data': [trace_upper, trace_mean, trace_lower, trace_min, trace_max], 'layout': dict(title=title, xaxis={'title': 'Episode'}, yaxis={'title': title}) }, filename=os.path.join(path, title + '.html'), auto_open=False)
def in_team_trace(player_eps: DF) -> Scatter: return Scatter( x=player_eps['Current Cost'], y=player_eps['Expected Points ' + horizon], mode='markers', marker={'size': MAX_POINT_SIZE, 'color': 'white', 'line': {'width': 1}}, name='In Team', text=player_eps['Label'])
def event_capture_trace(player_eps: DF) -> Scatter: return Scatter( x=player_eps['Current Cost'], y=player_eps['Expected Points ' + horizon], mode='markers', opacity=0, marker={'size': player_eps['Size'], 'color': 'white', 'opacity': 1.0}, name='Player', text=player_eps['Label'])
def run_backtester(ticker, degree, n_ticks): good_data = get_ticker_data_2(ticker) good_data['time'] = good_data.index start = good_data['time'][0] time = np.array([pd.Timedelta(x-start).total_seconds() for x in good_data['time']]) bt = Backtest(good_data, SmaCross, cash=10_000, commission=.002) stats = bt.optimize(n1=range(5, 50, 5), n2=range(10, 200, 5), maximize='Equity Final [$]', constraint=lambda param: param.n1 < param.n2) eq_curve = stats._equity_curve eq_curve['time'] = eq_curve.index fig5 = px.line(eq_curve,x='time',y='Equity',template='simple_white') fig1 = px.scatter(good_data,x='time',y='Open',template='simple_white',title='Time Series') fig1.update_traces(marker={'size': 4}) fig1.add_trace(Scatter(x=good_data['time'],y=SMA(good_data['Open'],stats._strategy.n1),name='Short MA')) fig1.add_trace(Scatter(x=good_data['time'],y=SMA(good_data['Open'],stats._strategy.n2),name='Long MA')) return fig5, fig1
def trace(player_eps: DF, position: str) -> Scatter: return Scatter( x=player_eps['Current Cost'], y=player_eps['Expected Points ' + horizon], name=position, mode='markers', marker={'color': POSITION_COLORS[position], 'opacity': player_eps['Opacity'], 'size': player_eps['Size']}, text=player_eps['Label'])
def create_traces(self): # --------------------------------------------------------------------- # Colors for cells background theme colors = ['rgb(144, 144, 144)', 'rgb(190, 190, 190)'] # --------------------------------------------------------------------- # Scatter plot with fact and predict time series trace_1 = Scatter(x=self.create_index(), y=self.y_pred, name='Прогноз', mode='lines', line=dict(color=colors[0]), showlegend=True) trace_2 = Scatter(x=self.create_index(), y=self.y, name='Факт', mode='lines', line=dict(color=colors[1]), showlegend=True) # --------------------------------------------------------------------- # Tables with stats params table_1 = self.create_table(self.table_metrics) table_2 = self.create_table(self.table_params) # --------------------------------------------------------------------- # add all objects to figure self.fig.add_trace(trace_1, row=1, col=1) self.fig.add_trace(trace_2, row=1, col=1) self.fig.add_trace(table_1, row=2, col=1) self.fig.add_trace(table_2, row=3, col=1) return self
def _draw_point(self, radius, color, name, center=[0, 0, 0] * u.km): x_center, y_center = self._project( center[None]) # Indexing trick to add one extra dimension trace = Scatter( x=x_center.to(u.km).value, y=y_center.to(u.km).value, mode="markers", marker=dict(size=10, color=color), name=name, ) self._figure.add_trace(trace) return trace
def create_traces(self, y_pred, y_fact, row, col): colors = ['rgb(144, 144, 144)', 'rgb(190, 190, 190)'] index = array(list(range(0, len(y_fact)))) trace_1 = Scatter(x=index, y=y_pred, mode='lines', line=dict(color=colors[0]), name='Прогноз', showlegend=False) trace_2 = Scatter(x=index, y=y_fact, mode='lines', line=dict(color=colors[1]), name='Факт', showlegend=False) self.fig.add_trace(trace_1, row=row, col=col) self.fig.add_trace(trace_2, row=row, col=col) return self
def _plot_trajectory(self, trajectory, label, color, dashed): if self._frame is None: raise ValueError("A frame must be set up first, please use " "set_frame(*orbit.pqw()) or plot(orbit).") rr = trajectory.represent_as(CartesianRepresentation).xyz.transpose() x, y = self._project(rr) trace = Scatter( x=x.to(u.km).value, y=y.to(u.km).value, name=label, line=dict(color=color, width=2, dash="dash" if dashed else "solid"), hoverinfo="none", # TODO: Review mode="lines", # Boilerplate ) self._figure.add_trace(trace) return trace
def _get_2d_domain_lines(draw_domains) -> List[Scatter]: """ Returns a list of Scatter objects tracing the domain lines on a 2-dimensional chemical potential diagram. """ x, y = [], [] for pts in draw_domains.values(): x.extend(pts[:, 0].tolist() + [None]) y.extend(pts[:, 1].tolist() + [None]) lines = [ Scatter( x=x, y=y, mode="lines+markers", line=dict(color="black", width=3), showlegend=False, ) ] return lines
def update_graph_live(n): count_list = sorted([this for this in list(count.items()) if this[0].lower() not in set(stop_word)], key=lambda x: x[1], reverse=True, ) to_show = {count_item[0]: count_item[1] for count_item in count_list[:token_count]} word_cloud = WordCloud().generate_from_frequencies(frequencies=to_show, max_font_size=max_font_size, ) max_size = max(this[1] for this in word_cloud.layout_) min_size = min(this[1] for this in word_cloud.layout_) logger.info('cloud min count: {}'.format(min([count[this[0][0]] for this in word_cloud.layout_]))) return Figure(data=[Scatter(mode='text', text=[this[0][0] if '/' not in this[0][0] else this[0][0].split('/')[0] for this in word_cloud.layout_], hoverinfo='text', hovertext=['{}: {}'.format(this[0][0], count[this[0][0]], ) for this in word_cloud.layout_], x=[this[2][0] for this in word_cloud.layout_], y=[this[2][1] for this in word_cloud.layout_], textfont=dict( # todo make the sizes less disparate color=[float_color_to_hex(int((this[1] - min_size) * 255 / max_size), cm.get_cmap(plotly_colormap)) for this in word_cloud.layout_], size=[2 * this[1] for this in word_cloud.layout_], ))], layout=Layout(autosize=True, height=800, width=1800, xaxis=dict(showticklabels=False), yaxis=dict(showticklabels=False), ))
def _plot_coordinates(self, coordinates, label, colors, dashed): if self._frame is None: raise ValueError("A frame must be set up first, please use " "set_orbit_frame(orbit) or plot(orbit)") rr = coordinates.xyz.transpose() x, y = self._project(rr) trace = Scatter( x=x.to(u.km).value, y=y.to(u.km).value, name=label, line=dict(color=colors[0], width=2, dash="dash" if dashed else "solid"), hoverinfo="none", # TODO: Review mode="lines", # Boilerplate ) self._figure.add_trace(trace) return trace
def _draw_marker(self, symbol, size, color, name=None, center=[0, 0, 0] * u.km): x_center, y_center = self._project( center[None]) # Indexing trick to add one extra dimension showlegend = False if name is None else True trace = Scatter( x=x_center.to_value(self._unit), y=y_center.to_value(self._unit), mode="markers", marker=dict(size=size, color=color, symbol=symbol), name=name, showlegend=showlegend, ) self._figure.add_trace(trace) return trace
def _get_2d_domain_lines(domains: Dict[str, np.ndarray], elements: List[Element]) -> List[Scatter]: """Returns a list of Scatter objects tracing the domain lines on a 2-dimensional chemical potential diagram""" x, y = [], [] elems = set(elements) for formula, pts in domains.items(): formula_elems = set(Composition(formula).elements) if not formula_elems.issubset(elems): continue x.extend(pts[:, 0].tolist() + [None]) y.extend(pts[:, 1].tolist() + [None]) lines = [ Scatter( x=x, y=y, mode="lines+markers", line=dict(color="black", width=3), showlegend=False, ) ] return lines
target_df[column], c='gray', label='forecast', marker='x', ) elif plot_method == plot_methods[1]: for col in range(1, 3): # todo fix name/legend for window in range(1, window_count + 1): column = 'projected_{}'.format(window) figure.add_trace( Scatter( marker=dict(color='Gray'), marker_symbol='x', mode='markers', name='forecast', showlegend=False, x=target_df['date'], y=target_df[column], ), col=col, row=1, ) else: if plot_method == plot_methods[0]: for window in range(1, window_count + 1): column = 'projected_{}'.format(window) axes.scatter( target_df['date'], target_df[column], c='gray',
def return_figures(df): figures = [] # visualize imbalance of classes if os.path.isfile('data/df_class_imbalance.pkl'): graph_one = [] data_stat = joblib.load('data/df_class_imbalance.pkl') graph_one.append( Bar(name='0', x=data_stat['Disaster message category'], y=data_stat['Distribution ratio - 0'])) graph_one.append( Bar(name='1', x=data_stat['Disaster message category'], y=data_stat['Distribution ratio - 1'])) layout_one = dict( barmode='group', title='Distribution ratio of messages for each disaster category', yaxis=dict(title="Percentage"), xaxis=dict(title="Category", tickangle=-45), margin=dict(b=160)) figures.append(dict(data=graph_one, layout=layout_one)) # visualize average message length if os.path.isfile('data/df_word_length.pkl'): graph_two = [] data_length = joblib.load('data/df_word_length.pkl') graph_two.append( Scatter( name='direct', x=data_length[data_length['genre'] == 'direct']['index'], y=data_length[data_length['genre'] == 'direct']['length'], showlegend=True, mode='markers', )) graph_two.append( Scatter( name='news', x=data_length[data_length['genre'] == 'news']['index'], y=data_length[data_length['genre'] == 'news']['length'], showlegend=True, mode='markers', )) graph_two.append( Scatter( name='social', x=data_length[data_length['genre'] == 'social']['index'], y=data_length[data_length['genre'] == 'social']['length'], showlegend=True, mode='markers', )) layout_two = dict(title='Average number of words per message', yaxis=dict(title="Average length"), xaxis=dict(visible=False, title="Message id")) figures.append(dict(data=graph_two, layout=layout_two)) # visualize count per genre graph_three = [] genre_counts = df.groupby('genre').count()['message'] genre_names = list(genre_counts.index) graph_three.append(Bar( x=genre_names, y=genre_counts, ), ) layout_three = dict(title='Distribution of Message Genres', yaxis=dict(title="Count"), xaxis=dict(title="Genre")) figures.append(dict(data=graph_three, layout=layout_three)) # visualize category correlation heat map graph_four = [] data_corr = df.iloc[:, 4:] corr_list = [] correl_val = data_corr.corr().values for row in correl_val: corr_list.append(list(row)) graph_four.append( Heatmap(z=corr_list, x=data_corr.columns, y=data_corr.columns, colorscale='Viridis')) layout_four = dict(title='Correlation map of the categories', height=900, margin=dict(l=130, b=160)) figures.append(dict(data=graph_four, layout=layout_four)) # visualize most frequent word per category if os.path.isfile('data/df_pop_word.pkl'): graph_five = [] pop_word = joblib.load('data/df_pop_word.pkl') most_used_words = pop_word['first_word'].unique() color_item = build_color_palette(most_used_words) colors = get_color_scale(color_item, pop_word['first_word']) graph_five.append( Bar(x=pop_word['category'], y=pop_word['first_word_count'], text=pop_word['first_word'], textposition='outside', textangle=-60, textfont={'size': 10}, marker={'color': colors})) layout_five = dict( title='Most used word in all messages for each category', yaxis=dict(title="Count of messages"), xaxis=dict(tickangle=-45, title="Category"), height=900, margin=dict(l=130, b=140)) figures.append(dict(data=graph_five, layout=layout_five)) return figures
def get_figure(hypothesis: Expr, gradient: MutableDenseMatrix, eta0: float, origin: np.ndarray, style: str, showlabels: bool, showgradient: bool, showcomponents: bool) -> Figure: # Function Lambdifying theta0, theta1 = symbols("theta0 theta1") f, grad = lambdify([theta0, theta1], hypothesis), lambdify([theta0, theta1], gradient) # Parameter and Contour Generation x = y = np.arange(start=-12, stop=12, step=0.25) meshgrid: List[np.ndarray] = np.meshgrid(x, y) Z = f(meshgrid[0], meshgrid[1]) point: np.ndarray = origin - eta0 * grad(origin[0], origin[1]).reshape( origin.shape) # Figure Meta Data markercolor = labelcolor = arrowcolor = "white" if style == "fill" else "black" # Figure Generation fig: Figure = Figure() fig.add_trace( Contour(x=x, y=y, z=Z, showscale=False, autocontour=False, contours={ "showlabels": showlabels, "labelfont": { "color": labelcolor }, "start": 0, "end": np.max(Z), "size": 20, "coloring": style })) fig.add_trace( Scatter(x=[*origin[0:1]], y=[*origin[1:2]], mode="markers", marker=dict(symbol="x", color=markercolor, size=10))) if showgradient: fig.add_trace( Scatter(x=[*point[0:1]], y=[*point[1:2]], mode="markers", marker=dict(symbol="x", color=markercolor, size=10))) fig.add_annotation(ax=origin[0], ay=origin[1], x=point[0], y=point[1], xref="x", yref="y", axref="x", ayref="y", showarrow=True, arrowhead=4, arrowsize=1.5, arrowwidth=2, arrowcolor=arrowcolor) if showcomponents: fig.add_annotation(ax=origin[0], ay=origin[1] - 0.5, x=origin[0], y=point[1], xref="x", yref="y", axref="x", ayref="y", showarrow=True, arrowhead=4, arrowsize=1.5, arrowwidth=2, arrowcolor=arrowcolor, opacity=0.5) fig.add_annotation(ax=origin[0], ay=origin[1], x=point[0], y=origin[1], xref="x", yref="y", axref="x", ayref="y", showarrow=True, arrowhead=4, arrowsize=1.5, arrowwidth=2, arrowcolor=arrowcolor, opacity=0.5) fig.update_layout(showlegend=False, margin=dict(l=0, r=0, t=0, b=0)) fig.update_xaxes(title="Parameter 0") fig.update_yaxes(title="Parameter 1") return fig
def _get_plotly_figure(self) -> Figure: """Returns a Plotly figure of reaction kinks diagram""" kinks = map(list, zip(*self.get_kinks())) _, x, energy, reactions, _ = kinks lines = Scatter( x=x, y=energy, mode="lines", name="Lines", line=dict(color="navy", dash="solid", width=5.0), hoverinfo="none", ) annotations = self._get_plotly_annotations(x, energy, reactions) # type: ignore min_idx = energy.index(min(energy)) # type: ignore x_min = x.pop(min_idx) e_min = energy.pop(min_idx) rxn_min = reactions.pop(min_idx) labels = [ rf"{htmlify(str(r))} <br>" + "\u0394" + f"E<sub>rxn</sub> = {round(e, 3)} eV/atom" # type: ignore for r, e in zip(reactions, energy) ] markers = Scatter( x=x, y=energy, mode="markers", name="Reactions", hoverinfo="text", hovertext=labels, marker=dict( color="black", size=12, opacity=0.8, line=dict(color="black", width=3), ), hoverlabel=dict(bgcolor="navy"), ) min_label = ( rf"{htmlify(str(rxn_min))} <br>" + "\u0394" + f"E<sub>rxn</sub> = {round(e_min, 3)} eV/atom" # type: ignore ) minimum = Scatter( x=[x_min], y=[e_min], mode="markers", hoverinfo="text", hovertext=[min_label], marker=dict(color="darkred", size=24, symbol="star"), name="Suggested reaction", ) data = [lines, markers, minimum] layout = plotly_layouts["default_interface_rxn_layout"] layout["xaxis"]["title"] = self._get_xaxis_title(latex=False) layout["annotations"] = annotations fig = Figure(data=data, layout=layout) return fig
def update_figure(time_value, y_column_name, x_column_name, json_data, marks, mdata): """This callback handles updating the graph in response to user actions.""" # Prevents updates without data if None in [json_data, x_column_name, y_column_name, mdata]: raise PreventUpdate( "Graph could not load data -- either this is at startup, or the Storage component isn't storing the data" ) if time_value == None: time_value = int(mdata.get("time_min")) # Loads dataframe at specific time value by getting the time as a key from a dictionary, # then evaluates it to turn it into a python dictionary, and then loads it as a dataframe try: df_by_time = pd.DataFrame.from_dict( literal_eval(json.loads(json_data).get(str(time_value)))) except ValueError: pass server.logger.debug("✅ dataframe filtered by time") x_range = list(mdata.get("ranges").get(x_column_name)) y_range = list(mdata.get("ranges").get(y_column_name)) server.logger.debug("✅ X and Y axis ranges created") scatterplot = Scatter( x=df_by_time[x_column_name], y=df_by_time[y_column_name], mode="markers", opacity=0.7, marker={ "size": 15, "line": { "width": 0.5, "color": "white" } }, hovertext=df_by_time["Subject"], ) traces_data = list() traces_data.append(scatterplot) server.logger.debug("✅ Bubble Chart Scatterplot appended for graphing") figure = { "data": traces_data, "layout": dict( xaxis={ "title": " ".join(x_column_name.split("_")).title(), "range": x_range, }, yaxis={ "title": " ".join(y_column_name.split("_")).title(), "range": y_range, }, margin={ "l": 40, "b": 40, "t": 10, "r": 10 }, legend={ "x": 0, "y": 1 }, hovermode="closest", # Defines transition behaviors transition={ "duration": 500, "easing": "cubic-in-out" }, ), } server.logger.debug("✅ Bubble Chart figure created") return figure
def update_line_chart(ticker, degree): good_data = results[ticker] try: good_data['time'] = good_data.index start = good_data['time'][0] time = np.array([ pd.Timedelta(x - start).total_seconds() for x in good_data['time'] ]) fig1 = px.scatter(good_data, x='time', y='Open', template='simple_white', title='Time Series') fig1.update_traces(marker={'size': 4}) bt = Backtest(results[ticker], SmaCross, cash=10_000, commission=.002) stats = bt.optimize(n1=range(5, 50, 5), n2=range(10, 200, 5), maximize='Equity Final [$]', constraint=lambda param: param.n1 < param.n2) eq_curve = stats._equity_curve eq_curve['time'] = eq_curve.index fig5 = px.line(eq_curve, x='time', y='Equity', template='simple_white') smac = str(stats._strategy) fig1.add_trace( Scatter(x=good_data['time'], y=SMA(good_data['Open'], stats._strategy.n1), name='Short MA')) fig1.add_trace( Scatter(x=good_data['time'], y=SMA(good_data['Open'], stats._strategy.n2), name='Long MA')) print( np.nan_to_num( np.array(SMA(good_data['Open'], stats._strategy.n1)))) coefs = np.polyfit( time, np.nan_to_num( np.array(SMA(good_data['Open'], stats._strategy.n1))), degree) print(coefs) print(np.polyval(time, coefs)) coef_df = pd.DataFrame.from_dict({ 'time': time, 'coeffs': np.polyval(coefs, time), 'original_t': good_data['time'] }) fig2 = px.line(coef_df, x='original_t', y='coeffs', template='simple_white', title='Polynomial Fit') der1 = np.polyder(coefs, 1) print('der1: ', der1) der1_df = pd.DataFrame.from_dict({ 'time': time, 'der1': np.polyval(der1, time), 'original_t': good_data['time'] }) fig3 = px.line(der1_df, x='original_t', y='der1', template='simple_white', title='First Derivative') der2 = np.polyder(coefs, 2) print('der2: ', der2) der2_df = pd.DataFrame.from_dict({ 'time': time, 'der2': np.polyval(der2, time), 'original_t': good_data['time'] }) fig4 = px.line(der2_df, x='original_t', y='der2', template='simple_white', title='Second Derivative') coefs = np.polyfit(time, np.array(good_data['Open']), degree) print('coefs: ', coefs) coef_df = pd.DataFrame.from_dict({ 'time': time, 'coeffs': np.polyval(coefs, time), 'original_t': good_data['time'] }) except exceptions.YahooFinanceError: fig1, fig2, fig3, fig4, fig5 = 'No Ticker Available' return fig1, fig2, fig3, fig4, fig5, coefs, smac
filepath = "twstockyear2018.csv" if os.path.isfile(filepath): title = ["日期", "成交股數", "成交金額", "開盤價", "最高價", "最低價", "收盤價", "漲跌價差", "成交筆數"] outputfile = open(filepath, "a", newline="", encoding="big5") outputwriter = csv.writer(outputfile) for i in range(12, 13): stock = twstock.Stock("2317") stocklist = stock.fetch(2018, i) data = [] for stock in stocklist: strdate = stock.date.strftime("%Y-%m-%d") li = [ strdate, stock.capacity, stock.turnover, stock.open, stock.high, stock.low, stock.close, stock.change, stock.transaction ] data.append(li) """if i==1: outputwriter.writerow(title) """ for dataline in (data): outputwriter.writerow(dataline) time.sleep(1) outputfile.close() pdstock = pd.read_csv(filepath, encoding="big5") pdstock["日期"] = pd.to_datetime(pdstock["日期"]) data1 = [ Scatter(x=pdstock["日期"], y=["收盤價"], name="收盤價"), Scatter(x=pdstock["日期"], y=["最低價"], name="最低價"), Scatter(x=pdstock["日期"], y=["最高價"], name="最高價") ] plot({"data": data1, "layout": Layout(title="2018年個股統計圖")}, auto_open=True)
def update_line_plots(left_value, right_value, json_data, mdata): """Generates line plots from given data values Args: y_value (str):y dropdown column name x_value (str): x dropdown column name json_data (dict): loaded json data from redis mdata (dict): extracted metadata from redis """ if None in [left_value, right_value, json_data, mdata]: raise PreventUpdate # Generates ranges for x and y dropdowns dependent values x_range = list(mdata.get("ranges").get(right_value)) y_range = list(mdata.get("ranges").get(left_value)) # Left and right scatterplot lists left_traces, right_traces = list(), list() # Populates lists of scatterplots by iterating over id for subject in literal_eval(json_data).keys(): df = pd.DataFrame.from_dict( literal_eval(json.loads(json_data).get(str(subject)))) left_traces.append( Scatter(x=df["X"], y=df[left_value], mode="lines", name=f"Subject: {subject}")) right_traces.append( Scatter(x=df["X"], y=df[right_value], mode="lines", name=f"Subject: {subject}")) # Generates title from column names dependentTitle = lambda value: " ".join(value.split("_")).title() return [ { "data": left_traces, "layout": dict( xaxis={ "title": "Time", "autorange": "true" }, yaxis={ "title": dependentTitle(left_value), "autorange": "true", }, title={ "text": f"{dependentTitle(left_value)} vs Time", "y": 0.9, "x": 0.5, "xanchor": "center", "yanchor": "top", }, margin={ "l": 40, "b": 40, "t": 10, "r": 10 }, legend={ "x": 0, "y": 1 }, hovermode="closest", # Defines transition behaviors transition={ "duration": 500, "easing": "cubic-in-out" }, ), }, { "data": right_traces, "layout": dict( xaxis={ "title": "Time", "autorange": "true", }, yaxis={ "title": dependentTitle(right_value), "autorange": "true", }, title={ "text": f"{dependentTitle(right_value)} vs Time", "y": 0.9, "x": 0.5, "xanchor": "center", "yanchor": "top", }, margin={ "l": 40, "b": 40, "t": 10, "r": 10 }, legend={ "x": 0, "y": 1 }, hovermode="closest", # Defines transition behaviors transition={ "duration": 500, "easing": "cubic-in-out" }, ), }, ]
word_cloud = WordCloud().generate_from_frequencies( frequencies=to_show, max_font_size=max_font_size) output_file_root = './output/demo_wordcloud.' colormap = cm.get_cmap(plotly_colormap) max_size = max(item[1] for item in word_cloud.layout_) min_size = min(item[1] for item in word_cloud.layout_) figure = Figure( Scatter(mode='text', text=[item[0][0] for item in word_cloud.layout_], x=[item[2][0] for item in word_cloud.layout_], y=[item[2][1] for item in word_cloud.layout_], textfont=dict( color=[ float_color_to_hex( int((item[1] - min_size) * 255 / max_size), colormap) for item in word_cloud.layout_ ], size=[item[1] for item in word_cloud.layout_], ))) app.layout = html.Div([ dcc.Graph( id='basic-interactions', figure=figure, ), html.Div(dcc.Input(id='input-box', type='text')), html.Button('Submit', id='button'), html.Div(id='output-container-button', children='Enter a value and press submit'),
def display_eps(player_gw_eps: DF) -> Widget: data = (player_gw_eps .reset_index() .sort_values(['Season', 'Game Week'])) data_formatted = data.pipe(ctx.dd.format) data = (data.assign(**{'Label': 'FDR: ' + data_formatted['Fixture Short Name FDR'] + ', ' + 'Rel. Strength: ' + data_formatted['Rel Strength'] + ', ' + 'Cost: ' + data_formatted['Fixture Cost']}) .assign(**{'Game Week': lambda df: 'GW ' + df['Game Week'].apply('{:.0f}'.format)}) .assign(**{'Season Game Week': lambda df: df['Season'] + ', GW ' + df['Game Week']})) x_axis = [data['Season'], data['Game Week']] eps_trace = Scatter(x=x_axis, y=data['Expected Points'], name='Expected Points', line=dict(color='rgb(255, 127, 14)'), mode='lines') ftp_trace = Scatter(x=x_axis, y=data['Fixture Total Points'], name='Actual Points', line=dict(color='rgba(44, 160, 44, 0.3)'), mode='lines') ftpr_trace = Scatter(x=x_axis, y=data['Rolling Avg Game Points'], name='Rolling Actual Points', line=dict(color='rgb(44, 160, 44)'), line_shape='spline', mode='lines') fs_trace = Scatter(x=x_axis, y=data['Expected Points'], name='Rel. Strength', mode='markers', marker=dict(color=(data['Team FDR'].fillna(3)), colorscale=FDR_COLOR_SCALE), text=data['Label']) last_gw = [ctx.current_season, f'GW {ctx.next_gw - 1}'] first_gw = [ctx.current_season, 'GW 1'] last_season_gws_color = 'rgb(230, 230, 230)' past_gws_color = 'rgb(240, 240, 240)' last_season_shape = Shape(type='rect', yref='paper', x0=-6, x1=first_gw, y0=0, y1=1, fillcolor=last_season_gws_color, layer='below', line_width=0, opacity=0.5) past_shape = Shape(type='rect', yref='paper', x0=first_gw, x1=last_gw, y0=0, y1=1, fillcolor=past_gws_color, layer='below', line_width=0, opacity=0.5) start_shape = Shape(type='line', yref='paper', x0=first_gw, x1=first_gw, y0=0, y1=1, line=dict(width=2, color='DarkGrey'), layer='below') current_gw_shape = Shape(type='line', yref='paper', x0=last_gw, x1=last_gw, y0=0, y1=1, line=dict(width=2, color='DarkGrey'), layer='below') max_points = max(max(data['Expected Points'].max(), data['Fixture Total Points'].max()) + 1, 15) min_points = min(data['Expected Points'].min(), data['Fixture Total Points'].min()) - 1 layout = dict( yaxis=dict(title=f'Points', showspikes=True, range=[min_points, max_points]), xaxis=dict(tickfont=dict(size=8)), shapes=[last_season_shape, start_shape, past_shape, current_gw_shape], hovermode='closest', legend=dict(yanchor='top', xanchor='left', x=0, y=1, bgcolor='rgba(0,0,0,0)'), height=300, margin=dict(l=20, r=0, t=5, b=20, pad=0), annotations=[ dict(x=last_gw, y=0.9, yref='paper', text='Last Game Week', ax=80, ay=0), dict(x=first_gw, y=0.9, yref='paper', text='Start of Season', ax=-80, ay=0) ] ) return VBox([HTML('<h3>Expected Points vs Actual Points</h3>'), FigureWidget([ftp_trace, ftpr_trace, eps_trace, fs_trace], layout=layout)])