def plot(adjacency_list: dict, elements: list, x_coordinates: list, y_coordinates: list, z_coordinates: list, plot_name: str = 'plot') -> None: """Creates a 3D scatter plot""" def atom_trace(): """Creates an atom trace for the plot""" colors = [ cpk_colors.get(element, cpk_color_rest) for element in elements ] markers = dict(color=colors, line=dict(color='lightgray', width=2), size=7, symbol='circle', opacity=0.8) trace = go.Scatter3d(x=x_coordinates, y=y_coordinates, z=z_coordinates, mode='markers', marker=markers, text=elements) return trace def bond_trace(): """"Creates a bond trace for the plot""" trace = go.Scatter3d(x=[], y=[], z=[], hoverinfo='none', mode='lines', marker=dict(color='grey', size=7, opacity=1)) adjascent_atoms = ((atom, neighbour) for atom, neighbours in adjacency_list.items() for neighbour in neighbours) for i, j in adjascent_atoms: trace['x'] += (x_coordinates[i], x_coordinates[j], None) trace['y'] += (y_coordinates[i], y_coordinates[j], None) trace['z'] += (z_coordinates[i], z_coordinates[j], None) return trace atoms = zip(elements, x_coordinates, y_coordinates, z_coordinates) annotations = [ dict(text=element, x=x, y=y, z=z, showarrow=False, yshift=15) for element, x, y, z in atoms ] data = [atom_trace(), bond_trace()] axis_params = dict(showgrid=False, showticklabels=False, zeroline=False, titlefont=dict(color='white')) layout = go.Layout(scene=dict(xaxis=axis_params, yaxis=axis_params, zaxis=axis_params, annotations=annotations), margin=dict(r=0, l=0, b=0, t=0), showlegend=False) fig = go.Figure(data=data, layout=layout) offline.plot(fig, show_link=False, filename=plot_name + '.html')
def plot(ip_count_list): data = [ go.Bar(x=[x[0] for x in ip_count_list], y=[x[1] for x in ip_count_list]) ] py.plot(data, filename='freq.html')
def interactive_plot_patients(df, df_label, fs_id1=1, fs_id2=2, class_patient=[1, 3, 5], period=0, display=True): """ df is table_patients_mca df_label is df label This function plots the patients into the plan FS_id1, FS_id2 (factors resulting of the MCA) df_label is a serie which references the label (1=not at risk, 3=risk, 5=psychose) for each patient period (int) refers to the time of the diagnosis. 0 means for t0, 1 means 6 months, etc. It is linked to the index of the columns in the df_label_time_clear period (int, between 0 and 4) is the number of the consultation (0 = T0 ie the first label, 4=T(24mois) ie label_24mois ) """ data_ = [] # data for the plot fs = 'Factor' df_label_color = apply_color_label(df_label.iloc[:, period]) df_label_copy = pd.DataFrame(df_label_color.iloc[:, period]) df_color = pd.DataFrame(df_label_color.loc[:, 'color' + str(period)]) # df_label_copy = pd.concat([df_label_copy, df_color]) df_label_copy = df_label_copy.dropna() df_color = df_color.dropna() points_x = df.loc[(fs, fs_id1)].values points_y = df.loc[(fs, fs_id2)].values labels = df.columns.values # index of patient (1,2,3,...) coordinates_max = max(max(abs(df.loc[(fs, fs_id1)].values)), max(abs(df.loc[(fs, fs_id2)].values))) for i in df_label_copy.index: if df_label_copy.loc[i,][0] in class_patient or str( int(df_label_copy.loc[i][0])) in class_patient: # in order to select just the patient in a class trace = go.Scatter(x=[points_x[i]], y=[points_y[i]], hovertext=str(labels[i]), mode='markers', name='patient {}'.format(i), marker=dict(size=10, color=df_color.loc[i, 'color' + str(period)])) data_.append(trace) layout = go.Layout( title="Coordonnées des patients projetées dans le plan des facteurs " + str(fs_id1) + ' et ' + str(fs_id2), xaxis={"title": "facteur" + str(fs_id1), "range": [-coordinates_max - 0.1, coordinates_max + 0.1]}, yaxis={"title": "facteur" + str(fs_id2), "range": [-coordinates_max - 0.1, coordinates_max + 0.1]}) fig = go.Figure(data=data_, layout=layout) offline.plot(fig, filename='Images/Patients dans le plan des facteurs scores.html', # to save the figure in the repertory auto_open=False) if display: offline.iplot(fig) return None else: return data_, layout
def gethtmlanalysis(category): #category=raw_input() df = pd.read_csv(os.path.join(settings.BASE_DIR, "muse/musedb.csv"), sep=',', error_bad_lines=False, warn_bad_lines=False) df_cat = df[df["CATEGORY_DESC"] == category] del df sub = df_cat["SUBCATEGORY_DESC"].value_counts() l = sub.sum() reg = pd.DataFrame({ 'labels': sub.index.tolist(), 'values': sub.values.tolist() }) sub = sub[sub > (l * 0.008)] trace = go.Pie(labels=sub.index.tolist(), values=sub.values.tolist()) data = go.Data([trace]) layout = go.Layout(title="Top subcategories of " + category + " with total number of items sold") figure = go.Figure(data=data, layout=layout) offline.plot(figure, filename=os.path.join(settings.BASE_DIR, "templates/tpl/cat-subcat.html"), auto_open=False) brand = df_cat["BRAND_DESC"].value_counts() l = brand.sum() reg = pd.DataFrame({ 'labels': brand.index.tolist(), 'values': brand.values.tolist() }) brand = brand[brand > (l * 0.008)] trace = go.Pie(labels=brand.index.tolist(), values=brand.values.tolist()) data = go.Data([trace]) layout = go.Layout(title="Top Brands of " + category + " with total number of items sold") figure = go.Figure(data=data, layout=layout) offline.plot(figure, filename=os.path.join(settings.BASE_DIR, "templates/tpl/cat-brand.html"), auto_open=False)
def graphNewcomers(repoPath, newcomers): # Sometimes we get bad data? newcomers = [x for x in newcomers if len(x.split('\t')) >= 4] issue = [x for x in newcomers if x.split('\t')[2].startswith('issue')] comment = [x for x in newcomers if x.split('\t')[2].startswith('comment')] pull = [x for x in newcomers if jsonIsPullRequest(x.split('\t')[2])] commentPR = [ x for x in newcomers if jsonIsPullRequestComment(x.split('\t')[2]) ] # For each line, pull out the filename (third item) data = [ Bar( x=[ 'Opened an issue', 'Commented on an issue<BR>opened by someone else', 'Opened a pull request', 'Commented on a pull request<BR>opened by someone else' ], y=[len(issue), len(comment), len(pull), len(commentPR)], ) ] layout = Layout(title='First contribution types for<BR>' + repoPath, ) fig = Figure(data=data, layout=layout) return offline.plot(fig, show_link=False, include_plotlyjs=False, output_type='div')
def getHTML(self,params): df = self.getData(params) # get data ## create plotly chart data data = [ go.Scatter( x=df['Date'], y=df['close'], name='Close' ), go.Scatter( x=df['Date'], y=df['high'], name='High' ), go.Scatter( x=df['Date'], y=df['low'], name='Low' ) ] ## create plotly layout layout = go.Layout( autosize=False, width=700, height=500, title='{} Price'.format(self.company_name) ) ## create the figure fig = go.Figure(data=data, layout=layout) ## generate the html html = offline.plot(fig, show_link=False, output_type='div', include_plotlyjs=False) return html
def plot_vals(objs, unc, preference, iteration, interaction_count, ideal, nadir, min, max): objs_orig = objs columns = ["f_" + str(i + 1) for i in range(np.shape(objs)[1])] range_plot = np.vstack((ideal, nadir)) range_plot = np.hstack((range_plot, [[3], [3]])) if np.shape(objs)[0] > 0: unc_avg = np.mean(unc, axis=1) #unc_avg = (unc_avg-np.min(unc_avg))/(np.max(unc_avg)-np.min(unc_avg)) unc_avg = (unc_avg - min) / (max - min) objs_col = unc_avg.reshape(-1, 1) objs = np.hstack((objs, objs_col)) objs = np.vstack((objs, range_plot)) objs = pd.DataFrame(objs, columns=columns + ["color"]) if preference is not None: pref = pd.DataFrame(np.hstack((preference.reshape(1, -1), [[2]])), columns=columns + ["color"]) data_final = pd.concat([objs, pref]) else: data_final = objs #color_scale_custom= [(0.0,'rgb(0,0,0)'),(0.5,'rgb(160,90,0)'),(0.5,'green'),(0.75,'green'),(0.75,'blue'),(1.0,'blue')] #color_scale_custom = [(0.0, 'rgb(36,86,104)'), (0.5, 'rgb(237,239,93)'), (0.5, 'red'), (0.75, 'red'), (0.75, 'lightgray'), # (1.0, 'lightgray')] # color_scale_custom = [(0.0, 'rgb(69,2,86)'), (0.5, 'rgb(249,231,33)'), (0.5, 'red'), (0.75, 'red'), (0.75, 'white'), # (1.0, 'white')] # color_scale_custom = [(0.0, 'rgb(69,2,86)'), (0.125, 'rgb(59,28,140)'), (0.25, 'rgb(33,144,141)'), # (0.375, 'rgb(90,200,101)'), (0.5, 'rgb(249,231,33)'), # (0.5, 'red'), (0.75, 'red'), (0.75, 'white'), # (1.0, 'white')] color_scale_custom = [(0.0, 'rgb(69,2,86)'), (0.083, 'rgb(59,28,140)'), (0.167, 'rgb(33,144,141)'), (0.25, 'rgb(90,200,101)'), (0.334, 'rgb(249,231,33)'), (0.334, 'red'), (0.7, 'red'), (0.7, 'white'), (1.0, 'white')] #color_scale_custom = ['Inferno', (1.5, 'green'), (2.5, 'green'), (2.5, 'white'), # (3.5, 'white')] #color_scale_custom = [(0.0,'red'),(1.5,'red'),(1.5, 'green'), (2.5, 'green'), (2.5, 'white'), # (3.5, 'white')] fig = ex.parallel_coordinates(data_final, dimensions=columns, color="color", color_continuous_scale=color_scale_custom, range_color=(0, 3)) plot(fig, filename="testfile_" + str(iteration) + "_" + str(interaction_count) + ".html") print('Plotting done!!')
def plot(trace1, trace2, annotations1 = None, annotations2 = None, plot_name = 'plot'): """Creates two 3D scatter plots""" if not annotations1: annotations1 = [] if not annotations2: annotations2 = [] fig = tools.make_subplots(rows=1, cols=2, specs=[[{'is_3d': True}, {'is_3d': True}]], print_grid=False, horizontal_spacing=0.01, ) fig.append_trace(trace1[0], 1, 1) fig.append_trace(trace1[1], 1, 1) fig.append_trace(trace2[0], 1, 2) fig.append_trace(trace2[1], 1, 2) axis_params = dict(showgrid=False, showticklabels=False, zeroline=False, titlefont=dict(color='white')) fig['layout'].update(showlegend=False, margin=dict(r=0, l=0, b=0, t=0)) fig['layout']['scene1'].update(dict(xaxis=axis_params, yaxis=axis_params, zaxis=axis_params, annotations=annotations1)) fig['layout']['scene2'].update(dict(xaxis=axis_params, yaxis=axis_params, zaxis=axis_params, annotations=annotations2)) offline.plot(fig, show_link=False, filename=plot_name + '.html')
def plot_graph(jobs): # iterate over all jobs and creater scatters results = {} lines = [] for job in jobs.keys(): critical = [] names = [] for run in sorted(jobs[job]): if CRITICAL in jobs[job][run] and ALL_TESTS in jobs[job][run]: critical.append(jobs[job][run][CRITICAL][PERCENT]) names.append("%s/%s" % (job, run)) results[job] = {} results[job]['percent'] = critical results[job]['names'] = names # iterate and get greater size = 0 for job in results: if size < len(results[job]['percent']): size = len(results[job]['percent']) # create lines for job in results: lines.append( go.Scatter(x=range(size - len(results[job]['percent']), size), y=results[job]['percent'], text=results[job]['names'], name='%s - %s' % (job, CRITICAL), mode="lines+markers")) data = go.Data(lines) layout = go.Layout(title="Regression Status", xaxis={'title': 'Last Builds'}, yaxis={ 'title': 'Percent', 'range': [0, 100] }) figure = go.Figure(data=data, layout=layout) plot(figure, filename='test.html', auto_open=True)
def visualize(max_x, max_y, barren_land_dicts): trace0 = go.Scatter( x=[1.5, 4.5], y=[0.75, 0.75], ) data = [trace0] layout = { 'xaxis': { 'range': [0, max_x], 'showgrid': True, 'fixedrange': True }, 'yaxis': { 'range': [0, max_y], 'fixedrange': True }, 'shapes': barren_land_dicts } fig = go.Figure(data=data, layout=layout) py.plot(fig, filename='barren_plot.html', auto_open=True)
def graphRampTime(deltas, nocontribs, graphtitle, xtitle, filename): data = [Histogram(x=deltas)] layout = Layout( title=graphtitle, yaxis=dict(title='Number of contributors'), xaxis=dict(title= xtitle + '<br>Mean: ' + '{:.2f}'.format(statistics.mean(deltas)) + ' days, ' + 'Median: ' + '{:.2f}'.format(statistics.median(deltas)) + ' days' + '<br>Number of contributors who did this: ' + '{:,g}'.format(len(deltas)) + '<br>Percentage of contributors who did this: ' + '{:.2f}'.format(len(deltas)/(len(deltas)+len(nocontribs))*100) + '%') ) fig = Figure(data=data, layout=layout) return offline.plot(fig, show_link=False, include_plotlyjs=False, output_type='div')
def show_box_plot(city_name, col, Title): fig = tls.make_subplots(rows=1, cols=1) for city in city_name: for each in col: plot = go.Box(x=dataset[dataset['city'] == city]['city'], y=dataset[dataset['city'] == city][each], showlegend=True, name=each + ' --- ' + city) fig.append_trace(plot, 1, 1) fig['layout'].update(title=Title) div = offline.plot(fig, show_link=False, output_type="div", include_plotlyjs=False) return div
def show_bar_plot(city_name, col, Title): fig = tls.make_subplots(rows=1, cols=1) for city in city_name: for each in col: plot = go.Bar(x=dataset[dataset['city'] == city]['city'], y=dataset[dataset['city'] == city][each], showlegend=True, name=each + ' --- ' + city) fig.append_trace(plot, 1, 1) fig['layout'].update(title=Title) div = offline.plot(fig, show_link=False, output_type="div", include_plotlyjs=False) return '<script src="https://cdn.plot.ly/plotly-1.2.0.min.js"></script>' + div
def graphRampTime(deltas, nocontribs, graphtitle, xtitle, filename): data = [Histogram(x=deltas)] title = "<br><i>Not enough data available.</i>" if deltas: title = ( '<br>Mean: {:.2f} days, Median: {:.2f} days' '<br>Number of contributors who did this: {:,g}' '<br>Percentage of contributors who did this: {:.2f}%').format( statistics.mean(deltas), statistics.median(deltas), len(deltas), len(deltas) / (len(deltas) + len(nocontribs)) * 100) layout = Layout(title=graphtitle, yaxis=dict(title='Number of contributors'), xaxis=dict(title=xtitle + title)) fig = Figure(data=data, layout=layout) return offline.plot(fig, show_link=False, include_plotlyjs=False, output_type='div')
def getHTML(self, params): df = self.getData(params) # get data ## create plotly chart data data = [ go.Scatter(x=df['Date'], y=df['close'], name='Close'), go.Scatter(x=df['Date'], y=df['high'], name='High'), go.Scatter(x=df['Date'], y=df['low'], name='Low') ] ## create plotly layout layout = go.Layout(autosize=False, width=700, height=500, title='{} Price'.format(self.company_name)) ## create the figure fig = go.Figure(data=data, layout=layout) ## generate the html html = offline.plot(fig, show_link=False, output_type='div', include_plotlyjs=False) return html
def show_city_frequency(number_of_city=10): plot_1 = go.Histogram(x=dataset[dataset.city.isin( city_count[:number_of_city].index.values)]['city'], showlegend=False) ## Creating the grid for the above plot fig = tls.make_subplots(rows=1, cols=1) ## appending the plot on to the grid fig.append_trace(plot_1, 1, 1) ## displaying the figure fig['layout'].update(showlegend=True, title="Frequency of cities in the dataset ") div = offline.plot(fig, show_link=False, output_type="div", include_plotlyjs=False) return '<script src="https://cdn.plot.ly/plotly-1.2.0.min.js"></script>' + div
def graphMergeDelay(coords): # Calculate, for each month, the average "age" of pull requests # (the average amount of time a pull request is open before being merged). # Discard all PRs opened after the end of the month # discard all PRs closed before the beginning of the month # in order to only look at PRs closed this month. # # Jan Feb # |---------1--------| # |-------2---------| # |---2---| # |-----------3------------| # # 1. If a pull request was opened before this month and closed this month, # count the length of time from when it was opened to when it was closed. # 2. If a pull request was opened and closed in this month, # count the length of time from when it was opened to when it was closed. # 3. If a pull request was opened this month but was not closed this month, # count the length of time from when it was opened to the end of this month. # # (So essentially, from when it was open to when it was closed or EOM, # whichever is sooner) beg = coords[0][0] end = coords[-1][0] means = [] bom = datetime(beg.year, beg.month, 1) while True: if bom.month + 1 <= 12: eom = datetime(bom.year, bom.month + 1, bom.day) else: eom = datetime(bom.year + 1, 1, bom.day) openpr = [(x, min(y, eom)) for (x, y) in coords if x < eom and y > bom] if not openpr: means.append((eom, 0)) bom = eom continue lengths = [(y - x).total_seconds() / (60 * 60 * 24.) for (x, y) in openpr] means.append((eom, numpy.average(lengths))) bom = eom if eom > end: break # Scatter chart - x is creation date, y is number of days open data = [ Scatter(x=[x for (x, y) in coords], y=[(y - x).total_seconds() / (60 * 60 * 24.) for (x, y) in coords], mode='markers', name='Pull requests<BR>by creation date'), Scatter(x=[x for (x, y) in means], y=[y for (x, y) in means], name='Average time open'), ] layout = Layout( title='Number of days a pull request is open', yaxis=dict(title='Number of days open'), xaxis=dict(title='Pull request creation date'), ) fig = Figure(data=data, layout=layout) return offline.plot(fig, show_link=False, include_plotlyjs=False, output_type='div')
def stock_detail(request, s): # 주식 그래프 생성 code_df = pd.read_html( 'http://kind.krx.co.kr/corpgeneral/corpList.do?method=download&searchType=13', header=0)[0] # 타입을 확인 print(type(code_df)) # <class 'pandas.core.frame.DataFrame'> print(code_df.head()) # 데이터를 확인 # code_df에 있는 '종목코드' 컬럼을 0을 채운 6자리 포멧으로 맞춰준다. code_df.종목코드 = code_df.종목코드.map('{:06d}'.format) # code_df를 회사명과 종목코드 컬럼만 뽑아낸다. # ***참고*** pandas에서 컬럼을 선택 할 때 # 단일개 선택: df['컬럼명'] or df.컬럼명 # 여러개 선택: df[['컬럼명', ... ,'컬럼명']] code_df = code_df[['회사명', '종목코드']] excel = code_df[[ '회사명', '종목코드', ]] print(code_df) # 데이터를 확인 print('----------배열만들기-----------') code_df.to_csv("test.csv", encoding="UTF-8") #csv로 저장해놓음 first_test = code_df[['회사명', '종목코드']] #호사명과 종목코드가 들어간것 # 한글로된 컬럼명을 영어로 바꿔준다. code_df = code_df.rename(columns={'회사명': 'name', '종목코드': 'code'}) def get_url(s, code_df): #s 파라미터로, 데이터 프레임 반환 # 코드를 가져오기 위한 처리. # 먼저 .query("name=='{}'".format(item_name))['code']는 name 컬럼에 item_name과 동일한 값의 code값을 반환한다는 뜻. # 즉, .query("쿼리".format(쿼리에 넣을 데이터))[얻을 자료] # .to_string(index = False)로 위에서 얻어진 값에 index를 빼고 string타입으로 바꿔준다. code = (code_df.query( "name=='{}'".format(s))['code'].to_string(index=False)).strip() # url은 일일 종가 시가 고가 저가 거래량을 보여주는 표이다. url = 'http://finance.naver.com/item/sise_day.nhn?code={code}'.format( code=code) print("요청 URL={}".format(url)) return url print('----------------------------') # 회사명 입력 -> 그 회사 주식 가져옴. item_name = s url = get_url(item_name, code_df) df = pd.DataFrame() # 크롤링. 페이지 20까지 크롤링을 한다. 1->20 페이지 생성 for page in range(1, 21): # 위에서 얻은 url에 page를 붙여줘서 url 포멧을 만들어준다. pg_url = '{url}&page={page}'.format(url=url, page=page) # pandas의 df에 위에서 얻은 url을 넣어줘서 우리가 구하고자 하는 데이터프레임을 만든다. # 데이터프레임을 만들 때 리스트에 [0]을 붙여줘서 만들 수 있음을 다시 확인. df = df.append(pd.read_html(pg_url, header=0)[0], ignore_index=True) # df.dropna()를 이용해 결측값(NaN) 있는 행을 제거한다. df = df.dropna() # 상위 5개 데이터 확인하기 print(df.head()) print("---------------head 이후 경계선------------") # 한글로 된 컬럼명을 영어로 바꿔준다. df = df.rename( columns={ '날짜': 'date', '종가': 'close', '전일비': 'diff', '시가': 'open', '고가': 'high', '저가': 'low', '거래량': 'volume' }) # 데이터의 타입을 int형으로 바꿔줌. \(역슬래쉬)는 뒤에 데이터가 이어진다는 의미이다. 한줄로 쓰면 \ 필요없음. df[['close', 'diff', 'open', 'high', 'low', 'volume']]\ = df[['close', 'diff', 'open', 'high', 'low', 'volume']].astype(int) # 컬럼명 'date'의 타입을 date로 바꿔줌 df['date'] = pd.to_datetime(df['date']) # 일자(date)를 기준으로 오름차순 정렬 df = df.sort_values(by=['date'], ascending=False) print('---최근날짜것만 가져옴----') myDate = df.iloc[0] print(myDate) print(myDate.close) # 상위 5개 데이터 확인 print(df.head()) # plotly 라이브러리 사용법은 ' Python ▒ plotly 라이브러리 ' 참고 trace = go.Scatter(x=df.date, y=df.close, name=item_name) data = [trace] # 그래프의 레이아웃을 설정한다. - 딕셔너리 타입으로 작성 layout = dict( title='{}의 종가 시간 흐름'.format(item_name), xaxis=dict(rangeselector=dict(buttons=list([ dict(count=1, label='1m', step='month', stepmode='backward'), dict(count=3, label='3m', step='month', stepmode='backward'), dict(count=6, label='6m', step='month', stepmode='backward'), dict(step='all') ])), rangeslider=dict(), type='date')) fig = go.Figure(data=data, layout=layout) # stock_img = offline.plot(fig, filename="C:/Users/Administrator/PycharmProjects/Crawling/img/inqury.html") stock_img = offline.plot( fig, filename="E:/ksy/python_project/bankproject/static/inqury.html") return redirect('stock:company_list2')
def graphSentiment(repoPath, debug): sentimentDict = createSentimentDict(repoPath) commentSentiment = createSentimentCounts(sentimentDict) combinedIssueSentiment = createIssueSentiment(commentSentiment) if debug: print('Have', len(commentSentiment), 'sentiment json files') jsonDict = createJsonDict(repoPath, combinedIssueSentiment.keys(), True) # List: [date, issue path (for now), (combinedIssueSentiment 5 tuple)] coords = [] for key, value in combinedIssueSentiment.items(): try: path = os.path.join(repoPath, key, key + '.json') with open(path) as issueFile: issueJson = json.load(issueFile) url = issueJson['html_url'] coords.append((jsonDict[path][0], key, value, url)) except: key2 = os.path.join(repoPath, key, key + '.json') if debug: print(key, 'IS in combinedIssueSentiment dict') print(key2, 'NOT in jsonDict') if key2 not in sentimentDict.keys(): print(key2, 'NOT in sentimentDict') else: print(key2, 'IS in sentimentDict') if key2 not in commentSentiment.keys(): print(key2, 'NOT in commentSentiment dict') else: print(key2, 'IS in commentSentiment dict') #print(key, value, key.split(os.sep)) pass if debug: print('coords len:', len(coords), 'number issues:', len(combinedIssueSentiment)) coords = sorted(coords, key=lambda tup: tup[1]) # Multiplier - what is the magnitude of positive comments you would have to receive vs negative comments # to have this issue "feel" positive? feelsMultipler = 2 posCoords = [(date, issue, sentiment, url) for (date, issue, sentiment, url) in coords if (sentiment[4] * 2 + sentiment[3]) > feelsMultipler * (sentiment[0] * 2 + sentiment[1])] negCoords = [(date, issue, sentiment, url) for (date, issue, sentiment, url) in coords if (sentiment[0] * 2 + sentiment[1]) > feelsMultipler * (sentiment[4] * 2 + sentiment[3])] # Issues can have a lot of neutral comments (debate on code) and still "feel" negative or mixed. # If more than 20% of the comments are positive or neutral, it's a mixed thread. mixedPercent = .20 neutralCoords = [(date, issue, sentiment, url) for ( date, issue, sentiment, url ) in coords if (sentiment[2] > 0) and (mixedPercent > ( (sentiment[0] * 2 + sentiment[1] + sentiment[3] + sentiment[4] * 2) / (sentiment[2]))) and ( (date, issue, sentiment, url) not in posCoords) and ( (date, issue, sentiment, url) not in negCoords)] mixedCoords = [ (date, issue, sentiment, url) for (date, issue, sentiment, url) in coords if ((date, issue, sentiment, url) not in neutralCoords) and ( (date, issue, sentiment, url) not in posCoords) and ( (date, issue, sentiment, url) not in negCoords) ] sentCoords = [ ('Neutral', 'rgba(0, 0, 0, .8)', neutralCoords), ('Positive', 'rgba(21, 209, 219, .8)', posCoords), ('Negative', 'rgba(250, 120, 80, .8)', negCoords), ('Mixed', 'rgba(130, 20, 160, .8)', mixedCoords), ] data = [] for s in sentCoords: data.append( Scatter( x=[date for (date, issue, sentiment, url) in s[2]], y=[sentiment[2] for (date, issue, sentiment, url) in s[2]], error_y=dict( type='data', symmetric=False, array=[ sentiment[3] + sentiment[4] * 2 for (date, issue, sentiment, url) in s[2] ], arrayminus=[ sentiment[1] + sentiment[0] * 2 for (date, issue, sentiment, url) in s[2] ], color=s[1], ), mode='markers', text=[url for (date, issue, sentiment, url) in s[2]], name=s[0] + ' community sentiment', marker=dict(color=s[1]), )) layout = Layout( title='Community sentiment', yaxis=dict( title='Number of + positive | neutral | - negative comments'), xaxis=dict(title='Issue or PR creation date'), ) fig = Figure(data=data, layout=layout) return offline.plot(fig, show_link=False, auto_open=False, include_plotlyjs=False, output_type='div')
def plot_map_station_with_plotly(station_control, station_id=None, width=800, height=600, offline_plot=False, return_plot=False,): """ Affiche une cartographie de l'agglomération de Bordeaux avec toutes les stations Vcub et leurs états provenant des algorithmes (normal, inactive et anomaly). Si "station_id" est indiqué, alors la cartographie est focus sur la lat / lon de station (Numéro) Parameters ---------- data : pd.DataFrame En provenance de station_control.csv (vcub_watcher) station_id : Int [opt] Numéro de station que l'on souhaite voir (en focus) sur la cartographie. width : int [opt] Largeur du graphique (en px). height : int [opt] Longeur du graphique (en px). offline_plot : bool [opt] Pour retourner le graphique et l'utilisé dans une application return_plot : bool [opt] Retourne le graphique pour être utilisé par le front. Returns ------- None Examples -------- plot_map_station_with_plotly(station_control=station_control, offline_plot=False) """ # Param plot with a given station_id if station_id is not None: # On centre le graphique sur la lat / lon de la station center_lat = \ station_control[station_control['station_id'] == station_id]['lat'].values[0] center_lon = \ station_control[station_control['station_id'] == station_id]['lon'].values[0] zoom_plot = 15 else: center_lat = 44.837794 center_lon = -0.581662 zoom_plot = 11 # Preprocess avant graphique station_control['etat'] = 'normal' # Non monitoré station_control.loc[station_control['mean_activity'] < THRESHOLD_PROFILE_STATION, 'etat'] = 'non surveillée' # En anoamlie (HS prediction) station_control.loc[station_control['is_anomaly'] == 1, 'etat'] = 'anomaly' # Inactive station_control.loc[station_control['is_inactive'] == 1, 'etat'] = 'inactive' # Transform date to string try: station_control['anomaly_since_str'] = \ station_control['anomaly_since'].dt.strftime(date_format='%Y-%m-%d %H:%M') except KeyError: # Pour vcub_watcher intégration # https://github.com/armgilles/vcub_keeper/issues/49#issuecomment-822504771 station_control['anomaly_since_str'] = \ station_control['En anomalie depuis'].dt.strftime(date_format='%Y-%m-%d %H:%M') station_control['anomaly_since_str'] = station_control['anomaly_since_str'].fillna('-') # Color for etat color_etat = {'anomaly': '#EB4D50', 'inactive': '#5E9BE6', 'normal': '#6DDE75', 'non surveillée': '#696A6A'} # To know when use add_trace after init fig wtf_compteur = 0 for etat in station_control['etat'].unique(): # Filter temp = station_control[station_control['etat'] == etat] # Building text texts = [] for idx, station in temp.iterrows(): text = str(station['NOM']) \ + " <br />" + "station N° : " + str(station['station_id']) \ + " <br />" + "Nombre de vélo dispo : " + str(station['available_bikes']) \ + " <br />" + "Activité suspecte depuis : " + str(station['anomaly_since_str']) texts.append(text) if wtf_compteur == 0: fig = go.Figure(go.Scattermapbox(lat=temp['lat'], lon=temp['lon'], mode='markers', hoverinfo='text', hovertext=texts, marker_size=9, marker_color=color_etat[etat], name=etat)) else: fig.add_trace(go.Scattermapbox(lat=temp['lat'], lon=temp['lon'], mode='markers', hoverinfo='text', hovertext=texts, marker_size=9, marker_color=color_etat[etat], name=etat)) wtf_compteur = 1 fig.update_layout(mapbox=dict(center=dict(lat=center_lat, lon=center_lon), accesstoken=MAPBOX_TOKEN, zoom=zoom_plot, style="light"), showlegend=True, width=width, height=height, legend=dict(orientation="h", yanchor="top", xanchor="center", y=1.1, x=0.5 )) # To get map on Front if return_plot is True: return fig if offline_plot is False: iplot(fig) else: offline.plot(fig)
def animate_2d_init_(data: Union[np.ndarray, pd.DataFrame, list], filename: str) -> dict: """Initiate a 2D scatter animation. Only for 2D data. Parameters ---------- data : Union[np.ndarray, pd.DataFrame, list] Objective values filename : str Name of the file to which plot is saved Returns ------- dict Plotly Figure Object """ figure = {"data": [], "layout": {}, "frames": []} figure["layout"]["xaxis"] = {"autorange": True} figure["layout"]["yaxis"] = {"autorange": True} figure["layout"]["hovermode"] = "closest" figure["layout"]["sliders"] = { "args": ["transition", { "duration": 400, "easing": "cubic-in-out" }], "initialValue": "1952", "plotlycommand": "animate", "visible": True, } sliders_dict = { "active": 0, "yanchor": "top", "xanchor": "left", "currentvalue": { "font": { "size": 20 }, "prefix": "Iteration:", "visible": True, "xanchor": "right", }, "transition": { "duration": 300, "easing": "cubic-in-out" }, "pad": { "b": 10, "t": 50 }, "len": 0.9, "x": 0.1, "y": 0, "steps": [], } figure["layout"]["sliders"] = [sliders_dict] data_dict = { "x": list(data[:, 0]), "y": list(data[:, 1]), "mode": "markers", "marker": { "size": 5, "color": "rgba(255, 182, 193, .9)", "line": dict(width=2), }, } figure["data"].append(data_dict) plot(figure, filename=filename) animate_2d_next_(data, figure, filename, 0) return figure
def animate_parallel_coords_next_( data: Union[np.ndarray, pd.DataFrame, list], figure: dict, filename: str, generation: int, ) -> dict: """Plot the next set of individuals in an animation. Plots parallel coordinate plot for 4D and up. Parameters ---------- data : Union[np.ndarray, pd.DataFrame, list] The objective values to be plotted figure : dict Plotly figure object compatible dict filename : str Name of the file to which the plot is saved generation : int Iteration Number Returns ------- dict Plotly Figure Object """ frame = {"data": [], "name": str(generation)} objectives = pd.DataFrame(data) sliders_dict = figure["layout"]["sliders"][0] dimensions = [ dict( range=[min(objectives[column]), max(objectives[column])], label="f" + str(column), values=objectives[column], ) for column in objectives ] line = dict( color=objectives[0], colorscale="Viridis", showscale=True, cmin=min(objectives[objectives.columns[0]]), cmax=max(objectives[objectives.columns[0]]), ) data_dict = go.Parcoords(line=line, dimensions=dimensions) frame["data"].append(data_dict) figure["frames"].append(frame) slider_step = { "args": [ [generation], { "frame": { "duration": 300, "redraw": True }, "mode": "immediate", "transition": { "duration": 300 }, }, ], "label": generation, "method": "animate", } sliders_dict["steps"].append(slider_step) figure["layout"]["sliders"] = [sliders_dict] plot(figure, auto_open=False, filename=filename) return figure
def animate_parallel_coords_init_(data: Union[np.ndarray, pd.DataFrame, list], filename: str) -> dict: """Plot the first (or zeroth) iteration of a population. Intended as a frames object. Plots parallel coordinate plot for >3D data. Parameters ---------- data : Union[np.ndarray, pd.DataFrame, list] Contains the data to be plotted. Each row is an individual's objective values. filename : str Contains the name of the file to which the plot is saved. Returns ------- dict Plotly figure object """ figure = {"data": [], "layout": {}, "frames": []} objectives = pd.DataFrame(data) figure["layout"]["hovermode"] = "closest" figure["layout"]["sliders"] = { "args": ["transition", { "duration": 400, "easing": "cubic-in-out" }], "initialValue": "1952", "plotlycommand": "animate", "visible": True, } sliders_dict = { "active": 0, "yanchor": "top", "xanchor": "left", "currentvalue": { "font": { "size": 20 }, "prefix": "Iteration:", "visible": True, "xanchor": "right", }, "transition": { "duration": 300, "easing": "cubic-in-out" }, "pad": { "b": 10, "t": 50 }, "len": 0.9, "x": 0.1, "y": 0, "steps": [], } figure["layout"]["sliders"] = [sliders_dict] dimensions = [ dict( range=[min(objectives[column]), max(objectives[column])], label="f" + str(column), values=objectives[column], ) for column in objectives ] line = dict( color=objectives[0], colorscale="Viridis", showscale=True, cmin=min(objectives[objectives.columns[0]]), cmax=max(objectives[objectives.columns[0]]), ) data_dict = go.Parcoords(line=line, dimensions=dimensions) figure["data"].append(data_dict) plot(figure, filename=filename) animate_parallel_coords_next_(data, figure, filename, 0) return figure
def animate_3d_next_( data: Union[np.ndarray, pd.DataFrame, list], figure: dict, filename: str, generation: int, ) -> dict: """Plot the next set of individuals in an animation. Plots scatter for 3D data. Parameters ---------- data : Union[np.ndarray, pd.DataFrame, list] The objective values to be plotted figure : dict Plotly figure object compatible dict filename : str Name of the file to which the plot is saved generation : int Iteration Number Returns ------- dict Plotly Figure Object """ frame = {"data": [], "name": str(generation)} sliders_dict = figure["layout"]["sliders"][0] data_dict = go.Scatter3d( x=list(data[:, 0]), y=list(data[:, 1]), z=list(data[:, 2]), mode="markers", marker=dict( size=8, color=data[:, 2], colorscale="Viridis", opacity=0.5, line=dict(width=2, color="black", colorscale="Viridis"), ), ) frame["data"].append(data_dict) figure["frames"].append(frame) slider_step = { "args": [ [generation], { "frame": { "duration": 300, "redraw": True }, "mode": "immediate", "transition": { "duration": 300 }, }, ], "label": generation, "method": "animate", } sliders_dict["steps"].append(slider_step) figure["layout"]["sliders"] = [sliders_dict] plot(figure, auto_open=False, filename=filename) return figure
def animate_3d_init_(data: Union[np.ndarray, pd.DataFrame, list], filename: str) -> dict: """Plot the first (or zeroth) iteration of a population. Intended as a frames object. Plots Scatter 3D data. Parameters ---------- data : Union[np.ndarray, pd.DataFrame, list] Contains the data to be plotted. Each row is an individual's objective values. filename : str Contains the name of the file to which the plot is saved. Returns ------- dict Plotly figure object """ figure = {"data": [], "layout": {}, "frames": []} figure["layout"]["hovermode"] = "closest" figure["layout"]["sliders"] = { "args": ["transition", { "duration": 400, "easing": "cubic-in-out" }], "initialValue": "1", "plotlycommand": "animate", "visible": True, } sliders_dict = { "active": 0, "yanchor": "top", "xanchor": "left", "currentvalue": { "font": { "size": 20 }, "prefix": "Iteration:", "visible": True, "xanchor": "right", }, "transition": { "duration": 300, "easing": "cubic-in-out" }, "pad": { "b": 10, "t": 50 }, "len": 0.9, "x": 0.1, "y": 0, "steps": [], } figure["layout"]["sliders"] = [sliders_dict] figure["layout"]["scene"] = dict( xaxis=dict( backgroundcolor="rgb(200, 200, 230)", gridcolor="rgb(255, 255, 255)", showbackground=True, zerolinecolor="rgb(255, 255, 255)", ), yaxis=dict( backgroundcolor="rgb(230, 200,230)", gridcolor="rgb(255, 255, 255)", showbackground=True, zerolinecolor="rgb(255, 255, 255)", ), zaxis=dict( backgroundcolor="rgb(230, 230,200)", gridcolor="rgb(255, 255, 255)", showbackground=True, zerolinecolor="rgb(255, 255, 255)", ), ) data_dict = go.Scatter3d( x=list(data[:, 0]), y=list(data[:, 1]), z=list(data[:, 2]), mode="markers", marker=dict( size=8, color=data[:, 2], colorscale="Viridis", opacity=0.5, line=dict(width=2, color="black", colorscale="Viridis"), ), ) figure["data"].append(data_dict) plot(figure, filename=filename) animate_3d_next_(data, figure, filename, 0) return figure
def animate_2d_next_( data: Union[np.ndarray, pd.DataFrame, list], figure: dict, filename: str, generation: int, ) -> dict: """Plot the next set of individuals in a 2D scatter animation. Parameters ---------- data : Union[np.ndarray, pd.DataFrame, list] The objective values to be plotted figure : dict Plotly figure object compatible dict filename : str Name of the file to which the plot is saved generation : int Iteration Number Returns ------- dict Plotly Figure Object """ frame = {"data": [], "name": str(generation)} sliders_dict = figure["layout"]["sliders"][0] data_dict = { "x": list(data[:, 0]), "y": list(data[:, 1]), "mode": "markers", "marker": { "size": 5, "color": "rgba(255, 182, 193, .9)", "line": dict(width=2), }, } frame["data"].append(data_dict) figure["frames"].append(frame) slider_step = { "args": [ [generation], { "frame": { "duration": 300, "redraw": False }, "mode": "immediate", "transition": { "duration": 300 }, }, ], "label": generation, "method": "animate", } sliders_dict["steps"].append(slider_step) figure["layout"]["sliders"] = [sliders_dict] plot(figure, auto_open=False, filename=filename) return figure
def gen_plot_page(df): # Uniquify by real_time and op_group page df = df[df.sub_type=='FullOp'] df = df[['real_time','op_group']] df = df.drop_duplicates() df = df.sort_values(by="real_time",ascending=False) # Prepare addition columns for Pareto Chart df['cumulative_sum'] = df.real_time.cumsum() df['cumulative_perc'] = 100*df.cumulative_sum/df.real_time.sum() df['demarcation'] = 80 # Filter out until 80% df = df.query('cumulative_perc < 80') # Prepare plotly data trace1 = Bar( x=df.op_group, y=df.real_time, name='Real Time', marker=dict( color='rgb(34,163,192)' ) ) trace2 = Scatter( x=df.op_group, y=df.cumulative_perc, name='Cumulative Percentage', yaxis='y2', line=dict( color='rgb(243,158,115)', width=2.4 ) ) trace3 = Scatter( x=df.op_group, y=df.demarcation, name='80%', yaxis='y2', line=dict( color='rgba(128,128,128,.45)', dash = 'dash', width=1.5 ) ) data = [trace1, trace2, trace3] layout = Layout( title='Smartfill run time - Pareto Chart', titlefont=dict( color='', family='', size=0 ), font=Font( color='rgb(128,128,128)', family='Balto, sans-serif', size=12 ), width=1500, height=623, paper_bgcolor='rgb(240, 240, 240)', plot_bgcolor='rgb(240, 240, 240)', hovermode='compare', margin=dict(b=250,l=60,r=60,t=65), showlegend=True, legend=dict( x=.83, y=1.3, font=dict( family='Balto, sans-serif', size=12, color='rgba(128,128,128,.75)' ), ), annotations=[ dict( text="Cumulative Percentage", showarrow=False, xref="paper", yref="paper", textangle=90, x=1.029, y=.75, font=dict( family='Balto, sans-serif', size=14, color='rgba(243,158,115,.9)' ),)], xaxis=dict( tickangle=-90 ), yaxis=dict( title='Real Time', range=[0,30300], tickfont=dict( color='rgba(34,163,192,.75)' ), tickvals = [0,6000,12000,18000,24000,30000], titlefont=dict( family='Balto, sans-serif', size=14, color='rgba(34,163,192,.75)') ), yaxis2=dict( range=[0,101], tickfont=dict( color='rgba(243,158,115,.9)' ), tickvals = [0,20,40,60,80,100], overlaying='y', side='right' ) ) fig = dict(data=data, layout=layout) # Gen plotly page offline.plot(fig, auto_open=False, filename="pareto_chart.html")
def plot_station_anomalies_with_score(data, clf, station_id, start_date='', end_date='', return_data=False, offline_plot=False, display_title=True, return_plot=False): """ Plot Time Series activty and anomaly score Parameters ---------- data : pd.DataFrame Tableau temporelle de l'activité des stations Vcub clf : Pipeline Scikit Learn Estimator already fit station_id : Int ID station start_date : str [opt] Date de début du graphique yyyy-mm-dd end_date : str [opt] Date de fin du graphique yyyy-mm-dd return_data : bool [opt] Retour le DataFrame lié à la station demandé et au contraintes de date si remplie. offline_plot : bool [opt] Pour exporter le graphique display_title : bool [opt] Afin d'afficher le titre du graphique offline_plot : bool [opt] Pour retourner le graphique et l'utiliser dans une application Returns ------- data : pd.DataFrame Could return it if return_data is True. Examples -------- plot_station_anomalies_with_score(data=ts_activity, clf=clf, station_id=22) """ # Filter on station_id data_station = data[data['station_id'] == station_id].copy() if 'consecutive_no_transactions_out' not in data.columns: # Some features data_station = get_transactions_in(data_station) data_station = get_transactions_out(data_station) data_station = get_transactions_all(data_station) data_station = get_consecutive_no_transactions_out(data_station) data_pred = predict_anomalies_station(data=data_station, clf=clf, station_id=station_id) data_pred['anomaly_score'] = \ logistic_predict_proba_from_model(clf.decision_function(data_pred[FEATURES_TO_USE_CLUSTER])) * 100 if start_date != '': data_pred = data_pred[data_pred['date'] >= start_date] if end_date != '': data_pred = data_pred[data_pred['date'] <= end_date] # Figure if display_title: title = "Détection d'anomalies sur la stations N° " + str(station_id) else: title = None fig = make_subplots(rows=2, cols=1, shared_xaxes=True, specs=[[{"secondary_y": True}], [{"secondary_y": True}]], row_heights=[0.82, 0.18], vertical_spacing=0.01, x_title=title, ) # Row 1 # Axe 1 fig.add_trace(go.Scatter(x=data_pred['date'], y=data_pred['available_bikes'], mode='lines', line={'width': 2}, name="Vélo disponible"), row=1, col=1) # Axe 2 fig.add_trace(go.Scatter(x=data_pred['date'], y=data_pred['consecutive_no_transactions_out'], mode='lines', line={'width': 1, 'dash': 'dot', 'color': 'rgba(189,189,189,1)'}, #yaxis='y2', name='Absence consécutive de prise de vélo'), row=1, col=1, secondary_y=True) # For shape hoverdata anomaly data_pred['ano_hover_text'] = np.NaN data_pred.loc[data_pred['anomaly'] == -1, 'ano_hover_text'] = data_pred['available_bikes'] fig.add_trace(go.Scatter(x=data_pred['date'], y=data_pred['ano_hover_text'], mode='lines', text='x', connectgaps=False, line={'width': 2, 'color': 'red'}, name='anomaly'), row=1, col=1) # Row 2 fig.add_trace(go.Scatter(x=data_pred['date'], y=data_pred['anomaly_score'], line={'width': 1, 'color': 'black'}, fill="tozeroy", mode='lines', #'lines' #'none' name="Score d'anomalie"), row=2, col=1) # Shapes anomaly shapes = [] # https://github.com/armgilles/vcub_keeper/issues/38 data_pred['no_anomalie'] = (data_pred['anomaly'] == 1) data_pred['anomaly_grp'] = data_pred['no_anomalie'].cumsum() grp = \ data_pred[data_pred['anomaly'] == -1].groupby('anomaly_grp', as_index=False)['date'].agg({'min': 'min', 'max': 'max'}) max_value = data_pred['available_bikes'].max() for idx, row in grp.iterrows(): shapes.append(dict(type="rect", xref="x", yref="y", x0=row['min'], y0=0, x1=row['max'], y1=max_value, fillcolor="red", opacity=0.7, layer="below", line_width=0 )) data_pred = data_pred.drop(['no_anomalie', 'anomaly_grp'], axis=1) # Design graph layout = dict( showlegend=True, legend=dict(orientation="h", yanchor="top", xanchor="center", y=1.2, x=0.5 ), xaxis=dict( rangeslider=dict( visible=False ), type='date', tickformat='%a %Y-%m-%d %H:%M', hoverformat='%a %Y-%m-%d %H:%M' ), yaxis={'title': 'Nombre de vélo disponible', 'title_font': {'color': 'rgba(100, 111, 251, 1)'}, 'tickfont': {'color': 'rgba(100, 111, 251, 1)'} }, yaxis2={'title': 'Absence consécutive de prise de vélo', 'title_font': {'color': 'rgba(122, 122, 122, 1)'}, #'overlaying': 'y', 'side': 'right', 'showgrid': False, 'visible': True, 'tickfont': {'color': 'rgba(122, 122, 122, 1)'} }, xaxis2=dict( rangeslider=dict( visible=False ), type='date', hoverformat='%a %Y-%m-%d %H:%M' ), yaxis3={'title': 'Score', 'title_font': {'color': 'rgba(0, 0, 0, 0.8)'}, 'range': [0, 100], #'gridwidth': 25 'tickmode': 'linear', 'tick0': 0.0, 'dtick': 25 }, template='plotly_white', hovermode='x', shapes=shapes ) fig.update_layout(layout) # Horizontal line for anomaly score fig.add_shape(go.layout.Shape(type="line", name='test', x0=data_pred['date'].min(), y0=50, x1=data_pred['date'].max(), y1=50, line=dict(color='Red', width=1, dash='dot'), #xref='x', #yref='y' ), row=2, col=1) if return_plot is True: return fig if offline_plot is False: iplot(fig) else: offline.plot(fig) if return_data is True: return data_pred
def interactive_plot_patient_time_3d(list_patients_to_keep, df, df_label, fs_id1=1, fs_id2=2, fs_id3=3, class_patient=[1, 3, 5], display=True, ): """ :param fs_id1: :param fs_id2: :param fs_id3: :param df: table_patients_mca :param df_label: df_label :param class_patient: :param display: :param list_patients_to_keep: table_patients_mca.columns.to_list() :return: """ df_copy = deepcopy(df) # deepcopy because some columns may be deleted # delete columns (patients) accroding to the list_patients_to_keep list_to_delete = select_list_to_delete_from_list_to_keep(df_copy, list_patients_to_keep) df_copy = df_copy.drop(list_to_delete, axis=1) df_label_color = apply_color_label(df_label) fs = 'Factor' points_x = df_copy.loc[(fs, fs_id1)].values points_y = df_copy.loc[(fs, fs_id2)].values points_z = df_copy.loc[(fs, fs_id3)].values labels = df_copy.columns.values coordinates_max = max(max(abs(df.loc[(fs, fs_id1)].values)), max(abs(df.loc[(fs, fs_id2)].values)), max(abs(df.loc[(fs, fs_id3)].values))) fig = go.Figure() dic_nb_patients = {} for step in np.arange(0, 5): df_label_copy = pd.DataFrame(df_label_color.iloc[:, step]) df_color = pd.DataFrame(df_label_color.loc[:, 'color' + str(step)]) df_label_copy = df_label_copy.dropna() df_color = df_color.dropna() data_ = [] dic_nb_patients[step] = 0 for i, i_patient in enumerate(df_copy.columns): if df_label_copy.loc[i_patient,][0] in class_patient or str( int(df_label_copy.loc[i_patient][0])) in class_patient: trace = go.Scatter3d( visible=False, mode='markers', marker=dict(size=10, color=df_color.loc[i_patient, 'color' + str(step)]), name='patient {}'.format(i_patient), x=[points_x[i]], y=[points_y[i]], z=[points_z[i]], hovertext=str(labels[i])) fig.add_trace(trace) dic_nb_patients[step] = dic_nb_patients[step] + 1 # Make 10th trace visible for i in range(dic_nb_patients[0]): fig.data[i].visible = True # Create and add slider steps = [] p_min = 0 # count the number of patient by time p_max = 0 for i in range(5): nb_patients = dic_nb_patients[i] # nb of points (graphs) for a period of time p_max = p_min + nb_patients step = dict( method="restyle", args=["visible", [False] * len(fig.data)], # intitialize all to false ) for j in range(p_min, p_max): step["args"][1][j] = True # Toggle i'th trace to "visible" steps.append(step) p_min = p_max sliders = [dict( active=0, currentvalue={"prefix": "Durée de suivi "}, pad={"t": 50}, steps=steps )] fig.update_layout( sliders=sliders, title="Coordonnées des patients projetés dans le plan 3D des facteurs " + str(fs_id1) + ', ' + str( fs_id2) + ' et ' + str(fs_id3), scene=dict( xaxis={"title": "facteur" + str(fs_id1), "range": [-coordinates_max - 0.1, coordinates_max + 0.1]}, yaxis={"title": "facteur" + str(fs_id2), "range": [-coordinates_max - 0.1, coordinates_max + 0.1]}, zaxis={"title": "facteur" + str(fs_id3), "range": [-coordinates_max - 0.1, coordinates_max + 0.1]}), height=600 ) offline.plot(fig, filename='Images/Patients en fonction du temps dans le plan des facteurs scores.html', # to save the figure in the repertory auto_open=False) if display: offline.iplot(fig) return None else: return fig['data'], fig['layout']
def graphFrequency(data, graphtitle, xtitle, filename): botNames = getBots() data = sorted(data, key=lambda tup: tup[2], reverse=True) # Filter out any bots bots = [x for x in data if x[3] in botNames] nobots = [x for x in data if not (x[3] in botNames)] # Filter out contributors who have been inactive for a year recent = nobots[0][4] for x in nobots: if x[4] > recent: recent = x[4] recent = datetime(recent.year - 1, recent.month, recent.day, recent.hour, recent.minute, recent.second, recent.microsecond) inactive = [x for x in nobots if x[4] < recent] active = [x for x in nobots if x[4] >= recent] # Divide the remaining list into roughly fourths # to get 25th, 50th, 75th percentiles # Up to 3 extra people may end up in the last quartile # FIXME: I'm sure there's a more Pythonic way to do this quartiles = [] chunks = int(len(active) / 4) for i in range(0, 4): if i != 3: quartiles.append(active[(chunks * i):(chunks * (i + 1))]) else: quartiles.append(active[(chunks * i):len(active) + 1]) data = [] labels = [ ('rgba(213, 94, 0, .8)', 'Top 25% of active contributors'), ('rgba(230, 159, 0, .8)', 'Above average active contributors'), ('rgba(86, 180, 233, .8)', 'Somewhat active contributors'), ('rgba(0, 114, 178, .8)', 'Least active contributors'), ] for i in range(4): data.append( Scatter(x=[coord[0] for coord in quartiles[i]], y=[coord[1] for coord in quartiles[i]], name=labels[i][1], mode='markers', text=[coord[3] for coord in quartiles[i]], marker=dict(color=labels[i][0]))) if inactive: data.append( Scatter(x=[coord[0] for coord in inactive], y=[coord[1] for coord in inactive], name='Inactive for more than 1 year', mode='markers', text=[coord[3] for coord in inactive], marker=dict(color='rgba(0, 0, 0, .8)'))) if bots: data.append( Scatter(x=[coord[0] for coord in bots], y=[coord[1] for coord in bots], name='Bots', mode='markers', text=[coord[3] for coord in bots], marker=dict(color='rgba(240, 228, 66, .8)'))) layout = Layout( title=graphtitle, yaxis=dict(title='Number of contributions'), xaxis=dict(title=xtitle), ) fig = Figure(data=data, layout=layout) return offline.plot(fig, show_link=False, include_plotlyjs=False, output_type='div')
def offline_plot(graph_object: go): """Plot a graph object to an html file""" fig = go.Figure() fig.add_trace(graph_object) offline.plot(fig, filename="chart.html")