def show_progress_bar(scan_job):
from ipywidgets import FloatProgress, Label, VBox, HBox
from IPython.display import display
progress_bars = []
scan_progress = FloatProgress(value=0.0, min=0.0, max=1.0, step=0.01, bar_style='info')
scan_label = Label('Scan user repositories')
box = VBox([
Label('GitHub user "{}"'.format(scan_job.args[-1])),
HBox([ scan_progress, scan_label ]),
])
display(box)
bar_styles = {'queued': 'info', 'started': 'info', 'deferred': 'warning', 'failed': 'danger', 'finished': 'success' }
while True:
scan_job.refresh()
if 'finished' in scan_job.meta:
percentage_complete = sum(scan_job.meta['finished'].values()) / max(sum(scan_job.meta['steps'].values()), 1)
scan_progress.value = 1.0 if scan_job.status == 'finished' else max(0.01, percentage_complete) # the metadata is bogus once the job is finished
scan_progress.bar_style = bar_styles[scan_job.status]
if scan_job.status == 'finished':
scan_progress.value = 1.0
scan_progress.bar_style = bar_styles[scan_job.status]
break
elif scan_job.status == 'failed':
scan_progress.value = max(0.01, scan_progress.value)
break
else:
time.sleep(2)
def benchmark(param, param_range=[0, 1, 0.1], learn=[], learn_i=[], test=[], test_i=[], learn_v="auto", test_v="auto", options={}, folder_learn="src/learning/", folder_test="src/tests/", neurons=(100), curve="interpolate"):
"""
Effectue un banc de tests avec des paramètres donnés en évaluant la précision du réseau de neurones artificiels.
:param param: Nom du paramètre à changer (doit être le nom de la variable tel que défini dans la fonction compare)
:type param: string (paramètre accepté par la fonction compare)
:param param_range: Tableau tridimensionnel contenant la valeur de début, de fin et le pas
:type param_range: number[start, end, step]
:param learn: Liste de noms formattable des échantillons d'apprentissage
:type learn: string[]
:param test: Liste de noms formattable des échantillons de test
:type test: string[]
:param learn_i: Liste de range (de 1 à n) pour la génération des fichiers du paramètre learn
:type learn_i: number[]
:param test_i: Liste de range (de 1 à n) pour la génération des fichiers du paramètre test
:type test_i: number[]
:param learn_v: Liste des valeurs des échantillons d'apprentissage (déterminé selon le nom du fichier si non précisé)
:type learn_v: string[]
:param test_v: Liste des valeurs des échantillons de test (déterminé selon le nom du fichier si non précisé)
:type test_v: string[]
:param folder_learn: Dossier contenant les échantillons d'apprentissage
:type folder_learn: string
:param folder_test: Dossier contenant les échantillons de tests
:type folder_test: string
:param options: Options de comparaison (voir la documentation de compare, certains paramètres sont requis)
:type options: object
:param neurons: Nombre de couches et de neuronnes
:type neurons: (number, ...)
"""
# Initialisation
x = []
y = []
# Barre de progression
progress = FloatProgress(min=param_range[0], max=param_range[1]+param_range[2], description="En attente...")
display(progress)
# Récupération des noms de fichiers pour réduire les temps de calculs
#_learn = learning_files(learn, learn_i)
#_test = learning_files(test, test_i)
# Variation du paramètre
for value in np.arange(param_range[0], param_range[1]+param_range[2], param_range[2]):
# Calculs en cours
progress.value = value
progress.description = "{p} : {v}".format(p=param, v=value)
options[param] = value
x.append(value)
y.append(learning(
learn=learn, learn_i=learn_i, test=test, test_i=test_i, learn_v=learn_v, test_v=test_v,
debug=False, benchmark_only=True, progress=[progress, param_range[2]],
options=options, folder_learn=folder_learn, folder_test=folder_test, neurons=neurons
))
# Mise à jour de la barre de progression
progress.value = progress.max
progress.description = "Terminé !"
progress.bar_style = "success"
# Nouvelle figure
plt.figure(figsize=(8, 8), dpi= 80, facecolor="w", edgecolor="k")
ax = plt.subplot(111)
if (curve == "interpolate") and (len(x) >= 3):
xi = np.linspace(x[0], x[-1], num=len(x)*10)
ax.plot(xi, interp1d(x, y, kind="cubic")(xi))
else:
ax.plot(x, y)
ax.set_xlabel("Variation du paramètre {x}".format(x=param))
ax.set_xlim(param_range[0], param_range[1])
ax.set_ylabel("Précision")
ax.set_ylim(0, 1)
plt.show()
return x, y
def live_record2(filters, filters_fq, time_res, amp_res, fs, last, formants, drc_tl, drc_th, drc_r, duration, adc_res, predict):
import pyaudio
# Taille des blocs enregistrés
chunk_size = 4096
# Barre de progression
maxi = int(np.ceil(fs / chunk_size * duration))
progress = FloatProgress(min=0, max=maxi, description="Chargement")
display(progress)
# Initialisation
plt.ion()
f, ax = plt.subplots(2, 1, figsize=(24, 12), dpi= 80, facecolor="w", edgecolor="k")
f.show()
# Boucle principale
try:
while True:
# Ouverture du flux
p = pyaudio.PyAudio()
stream = p.open(format=pyaudio.paInt16, channels=1, rate=fs, input=True, frames_per_buffer=chunk_size)
# Enregistrement
frames = []
progress.value = progress.min
progress.description = "Enregistrement"
progress.bar_style = ""
for i in range(0, maxi):
data = stream.read(chunk_size)
frames.append(data)
progress.value = i
# Mise à jour de la barre de progression
progress.value = progress.max
progress.description = "Terminé !"
progress.bar_style = "success"
# Fermeture du flux
stream.stop_stream()
stream.close()
p.terminate()
# Enregistrement
wf = wave.open("src/record.wav", "wb")
wf.setnchannels(1)
wf.setsampwidth(p.get_sample_size(pyaudio.paInt16))
wf.setframerate(fs)
wf.writeframes(b''.join(frames))
wf.close()
# Traitement
ax[0].clear() ; ax[1].clear()
_, _, rseqs = compute(file="src/record.wav", filters=filters, filters_fq=filters_fq, time_res=time_res, amp_res=amp_res, ax=ax, dbfs=False, drc_tl=drc_tl, drc_th=drc_th, drc_r=drc_r, adc_res=adc_res)
# Prédiction
if predict:
f.suptitle(predict(rseqs, name=False, debug=False)[0], fontsize=30)
# Pas très joli, mais évite le NonImplemented error ?
try:
plt.pause(3)
except Exception:
continue
# Masque l'erreur en cas d'interruption du Kernel
except KeyboardInterrupt:
# Fermeture du flux
stream.stop_stream()
stream.close()
p.terminate()
clear_output()
plt.close()
print("Terminé !")
return
