def eda(): with st.beta_expander(label='Descripción de la sección', expanded=True): st.subheader( 'En esta sección, el usuario puede examinar y visualizar los conjuntos de datos que conforman al corpus de este estudio.' ) opcion_general = st.sidebar.radio( 'Selecciona el conjunto de datos, o el corpus general para su análisis', options=['Conjuntos de datos separados', 'Corpus general']) if opcion_general == 'Conjuntos de datos separados': opcion_clase = st.selectbox( label='Seleciona uno de los conjuntos de datos disponibles', options=['Microficciones', 'Noticias', 'Frases/Reflexiones']) if opcion_clase == 'Microficciones': datos = carga(archivo='microficciones.csv') st.dataframe(data=datos) elif opcion_clase == 'Noticias': datos = carga(archivo='noticias.csv') st.dataframe(data=datos) elif opcion_clase == 'Frases/Reflexiones': datos = carga(archivo='frases_pensamientos.csv') st.dataframe(data=datos) elif opcion_general == 'Corpus general': opcion_corpus = st.sidebar.radio( label='Seleciona el corpus sin procesar, o ya preprocesado', options=['corpus', 'corpus preprocesado'], key=1) if opcion_corpus == 'corpus': datos = carga(archivo='corpus.csv') st.dataframe(data=datos) elif opcion_corpus == 'corpus preprocesado': datos = carga(archivo='corpus_preprocesado.csv') st.dataframe(data=datos) if st.button(label='Generar nube de palabras'): nube = hero.wordcloud(datos['Texto limpio']) st.pyplot(nube) if st.button(label='Frecuencia de palabras', key=1): fig, ax = plt.subplots() ax = hero.top_words(datos['Texto limpio'], normalize=False).head(n=30).plot( kind='barh', color=[ 'C0', 'C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', 'C8', 'C9' ]) st.pyplot(fig) opcion_tipo = st.selectbox( label='Seleciona la clase de microtexto ya preprocesado', options=['Microficción', 'Noticia', 'Frase/Pensamiento']) if opcion_tipo == 'Microficción': datos_seleccionados = datos.loc[datos[opcion_tipo] == True] st.dataframe(data=datos_seleccionados) opcion_uno, opcion_dos = st.beta_columns(2) with opcion_uno: if st.checkbox(label='Nube de palabras', key=1): nube = hero.wordcloud( datos_seleccionados['Texto limpio']) st.pyplot(nube) with opcion_dos: if st.checkbox(label='Frecuencia de palabras', key=2): fig, ax = plt.subplots() ax = hero.top_words( datos_seleccionados['Texto limpio'], normalize=False).head(n=30).plot(kind='barh', color=[ 'C0', 'C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', 'C8', 'C9' ]) st.pyplot(fig) elif opcion_tipo == 'Noticia': datos_seleccionados = datos.loc[datos[opcion_tipo] == True] st.dataframe(data=datos_seleccionados) opcion_uno, opcion_dos = st.beta_columns(2) with opcion_uno: if st.checkbox(label='Nube de palabras', key=1): nube = hero.wordcloud( datos_seleccionados['Texto limpio']) st.pyplot(nube) with opcion_dos: if st.checkbox(label='Frecuencia de palabras', key=2): fig, ax = plt.subplots() ax = hero.top_words( datos_seleccionados['Texto limpio'], normalize=False).head(n=30).plot(kind='barh', color=[ 'C0', 'C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', 'C8', 'C9' ]) st.pyplot(fig) elif opcion_tipo == 'Frase/Pensamiento': datos_seleccionados = datos.loc[datos[opcion_tipo] == True] st.dataframe(data=datos_seleccionados) opcion_uno, opcion_dos = st.beta_columns(2) with opcion_uno: if st.checkbox(label='Nube de palabras', key=1): nube = hero.wordcloud( datos_seleccionados['Texto limpio']) st.pyplot(nube) with opcion_dos: if st.checkbox(label='Frecuencia de palabras', key=2): fig, ax = plt.subplots() ax = hero.top_words( datos_seleccionados['Texto limpio'], normalize=False).head(n=30).plot(kind='barh', color=[ 'C0', 'C1', 'C2', 'C3', 'C4', 'C5', 'C6', 'C7', 'C8', 'C9' ]) st.pyplot(fig)
def main(): ''' The main code for Streamlit ''' #allows us to Pick what page we want to be on st.sidebar.title("type in the stock you want to predict") stock = st.sidebar.text_input('stock name', 'Type Here') app_mode = st.sidebar.selectbox( "Choose how many months to predict", ["one month", "two months", "three months"]) if app_mode == "one month": time = 30 elif app_mode == "two months": time = 60 elif app_mode == "three months": time = 90 if stock != 'Type Here': df = data_load(stock) df_lstm = pd.DataFrame() df_lstm['close'] = df.Close #df_lstm = df_lstm.reindex(pd.date_range(df_lstm.index[0], df_lstm.index[-1]+datetime.timedelta(days=time), freq='D')).interpolate() scaler = MinMaxScaler(feature_range=(0, 1)) dataset = scaler.fit_transform(df_lstm) train, test = dataset[:-time], dataset[-time:] look_back = 1 trainX, trainY = create_dataset(train, look_back) testX, testY = create_dataset(test, look_back) trainX = np.reshape(trainX, (trainX.shape[0], 1, trainX.shape[1])) testX = np.reshape(testX, (testX.shape[0], 1, testX.shape[1])) model = Sequential() model.add(LSTM(4, input_shape=(1, look_back))) model.add(Dense(1)) model.compile(loss='mean_squared_error', optimizer='adam') model.fit(trainX, trainY, epochs=1, batch_size=1, verbose=0) trainPredict = model.predict(trainX) testPredict = model.predict(testX) trainPredict = scaler.inverse_transform(trainPredict) trainY = scaler.inverse_transform([trainY]) testPredict = scaler.inverse_transform(testPredict) testY = scaler.inverse_transform([testY]) trainPredictPlot = np.empty_like(dataset) trainPredictPlot[:, :] = np.nan trainPredictPlot[look_back:len(trainPredict) + look_back, :] = trainPredict # shift test predictions for plotting testPredictPlot = np.empty_like(dataset) testPredictPlot[:, :] = np.nan testPredictPlot[len(trainPredict) + (look_back * 2) + 1:len(dataset) - 1, :] = testPredict # plot baseline and predictions fig, ax = plt.subplots() ax.plot(df_lstm.index, scaler.inverse_transform(dataset), label='original') ax.plot(df_lstm.index, trainPredictPlot, label='trian prediction') ax.plot(df_lstm.index, testPredictPlot, label='test prediction') ax.set_xlabel('Date') ax.set_ylabel('Close Price') ax.set_title(f'{app_mode} price prediction') ax.legend() st.pyplot(fig) lstm = pd.DataFrame(testPredictPlot[-time + 1:-1]) lstm.index = df_lstm.index[-time + 1:-1] lstm.index.name = 'Date' lstm.columns = ['price'] st.table(lstm)
ax = fig.gca() # plot circle first plt.xlim(-1,1) plt.ylim(-1,1) plt.grid(linestyle='--') ax.set_aspect(1) ax.add_artist(circle) #plot our points on it plt.scatter(x_list, y_list,s=1, color='r') ax.set_ylabel("y-value", fontsize = 10) ax.set_xlabel("x-value", fontsize = 10) st.pyplot(fig) # finally lets display our estimation of Pi, the true value and the percent # difference between the two (in this example r = 1, so dont need to divide by it) estimated_pi = 4*inside_count/iterations st.write("Your Estimation of Pi:", estimated_pi) st.write("True Value of Pi:", np.pi) #calculate the percent difference from the standard: |value - true_value|/|true_value|*100% diff_percent = abs(estimated_pi-np.pi)/np.pi*100 st.write("The percent error between your estimation and the true value is:", round(diff_percent,3), "%") # lets track how the estimations change as we change the number of iterations! # actually going to add a new point to the graph for every new estimation of \pi st.header("How the Total Number of Points Affects Your Estimate") st.write("One really cool thing about Monte Carlo is as you increase \ the total number of points you use in your simulation, the more accurate your results. \
# Information of mnist dataset # (x_train, y_train), (x_test, y_test) = mnist.load_data() if st.checkbox('Show images sizes'): st.write(f'##### X Train Shape: {x_train.shape}') st.write(f'##### X Test Shape: {x_test.shape}') st.write(f'##### Y Train Shape: {y_train.shape}') st.write(f'##### Y Test Shape: {y_test.shape}') # display one random image from our training set: # st.subheader('Inspecting dataset') # if st.checkbox('Show random image from the train set'): # num = np.random.randint(0, x_train.shape[0]) # image = x_train[num] # st.image(image, caption=class_names[y_train[num]], width=96) st.write('***') if st.checkbox('Show 10 different image from the train set'): num_10 = np.unique(y_train, return_index=True)[1] # st.write(num_10) images = x_train[num_10] for i in range(len(images)): # define subplot plt.subplot(2, 5, 1 + i) #, sharey=False) # plot raw pixel data plt.imshow(images[i]) plt.title(class_names[i]) plt.xticks([]) plt.yticks([]) plt.suptitle("10 different numbers", fontsize=18) st.pyplot() # Warning
st.header('Display Player Stats of Selected Team(s)') st.write('Data Dimension: ' + str(df_selected_team.shape[0]) + ' rows and ' + str(df_selected_team.shape[1]) + ' columns.') st.dataframe(df_selected_team) # Download NBA player stats data def filedownload(df): csv = df.to_csv(index=False) b64 = base64.b64encode( csv.encode()).decode() # strings <-> bytes conversions href = f'<a href="data:file/csv;base64,{b64}" download="playerstats.csv">Download CSV File</a>' return href st.markdown(filedownload(df_selected_team), unsafe_allow_html=True) # Heatmap if st.button('Intercorrelation Heatmap'): st.header('Intercorrelation Matrix Heatmap') df_selected_team.to_csv('output.csv', index=False) df = pd.read_csv('output.csv') corr = df.corr() mask = np.zeros_like(corr) mask[np.triu_indices_from(mask)] = True with sns.axes_style("white"): f, ax = plt.subplots(figsize=(7, 5)) ax = sns.heatmap(corr, mask=mask, vmax=1, square=True) st.pyplot(f)
def speed_accuracy_test(self, path_x_train, path_y_train): h5f = h5py.File(path_x_train) self.x_train = h5f['dataset_1'][:] #st.write("Shape:",self.x_train.shape) h5f = h5py.File(path_y_train) self.y_train = h5f['dataset_1'][:] self.Predict_Neural_Network() self.prediction = np.squeeze(self.prediction) self.average_error = round( (np.mean(self.y_train - self.prediction)) * 1000000, 2) self.average_absolute_error = round( (np.mean(np.abs(self.y_train - self.prediction))) * 1000000, 2) self.maximum_error = round( np.max((np.abs(self.y_train - self.prediction)) * 1000000), 2) self.NN_Time_Taken = round(float(self.stop - self.start), 2) self.Average_Time_Taken = round( (self.NN_Time_Taken / self.x_train.shape[0]) * 1000000, 2) self.std_dev = round( (np.std(self.y_train - self.prediction)) * 1000000, 2) greater_than_one_percent = np.sum( (self.prediction - self.y_train) > 0.01) percentage_greater_than_one_percent = (np.sum( (self.prediction - self.y_train) > 0.01) / self.x_train.shape[0]) * 100.0 greater_than_half_percent = np.sum( (self.prediction - self.y_train) > 0.005) percentage_greater_than_half_percent = (np.sum( (self.prediction - self.y_train) > 0.005) / self.x_train.shape[0]) * 100.0 greater_than_quarter_percent = np.sum( (self.prediction - self.y_train) > 0.0025) percentage_greater_than_quarter_percent = (np.sum( (self.prediction - self.y_train) > 0.0025) / self.x_train.shape[0] ) * 100.0 lesser_than_one_percent = np.sum( (self.prediction - self.y_train) < -0.01) percentage_lesser_than_one_percent = (np.sum( (self.prediction - self.y_train) < -0.01) / self.x_train.shape[0]) * 100.0 lesser_than_half_percent = np.sum( (self.prediction - self.y_train) < -0.005) percentage_lesser_than_half_percent = (np.sum( (self.prediction - self.y_train) < -0.005) / self.x_train.shape[0]) * 100.0 lesser_than_quarter_percent = np.sum( (self.prediction - self.y_train) < -0.0025) percentage_lesser_than_quarter_percent = (np.sum( (self.prediction - self.y_train) < -0.0025) / self.x_train.shape[0] ) * 100.0 st.write( "For the testing dataset of ", self.x_train.shape[0], " Options, we look at the statistics of the error distribution. Therefore an error of $10,000 would correspond to a 1% error" ) st.markdown( "The error values are quoted on a notional of a million dollars") st.write("Average Absolute error: $", self.average_absolute_error, " per million") st.write("Average error: $", self.average_error, " per million") st.write("Maximum error: $", self.maximum_error, " per million") st.write("Total Time Taken to price ", self.x_train.shape[0], " options is ", self.NN_Time_Taken, " seconds") st.write("Time Taken is ", self.Average_Time_Taken, "microseconds per option") st.write("Percentage of Options with error > +/-1% : " + "{:.5%}".format( (greater_than_one_percent + lesser_than_one_percent) / self.x_train.shape[0])) st.write("Percentage of Options with error > +/-0.5% : " + "{:.5%}".format( (greater_than_half_percent + lesser_than_half_percent) / self.x_train.shape[0])) st.write("Percentage of Options with error > +/-0.25% : " + "{:.5%}".format((greater_than_quarter_percent + lesser_than_quarter_percent) / self.x_train.shape[0])) st.write( "The plot below is a distribution of the error values along with vertical lines marking the 1%, 0.5% and 0.25% error values along with " "the number and percentage of total options which have error values that exceed these bounds. Please enlarge the chart by clicking the enlarge option on the top right corner of the chart" ) a4_dims = (20, 15) fig, ax = plt.subplots(figsize=a4_dims) error = pd.DataFrame((self.prediction - self.y_train)) * 100.0 error.columns = ['Error'] error_plot = sns.kdeplot(ax=ax, data=error['Error'], shade=True) p = plt.axvline(-0.25, 0, 20, color="red") p = plt.axvline(0.25, 0, 20, color="red") p = plt.axvline(-0.5, 0, 20, color="green") p = plt.axvline(0.5, 0, 20, color="green") p = plt.axvline(-1, 0, 20, color="blue") p = plt.axvline(1, 0, 20, color="blue") p = plt.text(-1.0 + 0.02, 10.0, str(lesser_than_one_percent), fontsize=16) p = plt.text(-1.0 + 0.02, 9.0, str(round(percentage_lesser_than_one_percent, 3)), fontsize=16) p = plt.text(-0.5, 10.0, str(lesser_than_half_percent), fontsize=16) p = plt.text(-0.5, 9.0, str(round(percentage_lesser_than_half_percent, 3)), fontsize=16) p = plt.text(-0.25, 10.0, str(lesser_than_quarter_percent), fontsize=16) p = plt.text(-0.25, 9.0, str(round(percentage_lesser_than_quarter_percent, 3)), fontsize=16) p = plt.text(0.25 - 0.11, 10.0, str(greater_than_quarter_percent), fontsize=16) p = plt.text(0.25 - 0.12, 9.0, str(round(percentage_greater_than_quarter_percent, 3)), fontsize=16) p = plt.text(0.5 - 0.07, 10.0, str(greater_than_half_percent), fontsize=16) p = plt.text(0.5 - 0.09, 9.0, str(round(percentage_greater_than_half_percent, 3)), fontsize=16) p = plt.text(1.0 - 0.05, 10.0, str(greater_than_one_percent), fontsize=16) p = plt.text(1.0 - 0.05, 9.0, str(round(percentage_greater_than_one_percent, 3)), fontsize=16) st.pyplot()
with st.beta_expander("Excluded tags"): st.write(config.EXCLUDED_TAGS) # Number of tags per project st.write("---") st.subheader("Exploratory Data Analysis") num_tags_per_project = [len(tags) for tags in df.tags] num_tags, num_projects = zip(*Counter(num_tags_per_project).items()) plt.figure(figsize=(10, 3)) ax = sns.barplot(list(num_tags), list(num_projects)) plt.title("Tags per project", fontsize=20) plt.xlabel("Number of tags", fontsize=16) ax.set_xticklabels(range(1, len(num_tags) + 1), rotation=0, fontsize=16) plt.ylabel("Number of projects", fontsize=16) plt.show() st.pyplot(plt) # Distribution of tags tags = list(itertools.chain.from_iterable(df.tags.values)) tags, tag_counts = zip(*Counter(tags).most_common()) plt.figure(figsize=(10, 3)) ax = sns.barplot(list(tags), list(tag_counts)) plt.title("Tag distribution", fontsize=20) plt.xlabel("Tag", fontsize=16) ax.set_xticklabels(tags, rotation=90, fontsize=14) plt.ylabel("Number of projects", fontsize=16) plt.show() st.pyplot(plt) # Plot word clouds top top tags plt.figure(figsize=(20, 8))
def main(): """A Simple Summarization NLP App""" st.title("NLP App with Streamlit") menu = ["Home", "NLP(files)", "About"] choice = st.sidebar.selectbox("Menu", menu) if choice == "Home": st.subheader("Home: Analyse Text") raw_text = st.text_area("Enter Text Here") num_of_most_common = st.sidebar.number_input("Most Common Tokens", 5, 15) if st.button("Analyze"): with st.beta_expander("Original Text"): st.write(raw_text) with st.beta_expander("Text Analysis"): token_result_df = text_analyzer(raw_text) st.dataframe(token_result_df) with st.beta_expander("Entities"): # entity_result = get_entities(raw_text) # st.write(entity_result) entity_result = render_entities(raw_text) # st.write(entity_result) stc.html(entity_result, height=1000, scrolling=True) # Layouts col1, col2 = st.beta_columns(2) with col1: with st.beta_expander("Word Stats"): st.info("Word Statistics") docx = nt.TextFrame(raw_text) st.write(docx.word_stats()) with st.beta_expander("Top Keywords"): st.info("Top Keywords/Tokens") processed_text = nfx.remove_stopwords(raw_text) keywords = get_most_common_tokens( processed_text, num_of_most_common ) st.write(keywords) with st.beta_expander("Sentiment"): sent_result = get_sentiment(raw_text) st.write(sent_result) with col2: with st.beta_expander("Plot Word Freq"): fig = plt.figure() # sns.countplot(token_result_df['Token']) top_keywords = get_most_common_tokens( processed_text, num_of_most_common ) plt.bar(keywords.keys(), top_keywords.values()) plt.xticks(rotation=45) st.pyplot(fig) with st.beta_expander("Plot Part of Speech"): try: fig = plt.figure() sns.countplot(token_result_df["PoS"]) plt.xticks(rotation=45) st.pyplot(fig) except: st.warning("Insufficient Data: Must be more than 2") with st.beta_expander("Plot Wordcloud"): try: plot_wordcloud(raw_text) except: st.warning("Insufficient Data: Must be more than 2") with st.beta_expander("Download Text Analysis Result"): make_downloadable(token_result_df) elif choice == "NLP(files)": st.subheader("NLP Task") text_file = st.file_uploader("Upload Files", type=["pdf", "docx", "txt"]) num_of_most_common = st.sidebar.number_input("Most Common Tokens", 5, 15) if text_file is not None: if text_file.type == "application/pdf": raw_text = read_pdf(text_file) # st.write(raw_text) elif text_file.type == "text/plain": # st.write(text_file.read()) # read as bytes raw_text = str(text_file.read(), "utf-8") # st.write(raw_text) else: raw_text = docx2txt.process(text_file) # st.write(raw_text) with st.beta_expander("Original Text"): st.write(raw_text) with st.beta_expander("Text Analysis"): token_result_df = text_analyzer(raw_text) st.dataframe(token_result_df) with st.beta_expander("Entities"): # entity_result = get_entities(raw_text) # st.write(entity_result) entity_result = render_entities(raw_text) # st.write(entity_result) stc.html(entity_result, height=1000, scrolling=True) # Layouts col1, col2 = st.beta_columns(2) with col1: with st.beta_expander("Word Stats"): st.info("Word Statistics") docx = nt.TextFrame(raw_text) st.write(docx.word_stats()) with st.beta_expander("Top Keywords"): st.info("Top Keywords/Tokens") processed_text = nfx.remove_stopwords(raw_text) keywords = get_most_common_tokens( processed_text, num_of_most_common ) st.write(keywords) with st.beta_expander("Sentiment"): sent_result = get_sentiment(raw_text) st.write(sent_result) with col2: with st.beta_expander("Plot Word Freq"): fig = plt.figure() # sns.countplot(token_result_df['Token']) top_keywords = get_most_common_tokens( processed_text, num_of_most_common ) plt.bar(keywords.keys(), top_keywords.values()) plt.xticks(rotation=45) st.pyplot(fig) with st.beta_expander("Plot Part of Speech"): try: fig = plt.figure() sns.countplot(token_result_df["PoS"]) plt.xticks(rotation=45) st.pyplot(fig) except: st.warning("Insufficient Data") with st.beta_expander("Plot Wordcloud"): try: plot_wordcloud(raw_text) except: st.warning("Insufficient Data") with st.beta_expander("Download Text Analysis Result"): make_downloadable(token_result_df) else: st.subheader("About")
def main(): frontendtemplate = FrontEndTemplate() init_invoice_df = getInitDataFrame() plot_one_df = get_city_size(init_invoice_df) # TODO show sidebar showSideBar() if btn_dic['btn_datashow']: st.markdown(frontendtemplate.title_temp.format('Data View'), unsafe_allow_html=True) st.dataframe(init_invoice_df[[ 'invoice_number', 'product_name', 'quantity', 'unit_price', 'invoice_number', 'invoice_date', 'store_address', ]]) # TODO st.markdown(frontendtemplate.title_temp.format('各類別數量'), unsafe_allow_html=True) plot_cat_cal = init_invoice_df.groupby( 'cat_id')['invoice_number'].count() plot_cat_cal.plot(kind='bar', rot=85, figsize=(10, 6)) st.set_option('deprecation.showPyplotGlobalUse', False) st.pyplot() # st.bar_chart(plot_cat_cal, width=20,use_container_width=True) # st.dataframe(init_invoice_df.groupby('cat_id')['unit_price'].count()) # TODO st.markdown(frontendtemplate.title_temp.format('各載具在各類別的數量'), unsafe_allow_html=True) plot_catcnid_cal = init_invoice_df.groupby( ['carrier_number', 'cat_id'], as_index=False).size() st.dataframe(plot_catcnid_cal) # TODO st.markdown(frontendtemplate.title_temp.format('各類別在各縣市上的數量'), unsafe_allow_html=True) # TODO 分欄 left_column, right_column = st.beta_columns(2) with left_column: left_column.write("飲料沖泡") plot_one_df.loc[plot_one_df['cat_id'] == 1, ['city', 'size']].plot.bar(x='city', y='size', rot=85) left_column.pyplot() left_column.write("美食生鮮") plot_one_df.loc[plot_one_df['cat_id'] == 3, ['city', 'size']].plot.bar(x='city', y='size', rot=85) left_column.pyplot() left_column.write("居家生活") plot_one_df.loc[plot_one_df['cat_id'] == 5, ['city', 'size']].plot.bar(x='city', y='size', rot=85) left_column.pyplot() left_column.write("家電") plot_one_df.loc[plot_one_df['cat_id'] == 7, ['city', 'size']].plot.bar(x='city', y='size', rot=85) left_column.pyplot() left_column.write("零食") plot_one_df.loc[plot_one_df['cat_id'] == 9, ['city', 'size']].plot.bar(x='city', y='size', rot=85) left_column.pyplot() left_column.write("菸酒") plot_one_df.loc[plot_one_df['cat_id'] == 13, ['city', 'size']].plot.bar(x='city', y='size', rot=85) left_column.pyplot() left_column.write("生活休閒") plot_one_df.loc[plot_one_df['cat_id'] == 15, ['city', 'size']].plot.bar(x='city', y='size', rot=85) left_column.pyplot() with right_column: right_column.write("麵食料理") plot_one_df.loc[plot_one_df['cat_id'] == 2, ['city', 'size']].plot.bar(x='city', y='size', rot=85) right_column.pyplot() right_column.write("保健生機") plot_one_df.loc[plot_one_df['cat_id'] == 4, ['city', 'size']].plot.bar(x='city', y='size', rot=85) right_column.pyplot() right_column.write("美容保養") plot_one_df.loc[plot_one_df['cat_id'] == 6, ['city', 'size']].plot.bar(x='city', y='size', rot=85) right_column.pyplot() right_column.write("箱包服飾") plot_one_df.loc[plot_one_df['cat_id'] == 8, ['city', 'size']].plot.bar(x='city', y='size', rot=85) right_column.pyplot() right_column.write("其他") plot_one_df.loc[plot_one_df['cat_id'] == 10, ['city', 'size']].plot.bar(x='city', y='size', rot=85) right_column.pyplot() right_column.write("3C") plot_one_df.loc[plot_one_df['cat_id'] == 12, ['city', 'size']].plot.bar(x='city', y='size', rot=85) right_column.pyplot() right_column.write("寵物專區") plot_one_df.loc[plot_one_df['cat_id'] == 14, ['city', 'size']].plot.bar(x='city', y='size', rot=85) right_column.pyplot() if btn_dic['btn_predict']: classifierName = ClassifierByName(df=init_invoice_df) result = classifierName.testByData([getproductword]) st.markdown(frontendtemplate.title_temp.format('預測結果'), unsafe_allow_html=True) st.markdown( """<h3 style="color:#0877E3;font-weight:bold;">準確率為:0.9633427718680646</h3>""", unsafe_allow_html=True) outputHtml = predictShow(getproductword, result[0]) st.markdown(outputHtml, unsafe_allow_html=True) st.markdown( """<h3 style="color:#0877E3;font-weight:bold;">各類別數據量</h3>""", unsafe_allow_html=True) catval_df = dfValueCount(init_invoice_df) catval_df.value_counts().plot(kind='bar', rot=85, figsize=(10, 6)) st.set_option('deprecation.showPyplotGlobalUse', False) st.pyplot() if btn_dic['btn_rec']: invoice_afterFilter_df, resdf, final_dict = getFilterDataFrame( init_invoice_df, selected_cat_list, getwordListStr) # TODO 主頁 st.markdown(frontendtemplate.title_temp.format('此次查詢Infos'), unsafe_allow_html=True) st.subheader("此次查詢共{}筆".format(invoice_afterFilter_df.shape[0])) st.dataframe(invoice_afterFilter_df[[ 'invoice_number', 'product_name', 'store_address', 'quantity', 'unit_price', ]]) # # 分群資料 # st.dataframe(resdf.head(25)) group_users_cal_dict = resdf.set_index(['group_name' ])['users'].to_dict() group_users_count_dict = resdf.set_index(['group_name' ])['users_count'].to_dict() # # 分群人數資料 # st.write(group_users_cal_dict) # TODO 分欄 left_column, right_column = st.beta_columns(2) # Or even better, call Streamlit functions inside a "with" block: with left_column: left_column.markdown(frontendtemplate.title_temp.format('曾經購買'), unsafe_allow_html=True) used_buy_items = final_dict['used_buy'] # left_column.write(used_buy_items) for item in used_buy_items: card_temp_body = "" group_name = item['group_name'] result = item['result'] outputHtmlList = imageListShow(result) for item in outputHtmlList: card_temp_body += item # print(type(group_users_cal_dict[group_name])) group_users_cal_dict[group_name] = group_users_cal_dict[ group_name].replace('\r', '\\r').replace('\n', '\\n') # users_list = json.loads(group_users_cal_dict[group_name], strict=False) # print(users_list) card_temp = frontendtemplate.card_temp_up + card_temp_body + frontendtemplate.card_temp_down left_column.markdown(card_temp.format( '#F6800A', group_name, group_users_count_dict[group_name]), unsafe_allow_html=True) with right_column: right_column.markdown(frontendtemplate.title_temp.format('未來可能購買'), unsafe_allow_html=True) feature_buy_items = final_dict['feature_buy'] # right_column.write(feature_buy_items) for item in feature_buy_items: card_temp_body = "" group_name = item['group_name'] result = item['result'] outputHtmlList = imageListShow(result) for item in outputHtmlList: card_temp_body += item card_temp = frontendtemplate.card_temp_up + card_temp_body + frontendtemplate.card_temp_down right_column.markdown(card_temp.format( '#03b6fc', group_name, group_users_count_dict[group_name]), unsafe_allow_html=True)
def page_viewer(): st.write( 'Viewer for VTK file in [XML format](https://vtk.org/Wiki/VTK_XML_Formats) (Unstructured grid)' ) base_dir = st.text_input('Input base dir', '.') file_buffer = st.file_uploader("or upload .vtu file", type=None, encoding=None) if file_buffer: content_byte = file_buffer.read() content_decoded = content_byte.decode('utf-8') file_path = './result.vtu' with open(file_path, mode='w') as f: f.write(content_decoded) files = [] files.append(file_path) else: files = [ f.name for f in os.scandir(base_dir) if re.search(r'\d+', f.name) ] headers = list( set([re.sub(r'\d+$', '', f.rsplit('.')[0]) for f in files])) header = st.sidebar.selectbox('Select header', headers) files = [ os.path.join(base_dir, f) for f in files if re.fullmatch(header, re.sub(r'\d+$', '', f.rsplit('.')[0])) is not None ] files.sort(key=lambda s: int(re.search(r'\d+', s).group())) # VTK Reader reader = VtkReader() # Read first data try: reader.read(files[0]) except Exception: st.error('Invalid file format') return data_dict = reader.get_data_dict() c0_xmin = np.min(reader.Coords[0, :]) c0_xmax = np.max(reader.Coords[0, :]) c0_ymin = np.min(reader.Coords[1, :]) c0_ymax = np.max(reader.Coords[1, :]) # Read last data reader.read(files[-1]) cn_xmin = np.min(reader.Coords[0, :]) cn_xmax = np.max(reader.Coords[0, :]) cn_ymin = np.min(reader.Coords[1, :]) cn_ymax = np.max(reader.Coords[1, :]) # Set display area domain = {} domain['xmin'] = min(c0_xmin, cn_xmin) domain['xmax'] = max(c0_xmax, cn_xmax) domain['ymin'] = min(c0_ymin, cn_ymin) domain['ymax'] = max(c0_ymax, cn_ymax) len_x = domain['xmax'] - domain['xmin'] len_y = domain['ymax'] - domain['ymin'] domain['xmin'] -= 0.1 * len_x domain['xmax'] += 0.1 * len_x domain['ymin'] -= 0.1 * len_y domain['ymax'] += 0.1 * len_y domain['aspect'] = (domain['ymax'] - domain['ymin']) / (domain['xmax'] - domain['xmin']) # Get data list data_dict = reader.get_data_dict() # Get value list values = list(data_dict.keys()) value = st.sidebar.selectbox('Select value', values) if value is not None: # Set system systems = [i + 1 for i in range(data_dict[value])] system = st.sidebar.selectbox('Select system', systems) display_mode = st.sidebar.selectbox('Select mode', ['Frame', 'Animation']) if display_mode == 'Frame': step = st.sidebar.number_input( f'Step No. 0 to {len(files) - 1}', min_value=0, max_value=len(files) - 1, value=0, step=1, ) st.info('Value: {} System: {} Step: {}/{}'.format( value, system, step, len(files) - 1)) reader.read(files[step]) val = reader.get_value(value, system=system) drawer = DrawMesh() fig = plt.figure() ax = fig.add_subplot(1, 1, 1) drawer.set_domain(ax, domain=domain) drawer.draw(coords=reader.Coords, connectivity=reader.Lnodes, value=val) st.pyplot(plt) elif display_mode == 'Animation': drawer = DrawMesh() fig = plt.figure() ax = fig.add_subplot(1, 1, 1) drawer.set_domain(ax, domain=domain) latest_iteration = st.empty() bar = st.progress(0) stplot = st.pyplot(plt) def animate(istep): reader.read(files[istep]) val = reader.get_value(value, system=system) drawer.draw(coords=reader.Coords, connectivity=reader.Lnodes, value=val) stplot.pyplot(plt) latest_iteration.text(f'Step: {istep}') bar.progress((istep + 1) / len(files)) for istep in range(len(files)): animate(istep) time.sleep(0.005)
def plot_wordcloud(my_text): my_wordcloud = WordCloud().generate(my_text) fig = plt.figure() plt.imshow(my_wordcloud, interpolation="bilinear") # plt.axis('off') st.pyplot(fig)
# Main Panel # Print specified input parameters st.header('Specified Input parameters') st.write(df) st.write('---') # Load Fitted-Model model = pickle.load(open('doc/boston_clf.pkl', 'rb')) # Prediction prediction = model.predict(df) st.header('Prediction of MEDV') st.write(prediction) st.write('---') # Explaining the model's predictions using SHAP values # https://github.com/slundberg/shap explainer = shap.TreeExplainer(model) shap_values = explainer.shap_values(X) st.header('Feature Importance') st.set_option('deprecation.showPyplotGlobalUse', False) plt.title('Feature importance based on SHAP values') shap.summary_plot(shap_values, X) st.pyplot(bbox_inches='tight') st.write('---') plt.title('Feature importance based on SHAP values (Bar)') shap.summary_plot(shap_values, X, plot_type="bar") st.pyplot(bbox_inches='tight')
def run_cluster_app(): st.header('■Cluster Analysis') st.write('- To group students with similar learning characteristics.') st.sidebar.subheader('Data upload') df_edu = pd.read_csv("data/eng_sample_data_cluster.csv") def download_link(object_to_download, download_filename, download_link_text): if isinstance(object_to_download,pd.DataFrame): object_to_download = object_to_download.to_csv(index=False, encoding = 'utf_8_sig') b64 = base64.b64encode(object_to_download.encode()).decode() return f'<a href="data:file/txt;base64,{b64}" download="{download_filename}">{download_link_text}</a>' tmp_download_link = download_link(df_edu, 'sample_cluster.csv', 'Download sample csv file.') st.sidebar.markdown(tmp_download_link, unsafe_allow_html=True) # st.sidebar.info(""" # [Download the sample csv file](https://github.com/59er/eng_learning_analytics_web/blob/master/sample_data/eng_sample_data_cluster_for_WEB.csv) # """) try: uploaded_file = st.sidebar.file_uploader("File upload (Drag and drop or use [Browse files] button to import csv file. Only utf-8 format is available.)", type=["csv"]) # uploaded_file = st.file_uploader( # label = 'File Upload(drag and drop csv/Excel)', # type = ['csv', 'xlsx'] # ) if uploaded_file is not None: df_edu = pd.read_csv(uploaded_file) uploaded_file.seek(0) display_data = st.sidebar.checkbox(label = 'Show uploaded data') if display_data: st.dataframe(df_edu) # df_edu.columns = ['','Literature','History','Math','Physics'] # st.write(df_edu.columns) dat_i = df_edu.set_index('ID') dat_i.describe().round(2) dat_i.mean(axis=1) pred = KMeans(n_clusters = 3).fit_predict(dat_i) dat_i1 = dat_i.copy() dat_i1['cluster_id'] = pred dat_i1['cluster_id'].value_counts() # z = linkage(dat_i, metric = 'euclidean', method = 'ward') # st.set_option('deprecation.showPyplotGlobalUse', False) # fig = plt.figure(figsize = (12,6), facecolor = 'w') # ax = fig.add_subplot(title= '樹形図: 全体') # dendrogram(z) # st.pyplot(fig) st.set_option('deprecation.showPyplotGlobalUse', False) st.write(sns.clustermap(dat_i,col_cluster = False, cmap='Blues', linewidth=.5)) st.pyplot() else: df_edu = pd.read_csv('data/eng_sample_data_cluster.csv') show_df = st.sidebar.checkbox('Show DataFreme') if show_df == True: st.write(df_edu) df_edu.columns = ['','Literature','Reading','History','Math','Physics'] dat_i = df_edu.set_index('') dat_i.describe().round(2) dat_i.mean(axis=1) pred = KMeans(n_clusters = 3).fit_predict(dat_i) dat_i1 = dat_i.copy() dat_i1['cluster_id'] = pred dat_i1['cluster_id'].value_counts() # z = linkage(dat_i, metric = 'euclidean', method = 'ward') # st.set_option('deprecation.showPyplotGlobalUse', False) # fig = plt.figure(figsize = (12,6), facecolor = 'w') # ax = fig.add_subplot(title= '樹形図: 全体') # dendrogram(z) # st.pyplot(fig) st.set_option('deprecation.showPyplotGlobalUse', False) st.write(sns.clustermap(dat_i,col_cluster = False, cmap='Blues', linewidth=.5)) st.pyplot() st.write('This example suggests that there are two groups: those who are good at humanities subjects and those who are good at science subjects.') except Exception as e: st.header('ERROR: Data inconsistency. Check data format to be uploaded.') print('Data inconsistency error')
def files(data): if data is not None: df = pd.read_csv(data) st.dataframe(df.head()) if st.checkbox("Show Shape"): st.write(df.shape) if st.checkbox("Show Columns"): st.write(df.columns) if st.checkbox("Show Full dataframe"): pd.set_option("display.max_rows", None, "display.max_columns", None) st.write(df) if st.checkbox("Show Statistics"): st.write(df.describe()) if st.checkbox("Show Selected Columns"): mult_col = st.multiselect("Select Columns", df.columns) cols = df[mult_col] st.write(cols) if st.checkbox("Show Count of Unique values"): st.write(df.nunique().to_frame('counts')) if st.checkbox("Show Value Counts"): option = st.selectbox("Select Columns", df.columns) for i in df.columns: if i == option: st.write(df[i].value_counts().rename_axis( 'unique values').to_frame('counts')) if st.checkbox("Check Null values"): st.write(df.isnull().sum()) var = ["Numerical", "Categorical"] st.info("Handle Missing values") select = st.selectbox("Select Varaibles", var) if var[0] == select: opt = st.radio("Fill with ", ("Mean", "Median")) if opt == "Mean": st.write(df.fillna(df.mean)) else: st.write(df.fillna(df.median)) else: opt = st.radio("Fill with ", ("Most common class", "Unknown variable")) if opt == "Most common class": st.write( df.apply( lambda x: x.fillna(x.value_counts().index[0]))) else: text = st.text_input("Enter a variable or text to fill") st.write(df.fillna(text)) if st.checkbox("Correlation Plot"): st.write(sns.heatmap(df.corr(), annot=True)) st.pyplot() st.subheader("Plots") def plots(df): type_of_plot = st.selectbox("Select Type of Plot", ["Area", "Bar", "Line", "Hist", "Box"]) selected_columns_names = st.multiselect("Select Columns To Plot", df.columns) if st.button("Plot"): st.success("Plotted {} plot for {}".format( type_of_plot, selected_columns_names)) if type_of_plot == 'Area': cust_data = df[selected_columns_names] st.area_chart(cust_data) elif type_of_plot == 'Bar': cust_data = df[selected_columns_names] st.bar_chart(cust_data) elif type_of_plot == 'Line': cust_data = df[selected_columns_names] st.line_chart(cust_data) elif type_of_plot: cust_plot = df[selected_columns_names].plot( kind=type_of_plot) st.write(cust_plot) st.pyplot() st.markdown("#### Relationship") plot_type = st.selectbox("Select Type of Plot", ["Count", "Box", "Violin", "Swarm"]) column1 = st.selectbox("Select the x axis", df.columns) column2 = st.selectbox("Select the y axis", df.columns) if st.button("Generate Plot"): st.success("Plotted {} plot".format(type_of_plot)) if plot_type == "Count": st.warning( "Note: You dont need to select y axis for this plot") st.write(sns.countplot(data=df, x=column1)) st.pyplot() elif plot_type == "Box": st.write(sns.boxplot(data=df, x=column1, y=column2)) st.pyplot() elif plot_type == "Violin": st.write(sns.violinplot(data=df, x=column1, y=column2)) st.pyplot() else: st.write(sns.swarmplot(data=df, x=column1, y=column2)) st.pyplot() plots(df)
def main(): """ BPX Energy """ st.title("BPX Energy LE Forecast Tool") st.subheader("SoHa Change Dev/Test") html_temp = """ <div style="background-color:green;"><p style="color:white;font-size:50px;padding:10px">LE Forecast Application</p></div> """ st.markdown(html_temp, unsafe_allow_html=True) def file_selector(folder_path='./datasets'): filenames = os.listdir(folder_path) selected_filename = st.selectbox("Select A file", filenames) return os.path.join(folder_path, selected_filename) filename = file_selector() st.info("You Selected {}".format(filename)) # Read Data df = pd.read_csv(filename) # Show Dataset if st.checkbox("Show Dataset"): number = st.number_input("Number of Rows to View") st.dataframe(df.head(n=1000)) # Show Columns if st.button("Column Names"): st.write(df.columns) # Show Shape if st.checkbox("Shape of Dataset"): data_dim = st.radio("Show Dimension By ", ("Rows", "Columns")) if data_dim == 'Rows': st.text("Number of Rows") st.write(df.shape[0]) elif data_dim == 'Columns': st.text("Number of Columns") st.write(df.shape[1]) else: st.write(df.shape) # Select Columns if st.checkbox("Select Columns To Show"): all_columns = df.columns.tolist() selected_columns = st.multiselect("Select", all_columns) new_df = df[selected_columns] st.dataframe(new_df) # Show Values if st.button("Value Counts"): st.text("Value Counts By Target/Class") st.write(df.iloc[:, -1].value_counts()) # Show Datatypes if st.button("Data Types"): st.write(df.dtypes) # Show Summary if st.checkbox("Summary"): st.write(df.describe().T) ## Plot and Visualization st.subheader("Data Visualization") # GFOz if st.checkbox("GFOz[Bokeh]"): st.text("GFOz vs actuals [LE]") if st.checkbox("Chart LE"): st.text("Value of LE Curve") all_columns_names = df.columns.tolist() primary_col = st.selectbox("Primary Columm to GroupBy", all_columns_names) selected_columns_names = st.multiselect("Select Columns", all_columns_names) if st.button("Chart"): st.text("Generate Chart") if selected_columns_names: bokeh_chart = df.groupby( primary_col)[selected_columns_names].count() else: bokeh_chart = df.iloc[:, -1].value_counts() st.write(bokeh_chart.plot(kind="line")) st.bokeh_chart() # Pie Chart if st.checkbox("Pie Plot"): all_columns_names = df.columns.tolist() if st.button("Generate Pie Plot"): st.success("Generating A Pie Plot") st.write(df.iloc[:, -1].value_counts().plot.pie(autopct="%1.1f%%")) st.pyplot() # Count Plot if st.checkbox("Plot of Value Counts"): st.text("Value Counts By Target") all_columns_names = df.columns.tolist() primary_col = st.selectbox("Primary Columm to GroupBy", all_columns_names) selected_columns_names = st.multiselect("Select Columns", all_columns_names) if st.button("Plot"): st.text("Generate Plot") if selected_columns_names: vc_plot = df.groupby( primary_col)[selected_columns_names].count() else: vc_plot = df.iloc[:, -1].value_counts() st.write(vc_plot.plot(kind="bar")) st.pyplot() # Customizable Plot st.subheader("Customizable Plot") all_columns_names = df.columns.tolist() type_of_plot = st.selectbox("Select Type of Plot", ["area", "bar", "line", "hist", "box", "kde"]) selected_columns_names = st.multiselect("Select Columns To Plot", all_columns_names) if st.button("Generate Plot"): st.success("Generating Customizable Plot of {} for {}".format( type_of_plot, selected_columns_names)) # Plot By Streamlit if type_of_plot == 'area': cust_data = df[selected_columns_names] st.area_chart(cust_data) elif type_of_plot == 'bar': cust_data = df[selected_columns_names] st.bar_chart(cust_data) elif type_of_plot == 'line': cust_data = df[selected_columns_names] st.line_chart(cust_data) # Custom Plot elif type_of_plot: cust_plot = df[selected_columns_names].plot(kind=type_of_plot) st.write(cust_plot) st.pyplot() if st.button("SoHa Change"): st.balloons() st.sidebar.header("LE Utility Tool") st.sidebar.info( "The LE & Forecast Utility is a tool meant to improve the speed & consistency of production reporting for operations PEs." ) st.sidebar.header("Get Datasets") st.sidebar.markdown("[Common ML Dataset Repo](" ")") st.sidebar.header("Developed By") st.sidebar.info("*****@*****.**") st.sidebar.info("*****@*****.**") st.sidebar.text("SoHa Change Team lead: Kellen McLoughlin") st.sidebar.text("Web App maintained by MarkusJBPX")
def main(): xw = st.sidebar.slider('bottoms concentration', .04, .99, .058) xf = st.sidebar.slider('Feed concentration', .04, .99, .45) yd = st.sidebar.slider('Top concentration', .04, .99, .9) rv= st.sidebar.slider('Relative volatality', 1.5, 10.0, 3.0) q = st.sidebar.slider('vapour liquid ratio', .04, .99, .33) mul = st.sidebar.slider('Multiplies R mini', 1.0, 10.0, 2.0) x1 = np.linspace(0, 1, 11) y1 = np.linspace(0, 1, 11) xe = np.linspace(0, 1, 100) ye = rv * xe / (1 + (rv - 1) * xe) plt.plot(xe, ye) plt.plot(x1, y1) m1 = (-q / (1 - q)) n1 = (xf / (1 - q)) a = (m1 * rv - m1) b = (m1 + n1 * rv - n1 - rv) c = n1 xd = yd yw = xw yf = xf x3 = (-b - math.sqrt(b ** 2 - 4 * a * c)) / (2 * a) x4 = (-b - math.sqrt(b ** 2 - 4 * a * c)) / (2 * a) if x3 > 0: p = x3 l = (m1 * p) + n1 elif x3 < 0: y = 0 elif x4 > 0: p = x4 l = (m1 * p) + n1 elif x4 < 0: u = 0 rm = (xd - l) / (l - p) R = rm * mul n2 = xd / (R + 1) m2 = (yd - n2) / yd mx = (n1 - n2) / (m2 - m1) my = (m1 * mx) + n1 c = (my - yw) / (mx - xw) xs = np.linspace(xw, mx, 11) ys = c * (xs - xw) + yw xo = np.linspace(mx, yd, 11) yo = m2 * xo + n2 xfe = np.linspace(mx, xf, 11) yfe = (m1 * xfe) + n1 plt.plot(xfe, yfe) plt.plot(xo, yo) plt.plot(xs, ys) plt.xlabel("x") plt.ylabel("y") matplotlib.pyplot.annotate("yd", (xd, yd)) matplotlib.pyplot.annotate("xw", (xw, yw)) matplotlib.pyplot.annotate("xf", (xf, yf)) h = np.zeros(20) t = np.zeros(20) c = yd v = (yd - my) / (yd - mx) z = (my - xw) / (mx - xw) for i in range(1, 20): h[0] = yd t[0] = yd h[i] = c / (rv * (1 - c) + c) if h[i] < xw: gh = i st.write("Number of stages in distillation cloumn=",gh-1) break; else: if h[i] > mx: t[i] = v * (h[i] - mx) + my c = t[i] else: t[i] = z * (h[i] - xw) + xw c = t[i] for i in range(gh - 1): gy = np.linspace(h[i + 1], h[i], gh + 1) hu = np.ones(gh + 1) * t[i] plt.plot(gy, hu, 'r') ay = np.linspace(t[i], t[i + 1], gh + 1) au = np.ones(gh + 1) * h[i + 1] plt.plot(au, ay, 'r') sns.set_style("darkgrid") st.pyplot()
def app(im): """Page App""" width, choice = app_sidebar() if im is not None: if choice == "Bilevel": img = im.convert("1") elif choice == "Greyscale": img = im.convert("L") elif choice == "Contrast": factor = st.sidebar.slider(choice, 0.0, 3.0, 1.0) enhancer = ImageEnhance.Contrast(im) img = enhancer.enhance(factor) elif choice == "Brightness": factor = st.sidebar.slider(choice, 0.0, 3.0, 1.0) enhancer = ImageEnhance.Brightness(im) img = enhancer.enhance(factor) elif choice == "Colorpick": arr = np.array(im.convert("RGB")) hsv = cv2.cvtColor(arr, cv2.COLOR_BGR2HSV) a, b = st.sidebar.slider(choice, 0, 255, (0, 255)) img_mask = cv2.inRange(hsv, np.ones(3) * a, np.ones(3) * b) img = cv2.bitwise_and(arr, arr, mask=img_mask) elif choice == "Canny": arr = np.array(im.convert("RGB")) gray = cv2.cvtColor(arr, cv2.COLOR_BGR2GRAY) a, b = st.sidebar.slider(choice, 0, 500, (200, 400)) img = cv2.Canny(gray, a, b) img = signature(img) elif choice == "Hist": from matplotlib import pyplot as plt arr = np.array(im.convert("RGB")) for i, col in enumerate(("b", "g", "r")): histr = cv2.calcHist([arr], [i], None, [256], [0, 256]) plt.plot(histr, color=col) plt.xlim([0, 256]) st.pyplot() elif choice == "Kuwahara": # https://en.wikipedia.org/wiki/Kuwahara_filter # https://qiita.com/Cartelet/items/5c1c012c132be3aa9608 r = st.sidebar.slider(choice, 5, 50, 5, 5) arr = np.array(im.convert("RGB")) h, w, _ = arr.shape img = np.empty_like(arr) arr = np.pad(arr, ((r, r), (r, r), (0, 0)), "edge") ave, var = cv2.integral2(arr) ave_mask = (ave[:-r - 1, :-r - 1] + ave[r + 1:, r + 1:] - ave[r + 1:, :-r - 1] - ave[:-r - 1, r + 1:]) ave = ave_mask / (r + 1)**2 var_mask = (var[:-r - 1, :-r - 1] + var[r + 1:, r + 1:] - var[r + 1:, :-r - 1] - var[:-r - 1, r + 1:]) var = (var_mask / (r + 1)**2 - ave**2).sum(axis=2) for i in range(h): for j in range(w): a1, b1, c1, d1, = ( ave[i, j], ave[i + r, j], ave[i, j + r], ave[i + r, j + r], ) a2, b2, c2, d2, = ( var[i, j], var[i + r, j], var[i, j + r], var[i + r, j + r], ) img[i, j] = np.array([a1, b1, c1, d1])[np.array([a2, b2, c2, d2]).argmin()] img = signature(img) try: st.image(img, width=width) except UnboundLocalError: st.image(im, width=width)
from db_handler import get_market_tracker game = st.Game() user = st.get_user("JimHawkins") sl.title("Hi, " + user.username) # Display the different planets in a table sl.title("OE System") OE = pd.DataFrame(game.systems[0]['locations']) OE fig, ax = plt.subplots(figsize=(12,12)) ax.scatter(OE.x, OE.y) OE[['x','y','name']].apply(lambda x: ax.text(*x),axis=1) sl.pyplot(fig) # Display the entire Market Tracker Database sl.title("Market Tracker") market = get_market_tracker() market # Plot how the sell price of a good on each planet has changed over time """ # Sell Price of Goods Over Time *Use the dropdown to select the good to graph* """ good = sl.selectbox('Select', market.symbol.unique()) good_mask = market['symbol'] == good fig = plt.figure()
# Age vs Pregnancies st.header('Pregnancy count Graph (Others vs Yours)') fig_preg = plt.figure() ax1 = sns.scatterplot(x='Age', y='Pregnancies', data=df, hue='Outcome', palette='Greens') ax2 = sns.scatterplot(x=user_data['age'], y=user_data['pregnancies'], s=150, color=color) plt.xticks(np.arange(10, 100, 5)) plt.yticks(np.arange(0, 20, 2)) plt.title('0 - Healthy & 1 - Unhealthy') st.pyplot(fig_preg) # Age vs Glucose st.header('Glucose Value Graph (Others vs Yours)') fig_glucose = plt.figure() ax3 = sns.scatterplot(x='Age', y='Glucose', data=df, hue='Outcome', palette='magma') ax4 = sns.scatterplot(x=user_data['age'], y=user_data['glucose'], s=150, color=color) plt.xticks(np.arange(10, 100, 5)) plt.yticks(np.arange(0, 220, 10))
lb_dict = {} lb_name = [] lb_num = [] for i in lb: lb_dict.update({i: lb_list.count(i)}) lb2 = sorted(lb_dict.items(), key=lambda lb_dict: lb_dict[1], reverse=True) for i in range(0, len(lb2)): lb_num.append(lb2[i][1]) lb_name.append(lb2[i][0]) fig = plt.figure(figsize=(15, 8)) plt.bar(range(0, len(lb_num)), lb_num, color='pink') plt.plot(range(0, len(lb_num)), lb_num, color='lightblue') plt.title("当日反馈类型统计", fontsize=24) plt.xticks(range(0, len(lb_num)), lb_name, rotation=60, fontsize=12) plt.rcParams['font.sans-serif'] = ['SimHei'] st.pyplot(fig) fig2 = plt.figure(figsize=(10, 6)) lb = list(set(df2['记录人'].values)) lb_list = list(df2['记录人'].values) lb_dict = {} lb_name = [] lb_num = [] for i in lb: lb_dict.update({i: lb_list.count(i)}) lb2 = sorted(lb_dict.items(), key=lambda lb_dict: lb_dict[1], reverse=True) for i in range(0, len(lb2)): lb_num.append(lb2[i][1]) lb_name.append(lb2[i][0]) colors = [ '#F08080', '#FFB6C1', '#B0E0E6', '#ADD8E6', 'lightblue', 'pink', 'cyan'
def main(): st.title('Iris EDA APP') st.subheader('EDA Web App with Streamlit') st.markdown(""" #### Description + This is a simple Exploratory Data Analysis of the Iris Dataset depicting the various species built with Streamlit. #### Purpose + To show a simple EDA of Iris using Streamlit framework. """) #code beloow my_dataset = "iris.csv" @st.cache(persist=True) def explore_data(dataset): df = pd.read_csv(os.path.join(dataset)) return df # load the dataset data = explore_data(my_dataset) if st.checkbox("Preview DataFrame"): if st.button("Head"): st.write(data.head()) if st.button("Tail"): st.write(data.tail()) else: st.write(data.head(2)) # Show Entire DataFrame if st.checkbox("Show All DataFrame"): st.dataframe(data) #Show All Columns Name if st.checkbox("Show All Column Names"): st.text("Columns:") st.write(data.columns) data_dim = st.radio('What Dimension Do you want to show',('Rows','Columns')) if data_dim == 'Rows': st.text("Showing Length of Rows") st.write(len(data)) if data_dim == 'Column': st.text("Showing Length of Columns") st.write(data.shape[1]) # SHow summary of Dataset if st.checkbox("Show Summary of Dataset") st.write(data.describe()) species_option = st.selectbox('Select Columns',('sepal_length','sepal_width','petal_length','petal_width','species')) if species_option == 'sepal_length': st.write(data['sepal_length']) elif species_option =='sepal_width': st.write(data['sepal_width']) elif species_option =='petal_length': st.write(data['petal_length']) elif species_option =='petal_width': st.write(data['petal_width']) elif species_option =='species': st.write(data['species']) else: st.write("Select A Column") #show plots if st.checkbox("Simple bar plot with Matplotlib"): data.plot(kind='bar') st.pyplot() if st.checkbox("Simple Correlation with Matplotlib"): plt.matshow(data.corr()) st.pyplot() if st.checkbox("Simple Correlation with Seaborn"): st.write(sns.heatmap(data.corr(),annot=True)) st.pyplot() #Show plots if st.checkbox("Bar plot of Groups or Counts"): v_counts = data.groupby('species') st.bar_chart(v_counts) #Iris Image Manipulation @st.cache def load_img(img): im = Image.open(os.path.join(img)) return im species_type = st.radio('What is the Iris Species do you want to see?',('Satosa','Versicolor','Virginica')) if species_type =='Setosa': st.text("Showing Iris Setosa") st.image(load_img('imgs/iris_setosa.jpg')) elif species_type =='Versicolor': st.text("Showing Iris Versicolor") st.image(load_img('imgs/iris_versicolor.jpg')) elif species_type == 'Virginica': st.text("Showing Iris Virginica") st.image(load_img('imgs/iris_virginica.jpg')) # Show Image or Hide Image with Checkbox if st.checkbox("Show Image/Hide Image"): my_image = load_image('iris_setosa.jpg') enh = ImageEnhance.Contrast(my_image) num = st.slider("Set Your Contrast Number", 1.0, 3.0) img_width = st.slider("Set Image Width", 300, 500) st.image(enh.enhance(num), width=img_width) # About if st.button("About App"): st.subheader("Iris Dataset EDA App") st.text("Built with Streamlit") st.text("Thanks to the Streamlit Team Amazing Work") if st.checkbox("By"): st.text("Ehtisham Raza") st.text("*****@*****.**")
var3 = group_by_1[mask]['Girl Power'].unique()[0] var4 = group_by_1[mask]['Gotheim'].unique()[0] var5 = group_by_1[mask]['Boy Power'].unique()[0] # Pie chart labels = ['Les Gaulois','Girl Power','Gotheim','Boy Power' , 'Just For Fun' ] sizes = [var1,var2,var3,var4,var5] colors = ['red','lightcoral','darkorange','cornflowerblue','royalblue'] fig1, ax1 = plt.subplots() title1 = "<h2 style='text-align: center; color: grey;'>Répartition des votes par groupe politique</h2></br><h3 style='text-align: center; color: grey;'>Département : "+dept+" </br> Année "+str(annee)+" - "+tour_label+"</h3>" st.markdown(title1, unsafe_allow_html=True) ax1 = plt.pie(sizes, labels=labels, autopct='%1.1f%%', colors=colors, startangle=90) st.pyplot(clear_figure=False) # Equal aspect ratio ensures that pie is drawn as a circle title2 = "<h2 style='text-align: center; color: grey;'>Abstention</h2></br><h3 style='text-align: center; color: grey;'>Département : "+dept+" </br> Année "+str(annee)+" - "+tour_label+"</h3>" st.markdown(title2, unsafe_allow_html=True) var1 = toto[mask]['Inscrits'].unique()[0] - toto[mask]['Votants'].unique()[0] var2 = toto[mask]['Inscrits'].unique()[0] # Pie chart labels = ['Abstentionnistes','Votants'] sizes = [var1,var2] colors = ['mediumpurple','cadetblue'] fig, ax2 = plt.subplots() ax2 = plt.pie(sizes, labels=labels, autopct='%1.1f%%', colors=colors, startangle=90) st.pyplot(clear_figure=False) # Equal aspect ratio ensures that pie is drawn as a circle
###############################################---------------------------------- elif page == options[1]: #if the second page is selected st.header('Firearm Alarm in Action') st.text('For how long would you like Firearm Alarm to listen?') t = st.slider('Select the time (hours).', min_value=1, max_value=24, step=1) x = np.arange(0, 4, 1 / int(args.samplerate)) fig, ax = plt.subplots() ax.set_ylim(-1, 1) line, = ax.plot(x, np.zeros(len(x)), color='m', linewidth=2) plt.xlabel('Time (s)') plt.ylabel('Sound Wave') the_plot = st.pyplot(plt) if st.button('Start listening with Firearm Alarm'): with st.spinner("Listening..."): for i in range(0, int(t * 3600)): recording = record() ## run it through the model mfcc = wav2mfcc(recording) X_test = np.reshape(mfcc, (1, 20, 170, 1)) Y_predict = cnn_model.predict(X_test) if Y_predict.round()[0][0] == 1: plt.text(0,
corr2_fig = px.scatter( df, x=corr_x, y=corr_y, # corr_x, corr_y 선택한 것 color='Outcome', color_discrete_map=dict(noDM='green', DM='red'), template="plotly_white") st.write(corr2_fig) # heatmap st.subheader('Heatmap of correlation') fig4 = plt.figure(figsize=(6, 5)) sns.heatmap(df.corr(), annot=True, vmin=-1, vmax=1, cmap='coolwarm') # correlation matrix 함수로 그려줌 # -1, 1 완벽한 결과를 위해 / 반상관성 cool, 상관성 warm st.pyplot(fig4) # st.write(fig4) # 출처: https://rfriend.tistory.com/409 [R, Python 분석과 프로그래밍의 친구 (by R Friend)] # correlation heatmap st.subheader('Heatmap of selected parameters') fig5 = plt.figure(figsize=(5, 4)) hmap_params = st.multiselect( "Select parameters to include on heatmap", options=list(df.columns), default=[p for p in df.columns if "Outcome" not in p]) sns.heatmap(df[hmap_params].corr(), annot=True, vmin=-1, vmax=1,
ss.Agent01.play_bernoulli_bandit(0) if go2: ss.Agent01.play_bernoulli_bandit(1) if go3: ss.Agent01.play_bernoulli_bandit(2) if go4: ss.Agent01.play_bernoulli_bandit(3) if go5: ss.Agent01.play_bernoulli_bandit(4) ## Output st.header("Expected Distributions of Bandits") st.text("Played so far:") for no in range(5): a = ss.Agent01.bandit_beta_expectations[no].Alpha b = ss.Agent01.bandit_beta_expectations[no].Beta st.text(f"Bandit {no+1}: {a+b-2} times with {a-1} successes.") # Configure Plot fig, ax = plt.subplots() x = np.linspace(0, 1, 200) # Get expectations expectations = {} for no in range(5): a = ss.Agent01.bandit_beta_expectations[no].Alpha b = ss.Agent01.bandit_beta_expectations[no].Beta sns.lineplot(x=x, y=beta.pdf(x, a, b)) st.pyplot(fig)
def main(): st.title("Chinese GDP 2000 to 2016") st.text("Execept Hong Kong, Macau and Taiwanfrom") st.header("Spatial/Time Distribution") china_gdp = load_data() year = st.slider("Year: ", value=int(2000), min_value=int(2000), max_value=int(2016)) if st.checkbox("Spatial Distribution by Year"): st.bokeh_chart(bokeh_plot_map(china_gdp, str(year))) x = china_gdp["ID"] y = china_gdp[str(year)] st.plotly_chart(plot_bar_chart(x, y)) if st.checkbox("Time Trend by District"): district_selected = st.multiselect("District:", china_gdp["ID"]) years = np.arange(2000, 2017).astype(str) # gdps = china_gdp.loc[china_gdp["ID"] == district_selected[0], years].values.ravel() st.plotly_chart(plot_time_series(china_gdp, years, district_selected)) st.header("Global Spatial Autocorrelation") # create spatial weights w = weights.KNN.from_dataframe(china_gdp, k=8) w.transform = 'R' china_gdp[str(year) + "_lag"] = weights.spatial_lag.lag_spatial( w, china_gdp["2000"]) china_gdp[str(year) + "_std"] = (china_gdp[str(year)] - china_gdp[str(year)].mean()) \ / china_gdp[str(year)].std() china_gdp[str(year) + "_lag_std"] = (china_gdp[str(year) + "_lag"] - china_gdp[str(year) + "_lag"].mean()) \ / china_gdp[str(year) + "_lag"].std() if st.checkbox("Spatial Lag"): st.bokeh_chart(bokeh_plot_map(china_gdp, str(year) + "_lag")) if st.checkbox("Binary Classification"): gdp_threshold = float(st.text_input("larger than:", 8000)) gdp_min = china_gdp[str(year)].min() gdp_max = china_gdp[str(year)].max() if gdp_threshold > gdp_min and gdp_threshold < gdp_max: china_gdp["binary"] = np.where( china_gdp[str(year)] > gdp_threshold, 1, 0) st.bokeh_chart(bokeh_plot_map(china_gdp, "binary")) else: st.info("Please input a number between {} and {}".format( gdp_min, gdp_max)) # china_gdp[str(year) + "_std"] = (china_gdp[str(year)] - china_gdp[str(year)].mean()) \ # / china_gdp[str(year)].std() # china_gdp[str(year) + "_lag_std"] = (china_gdp[str(year) + "_lag"] - china_gdp[str(year) + "_lag"].mean()) \ # / china_gdp[str(year) + "_lag"].std() # Moran Plot" if st.checkbox("Moran Plot"): st.write( plot_moranI(china_gdp[str(year) + "_std"], china_gdp[str(year) + "_lag_std"])) # Moran's I" w.transform = 'R' moran = esda.moran.Moran(china_gdp[str(year)], w) st.text("Moran's I: {}".format(moran.I)) plot_moran(moran) st.pyplot() # st.write(plot_moran(moran)) # local spatial autocorrelation st.header("Local Spatial Autocorrelation") lisa = esda.moran.Moran_Local(china_gdp[str(year)], w) if st.checkbox("LISA"): china_gdp['Is'] = lisa.Is st.bokeh_chart(bokeh_plot_map(china_gdp, 'Is')) if st.checkbox("The Location of the LISA "): q_labels = ['Q1', 'Q2', 'Q3', 'Q4'] labels = [q_labels[i - 1] for i in lisa.q] china_gdp["cl"] = labels palette = ['red', 'lightblue', 'blue', 'pink'] st.bokeh_chart(plot_moran_map(china_gdp, "cl", palette)) if st.checkbox("The significant observations "): sig = 1 * (lisa.p_sim < 0.05) labels = ['non-sig.', 'significant'] labels = [labels[i] for i in sig] china_gdp["cl"] = labels palette = ['white', 'black'] st.bokeh_chart(plot_moran_map(china_gdp, "cl", palette)) if st.checkbox("LISA statistics"): sig = 1 * (lisa.p_sim < 0.05) hotspot = 1 * (sig * lisa.q == 1) coldspot = 3 * (sig * lisa.q == 3) doughnut = 2 * (sig * lisa.q == 2) diamond = 4 * (sig * lisa.q == 4) spots = hotspot + coldspot + doughnut + diamond spot_labels = [ '0 ns', '1 hot spot', '2 doughnut', '3 cold spot', '4 diamond' ] labels = [spot_labels[i] for i in spots] china_gdp["cl"] = labels palette = ['grey', 'red', 'lightblue', 'blue', 'pink'] st.bokeh_chart(plot_moran_map(china_gdp, "cl", palette))
ax.tick_params(axis='x', colors='#777777', labelsize=12) ax.set_yticks([]) ax.margins(0, 0.01) ax.grid(which='major', axis='x', linestyle='-') ax.set_axisbelow(True) ax.text(0, 1.15, 'Casos confirmados por región covid Chile', transform=ax.transAxes, size=24, weight=600, ha='left', va='top') ax.text(1, 0, 'by Monin Leonor @joquitz; credit @pratapvardhan', transform=ax.transAxes, color='#777777', ha='right', bbox=dict(facecolor='white', alpha=0.8, edgecolor='white')) plt.box(False) # Create a simple app ultimodia = df_region.ndia.max() st.title("Evolucion del Covid19 en Chile por región") day = st.slider("Selecciones día", 1, ultimodia) st.markdown("Chile 2020 luego de %i días desde el primer caso" % day) plot = st.pyplot(draw_barchart(day))
def app(): #st.title('Tweet Analysis') img = Image.open("ana.jpg") st.image(img,width=200) activity = ['Tweet Analyzer','Generate CSV'] choice = st.sidebar.selectbox("Select What to want",activity) if choice == 'Tweet Analyzer': html_temp1 = """ <div style="background-color:#FFE4C4;padding:10px"> <h3 style="color:#0080ff;text-align:center;">Analysis Tweets</h3> </div> """ st.markdown(html_temp1,unsafe_allow_html=True) st.subheader('Enter Username (without @) :') #st.write('Most Recent Tweets') #st.write('Word Cloud') #st.write('Bar Graph') text = st.text_input('') user_choice = st.selectbox("Select Option",['Recent Tweet','WordCloud','View Data and Download','Visualize types of comments']) if st.button('Analysis'): if user_choice == 'Recent Tweet': st.success('Fetching Recent Tweets') def show_recent(text): posts = api.user_timeline(screen_name=text,count=100,lang='en',tweet_mode='extended') def get_tweet(): l=[] i=1 for tw in posts[:5]: l.append(tw.full_text) i=i+1 return l recent_tweet = get_tweet() return recent_tweet recent_tweet = show_recent(text) st.write(recent_tweet) elif user_choice == 'WordCloud': st.success('Generating Cloud') def gen_cloud(): posts = api.user_timeline(screen_name=text,count=100,lang='en',tweet_mode='extended') df =pd.DataFrame([tw.full_text for tw in posts],columns=['Tweets']) all_words = ' '.join([tw for tw in df['Tweets']]) wordCloud = WordCloud(width=500, height=300, random_state=21, max_font_size=110).generate(all_words) plt.imshow(wordCloud,interpolation='bicubic') plt.axis('off') plt.savefig('WC.jpg') plt.show() img = Image.open('WC.jpg') return img img = gen_cloud() st.image(img) elif user_choice == 'View Data and Download': def get_csv(): st.success("Generating CSV and Downloading Link") posts = api.user_timeline(screen_name=text,count=100,lang='en',tweet_mode='extended') df =pd.DataFrame([tw.full_text for tw in posts],columns=['Tweets']) def cleanTxt(textt): textt = re.sub('@[A-Za-z0–9]+', '', textt) #Removing @mentions textt = re.sub('#', '', textt) # Removing '#' hash tag textt = re.sub('RT[\s]+', '', textt) # Removing RT textt = re.sub('https?:\/\/\S+', '', textt) # Removing hyperlink return textt df['Tweets'] = df['Tweets'].apply(cleanTxt) def getSub(textt): return TextBlob(textt).sentiment.subjectivity def getpolar(textt): return TextBlob(textt).sentiment.polarity df['Subjectivity'] = df['Tweets'].apply(getSub) df['Polarity'] = df['Tweets'].apply(getpolar) def getanlysis(score): if score<0: return 'Negative' elif score == 0: return 'Neutral' else: return 'Positive' df['Analysis'] = df['Polarity'].apply(getanlysis) return df df = get_csv() st.write(df) def get_link(): data = df csv = data.to_csv(index=False) b64 = base64.b64encode(csv.encode()).decode() return f'<a href="data:file/csv;base64,{b64}" download="xyz.csv">Download csv file</a>' st.markdown(get_link(),unsafe_allow_html=True) else: def Plot_Analysic(): st.success("Generating Visualisation for Sentiment Analysis") posts = api.user_timeline(screen_name=text,count=100,lang='en',tweet_mode='extended') df =pd.DataFrame([tw.full_text for tw in posts],columns=['Tweets']) def cleanTxt(textt): textt = re.sub('@[A-Za-z0–9]+', '', textt) #Removing @mentions textt = re.sub('#', '', textt) # Removing '#' hash tag textt = re.sub('RT[\s]+', '', textt) # Removing RT textt = re.sub('https?:\/\/\S+', '', textt) # Removing hyperlink return textt df['Tweets'] = df['Tweets'].apply(cleanTxt) def getSub(textt): return TextBlob(textt).sentiment.subjectivity def getpolar(textt): return TextBlob(textt).sentiment.polarity df['Subjectivity'] = df['Tweets'].apply(getSub) df['Polarity'] = df['Tweets'].apply(getpolar) def getanlysis(score): if score<0: return 'Negative' elif score == 0: return 'Neutral' else: return 'Positive' df['Analysis'] = df['Polarity'].apply(getanlysis) return df df = Plot_Analysic() st.write(sns.countplot(x=df["Analysis"],data=df)) #st.write(sns.pie(x=df["Analysis"],data=df)) st.pyplot(use_container_width=True) else: html_temp4 = """ <div style="background-color:#FFE4C4;padding:10px"> <h3 style="color:#0080ff;text-align:center;">Analysis Using NLP</h3> </div> """ st.markdown(html_temp4,unsafe_allow_html=True) st.subheader('Click On button to get data from web') if st.button('Web Scrapping'): st.success('Scrapping Done') status = st.radio("See data",("Data","Hide Data")) if status == 'Data': def web_data(): htmlfile = open('Reserve Bank of India - Speeches.html',encoding="utf8").read() soup = BeautifulSoup(htmlfile) for speech_text_1 in soup.findAll(attrs={'class' : 'tablecontent2'}): speech_text_1 = speech_text_1.text.strip() lines = (line.strip() for line in speech_text_1.splitlines()) chunks = (phrase.strip() for line in lines for phrase in line.split(" ")) speech_1 = '\n'.join(chunk for chunk in chunks if chunk) return speech_1 speech = web_data() st.write(speech) elif st.button('Tokenize'): def tokenn(spee): a = word_tokenize(spee) return a token = tokenn(speech) st.write(token)
x='airline', y='airline_sentiment', histfunc='count', color='airline_sentiment', facet_col='airline_sentiment', labels={'airline_sentiment': 'tweets'}, height=600, width=800) st.plotly_chart(fig_choice) st.sidebar.header("Word Cloud") word_sentiment = st.sidebar.radio('Display Word Cloud for which sentiment?', ('positive', 'neutral', 'negative')) if not st.sidebar.checkbox("Hide", True, key='3'): st.header('Word cloud for %s sentiment' % (word_sentiment)) df = data[data['airline_sentiment'] == word_sentiment] words = ' '.join(df['text']) processed_words = ' '.join([ word for word in words.split() if 'http' not in word and not word.startswith('@') and word != 'RT' ]) wordcloud = WordCloud(stopwords=STOPWORDS, background_color='white', height=640, width=800).generate(processed_words) plt.imshow(wordcloud) plt.xticks([]) plt.yticks([]) st.pyplot()
import streamlit as st import network_stability st.title('Network Stability') hours = st.text_input(label='Hours', value=0) minutes = st.text_input(label='Minutes', value=0) seconds = st.text_input(label='Seconds', value=0) speed_button = st.button(label='Run Speed Test') connection_button = st.button(label='Run Connection Test') if speed_button: with st.spinner('Wait for it...'): net = network_stability.NetworkTest() net.speed_test_interval(hours=int(hours), minutes=int(minutes), seconds=int(seconds)) st.success('Speed test completed.') fig = net.report_speed('speed.png') st.pyplot(fig, bbox_inches='tight') if connection_button: with st.spinner('Wait for it...'): net = network_stability.NetworkTest() net.connection_test_interval(hours=int(hours), minutes=int(minutes), seconds=int(seconds)) st.success('Connection test completed.') fig = net.report_connection('connection.png') st.pyplot(fig, bbox_inches='tight')