with tf.GradientTape() as tape:
output_prep = self.preprocess_image(output_image.value())
output_features = self.feature_extractor(output_prep)
output_content_map = build_content_layer_map(output_features, content_layer_weights.keys())
output_style_map = build_style_layer_map(output_features, style_layer_weights.keys())
total_loss = style_content_loss( output_content_map,output_style_map,self.content_layer_weights, self.style_layer_weights, self.content_targets, \
self.style_targets,self.content_reconstruction_weight, self.style_reconstruction_weight, self.total_variation_weight, output_image)
grads = tape.gradient(total_loss, output_image)
optimizer.apply_gradients([(grads, output_image)])
output_image.assign(clipping(output_image))
try:
st.title("Neural Style Transfer With Tensorflow")
progress_text = st.empty()
output_image_placeholder = st.empty()
model_load_unable_error = st.empty()
progress_text.text("Preparing given data for applying NST ...")
progress_bar = st.progress(0)
st.sidebar.text("Neural Style Transfer")
style_image = cv2.imread("./images/logo_image/nst_image.jpg")
st.sidebar.image(image=np.asarray(style_image), use_column_width=True,
caption='', clamp=True, channels='RGB')
video_required = st.sidebar.number_input(label='Is video of output required(1 for yes , 0 for No)', min_value=0, max_value=1, value=0, step=1)
images_required = st.sidebar.number_input(label='Are images of output required(1 for yes , 0 for No)', min_value=0, max_value=1, value=0, step=1)
st.sidebar.header("Set images and various parameters ")
that this file lives outside the Streamlit distribution. Otherwise, changes
to this file may be ignored!
""")
"""
1. If run-on-save is on, make sure the page changes every few seconds. Then
turn run-on-save off in the settigns menu and check (2).
2. If run-on-save is off, make sure "Rerun"/"Always rerun" buttons appear in
the status area. Click "Always rerun" and check (1).
"""
st.write("This should change every ", secs_to_wait, " seconds: ", random())
# Sleep for 5s (rather than, say, 1s) because on the first run we need to make
# sure Streamlit is fully initialized before the timer below expires. This can
# take several seconds.
status = st.empty()
for i in range(secs_to_wait, 0, -1):
time.sleep(1)
status.text("Sleeping %ss..." % i)
status.text("Touching %s" % __file__)
platform_system = platform.system()
if platform_system == "Linux":
cmd = (
"sed -i "
"'s/^# MODIFIED AT:.*/# MODIFIED AT: %(time)s/' %(file)s"
" && touch %(file)s"
% { # sed on Linux modifies a different file.
"time": time.time(),
import time
import numpy as np
from ga_tsp import *
max_iterations = 200
city_count = 25
population_size = 100
elite_size = 20
mutation_rate = 0.05
st.markdown('## Genetic Algorithm (Travelling Postman Problem)')
##################
# Progress Update
##################
latest_iteration = st.empty()
bar = st.progress(0)
###########################
# Initialize cities
# Initialize GA algorithm
###########################
cityList = [
City(x=int(random.gauss(0, 1) * 100), y=int(random.gauss(0, 1) * 100))
for i in range(city_count)
]
GA_gen = geneticAlgorithm(population=cityList,
popSize=population_size,
eliteSize=elite_size,
mutationRate=mutation_rate)
def write():
st.markdown("## Modelo Epidemiológico (SEIR-Bayes)")
st.sidebar.markdown(texts.PARAMETER_SELECTION)
w_granularity = st.sidebar.selectbox('Unidade',
options=['state', 'city'],
index=1,
format_func=global_format_func)
source = 'ms' if w_granularity == 'state' else 'wcota'
cases_df = data.load_cases(w_granularity, source)
population_df = data.load_population(w_granularity)
DEFAULT_PLACE = (DEFAULT_CITY
if w_granularity == 'city' else DEFAULT_STATE)
options_place = make_place_options(cases_df, population_df)
w_place = st.sidebar.selectbox('Município',
options=options_place,
index=options_place.get_loc(DEFAULT_PLACE),
format_func=global_format_func)
options_date = make_date_options(cases_df, w_place)
w_date = st.sidebar.selectbox('Data inicial',
options=options_date,
index=len(options_date) - 1)
NEIR0 = make_NEIR0(cases_df, population_df, w_place, w_date)
# Estimativa R0
st.markdown(texts.r0_ESTIMATION_TITLE)
should_estimate_r0 = st.checkbox('Estimar R0 a partir de dados históricos',
value=True)
if should_estimate_r0:
r0_samples, used_brazil = estimate_r0(cases_df, w_place, SAMPLE_SIZE,
MIN_DAYS_r0_ESTIMATE, w_date)
if used_brazil:
st.write(texts.r0_NOT_ENOUGH_DATA(w_place, w_date))
_place = 'Brasil' if used_brazil else w_place
st.markdown(texts.r0_ESTIMATION(_place, w_date))
st.altair_chart(
plot_r0(r0_samples, w_date, _place, MIN_DAYS_r0_ESTIMATE))
r0_dist = r0_samples[:, -1]
st.markdown(
f'*O $R_{{0}}$ estimado está entre '
f'${np.quantile(r0_dist, 0.01):.03}$ e ${np.quantile(r0_dist, 0.99):.03}$*'
)
st.markdown(texts.r0_CITATION)
else:
r0_dist = make_r0_widgets()
st.markdown(texts.r0_ESTIMATION_DONT)
# Previsão de infectados
w_params = make_param_widgets(NEIR0)
model = SEIRBayes(**w_params, r0_dist=r0_dist)
model_output = model.sample(SAMPLE_SIZE)
ei_df = make_EI_df(model, model_output, SAMPLE_SIZE)
st.markdown(texts.MODEL_INTRO)
w_scale = st.selectbox('Escala do eixo Y', ['log', 'linear'], index=1)
fig = plot_EI(model_output, w_scale, w_date)
st.altair_chart(fig)
download_placeholder = st.empty()
if download_placeholder.button('Preparar dados para download em CSV'):
href = make_download_href(ei_df, w_params, r0_dist, should_estimate_r0)
st.markdown(href, unsafe_allow_html=True)
download_placeholder.empty()
# Parâmetros de simulação
dists = [w_params['alpha_inv_dist'], w_params['gamma_inv_dist'], r0_dist]
SEIR0 = model._params['init_conditions']
params_intro_txt, seir0_dict, other_params_txt = texts.make_SIMULATION_PARAMS(
SEIR0, dists, should_estimate_r0)
st.markdown(params_intro_txt)
st.write(pd.DataFrame(seir0_dict).set_index("Compartimento"))
st.markdown(other_params_txt)
# Configurações da simulação
st.markdown(texts.SIMULATION_CONFIG)
# Fontes dos dados
st.markdown(texts.DATA_SOURCES)
# net = NeuralMem(image_size=TRAINING_IMAGE_SIZE, index_pretrain=INDEX_PRETRAIN, kernel_size=KERNEL_SIZE, stride=STRIDE, padding=PADDING)
with st.beta_expander("FAST AND ROBUST IMAGE STYLETRANSFER AND COLORIZATION", expanded=True):
# header1 = st.write('## FAST AND ROBUST IMAGE STYLETRANSFER AND COLORIZATION')
header2 = st.markdown('#### by providing input and output example image pairs and by using similarity search')
header3 = st.markdown('##### Transfer the style of images by providing input and output example images.')
header4 = st.markdown('##### Colorize images by providing black-white or grayscale input and colored output example images(like grayscale photo as input example and colored photo as output example for training)')
# video_file = open('tutorial.webm', 'rb')
# video_bytes = video_file.read()
# st.video(video_bytes)
col1_1, col1_2 = st.beta_columns(2)
input_ph = st.empty()
train_int_col, train_out_col= st.beta_columns(2)
input_col, output_col = st.beta_columns(2)
rand_input_col, rand_output_col = st.beta_columns(2)
uploaded_inp_example = col1_1.file_uploader("Choose INPUT EXAMPLE for training", type=['png', 'jpg'])
uploaded_out_example = col1_2.file_uploader("Choose OUTPUT EXAMPLE for training", type=['png', 'jpg'])
uploaded_file = input_ph.file_uploader("Choose input image", type=['png', 'jpg'] )
if uploaded_inp_example is not None and uploaded_out_example is not None and uploaded_file is not None:
net = NeuralMem(image_size=TRAINING_IMAGE_SIZE, index_pretrain=INDEX_PRETRAIN, kernel_size=KERNEL_SIZE,
stride=STRIDE, padding=PADDING)
train_inp_example = preprocess(uploaded_inp_example, image_size=TRAINING_IMAGE_SIZE[0:2], gray_scale=False)
train_int_col.image(train_inp_example, caption="INPUT EXAMPLE", width=250)
train_inp_example = torch.tensor(train_inp_example)
projData
from sklearn import manifold
from sklearn import decomposition
if method_name == 'PCA':
method = decomposition.PCA(n_components=2)
if method_name == 'MDS':
method = manifold.MDS(n_components=2)
if method_name == 'TSNE':
perplexity = st.slider('Perplexity', 10, 100, 30)
method = manifold.TSNE(n_components=2, perplexity=perplexity)
placeholder = st.empty()
placeholder.text('calculating...')
pos = pd.DataFrame(method.fit_transform(projData), columns=['x', 'y'])
projcars = pd.concat([projcars, pos.reset_index(drop=True)], axis='columns')
placeholder.empty()
color = st.selectbox(
'Color by:', ('Origin', 'Weight_in_lbs', 'Horsepower', 'Miles_per_Gallon',
'Displacement', 'Cylinders', 'Acceleration'))
# We use a point as mark
chart = alt.Chart(projcars).mark_point().encode(
x='x', y='y', color=color).properties(width=600, height=600)
chart
projcars
import streamlit as st
import time
# import numpy as np
# import pandas as pd
# from PIL import Image
# heading
st.title('Streamlit 入門')
st.write('プログレスバー')
'Start!!'
latest_iteration = st.empty() # 空の要素
bar = st.progress(0)
for i in range(100):
latest_iteration.text(f'Iteration {i+1}')
bar.progress(i + 1)
time.sleep(0.1)
'Done!!'
# text
# st.write('DataFrame')
# df = pd.DataFrame(
# np.random.rand(20,3), # 正規分布を元に乱数を生成
# columns=['a','b','c'],
# )
# dfの描画
# st.write(df)
def dashboard():
''' Main code to display the streamlit dashboard '''
# get score data
df_scores_full, scorenames = load_real_data()
# descriptive names for each score
scorenames_desc_manual = {
"gmap_score": "Menschen an Haltestellen des ÖPNV",
"gmap_supermarket_score": "Besucher in Supermärkten",
"hystreet_score": "Fußgänger in Innenstädten",
"zug_score": "DB Züge",
"bike_score": "Fahrradfahrer",
"bus_score": "ÖPV Busse",
"national_score": "ÖPV IC-Züge",
"suburban_score": "ÖPV Nahverkehr",
"regional_score": "ÖPV Regionalzüge",
"nationalExpress_score": "ÖPV ICE-Züge",
"webcam_score": "Fußgänger auf öffentlichen Webcams",
"tomtom_score": "Autoverkehr",
"airquality_score": "Luftqualität"
}
# very short axis labels for each score
scorenames_axis_manual = {
"gmap_score": "Menschen",
"gmap_supermarket_score": "Besucher",
"hystreet_score": "Fußgänger",
"zug_score": "Züge",
"bike_score": "Fahrradfahrer",
"bus_score": "Busse",
"national_score": "IC-Züge",
"suburban_score": "Nahverkehr",
"regional_score": "Regionalzüge",
"nationalExpress_score": "ICE-Züge",
"webcam_score": "Fußgänger",
"tomtom_score": "Traffic Index",
"airquality_score": "Luftqualität"
}
# for scores not in the hardcoded list above
# default to their scorename as a fallback
scorenames_desc = {}
scorenames_axis = {}
for scorename in scorenames:
if scorename in scorenames_desc_manual:
scorenames_desc[scorename] = scorenames_desc_manual[scorename]
else:
scorenames_desc[scorename] = scorename
if scorename in scorenames_axis_manual:
scorenames_axis[scorename] = scorenames_axis_manual[scorename]
else:
scorenames_axis[scorename] = scorename
st.markdown('''
Die Maßnahmen gegen COVID19 wie Kontaktverbote und geschlossene Geschäfte haben große Änderungen in unserem Alltag mit sich gebracht. Wir sehen dies jeden Tag wenn wir vor die Haustür gehen. Aber wie ist die Lage im Rest des Landes? Wird Social Distancing überall gleich strikt befolgt? Sinkt die Zurückhaltung am Wochenende oder bei guten Wetter? Sind tatsächlich mehr/weniger Menschen im Park unterwegs? Diese Fragen sind sehr schwer direkt zu beantworten, aber wir können versuchen, **indirekt** Erkentnisse darüber zu gewinnen indem wir verschiedene Indikatoren betrachten.
Dazu setzen wir auf unterschiedliche Datenquellen, um ein möglichst umfassendes Bild zu zeichnen.
Wo es möglich ist, berechnen wir einen einfach verständlichen relativen Wert. Dabei entspricht **100% dem Normal-Wert vor der COVID19-Pandemie**, also bevor die Bürger zu Social Distancing aufgerufen wurden. Ein kleiner Wert weist darauf hin, dass in unserer Datenquelle eine Verringerung der Aktivität gemessen wurde. Wenn eine relative Angabe nicht möglich ist (z.B. weil unsere Daten nicht weit genug in die Vergangenheit reichen um zu bestimmen was ein "normales" Aktivitätsniveau ist) werden absolute Werte angegeben.
Im Folgenden kannst Du unseren Datensatz auf unterschiedliche Weise interaktiv erkunden:
- <a href="#map">Aktuelle Deutschlandkarte</a>
- <a href="#timeline">Zeitlicher Verlauf</a>
- <a href="#histogram">Verteilung über alle Landkreise</a>
''',
unsafe_allow_html=True)
# MAP DESCRIPTION
st_map_desc = st.empty()
# Selection box for the map
df_scores, selected_score, selected_score_desc, selected_score_axis, use_states, use_states_select, countys, latest_date = detail_score_selector(
df_scores_full,
scorenames_desc,
scorenames_axis,
allow_county_select=False,
allow_detail_select=True,
key='map',
default_detail_index=0,
default_score="hystreet_score")
st_map_desc.markdown('''
---
## Aktuelle Karte vom {datum}<span id="map"></span>
In der Karte siehst Du wie sich die COVID-19-Maßnahmen auf die verschiedenen **{regionen}** in Deutschland auswirkt. Angezeigt werden Daten über **{datasource}**. Du kannst die Datenquelle über die Schaltflächen ändern.
'''.format(regionen=use_states_select,
datasource=selected_score_desc,
datum=datetime.datetime.strptime(
latest_date, "%Y-%m-%d").strftime("%d.%m.%Y")),
unsafe_allow_html=True)
# DRAW MAP
map = get_map(df_scores, selected_score, selected_score_axis,
selected_score_desc, use_states, latest_date)
map2 = map.copy(
) # otherwise streamlit gives a Cached Object Mutated warning
st.altair_chart(map2)
# MAP LEGEND
if selected_score == "airquality_score":
st.image("images/legende_airquality.png")
elif selected_score in ["webcam_score", "tomtom_score"]:
pass # no legend
else:
st.image("images/legende.png")
# TIMELINE DESCRIPTION
st_timeline_desc = st.empty()
# Selection box for the timeline
df_scores2, selected_score2, selected_score_desc2, selected_score_axis2, use_states2, use_states_select2, countys2, latest_date2 = detail_score_selector(
df_scores_full,
scorenames_desc,
scorenames_axis,
allow_county_select=True,
allow_detail_select=True,
key='timeline',
default_detail_index=1,
default_score="hystreet_score")
st_timeline_desc.markdown('''
---
## Zeitlicher Verlauf <span id="timeline"></span>
Hier kannst Du den zeitlichen Verlauf der gewählten Datenquelle für verschiedene **{regionen}** in Deutschland vergleichen. Angezeigt werden Daten über **{datasource}**. Du kannst die Datenquelle über die Schaltflächen ändern.
**Sieh doch mal nach wie die Lage in Deiner Region ist!**
'''.format(regionen=use_states_select2, datasource=selected_score_desc2),
unsafe_allow_html=True)
timeline = get_timeline_plots(df_scores2, selected_score2,
selected_score_axis2, selected_score_desc2,
use_states2, countys2)
if timeline is not None:
timeline2 = timeline.copy(
) # otherwise streamlit gives a Cached Object Mutated warning
st.altair_chart(timeline2)
# DRAW HISTOGRAMS
# ===============
st_histo_desc = st.empty()
# Selection box for the timeline
df_scores3, selected_score3, selected_score_desc3, selected_score_axis3, use_states3, use_states_select3, countys3, latest_date3 = detail_score_selector(
df_scores_full,
scorenames_desc,
scorenames_axis,
allow_county_select=False,
allow_detail_select=False,
key='histo',
default_score="hystreet_score")
st_histo_desc.markdown('''
---
## Verteilung über alle Landkreise <span id="histogram"></span>
Hier kannst Du einen Überblick bekommen, wie die Verteilung der Daten über **{datasource}** für alle verfügbaren Landkreise ist. Du kannst die Datenauswahl weiter unten im Menü ändern.
Die pinke Linie ist der **Median**, das heißt jeweils die Hälfte aller Landkreise hat einen höheren beziehungswiese niedrigeren Score als dieser Wert. Im unteren Graph ist der zeitliche Verlauf des Medians dargestellt. **In diesem Graph kannst Du das Datum auswählen, für welches Dir die Verteilung über alle Landkreise angezeigt wird.**
'''.format(datasource=selected_score_desc3),
unsafe_allow_html=True)
c = get_histograms(df_scores3, selected_score3, selected_score_desc3,
selected_score_axis3)
st.altair_chart(c)
st.markdown('''
Zur zeitlichen Einordung: Die [Vereinbarung zwischen der Bundesregierung und den Regierungschefinnen und Regierungschefs der Bundesländer angesichts der Corona-Epidemie in Deutschland](https://www.bundeskanzlerin.de/bkin-de/aktuelles/vereinbarung-zwischen-der-bundesregierung-und-den-regierungschefinnen-und-regierungschefs-der-bundeslaender-angesichts-der-corona-epidemie-in-deutschland-1730934) wurde am 16. März veröffentlicht.
''')
# tracking javascript
st.markdown("""
<!-- Matomo Image Tracker-->
<img src="https://matomo.everyonecounts.de/matomo.php?idsite=1&rec=1&action_name=Dashboard" style="border:0" alt="" />
<!-- End Matomo -->
""",
unsafe_allow_html=True)
def app_sst(model_path: str, lm_path: str, lm_alpha: float, lm_beta: float,
beam: int):
webrtc_ctx = webrtc_streamer(
key="speech-to-text",
mode=WebRtcMode.SENDONLY,
audio_receiver_size=1024,
client_settings=ClientSettings(
rtc_configuration={
"iceServers": [{
"urls": ["stun:stun.l.google.com:19302"]
}]
},
media_stream_constraints={
"video": False,
"audio": True
},
),
)
status_indicator = st.empty()
if not webrtc_ctx.state.playing:
return
status_indicator.write("Loading...")
text_output = st.empty()
stream = None
while True:
if webrtc_ctx.audio_receiver:
if stream is None:
from deepspeech import Model
model = Model(model_path)
model.enableExternalScorer(lm_path)
model.setScorerAlphaBeta(lm_alpha, lm_beta)
model.setBeamWidth(beam)
stream = model.createStream()
status_indicator.write("Model loaded.")
sound_chunk = pydub.AudioSegment.empty()
try:
audio_frames = webrtc_ctx.audio_receiver.get_frames(timeout=1)
except queue.Empty:
time.sleep(0.1)
status_indicator.write("No frame arrived.")
continue
status_indicator.write("Running. Say something!")
for audio_frame in audio_frames:
sound = pydub.AudioSegment(
data=audio_frame.to_ndarray().tobytes(),
sample_width=audio_frame.format.bytes,
frame_rate=audio_frame.sample_rate,
channels=len(audio_frame.layout.channels),
)
sound_chunk += sound
if len(sound_chunk) > 0:
sound_chunk = sound_chunk.set_channels(1).set_frame_rate(
model.sampleRate())
buffer = np.array(sound_chunk.get_array_of_samples())
stream.feedAudioContent(buffer)
text = stream.intermediateDecode()
text_output.markdown(f"**Text:** {text}")
else:
status_indicator.write("AudioReciver is not set. Abort.")
break
def ProcessFrames(vf, stop, hyp, tfile, phrase_id, signer_ids, state):
"""
main loop for processing video file:
Params
vf = VideoCapture Object
tracker = Tracker Object that was instantiated
obj_detector = Object detector (model and some properties)
"""
try:
num_frames = int(vf.get(cv2.CAP_PROP_FRAME_COUNT))
fps = int(vf.get(cv2.CAP_PROP_FPS))
print('Total number of frames to be processed:', num_frames,
'\nFrame rate (frames per second):', fps)
except:
print('We cannot determine number of frames and FPS!')
frame_counter = 0
_stop = stop.button("stop")
new_car_count_txt = st.empty()
fps_meas_txt = st.empty()
bar = st.progress(frame_counter)
stframe = st.empty()
start = time.time()
pred_txt = st.empty()
upload = st.empty()
while vf.isOpened():
# if frame is read correctly ret is True
ret, frame = vf.read()
if _stop:
break
if not ret:
st.markdown("""
<style>
.big-font {
font-size:25px !important;
}
</style>
""", unsafe_allow_html=True)
st.markdown(f'**Prediction**: <p class="big-font">{hyp[0]} </p>', unsafe_allow_html=True)
with open("/app/app/upload.txt") as f:
bool = int(f.readline())
if phrase_id == None or not bool:
st.info("Please login and specify the phrase to upload the video to our database!")
#pred_txt.markdown(f'**Prediction:** {hyp[0]}')
print("Can't receive frame (stream end?). Exiting ...")
break
end = time.time()
frame_counter += 1
fps_measurement = frame_counter/(end - start)
bar.progress(frame_counter/num_frames)
frm = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
stframe.image(cv2.resize(frm, (224, 224)))
time.sleep(0.02)
def detail_score_selector(df_scores_in,
scorenames_desc,
scorenames_axis,
allow_county_select,
allow_detail_select,
key,
default_detail_index=0,
default_score="hystreet_score"):
df_scores = df_scores_in.copy()
# get counties
county_names, county_ids, state_names, state_ids = load_topojson()
id_to_name = {cid: county_names[idx] for idx, cid in enumerate(county_ids)}
state_id_to_name = {
cid: state_names[idx]
for idx, cid in enumerate(state_ids)
}
state_name_to_id = {
state_names[idx]: cid
for idx, cid in enumerate(state_ids)
}
st_desc = st.empty()
# LEVEL OF DETAIL SELECT
if allow_detail_select:
use_states_select = st.radio('Detailgrad:',
('Bundesländer', 'Landkreise'),
index=default_detail_index,
key=key)
else:
use_states_select = 'Landkreise'
use_states = use_states_select == 'Bundesländer'
# SCORE SELECT
sorted_desc = sorted(list(scorenames_desc.values()))
selected_score_desc = st.selectbox(
'Datenquelle:',
sorted_desc,
index=sorted_desc.index(
scorenames_desc[default_score]), # default value in sorted list
key=key)
inverse_scorenames_desc = {
scorenames_desc[key]: key
for key in scorenames_desc.keys()
}
selected_score = inverse_scorenames_desc[selected_score_desc]
if selected_score == "webcam_score":
selected_score_axis = scorenames_axis[
selected_score] + ' (Tagesdurchschnitt)' # absolute values
elif selected_score == "airquality_score":
selected_score_axis = scorenames_axis[
selected_score] + ' (AQI)' # absolute values
else:
selected_score_axis = scorenames_axis[selected_score] + ' (%)'
latest_date = pd.Series(
df_scores[df_scores[selected_score] > 0]["date"]).values[-1]
# COUNTY SELECT
if (not use_states) and allow_county_select:
available_countys = [
value for value in county_names if value in df_scores[
df_scores[selected_score] >= 0]["name"].values
]
if len(available_countys) > 1:
default = available_countys[:2]
else:
default = []
countys = st.multiselect('Wähle Landkreise aus:',
options=available_countys,
default=default,
key=key)
else:
countys = []
# Show additional information text for certain scores
desc = ""
if selected_score in ["webcam_score", "airquality_score", "tomtom_score"]:
desc += '''
Für diesen Datensatz besitzen wir leider keine Referenz-Daten vor der COVID-Pandemie, daher werden **Absolutwerte** angezeigt und Werte zwischen {regionen}n lassen sich nicht vergleichen.
'''.format(regionen=use_states_select)
if selected_score == "airquality_score":
desc += '''
Die Daten kommen vom [World Air Quality Project](https://aqicn.org/here/de/) und die Skala richtet sich nach dem ["Air Quality Index" (AQI)](https://aqicn.org/scale/de/).
'''
elif selected_score == "tomtom_score":
desc += '''
Die Daten stammen vom [TomTom Traffic Index](https://www.tomtom.com/). Die Prozentangaben beschreiben die Zeit, die man aufgrund der Verkehrslage länger unterwegs ist als auf einer komplett freien Straße. Ein Wert von 50% bedeutet also, dass man für einen Trip, der normalerweise 30 Minuten dauern würde, aufgrund der Verkehrslage 15 Minuten mehr benötigt, nämlich 45 Minuten. ([Quelle](https://www.tomtom.com/en_gb/traffic-index/about/))
'''
if selected_score in ["gmap_score", "tomtom_score"]:
desc += '''
<div style="background:#FEE59F; border-radius:5px; padding:10px;"><b>Hinweis:</b> Für diesen Datensatz können wir leider keine aktuellen Daten mehr anbieten.</div>
'''.format(regionen=use_states_select)
st_desc.markdown(desc, unsafe_allow_html=True)
# Prepare df_scores according to Landkreis/Bundesland selection
if use_states:
# aggregate state data
df_scores['state_id'] = df_scores.apply(
lambda x: str(x['id'])[:2],
axis=1) # get state id (first two letters of county id)
df_scores['name'] = df_scores.apply(
lambda x: state_id_to_name[x['state_id']],
axis=1) # get state name
df_scores = df_scores.groupby(
['name',
'date']).mean() # group by state and date, calculate mean scores
df_scores = df_scores.round(1) #round
df_scores['id'] = df_scores.apply(
lambda x: state_name_to_id[x.name[0]],
axis=1) # re-add state indices
df_scores = df_scores.replace([np.inf, -np.inf], np.nan) # remove infs
df_scores = df_scores.reset_index(
) # make index columns into regular columns
df_scores["airquality_desc"] = df_scores.apply(
lambda x: get_airquality_desc(x["airquality_score"]), axis=1)
df_scores["date"] = pd.to_datetime(df_scores["date"])
df_scores = df_scores.round(1)
return (df_scores, selected_score, selected_score_desc,
selected_score_axis, use_states, use_states_select, countys,
latest_date)
def main():
#st.set_page_config(page_title = "Continuous Sign Language Recognition")
st.markdown("### Model Architecture")
st.image(
f'/app/architecture.png',
caption='Architecture overview',
use_column_width=True
)
base_size = [256, 256]
crop_size = [224, 224]
random_crop = False
p_drop = 0.5
random_drop = False
transform_phoenix = transforms.Compose(
[
transforms.Resize(base_size),
transforms.RandomCrop(crop_size)
if random_crop
else transforms.CenterCrop(crop_size),
transforms.ToTensor(),
#transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
transforms.Normalize([0.53724027, 0.5272855, 0.51954997], [1, 1, 1])
]
)
transform_krsl = transforms.Compose(
[
transforms.Resize(base_size),
transforms.RandomCrop(crop_size)
if random_crop
else transforms.CenterCrop(crop_size),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
#transforms.Normalize([0.53724027, 0.5272855, 0.51954997], [1, 1, 1])
]
)
state = SessionState.get(upload_key = None, enabled = True,
start = False, conf = 70, nms = 50, run = False, upload_db = False)
hide_streamlit_widgets()
"""
# Continuous Sign Language Recogntion
"""
with open("/app/phrases.txt", "r") as f:
lines = f.readlines()
my_phrases = [""] + [line.strip().split("\t")[1] for line in lines]
with open("/app/app/test_ids.txt", "r") as f:
ids = f.readlines()
signer_ids = [""] + [id.strip() for id in ids]
phrase_dict = {line.strip().split("\t")[1]:line.strip().split("\t")[0] for line in lines}
with st.sidebar:
"""
## :floppy_disk: Stochastic CSLR model
SOTA among single cue models
"""
#state.conf, state.nms = parameter_sliders(
# keys, state.enabled, value = [state.conf, state.nms])
st.text("")
st.text("")
st.text("")
lang = st.radio("Select language: ", ('Russian', 'German'))
backbone = st.sidebar.selectbox(
label = 'Please choose the backbone for Stochastic CSLR',
options = [
'ResNet18'
],
index = 0,
key = 'backbone'
)
phrase = st.sidebar.selectbox(
label = "Please select the phrase for K-RSL dataset here",
options = my_phrases,
index = 0,
key = 'phrase'
)
signer_id = st.sidebar.selectbox(
label = "Please select the signer id for K-RSL dataset here",
options = signer_ids,
index = 0,
key = 'signer_id'
)
upload = st.empty()
start_button = st.empty()
stop_button = st.empty()
with upload:
f = st.file_uploader('Upload Video file (mpeg/mp4 format)', key = state.upload_key)
if lang == "Russian" and len(phrase) != 0 and len(signer_id) != 0:
video_path = "/app/test_videos/" + str(phrase_dict[phrase]) + "/" + "P" + str(signer_id) + "_" + "S" + str(phrase_dict[phrase]) + "_" + "00.mp4"
if not os.path.exists(video_path):
st.info("The video is not in the database!")
return
vf = cv2.VideoCapture(video_path)
vf = cv2.VideoCapture(video_path)
frames = get_frames(video_path=video_path)
indices = sample_indices(n=len(frames), p_drop=p_drop, random_drop=random_drop)
frames = [Image.fromarray(frames[i].asnumpy(), 'RGB') for i in indices]
if lang == "Russian":
frames = map(transform_krsl, frames)
else:
frames = map(transform_phoenix, frames)
frames = np.stack(list(frames))
if lang == "Russian":
epoch = 18
vocab = create_vocab(split="train_rus", sep=",")
else:
vocab = create_vocab(split="train_ger", sep="|")
if backbone == "ResNet18":
epoch = 100
else:
epoch = 200
hyp = inference(epoch, vocab, frames, lang)
if not state.run:
start_button.empty()
start = start_button.button("PREDICT")
state.start = start
if state.start:
start_button.empty()
state.enabled = False
if state.run:
if phrase in phrase_dict:
phrase_id = phrase_dict[phrase]
state.upload_key = str(randint(1000, int(1e6)))
state.enabled = True
state.run = False
ProcessFrames(vf, stop_button, hyp, video_path, phrase_id, signer_ids, state)
else:
state.run = True
trigger_rerun()
if f is not None:
tfile = tempfile.NamedTemporaryFile(delete = False)
tfile.write(f.read())
upload.empty()
vf = cv2.VideoCapture(tfile.name)
frames = get_frames(video_path=tfile.name)
indices = sample_indices(n=len(frames), p_drop=p_drop, random_drop=random_drop)
frames = [Image.fromarray(frames[i].asnumpy(), 'RGB') for i in indices]
if lang == "Russian":
frames = map(transform_krsl, frames)
else:
frames = map(transform_phoenix, frames)
frames = np.stack(list(frames))
if lang == "Russian":
epoch = 18
vocab = create_vocab(split="train_rus", sep=",")
else:
vocab = create_vocab(split="train_ger", sep="|")
if backbone == "ResNet18":
epoch = 100
else:
epoch = 200
hyp = inference(epoch, vocab, frames, lang)
if not state.run:
start_button.empty()
start = start_button.button("PREDICT ")
state.start = start
with open("/app/app/upload.txt") as f:
bool = int(f.readline())
phrase_id = None
if phrase in phrase_dict:
phrase_id = phrase_dict[phrase]
if bool and phrase_id != None:
up = upload.button("UPLOAD TO DATABASE")
state.upload_db = up
if state.upload_db:
with open("/app/app/test_ids.txt", "a") as f:
if "51" not in signer_ids:
f.write("51\n")
shutil.move(tfile.name, f"/app/test_videos/{phrase_id}/P51_S{phrase_id}_00.mp4")
st.info("The data was successfully uploaded to the database!")
state.run = False
if state.start:
start_button.empty()
state.enabled = False
if state.run:
f.close()
state.upload_key = str(randint(1000, int(1e6)))
state.enabled = True
state.run = False
phrase_id = None
if phrase in phrase_dict:
phrase_id = phrase_dict[phrase]
ProcessFrames(vf, stop_button, hyp, tfile, phrase_id, signer_ids, state)
else:
state.run = True
trigger_rerun()
def run_app():
# GUI
epoch_loc = st.empty()
prog_bar = st.empty()
loss_loc = st.empty()
global_loss_loc = st.empty()
col1, col2 = st.beta_columns(2)
img_loc = col1.empty()
stats_loc = col2.empty()
image_meta_loc = st.empty()
right_chart = st.empty()
loss_chart = st.empty()
glob_loss_chart = st.empty()
# right_chart = st.empty()
test_progress_bar = st.empty()
testing_chart = st.empty()
test_stats = st.empty()
cuda = torch.device('cuda')
cpu = torch.device('cpu')
net = Net()
net.to(cuda)
criterion = nn.CrossEntropyLoss()
# criterion = nn.MSELoss()
#optimizer = optim.AdamW(net.parameters(), lr=0.01)
optimizer = optim.AdamW(net.parameters(), lr=0.001)
dataset = EegDataset()
EPOCHS = 200
losses = deque(maxlen=100)
global_losses = deque(maxlen=100)
right_list = deque(maxlen=100)
wrong_list = deque(maxlen=100)
# st.write(list(dataset))
for epoch in range(EPOCHS):
i = 1
epoch_loc.write(f"EPOCH:\t{epoch}/{EPOCHS-1}")
global_loss = torch.tensor([0.0], device=cuda)
optimizer.zero_grad()
right = 0
wrong = 0
for image in dataset:
# sleep(1)
prog_bar.progress(i / len(dataset))
i += 1
optimizer.zero_grad()
x = image.data
img_loc.image(image.data.numpy(), width=200)
image_meta_loc.write(f"ID:\t{image.id} \nCategory:\t{image.category}")
# out = net(x.cuda().float())#.unsqueeze(0)
out = net(x.cuda().float()).unsqueeze(0)
out_id = torch.argmax(out.detach().cpu(), 1)
target_id = dataset.categories.index(image.category)
target = torch.zeros(len(dataset.categories)).float()
target[target_id] = 1.0
target = target.cuda()
# target = torch.tensor([dataset.categories.index(image.category)]).cuda()
# stats_loc.write(f"OUTPUT:\t{torch.argmax(out.detach().cpu(), 1)} \nTARGET:\t{target.detach().cpu()}")
stats_loc.write(f"OUTPUT:\t{out_id} \nTARGET:\t{target_id}")
# out = torch.round(out)
# target = torch.round(target)
# loss = criterion(out, target)
loss = criterion(out, torch.tensor([target_id]).cuda())
if out_id == target_id:
right += 1
loss = loss * (1 / len(dataset))
else:
wrong += 1
loss = loss * 1
losses.append(loss.detach().cpu().numpy())
loss_chart.line_chart(
pd.DataFrame(losses, columns=['loss',])
)
global_loss += loss
loss.backward()
optimizer.step()
loss_loc.write(f"LOSS:\t{loss.detach().cpu()} \nRIGHT:\t{right}/{len(dataset)} \nWRONG:\t{wrong}/{len(dataset)}")
# print(loss)
right_list.append(right)
wrong_list.append(wrong)
rc_data = pd.DataFrame(np.array([[r,w] for r,w in zip(right_list, wrong_list)]), columns=['right', 'wrong'])
right_chart.line_chart(rc_data)
# wc_data = pd.DataFrame(np.array(wrong_list), columns=['wrong',])
global_loss_loc.write(f"GLOBAL LOSS:\t{global_loss.detach().cpu()} \nGLOB AVERAGE LOSS:\t{global_loss.detach().cpu()/len(dataset)}")
global_losses.append(global_loss.detach().cpu().numpy())
glob_loss_chart.line_chart(
pd.DataFrame(global_losses, columns=['global_loss', ])
)
# global_loss.backward()
# optimizer.step()
# TESTING PHASE:
dataset = EegDataset(testing=True)
right = 0
wrong = 0
st.write('TESTING!!!!!!!!!!!!!!!!!!!/EVALUATING????')
i = 1
with torch.no_grad():
for image in dataset:
test_progress_bar.progress(i / len(dataset))
i += 1
x = image.data
out = net(x.cuda().float())
out_id = torch.argmax(out.detach().cpu(), 0)
target_id = dataset.categories.index(image.category)
if out_id == target_id:
right += 1
else:
wrong += 1
# chart_data = pd.DataFrame(np.array([[right, wrong]]), columns=['right', wrong])
# testing_chart.bar_chart(chart_data)
test_stats.write(f'RIGHT: {right}/{len(dataset)} \nWRONG: {wrong}/{len(dataset)}')
st.sidebar.markdown("""
### Location of the property:
""")
property_address = st.sidebar.text_input('Property Adress',
value='R. Itapeva, 636 - Bela Vista')
property_municipality = st.sidebar.selectbox('Property municipality',
['São Paulo'])
property_metropolitan_region = st.sidebar.selectbox('Metropolitan region',
['São Paulo'])
run_button = st.sidebar.button('Get result')
result = st.sidebar.empty()
# main panels
text_description = st.empty()
if run_button:
# t_rex = st.empty()
# t_rex.markdown('<iframe width="560" height="315" src="http://wayou.github.io/t-rex-runner/"></iframe>', unsafe_allow_html=True)
# spinner_ = st.markdown('<div class="container"><h2>Spinners</h2><p>To create a spinner/loader, use the <code>.spinner-border</code> class:</p><div class="spinner-border"></div></div>', unsafe_allow_html=True)
text_description.empty()
with st.spinner('Please wait...'):
progress_bar = st.empty()
info_progress = st.empty()
progress_bar.progress(0)
info_progress.text('Geocoding address...')
property_location = utils.geo_code(
property_address,
"count",
"message count",
"msg count",
"msg",
]:
print(
f"Received message count: {receiver.received_messages}\n"
+ f"Produced message count: {producer.produced_messages}"
)
except KeyboardInterrupt:
thread_end_event.set()
receiver_thread.join()
producer_thread.join()
break
participant_list = [Participant() for i in range(20)]
game = Thread(target=f1_pipeline, args=(participant_list,))
game.daemon = True
if __name__ == "__main__":
st.title("F1 Dashboard")
game.start()
empty_element = st.empty()
while True:
empty_element.text(dict(participant_list[0]))
time.sleep(1)
def app_sst_with_video(model_path: str, lm_path: str, lm_alpha: float,
lm_beta: float, beam: int):
class AudioProcessor(AudioProcessorBase):
frames_lock: threading.Lock
frames: deque
def __init__(self) -> None:
self.frames_lock = threading.Lock()
self.frames = deque([])
async def recv_queued(self,
frames: List[av.AudioFrame]) -> av.AudioFrame:
with self.frames_lock:
self.frames.extend(frames)
# Return empty frames to be silent.
new_frames = []
for frame in frames:
input_array = frame.to_ndarray()
new_frame = av.AudioFrame.from_ndarray(
np.zeros(input_array.shape, dtype=input_array.dtype),
layout=frame.layout.name,
)
new_frame.sample_rate = frame.sample_rate
new_frames.append(new_frame)
return new_frames
webrtc_ctx = webrtc_streamer(
key="speech-to-text-w-video",
mode=WebRtcMode.SENDRECV,
audio_processor_factory=AudioProcessor,
client_settings=ClientSettings(
rtc_configuration={
"iceServers": [{
"urls": ["stun:stun.l.google.com:19302"]
}]
},
media_stream_constraints={
"video": True,
"audio": True
},
),
)
status_indicator = st.empty()
if not webrtc_ctx.state.playing:
return
status_indicator.write("Loading...")
text_output = st.empty()
stream = None
while True:
if webrtc_ctx.audio_processor:
if stream is None:
from deepspeech import Model
model = Model(model_path)
model.enableExternalScorer(lm_path)
model.setScorerAlphaBeta(lm_alpha, lm_beta)
model.setBeamWidth(beam)
stream = model.createStream()
status_indicator.write("Model loaded.")
sound_chunk = pydub.AudioSegment.empty()
audio_frames = []
with webrtc_ctx.audio_processor.frames_lock:
while len(webrtc_ctx.audio_processor.frames) > 0:
frame = webrtc_ctx.audio_processor.frames.popleft()
audio_frames.append(frame)
if len(audio_frames) == 0:
time.sleep(0.1)
status_indicator.write("No frame arrived.")
continue
status_indicator.write("Running. Say something!")
for audio_frame in audio_frames:
sound = pydub.AudioSegment(
data=audio_frame.to_ndarray().tobytes(),
sample_width=audio_frame.format.bytes,
frame_rate=audio_frame.sample_rate,
channels=len(audio_frame.layout.channels),
)
sound_chunk += sound
if len(sound_chunk) > 0:
sound_chunk = sound_chunk.set_channels(1).set_frame_rate(
model.sampleRate())
buffer = np.array(sound_chunk.get_array_of_samples())
stream.feedAudioContent(buffer)
text = stream.intermediateDecode()
text_output.markdown(f"**Text:** {text}")
else:
status_indicator.write("AudioReciver is not set. Abort.")
break
if file:
img = read_from_file(file)
grid = img_to_grid(img,
detector_model,
recognizer_model,
plot_path=None,
print_result=False)
x = [a for x in grid for a in x]
initial_board = Board(x)
set_initially_available(initial_board.cells)
solving_time = st.empty()
html_board = st.markdown("<center>" + initial_board.html() + "</center>",
unsafe_allow_html=True)
time.sleep(0.5)
to_solve_board = initial_board.copy()
start = time.time()
n_iter, _ = backtracking_solve(to_solve_board)
solve_duration = time.time() - start
solving_time.markdown(
"<center>" + "<h3>Solved in %.5f seconds and %s iterations</h3>" %
(solve_duration, n_iter) + "</center>",
unsafe_allow_html=True,
def update_doctor(self):
id = st.text_input('Enter Doctor ID of the doctor to be updated')
if id == '':
st.empty()
elif not verify_doctor_id(id):
st.error('Invalid Doctor ID')
else:
st.success('Verified')
conn, c = db.connection()
# shows the current details of the doctor before updating
with conn:
c.execute(
"""
SELECT *
FROM doctor_record
WHERE id = :id;
""",
{ 'id': id }
)
st.write('Here are the current details of the doctor:')
show_doctor_details(c.fetchall())
st.write('Enter new details of the doctor:')
department_id = st.text_input('Department ID')
if department_id == '':
st.empty()
elif not department.verify_department_id(department_id):
st.error('Invalid Department ID')
else:
st.success('Verified')
self.department_id = department_id
self.department_name = get_department_name(department_id)
self.contact_number_1 = st.text_input('Contact number')
contact_number_2 = st.text_input('Alternate contact number (optional)')
self.contact_number_2 = (lambda phone : None if phone == '' else phone)(contact_number_2)
self.email_id = st.text_input('Email ID')
self.qualification = st.text_input('Qualification')
self.specialisation = st.text_input('Specialisation')
self.years_of_experience = st.number_input('Years of experience', value = 0, min_value = 0, max_value = 100)
self.address = st.text_area('Address')
self.city = st.text_input('City')
self.state = st.text_input('State')
self.pin_code = st.text_input('PIN code')
update = st.button('Update')
# executing SQLite statements to update this doctor's record in the database
if update:
with conn:
c.execute(
"""
SELECT date_of_birth
FROM doctor_record
WHERE id = :id;
""",
{ 'id': id }
)
# converts date of birth to the required format for age calculation
dob = [int(d) for d in c.fetchone()[0].split('-')[::-1]]
dob = date(dob[0], dob[1], dob[2])
self.age = calculate_age(dob)
with conn:
c.execute(
"""
UPDATE doctor_record
SET age = :age, department_id = :dept_id,
department_name = :dept_name, contact_number_1 = :phone_1,
contact_number_2 = :phone_2, email_id = :email_id,
qualification = :qualification, specialisation = :specialisation,
years_of_experience = :experience, address = :address,
city = :city, state = :state, pin_code = :pin
WHERE id = :id;
""",
{
'id': id, 'age': self.age, 'dept_id': self.department_id,
'dept_name': self.department_name,
'phone_1': self.contact_number_1,
'phone_2': self.contact_number_2, 'email_id': self.email_id,
'qualification': self.qualification,
'specialisation': self.specialisation,
'experience': self.years_of_experience,
'address': self.address, 'city': self.city,
'state': self.state, 'pin': self.pin_code
}
)
st.success('Doctor details updated successfully.')
conn.close()
def main():
st.set_page_config(page_title = "Traffic Flow Counter",
page_icon=":vertical_traffic_light:")
obj_detector = load_obj_detector(config, wt_file)
tracker = tc.CarsInFrameTracker(num_previous_frames = 10, frame_shape = (720, 1080))
state = SessionState.get(upload_key = None, enabled = True,
start = False, conf = 70, nms = 50, run = False)
hide_streamlit_widgets()
"""
# Traffic Flow Counter :blue_car: :red_car:
Upload a video file to track and count vehicles. Don't forget to change parameters to tune the model!
#### Features to be added in the future:
+ speed measurement
+ traffic density
+ vehicle type distribution
"""
with st.sidebar:
"""
## :floppy_disk: Parameters
"""
state.conf, state.nms = parameter_sliders(
keys, state.enabled, value = [state.conf, state.nms])
st.text("")
st.text("")
st.text("")
"""
#### :desktop_computer: [Source code in Github](https://github.com/aldencabajar/traffic_flow_counter)
"""
#set model confidence and nms threshold
if (state.conf is not None):
obj_detector.confidence = state.conf/ 100
if (state.nms is not None):
obj_detector.nms_threshold = state.nms/ 100
upload = st.empty()
start_button = st.empty()
stop_button = st.empty()
with upload:
f = st.file_uploader('Upload Video file (mpeg/mp4 format)', key = state.upload_key)
if f is not None:
tfile = tempfile.NamedTemporaryFile(delete = True)
tfile.write(f.read())
upload.empty()
vf = cv2.VideoCapture(tfile.name)
if not state.run:
start = start_button.button("start")
state.start = start
if state.start:
start_button.empty()
#state.upload_key = str(randint(1000, int(1e6)))
state.enabled = False
if state.run:
tfile.close()
f.close()
state.upload_key = str(randint(1000, int(1e6)))
state.enabled = True
state.run = False
ProcessFrames(vf, tracker, obj_detector, stop_button)
else:
state.run = True
trigger_rerun()
def add_doctor(self):
st.write('Enter doctor details:')
self.name = st.text_input('Full name')
gender = st.radio('Gender', ['Female', 'Male', 'Other'])
if gender == 'Other':
gender = st.text_input('Please mention')
self.gender = gender
dob = st.date_input('Date of birth (YYYY/MM/DD)')
st.info('If the required date is not in the calendar, please type it in the box above.')
self.date_of_birth = dob.strftime('%d-%m-%Y') # converts date of birth to the desired string format
self.age = calculate_age(dob)
self.blood_group = st.text_input('Blood group')
department_id = st.text_input('Department ID')
if department_id == '':
st.empty()
elif not department.verify_department_id(department_id):
st.error('Invalid Department ID')
else:
st.success('Verified')
self.department_id = department_id
self.department_name = get_department_name(department_id)
self.contact_number_1 = st.text_input('Contact number')
contact_number_2 = st.text_input('Alternate contact number (optional)')
self.contact_number_2 = (lambda phone : None if phone == '' else phone)(contact_number_2)
self.aadhar_or_voter_id = st.text_input('Aadhar ID / Voter ID')
self.email_id = st.text_input('Email ID')
self.qualification = st.text_input('Qualification')
self.specialisation = st.text_input('Specialisation')
self.years_of_experience = st.number_input('Years of experience', value = 0, min_value = 0, max_value = 100)
self.address = st.text_area('Address')
self.city = st.text_input('City')
self.state = st.text_input('State')
self.pin_code = st.text_input('PIN code')
self.id = generate_doctor_id()
save = st.button('Save')
# executing SQLite statements to save the new doctor record to the database
if save:
conn, c = db.connection()
with conn:
c.execute(
"""
INSERT INTO doctor_record
(
id, name, age, gender, date_of_birth, blood_group,
department_id, department_name, contact_number_1,
contact_number_2, aadhar_or_voter_id, email_id,
qualification, specialisation, years_of_experience,
address, city, state, pin_code
)
VALUES (
:id, :name, :age, :gender, :dob, :blood_group, :dept_id,
:dept_name, :phone_1, :phone_2, :uid, :email_id, :qualification,
:specialisation, :experience, :address, :city, :state, :pin
);
""",
{
'id': self.id, 'name': self.name, 'age': self.age,
'gender': self.gender, 'dob': self.date_of_birth,
'blood_group': self.blood_group,
'dept_id': self.department_id,
'dept_name': self.department_name,
'phone_1': self.contact_number_1,
'phone_2': self.contact_number_2,
'uid': self.aadhar_or_voter_id, 'email_id': self.email_id,
'qualification': self.qualification,
'specialisation': self.specialisation,
'experience': self.years_of_experience,
'address': self.address, 'city': self.city,
'state': self.state, 'pin': self.pin_code
}
)
st.success('Doctor details saved successfully.')
st.write('Your Doctor ID is: ', self.id)
conn.close()
def main():
local_css(
"/home/pasonatech/workspace/albumentations_forked/albumentations-demo/src/custom_css.css"
)
# logo_img = "/home/pasonatech/workspace/albumentations_forked/albumentations-demo/images/p.png"
# html_sticky = f"""
# <div class="sticky pt-2">
# <img class="img-fluid" src="data:image/png;base64,{base64.b64encode(open(logo_img, "rb").read()).decode()}">
# </div>
# """
# st.markdown(html_sticky ,unsafe_allow_html = True)
# get CLI params: the path to images and image width
path_to_images, width_original = get_arguments()
if not os.path.isdir(path_to_images):
st.title("There is no directory: " + path_to_images)
else:
# select interface type
interface_type = st.sidebar.radio(
"Select the interface mode",
["Simple", "Professional", "Custom", "LoadMyFile"])
#pick css
if interface_type == "LoadMyFile":
local_css(
"/home/pasonatech/workspace/albumentations_forked/albumentations-demo/src/custom_loadmy_css.css"
)
if interface_type == "Custom":
json_file_name = st.sidebar.text_input(
"Insert Json File Name", "aug_file") #text_area same format
json_file_name = os.path.join("./my_json_files",
f"{json_file_name}" + '.json')
# select image
status, image = select_image(path_to_images, interface_type)
if status == 1:
st.title("Can't load image")
if status == 2:
st.title("Please, upload the image")
else:
# image was loaded successfully
placeholder_params = get_placeholder_params(image)
# load the config
augmentations = load_augmentations_config(
placeholder_params, "configs/augmentations.json")
if interface_type is not "LoadMyFile":
# get the list of transformations names
transform_names = select_transformations(
augmentations, interface_type)
if interface_type is "Custom":
transforms = get_transormations_params_custom(
transform_names, augmentations, json_file_name)
elif interface_type is "LoadMyFile":
f_name = st.sidebar.file_uploader("Select your json file",
type="json")
view_times = 0
if f_name:
j_text = StringIO.read(f_name)
j_data = json.loads(j_text)
image_replace = st.empty()
st.image(image,
caption="Original image",
width=width_original)
if st.sidebar.button("Play Preview"):
view_times = 1
stop_btn = st.sidebar.button("STOP Preview")
if stop_btn:
view_times = 0
# for seconds in range(view_times):
# data =j_data
try:
transform = A.from_dict(j_data)
display_value = True
except KeyError:
st.error(
"Please, confirm your augmentations structure.")
st.error(
"Supports only albumentations augmentation generated 'A.to_dict()'."
)
# view_times = 0
display_value = False
while (view_times == 1):
try:
# data = json.load(open(file_name, 'r'))
# transform = A.from_dict(data)
aug_img_obj = transform(image=image)
# print(aug_img_obj.keys())
aug_img = aug_img_obj['image']
image_replace.image(
aug_img,
caption="Transformed image",
width=width_original,
)
except IOError:
st.error("Confirm your json file path.")
view_times = 0
except UnboundLocalError:
st.error(
"Your json file seems incompatible to run this task. "
)
view_times = 0
except ValueError as e:
image_replace.error(
e) #replaces error log in same field
pass
time.sleep(1)
if stop_btn is True:
st.info(
"Preview Stopped. Press Play Preview button to resume previewing."
)
if display_value:
if st.sidebar.checkbox(
"Display Augmentation Parameters"):
onetine_data_loader(j_data)
transforms = []
else:
st.header("WELCOME")
st.header("Please upload a JSON File")
else:
# get parameters for each transform
transforms = get_transormations_params(transform_names,
augmentations)
if interface_type is not "LoadMyFile":
try:
# apply the transformation to the image
data = A.ReplayCompose(transforms)(image=image)
error = 0
except ValueError:
error = 1
st.title(
"The error has occurred. Most probably you have passed wrong set of parameters. \
Check transforms that change the shape of image.")
# proceed only if everything is ok
if error == 0:
augmented_image = data["image"]
# show title
st.title("Demo of Albumentations")
# show the images
width_transformed = int(width_original / image.shape[1] *
augmented_image.shape[1])
st.image(image,
caption="Original image",
width=width_original)
st.image(
augmented_image,
caption="Transformed image",
width=width_transformed,
)
# comment about refreshing
st.write("*Press 'R' to refresh*")
#custom preview of aug list
# random values used to get transformations
show_random_params(data, interface_type)
for transform in transforms:
show_docstring(transform)
st.code(str(transform))
show_credentials()
# adding google analytics pixel
# only when deployed online. don't collect statistics of local usage
if "GA" in os.environ:
st.image(os.environ["GA"])
st.markdown(
("[Privacy policy]" +
("(https://htmlpreview.github.io/?" +
"https://github.com/IliaLarchenko/" +
"albumentations-demo/blob/deploy/docs/privacy.html)")
))
def test_empty(self):
"""Test Empty."""
st.empty()
element = self.get_delta_from_queue().new_element
self.assertEqual(element.empty, EmptyProto())
df = load_data()
length = len(df)
if length == 1:
st.write("This webpage contains 1 table")
else:
st.write("This webpage contains " + str(length) + " tables")
#st.write("This webpage contains " + str(length) + " tables" )
if st.button("Show scraped tables"):
st.table(df)
else:
st.empty()
def createList(r1, r2):
return [item for item in range(r1, r2 + 1)]
r1, r2 = 1, length
funct = createList(r1, r2)
###### Selectbox - Selectbox - Selectbox - Selectbox - Selectbox - Selectbox - Selectbox -
st.markdown('### **2️⃣ Select a table to export **')
ValueSelected = st.selectbox('', funct)
st.write('You selected table #', ValueSelected)
df1 = df[ValueSelected - 1]
with st.echo():
st.write("Code!")
# Progress and Status
import time
myBar = st.progress(0)
for percent in range(100):
time.sleep(0.05)
myBar.progress(percent + 1)
# Temporarily Text Display
with st.spinner('Wait for it...'):
time.sleep(1)
st.success("Done!")
# Ballons
st.balloons()
# Timer
import time
with st.empty():
for seconds in range(60):
st.write(f"⏳ {seconds} seconds have passed")
time.sleep(1)
st.write("✔️ 1 minute over!")
def app_object_detection():
"""Object detection demo with MobileNet SSD.
This model and code are based on
https://github.com/robmarkcole/object-detection-app
"""
MODEL_URL = "https://github.com/robmarkcole/object-detection-app/raw/master/model/MobileNetSSD_deploy.caffemodel" # noqa: E501
MODEL_LOCAL_PATH = HERE / "./models/MobileNetSSD_deploy.caffemodel"
PROTOTXT_URL = "https://github.com/robmarkcole/object-detection-app/raw/master/model/MobileNetSSD_deploy.prototxt.txt" # noqa: E501
PROTOTXT_LOCAL_PATH = HERE / "./models/MobileNetSSD_deploy.prototxt.txt"
CLASSES = [
"background",
"aeroplane",
"bicycle",
"bird",
"boat",
"bottle",
"bus",
"car",
"cat",
"chair",
"cow",
"diningtable",
"dog",
"horse",
"motorbike",
"person",
"pottedplant",
"sheep",
"sofa",
"train",
"tvmonitor",
]
COLORS = np.random.uniform(0, 255, size=(len(CLASSES), 3))
download_file(MODEL_URL, MODEL_LOCAL_PATH, expected_size=23147564)
download_file(PROTOTXT_URL, PROTOTXT_LOCAL_PATH, expected_size=29353)
DEFAULT_CONFIDENCE_THRESHOLD = 0.5
class Detection(NamedTuple):
name: str
prob: float
class MobileNetSSDVideoTransformer(VideoTransformerBase):
confidence_threshold: float
result_queue: "queue.Queue[List[Detection]]"
def __init__(self) -> None:
self._net = cv2.dnn.readNetFromCaffe(
str(PROTOTXT_LOCAL_PATH), str(MODEL_LOCAL_PATH)
)
self.confidence_threshold = DEFAULT_CONFIDENCE_THRESHOLD
self.result_queue = queue.Queue()
def _annotate_image(self, image, detections):
# loop over the detections
(h, w) = image.shape[:2]
result: List[Detection] = []
for i in np.arange(0, detections.shape[2]):
confidence = detections[0, 0, i, 2]
if confidence > self.confidence_threshold:
# extract the index of the class label from the `detections`,
# then compute the (x, y)-coordinates of the bounding box for
# the object
idx = int(detections[0, 0, i, 1])
box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
(startX, startY, endX, endY) = box.astype("int")
name = CLASSES[idx]
result.append(Detection(name=name, prob=float(confidence)))
# display the prediction
label = f"{name}: {round(confidence * 100, 2)}%"
cv2.rectangle(image, (startX, startY), (endX, endY), COLORS[idx], 2)
y = startY - 15 if startY - 15 > 15 else startY + 15
cv2.putText(
image,
label,
(startX, y),
cv2.FONT_HERSHEY_SIMPLEX,
0.5,
COLORS[idx],
2,
)
return image, result
def transform(self, frame: av.VideoFrame) -> np.ndarray:
image = frame.to_ndarray(format="bgr24")
blob = cv2.dnn.blobFromImage(
cv2.resize(image, (300, 300)), 0.007843, (300, 300), 127.5
)
self._net.setInput(blob)
detections = self._net.forward()
annotated_image, result = self._annotate_image(image, detections)
# NOTE: This `transform` method is called in another thread,
# so it must be thread-safe.
self.result_queue.put(result)
return annotated_image
webrtc_ctx = webrtc_streamer(
key="object-detection",
mode=WebRtcMode.SENDRECV,
client_settings=WEBRTC_CLIENT_SETTINGS,
video_transformer_factory=MobileNetSSDVideoTransformer,
async_transform=True,
)
confidence_threshold = st.slider(
"Confidence threshold", 0.0, 1.0, DEFAULT_CONFIDENCE_THRESHOLD, 0.05
)
if webrtc_ctx.video_transformer:
webrtc_ctx.video_transformer.confidence_threshold = confidence_threshold
if st.checkbox("Show the detected labels", value=True):
if webrtc_ctx.state.playing:
labels_placeholder = st.empty()
# NOTE: The video transformation with object detection and
# this loop displaying the result labels are running
# in different threads asynchronously.
# Then the rendered video frames and the labels displayed here
# are not strictly synchronized.
while True:
if webrtc_ctx.video_transformer:
try:
result = webrtc_ctx.video_transformer.result_queue.get(
timeout=1.0
)
except queue.Empty:
result = None
labels_placeholder.table(result)
else:
break
st.markdown(
"This demo uses a model and code from "
"https://github.com/robmarkcole/object-detection-app. "
"Many thanks to the project."
)
def bar_plot(self, data_row):
empty_plot1 = st.empty()
empty_plot2 = st.empty()
num_mat = len(data_row['material'].unique().tolist())
i = 0
xx = pd.DataFrame({'radius_nm': data_row['radius_nm'].unique()})
xx = xx['radius_nm'].to_numpy()
yy = np.zeros(len(xx))
for material in data_row['material'].unique().tolist():
data = data_row[data_row['material'] == material]
data_medie = pd.DataFrame({'radius_nm': data['radius_nm'].unique()})
raggi = data['radius_nm'].unique().tolist()
media_quality = []
media_speed = []
media_error_q = []
media_error_s = []
media_material = []
for raggio in raggi:
media_quality.append(data['normalized_signal_quality'][data['radius_nm'] == raggio].mean())
media_speed.append(data['signal_speed'][data['radius_nm'] == raggio].mean())
media_error_q.append(data['normalized_signal_quality'][data['radius_nm'] == raggio].std())
media_error_s.append(data['signal_speed'][data['radius_nm'] == raggio].std())
media_material.append(material)
data_medie['normalized_signal_quality'] = media_quality
data_medie['signal_speed'] = media_speed
data_medie['normalized_signal_quality_err'] = media_error_q
data_medie['signal_speed_err'] = media_error_s
data_medie['material'] = media_material
data_medie = data_medie.fillna(0)
st.write(material)
st.table(data)
delta_delay = (12)/num_mat
delay = -3 + delta_delay*i
ds().nuova_fig(30)
ds().titoli(titolo='Normalized Signal Intensity', xtag='radius[nm]', ytag='counts')
ds().dati(x = data_medie['radius_nm'].to_numpy(), y = data_medie['normalized_signal_quality'].to_numpy(), scat_plot = 'bar', delay = delay, width = 3, descrizione=material)
ds().dati(x = data_medie['radius_nm'].to_numpy()+delay/2, y = data_medie['normalized_signal_quality'].to_numpy(), y_error=data_medie['normalized_signal_quality_err'].to_numpy()/2, scat_plot = 'err', colore='black')
ds().dati(x = data['radius_nm']+delay/2, y = data['normalized_signal_quality'], scat_plot ='scat', colore="blue", larghezza_riga =12, layer = 2)
ds().dati(x = xx, y = yy, scat_plot ='bar', width = 3, delay = 0)
ds().legenda()
ds().nuova_fig(31)
ds().titoli(titolo='Slope (C)', xtag='radius[nm]', ytag='T/I [k/uW]')
ds().dati(x = data_medie['radius_nm'].to_numpy(), y = data_medie['signal_speed'].to_numpy(), scat_plot = 'bar', delay = delay, width = 3, descrizione=material)
ds().dati(x = data_medie['radius_nm'].to_numpy()+delay/2, y = data_medie['signal_speed'].to_numpy(), y_error=data_medie['signal_speed_err'].to_numpy()/2, scat_plot = 'err', colore='black')
ds().dati(x = data['radius_nm']+delay/2, y = data['signal_speed'], scat_plot ='scat', colore="blue", larghezza_riga =12, layer = 2)
ds().dati(x = xx, y = yy, scat_plot ='bar', width = 3, delay = 0)
ds().legenda()
i = i+1
ds().nuova_fig(30)
empty_plot1.pyplot()
ds().nuova_fig(31)
empty_plot2.pyplot()
url = url + '.json'
post_ids = requests.get(url).json()['post_stream']['stream']
'## Analysis'
msg = 'There are %s posts in the selected thread.' % len(post_ids)
if len(post_ids) > 20:
msg = msg + ' Will load and analyze the first 20.'
post_ids = post_ids[0:20]
msg
try:
classifier = get_classifier('sentiment-analysis')
post_results = []
progress_wrapper = st.empty()
post_progress = progress_wrapper.progress(0)
for i, post_id in enumerate(post_ids):
# https://us.forums.blizzard.com/en/wow/posts/<post_id>.json
post = get_post(post_id)
post_text = post['raw'].replace('\n', ' ')
# '* ' + post_text
results = classifier(post_text)
post_progress.progress((i+1)/len(post_ids))
if results[0]['score'] > 0.75:
post_results.append({
'text': post['raw'],
'url': 'https://us.forums.blizzard.com/en/wow/p/%s' % post['id'],
'sentiment': results[0]['label'],
'score': results[0]['score']
language_index = st.selectbox("Select spoken language in file",
('Polish', 'English'))
uploaded_file = st.file_uploader("Choose a file...", type=["mp4", 'mp3'])
if uploaded_file is not None:
if uploaded_file.name.lower().strip().endswith("mp4"):
name = uploaded_file.name.replace(" ", "").replace(".", "_")
output_path = 'uploads/' + name + '.mp4'
if not os.path.exists(output_path):
preprocessing.upload_temporary(io.BytesIO(uploaded_file.read()),
output_path)
placeholder = st.empty()
placeholder.text('Sampling video...')
bar_placeholder = st.empty()
bar_placeholder.progress(0)
fps = preprocessing.get_fps(output_path)
placeholder.text('Sampling video...')
frame_path = 'frames/frames_' + name
if not os.path.exists(frame_path):
os.makedirs(frame_path, exist_ok=True)
preprocessing.get_frames(output_path, frame_path, fps, 30,
bar_placeholder)
placeholder.text('Magic happens...')
bar_placeholder.progress(0)
# st.image(image_x)
# st.stop()
# image_tensor = torch.tensor(dataset[0][0])
# image_tensor = image_tensor.unsqueeze(0)
# image_tensor = image_tensor.unsqueeze(0)
# image = image_tensor.squeeze(0).squeeze(0).numpy()
# st.image(image, 'original image')
# unfolded = torch.nn.functional.unfold(image_tensor, (5, 5), stride=5, padding=10)
# print(unfolded.shape)
# recovered_tensor = torch.nn.functional.fold(unfolded, output_size=(128, 128), kernel_size=(5, 5), stride=5, padding=10)
# image = recovered_tensor.squeeze(0).squeeze(0).clamp(0, 1).numpy()
# st.image(image, 'recovered image')
# exit()
st_orig_image = st.empty()
st_memorized_image = st.empty()
st_loss = st.empty()
for image_x, image_y in dataset:
image_tensor = torch.tensor(image_y)
net.add(torch.tensor(image_x))
print(net(torch.tensor(dataset[2][1])))
# exit()
average = torch.tensor([0])
# images = []
for image_x, image_y in dataset:
average += image_y
# images.append(image_y.flatten())
average /= len(dataset)
import streamlit as st
import pandas as pd
import numpy as np
import time
st.title('Metaverse Launcher')
st.sidebar.title("Test Agents")
if st.sidebar.button('Launch'):
"this is where we launch stuff"
progress_bar = st.progress(0)
status_text = st.empty()
chart = st.line_chart(np.random.randn(10, 2))
for i in range(100):
# Update progress bar.
progress_bar.progress(i + 1)
new_rows = np.random.randn(10, 2)
# Update status text.
status_text.text('The latest random number is: %s' % new_rows[-1, 1])
# Append data to the chart.
chart.add_rows(new_rows)
# Pretend we're doing some computation that takes time.
time.sleep(0.1)
