From d86788019957cfec119dca93b1a87894cab38cde Mon Sep 17 00:00:00 2001 From: Fabio Manganiello Date: Wed, 28 Oct 2020 18:12:19 +0100 Subject: [PATCH] Added proper README and examples --- .gitignore | 3 + LICENSE.txt | 22 ++ README.md | 313 ++++++++++++++++++++++++++++ examples/predict_from_audio_file.py | 16 ++ examples/predict_from_microphone.py | 18 ++ examples/train.py | 54 +++++ micmon/__init__.py | 2 +- micmon/audio/file.py | 27 ++- micmon/model/__init__.py | 9 +- micmon/utils/__init__.py | 0 micmon/utils/datagen.py | 117 +++++++++++ notebooks/dataset.ipynb | 141 +++++++++---- notebooks/predict.ipynb | 26 +-- notebooks/train.ipynb | 93 ++++----- requirements.txt | 3 + setup.py | 40 ++++ 16 files changed, 764 insertions(+), 120 deletions(-) create mode 100644 LICENSE.txt create mode 100644 README.md create mode 100644 examples/predict_from_audio_file.py create mode 100644 examples/predict_from_microphone.py create mode 100644 examples/train.py create mode 100644 micmon/utils/__init__.py create mode 100644 micmon/utils/datagen.py create mode 100644 requirements.txt create mode 100755 setup.py diff --git a/.gitignore b/.gitignore index dfe0523..cb9d68c 100644 --- a/.gitignore +++ b/.gitignore @@ -3,3 +3,6 @@ /data/ /models/ __pycache__ +/build +/dist +*.egg-info diff --git a/LICENSE.txt b/LICENSE.txt new file mode 100644 index 0000000..999f670 --- /dev/null +++ b/LICENSE.txt @@ -0,0 +1,22 @@ +MIT License + +Copyright (c) 2017, 2020 Fabio Manganiello + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + diff --git a/README.md b/README.md new file mode 100644 index 0000000..fe7f98d --- /dev/null +++ b/README.md @@ -0,0 +1,313 @@ +micmon +====== + +*micmon* is a ML-powered library to detect sounds in an audio stream, +either from a file or from an audio input. The use case for its development +has been the creation of a self-built baby monitor to detect the cries +of my new born through a RaspberryPi + USB microphone, but it should be +good enough to detect any type of noise or audio if used with a well trained +model. + +It works by splitting an audio stream into short segments, it calculates the +FFT and spectrum bins for each of these segments, and it uses such spectrum +data to train a model to detect the audio. It works well with sounds that are +loud enough to stand out of the background (it's good at detecting e.g. the +sound of an alarm clock, not the sound of flying mosquitto), that are long +enough compared to the size of the chunks (very short sounds will leave a +very small trace in the spectrum of an audio chunk) and, even better, if +their frequency bandwidth doesn't overlap a lot with other sounds (it's good +at detecting the cries of your baby, since his/her voice has a higher pitch +than yours, but it may not detect difference in the spectral signature of +the voice of two adult men in the same age group). It's not going to perform +very well if instead you are trying to use to detect speech - since it operates +on time-agnostic frequency data from chunks of audio it's not granular enough +for proper speech-to-text applications, and it wouldn't be robust enough to +detect differences in voice pitch, tone or accent. + +Dependencies +------------ + +The software uses *ffmpeg* to record and decode audio - check instructions for +your OS on how to get it installed. It also requires *lame* or any other mp3 +encoder to encode captured audio to mp3. + +Python dependencies: + +```bash +pip install numpy tensorflow keras + +# Optional, for graphs +pip install matplotlib +``` + +Installation +------------ + +```bash +git clone https://github.com/BlackLight/micmon +cd micmon +python setup.py install +``` + +Audio capture +------------- + +Once the software is installed, you can proceed with recording some audio that +will be used for training the model. First create a directory for your audio +samples dataset: + +```bash +# This folder will store our audio samples +mkdir -p ~/datasets/sound-detect/audio + +# This folder will store the datasets +# generated from the labelled audio samples +mkdir -p ~/datasets/sound-detect/data + +# This folder will store the generated +# Tensorflow models +mkdir -p ~/models + +cd ~/datasets/sound-detect/audio +``` + +Then create a new sub-folder for your first audio sample and start recording. +Example: + +```bash +mkdir sample_1 +cd sample_1 +arecord -D plughw:0,1 -f cd | lame - audio.mp3 +``` + +In the example above we are using *arecord* to record from the second channel +of the first audio device (check a list of available recording devices with +*arecord -l*) in WAV format, and we are then using the *lame* encoder to +convert the raw audio to mp3. When done with recording, just Ctrl-C the +application and your audio file will be ready. + +Audio labelling +--------------- + +In the same directory as your sample (in the example above it will be +`~/datasets/sound-detect/audio/sample_1`) create a new file named +`labels.json`. Now open your audio file in Audacity or any audio player +and identify the audio segments that match your criteria - for example +when your baby is crying, when the alarm starts, when your neighbour +starts drilling the wall, or whatever the criteria is. `labels.json` +should contain a key-value mapping in the form of `start_time -> label`. +Example: + +```json +{ + "00:00": "negative", + "02:13": "positive", + "04:57": "negative", + "15:41": "positive", + "18:24": "negative" +} +``` + +In the example above, all the audio segments between 00:00 and 02:12 will +be labelled as negative, all the segments between 02:13 and 04:56 as +positive, and so on. + +You can now use *micmon* to generate a frequency spectrum dataset out of +your labelled audio. You can do it either through the `micmon-datagen` +script or with your own script. + +### micmon-datagen + +Type `micmon-datagen --help` to get a full list of the available options. +In general, `micmon-datagen` requires a directory that contains the labelled +audio samples sub-directories as input and a directory where the calculated +numpy-compressed datasets will be stored. If you want to generate the dataset +for the audio samples captured on the previous iteration then the command +will be something like this: + +```bash +micmon-datagen --low 250 --high 7500 --bins 100 --sample-duration 2 --channels 1 \ + ~/datasets/sound-detect/audio ~/models +``` + +The `--low` and `--high` options respectively identify the lowest and highest +frequencies that should be taken into account in the output spectrum. By default +these values are 20 Hz and 20 kHz (respectively the lowest and highest frequency +audible to a healthy and young human ear), but you can narrow down the frequency +space to only detect the frequencies that you're interested in and to remove +high-frequency harmonics that may spoil your data. A good way to estimate the +frequency space is to use e.g. Audacity or any audio equalizer to select the +segments of your audio that contain the sounds that you want to detect and +check their dominant frequencies - you definitely want those frequencies to be +included in your range. + +`--bins` specifies in how many segments/buckets the frequency spectrum should +be split - 100 bins is the default value. `--sample-duration` specifies the +duration in seconds for each spectrum data point - 2 seconds is the default +value, i.e. the audio samples will be read in chunks of 2 seconds each and the +spectrum will be calculated for each of these chunks. If the sounds you want to +detect are shorter then you may want to reduce this value. + +### Generate the dataset via script + +The other way to generate the dataset from the audio is through the *micmon* API +itself. This option also enables you to take a peek at the audio data to better +calibrate the parameters. For example: + +```python +import os + +from micmon.audio import AudioDirectory, AudioPlayer, AudioFile +from micmon.dataset import DatasetWriter + +basedir = os.path.expanduser('~/datasets/sound-detect') +audio_dir = os.path.join(basedir, 'audio/sample_1') +datasets_dir = os.path.join(basedir, 'data') +cutoff_frequencies = [250, 7500] + +# Scan the base audio_dir for labelled audio samples +audio_dirs = AudioDirectory.scan(audio_dir) + +# Play some audio samples starting from 01:00 +for audio_dir in audio_dirs: + with AudioFile(audio_dir, start='01:00', duration=5) as reader, \ + AudioPlayer() as player: + for sample in reader: + player.play(sample) + +# Plot the audio and spectrum of the audio samples in the first 10 seconds +# of each audio file. +for audio_dir in audio_dirs: + with AudioFile(audio_dir, start=0, duration=10) as reader: + for sample in reader: + sample.plot_audio() + sample.plot_spectrum(low_freq=cutoff_frequencies[0], + high_freq=cutoff_frequencies[1]) + +# Save the spectrum information and labels of the samples to a +# different compressed file for each audio file. +for audio_dir in audio_dirs: + dataset_file = os.path.join(datasets_dir, os.path.basename(audio_dir.path) + '.npz') + print(f'Processing audio sample {audio_dir.path}') + + with AudioFile(audio_dir) as reader, \ + DatasetWriter(dataset_file, + low_freq=cutoff_frequencies[0], + high_freq=cutoff_frequencies[1]) as writer: + for sample in reader: + writer += sample + +``` + +Training the model +------------------ + +Once you have some `.npz` datasets saved under `~/datasets/sound-detect/data`, you can +use those datasets to train a Tensorflow+Keras model to classify an audio segment. A full +example is available under `examples/train.py`: + +```python +import os +from keras import layers + +from micmon.dataset import Dataset +from micmon.model import Model + +# This is a directory that contains the saved .npz dataset files +datasets_dir = os.path.expanduser('~/datasets/sound-detect/data') + +# This is the output directory where the model will be saved +model_dir = os.path.expanduser('~/models/sound-detect') + +# This is the number of training epochs for each dataset sample +epochs = 2 + +# Load the datasets from the compressed files. +# 70% of the data points will be included in the training set, +# 30% of the data points will be included in the evaluation set +# and used to evaluate the performance of the model. +datasets = Dataset.scan(datasets_dir, validation_split=0.3) +labels = ['negative', 'positive'] +freq_bins = len(datasets[0].samples[0]) + +# Create a network with 4 layers (one input layer, two intermediate layers and one output layer). +# The first intermediate layer in this example will have twice the number of units as the number +# of input units, while the second intermediate layer will have 75% of the number of +# input units. We also specify the names for the labels and the low and high frequency range +# used when sampling. +model = Model( + [ + layers.Input(shape=(freq_bins,)), + layers.Dense(int(2 * freq_bins), activation='relu'), + layers.Dense(int(0.75 * freq_bins), activation='relu'), + layers.Dense(len(labels), activation='softmax'), + ], + labels=labels, + low_freq=datasets[0].low_freq, + high_freq=datasets[0].high_freq +) + +# Train the model +for epoch in range(epochs): + for i, dataset in enumerate(datasets): + print(f'[epoch {epoch+1}/{epochs}] [audio sample {i+1}/{len(datasets)}]') + model.fit(dataset) + evaluation = model.evaluate(dataset) + print(f'Validation set loss and accuracy: {evaluation}') + +# Save the model +model.save(model_dir, overwrite=True) +``` + +At the end of the process you should find your Tensorflow model saved under `~/models/sound-detect`. +You can use it in your scripts to classify audio samples from audio sources. + +Classifying audio samples +------------------------- + +One use case is to analyze an audio file and use the model to detect specific sounds. Example: + +```python +import os + +from micmon.audio import AudioFile +from micmon.model import Model + +model_dir = os.path.expanduser('~/models/sound-detect') +model = Model.load(model_dir) +cur_seconds = 60 +sample_duration = 2 + +with AudioFile('/path/to/some/audio.mp3', + start=cur_seconds, duration='10:00', + sample_duration=sample_duration) as reader: + for sample in reader: + prediction = model.predict(sample) + print(f'Audio segment at {cur_seconds} seconds: {prediction}') + cur_seconds += sample_duration +``` + +Another is to analyze live audio samples imported from an audio device - e.g. a USB microphone. +Example: + +```python +import os + +from micmon.audio import AudioDevice +from micmon.model import Model + +model_dir = os.path.expanduser('~/models/sound-detect') +model = Model.load(model_dir) +audio_system = 'alsa' # Supported: alsa and pulse +audio_device = 'plughw:1,0' # Get list of recognized input devices with arecord -l + +with AudioDevice(audio_system, device=audio_device) as source: + for sample in source: + source.pause() # Pause recording while we process the frame + prediction = model.predict(sample) + print(prediction) + source.resume() # Resume recording +``` + +You can use these two examples as blueprints to set up your own automation routines +with sound detection. diff --git a/examples/predict_from_audio_file.py b/examples/predict_from_audio_file.py new file mode 100644 index 0000000..385ee94 --- /dev/null +++ b/examples/predict_from_audio_file.py @@ -0,0 +1,16 @@ +import os + +from micmon.audio import AudioFile +from micmon.model import Model + +model_dir = os.path.expanduser('~/models/sound-detect') +model = Model.load(model_dir) +cur_seconds = 60 +sample_duration = 2 + +with AudioFile('/path/to/some/audio.mp3', start=cur_seconds, duration='10:00', + sample_duration=sample_duration) as reader: + for sample in reader: + prediction = model.predict(sample) + print(f'Audio segment at {cur_seconds} seconds: {prediction}') + cur_seconds += sample_duration diff --git a/examples/predict_from_microphone.py b/examples/predict_from_microphone.py new file mode 100644 index 0000000..02f629c --- /dev/null +++ b/examples/predict_from_microphone.py @@ -0,0 +1,18 @@ +import os + +from micmon.audio import AudioDevice +from micmon.model import Model + +# Path to a previously saved sound detection Tensorflow model +model_dir = os.path.expanduser('~/models/sound-detect') +model = Model.load(model_dir) + +audio_system = 'alsa' # Supported: alsa and pulse +audio_device = 'plughw:1,0' # Get list of recognized input devices with arecord -l + +with AudioDevice(audio_system, device=audio_device) as source: + for sample in source: + source.pause() # Pause recording while we process the frame + prediction = model.predict(sample) + print(prediction) + source.resume() # Resume recording diff --git a/examples/train.py b/examples/train.py new file mode 100644 index 0000000..80d9e25 --- /dev/null +++ b/examples/train.py @@ -0,0 +1,54 @@ +# This script shows how to train a neural network to detect sounds given a training set of collected frequency +# spectrum data. + +import os +from keras import layers + +from micmon.dataset import Dataset +from micmon.model import Model + +# This is a directory that contains the saved .npz dataset files +datasets_dir = os.path.expanduser('~/datasets/baby-monitor/datasets') + +# This is the output directory where the model will be saved +model_dir = os.path.expanduser(os.path.join('~', 'models', 'baby-monitor')) + +# This is the number of training epochs for each dataset sample +epochs = 2 + +# This value establishes the share of the dataset to be used for cross-validation +validation_split = 0.3 + +# Load the datasets from the compressed files +datasets = Dataset.scan(datasets_dir, validation_split=0.3) + +# Get the number of frequency bins +freq_bins = len(datasets[0].samples[0]) + +# Create a network with 4 layers (one input layer, two intermediate layers and one output layer). +# The first intermediate layer in this example will have twice the number of units as the number +# of input units, while the second intermediate layer will have as many units as the number of +# input units. We also specify the names for the labels and the low and high frequency range +# used when sampling. +model = Model( + [ + layers.Input(shape=(freq_bins,)), + layers.Dense(int(2.0 * freq_bins), activation='relu'), + layers.Dense(int(freq_bins), activation='relu'), + layers.Dense(len(datasets[0].labels), activation='softmax'), + ], + labels=['negative', 'positive'], + low_freq=datasets[0].low_freq, + high_freq=datasets[0].high_freq, +) + +# Train the model +for epoch in range(epochs): + for i, dataset in enumerate(datasets): + print(f'[epoch {epoch+1}/{epochs}] [audio sample {i+1}/{len(datasets)}]') + model.fit(dataset) + evaluation = model.evaluate(dataset) + print(f'Validation set loss and accuracy: {evaluation}') + +# Save the model +model.save(model_dir, overwrite=True) diff --git a/micmon/__init__.py b/micmon/__init__.py index cfcda48..cf4e6e3 100644 --- a/micmon/__init__.py +++ b/micmon/__init__.py @@ -1,4 +1,4 @@ import logging import sys -logging.basicConfig(level=logging.DEBUG, stream=sys.stdout) +logging.basicConfig(level=logging.INFO, stream=sys.stdout) diff --git a/micmon/audio/file.py b/micmon/audio/file.py index ffed5e8..a314210 100644 --- a/micmon/audio/file.py +++ b/micmon/audio/file.py @@ -1,24 +1,40 @@ import json +import os +import pathlib from typing import Optional, List, Tuple, Union -from micmon.audio import AudioDirectory, AudioSegment, AudioSource +from micmon.audio import AudioSegment, AudioSource, AudioDirectory class AudioFile(AudioSource): - def __init__(self, path: AudioDirectory, + def __init__(self, + audio_file: Union[str, AudioDirectory], + labels_file: Optional[str] = None, start: Union[str, int, float] = 0, duration: Optional[Union[str, int, float]] = None, *args, **kwargs): super().__init__(*args, **kwargs) + if isinstance(audio_file, AudioDirectory): + audio_file = audio_file.audio_file + labels_file = audio_file.labels_file + + self.audio_file = os.path.abspath(os.path.expanduser(audio_file)) + + if not labels_file: + labels_file = os.path.join(pathlib.Path(self.audio_file).parent, 'labels.json') + if not os.path.isfile(labels_file): + labels_file = None + + self.labels_file = os.path.abspath(os.path.expanduser(labels_file)) if labels_file else None self.ffmpeg_args = ( - self.ffmpeg_bin, '-i', path.audio_file, *(('-ss', str(start)) if start else ()), + self.ffmpeg_bin, '-i', audio_file, *(('-ss', str(start)) if start else ()), *(('-t', str(duration)) if duration else ()), *self.ffmpeg_base_args ) self.start = self.convert_time(start)/1000 self.duration = self.convert_time(duration)/1000 - self.segments = self.parse_labels_file(path.labels_file) \ - if path.labels_file else [] + self.segments = self.parse_labels_file(labels_file) \ + if labels_file else [] self.labels = sorted(list(set(label for timestamp, label in self.segments))) self.cur_time = self.start @@ -53,4 +69,3 @@ class AudioFile(AudioSource): return audio raise StopIteration - diff --git a/micmon/model/__init__.py b/micmon/model/__init__.py index 88dc49a..31212e4 100644 --- a/micmon/model/__init__.py +++ b/micmon/model/__init__.py @@ -2,7 +2,7 @@ import json import os import numpy as np -from typing import List, Optional, Union, Tuple +from typing import List, Optional, Union from keras import Sequential, losses, optimizers, metrics from keras.layers import Layer from keras.models import load_model, Model as _Model @@ -20,10 +20,11 @@ class Model: model: Optional[_Model] = None, optimizer: Union[str, optimizers.Optimizer] = 'adam', loss: Union[str, losses.Loss] = losses.SparseCategoricalCrossentropy(from_logits=True), metrics: List[Union[str, metrics.Metric]] = ('accuracy',), - cutoff_frequencies: Tuple[int, int] = (AudioSegment.default_low_freq, AudioSegment.default_high_freq)): + low_freq: int = AudioSegment.default_low_freq, + high_freq: int = AudioSegment.default_high_freq): assert layers or model self.label_names = labels - self.cutoff_frequencies = list(map(int, cutoff_frequencies)) + self.cutoff_frequencies = (int(low_freq), int(high_freq)) if layers: self._model = Sequential(layers) @@ -74,4 +75,4 @@ class Model: with open(freq_file, 'r') as f: frequencies = json.load(f) - return cls(model=model, labels=label_names, cutoff_frequencies=frequencies) + return cls(model=model, labels=label_names, low_freq=frequencies[0], high_freq=frequencies[1]) diff --git a/micmon/utils/__init__.py b/micmon/utils/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/micmon/utils/datagen.py b/micmon/utils/datagen.py new file mode 100644 index 0000000..d703aad --- /dev/null +++ b/micmon/utils/datagen.py @@ -0,0 +1,117 @@ +import argparse +import logging +import os +import sys + +from micmon.audio import AudioDirectory, AudioFile, AudioSegment +from micmon.dataset import DatasetWriter + +logger = logging.getLogger(__name__) +defaults = { + 'sample_duration': 2.0, + 'sample_rate': 44100, + 'channels': 1, + 'ffmpeg_bin': 'ffmpeg', +} + + +def create_dataset(audio_dir: str, dataset_dir: str, + low_freq: int = AudioSegment.default_low_freq, + high_freq: int = AudioSegment.default_high_freq, + bins: int = AudioSegment.default_bins, + sample_duration: float = defaults['sample_duration'], + sample_rate: int = defaults['sample_rate'], + channels: int = defaults['channels'], + ffmpeg_bin: str = defaults['ffmpeg_bin']): + audio_dir = os.path.abspath(os.path.expanduser(audio_dir)) + dataset_dir = os.path.abspath(os.path.expanduser(dataset_dir)) + audio_dirs = AudioDirectory.scan(audio_dir) + + for audio_dir in audio_dirs: + dataset_file = os.path.join(dataset_dir, os.path.basename(audio_dir.path) + '.npz') + logger.info(f'Processing audio sample {audio_dir.path}') + + with AudioFile(audio_dir.audio_file, audio_dir.labels_file, + sample_duration=sample_duration, sample_rate=sample_rate, channels=channels, + ffmpeg_bin=os.path.expanduser(ffmpeg_bin)) as reader, \ + DatasetWriter(dataset_file, low_freq=low_freq, high_freq=high_freq, bins=bins) as writer: + for sample in reader: + writer += sample + + +def main(): + # noinspection PyTypeChecker + parser = argparse.ArgumentParser( + description=''' +Tool to create numpy dataset files with audio spectrum data from a set of labelled raw audio files.''', + + epilog=''' +- audio_dir should contain a list of sub-directories, each of which represents a labelled audio sample. + audio_dir should have the following structure: + + audio_dir/ + -> train_sample_1 + -> audio.mp3 + -> labels.json + -> train_sample_2 + -> audio.mp3 + -> labels.json + ... + +- labels.json is a key-value JSON file that contains the labels for each audio segment. Example: + + { + "00:00": "negative", + "02:13": "positive", + "04:57": "negative", + "15:41": "positive", + "18:24": "negative" + } + + Each entry indicates that all the audio samples between the specified timestamp and the next entry or + the end of the audio file should be applied the specified label. + +- dataset_dir is the directory where the generated labelled spectrum dataset in .npz format will be saved. + Each dataset file will be named like its associated audio samples directory.''', + + formatter_class=argparse.RawDescriptionHelpFormatter + ) + + parser.add_argument('audio_dir', help='Directory containing the raw audio samples directories to be scanned.') + parser.add_argument('dataset_dir', help='Destination directory for the compressed .npz files containing the ' + 'frequency spectrum datasets.') + parser.add_argument('--low', help='Specify the lowest frequency to be considered in the generated frequency ' + 'spectrum. Default: 20 Hz (lowest possible frequency audible to a human ear).', + required=False, default=AudioSegment.default_low_freq, dest='low_freq', type=int) + + parser.add_argument('--high', help='Specify the highest frequency to be considered in the generated frequency ' + 'spectrum. Default: 20 kHz (highest possible frequency audible to a human ear).', + required=False, default=AudioSegment.default_high_freq, dest='high_freq', type=int) + + parser.add_argument('-b', '--bins', help=f'Specify the number of frequency bins to be used for the spectrum ' + f'analysis (default: {AudioSegment.default_bins})', + required=False, default=AudioSegment.default_bins, dest='bins', type=int) + + parser.add_argument('-d', '--sample-duration', help=f'The script will calculate the spectrum of audio segments of ' + f'this specified length in seconds (default: ' + f'{defaults["sample_duration"]}).', + required=False, default=defaults['sample_duration'], dest='sample_duration', type=float) + + parser.add_argument('-r', '--sample-rate', help=f'Audio sample rate (default: {defaults["sample_rate"]} Hz)', + required=False, default=defaults['sample_rate'], dest='sample_rate', type=int) + + parser.add_argument('-c', '--channels', help=f'Number of destination audio channels (default: ' + f'{defaults["channels"]})', + required=False, default=defaults['channels'], dest='channels', type=int) + + parser.add_argument('--ffmpeg', help=f'Absolute path to the ffmpeg executable (default: {defaults["ffmpeg_bin"]})', + required=False, default=defaults['ffmpeg_bin'], dest='ffmpeg_bin', type=str) + + opts, args = parser.parse_known_args(sys.argv[1:]) + return create_dataset(audio_dir=opts.audio_dir, dataset_dir=opts.dataset_dir, low_freq=opts.low_freq, + high_freq=opts.high_freq, bins=opts.bins, sample_duration=opts.sample_duration, + sample_rate=opts.sample_rate, channels=opts.channels, ffmpeg_bin=opts.ffmpeg_bin) + + +if __name__ == '__main__': + main() diff --git a/notebooks/dataset.ipynb b/notebooks/dataset.ipynb index 6cb07ee..34340b0 100644 --- a/notebooks/dataset.ipynb +++ b/notebooks/dataset.ipynb @@ -17,34 +17,16 @@ "metadata": { "collapsed": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "DEBUG:matplotlib:(private) matplotlib data path: /usr/lib/python3.8/site-packages/matplotlib/mpl-data\n", - "DEBUG:matplotlib:matplotlib data path: /usr/lib/python3.8/site-packages/matplotlib/mpl-data\n", - "DEBUG:matplotlib:CONFIGDIR=/home/blacklight/.config/matplotlib\n", - "DEBUG:matplotlib:matplotlib version 3.3.2\n", - "DEBUG:matplotlib:interactive is False\n", - "DEBUG:matplotlib:platform is linux\n", - "DEBUG:matplotlib:loaded modules: ['sys', 'builtins', '_frozen_importlib', '_imp', '_warnings', '_frozen_importlib_external', '_io', 'marshal', 'posix', '_thread', '_weakref', 'time', 'zipimport', '_codecs', 'codecs', 'encodings.aliases', 'encodings', 'encodings.utf_8', '_signal', '__main__', 'encodings.latin_1', '_abc', 'abc', 'io', '_stat', 'stat', '_collections_abc', 'genericpath', 'posixpath', 'os.path', 'os', '_sitebuiltins', '_locale', '_bootlocale', 'types', 'importlib._bootstrap', 'importlib._bootstrap_external', 'warnings', 'importlib', 'importlib.machinery', 'importlib.abc', '_operator', 'operator', 'keyword', '_heapq', 'heapq', 'itertools', 'reprlib', '_collections', 'collections', '_functools', 'functools', 'contextlib', 'importlib.util', 'google', 'google.assistant', 'google.assistant.embedded', 'googlesamples', 'googlesamples.assistant', 'google.cloud', 'google.logging', 'google.iam', 'mpl_toolkits', 'ruamel', 'sphinxcontrib', 'zope', 'site', '_weakrefset', 'weakref', 'pkgutil', 'runpy', 'ipykernel._version', '__future__', 'enum', '_sre', 'sre_constants', 'sre_parse', 'sre_compile', 'copyreg', 're', '_json', 'json.scanner', 'json.decoder', 'json.encoder', 'json', 'errno', 'signal', 'threading', '_posixsubprocess', 'select', 'collections.abc', 'math', 'selectors', 'subprocess', 'IPython.core', 'IPython.core.getipython', 'IPython.core.release', 'atexit', 'copy', 'fnmatch', 'glob', 'token', 'tokenize', 'linecache', 'traceback', '_string', 'string', 'logging', 'zlib', '_compression', '_bz2', 'bz2', '_lzma', 'lzma', 'pwd', 'grp', 'shutil', '_opcode', 'opcode', 'dis', 'inspect', '_struct', 'struct', 'six', 'traitlets.utils', 'traitlets.utils.getargspec', 'ipython_genutils._version', 'ipython_genutils', 'locale', 'ipython_genutils.encoding', 'ipython_genutils.py3compat', 'traitlets.utils.importstring', 'traitlets.utils.sentinel', 'traitlets.utils.bunch', 'traitlets.traitlets', 'traitlets._version', 'traitlets', 'decorator', 'gettext', 'argparse', '_ast', 'ast', '_bisect', 'bisect', '_sha512', '_random', 'random', 'ipython_genutils.path', 'traitlets.config.loader', 'textwrap', 'ipython_genutils.text', 'traitlets.config.configurable', 'ipython_genutils.importstring', 'traitlets.config.application', 'traitlets.config', 'pprint', 'platform', 'sysconfig', 'urllib', 'urllib.parse', '_sysconfigdata__linux_x86_64-linux-gnu', 'pydoc', 'bdb', 'IPython.utils', 'IPython.utils.ipstruct', 'IPython.utils.coloransi', 'pygments', 'IPython.utils.colorable', 'IPython.utils.PyColorize', 'IPython.utils.encoding', 'IPython.utils.py3compat', 'IPython.core.excolors', 'IPython.testing', 'IPython.testing.skipdoctest', 'cmd', 'codeop', 'code', 'pdb', 'IPython.core.debugger', 'IPython.core.display_trap', 'pexpect.exceptions', 'pexpect.utils', 'pexpect.expect', 'termios', 'tty', 'pty', 'fcntl', 'resource', 'ptyprocess.util', 'ptyprocess.ptyprocess', 'ptyprocess', 'pexpect.spawnbase', 'pexpect.pty_spawn', 'pexpect.run', 'pexpect', 'shlex', 'IPython.utils._process_common', 'IPython.utils._process_posix', 'IPython.utils.process', 'IPython.utils.decorators', 'IPython.utils.path', 'IPython.utils.data', 'IPython.utils.terminal', 'IPython.core.ultratb', 'IPython.utils._sysinfo', 'IPython.utils.sysinfo', 'IPython.core.crashhandler', 'tempfile', 'IPython.utils.importstring', 'IPython.paths', 'IPython.core.profiledir', 'IPython.core.application', 'IPython.terminal', '_hashlib', '_blake2', '_sha3', 'hashlib', 'IPython.core.compilerop', 'IPython.core.error', 'ntpath', 'pathlib', 'IPython.utils.text', 'IPython.core.magic_arguments', 'getopt', 'typing.io', 'typing.re', 'typing', 'binascii', 'mimetypes', 'IPython.core.display', 'IPython.core.page', 'getpass', 'IPython.lib.security', 'IPython.lib', '_datetime', 'datetime', 'IPython.lib.pretty', 'IPython.utils.openpy', 'IPython.utils.dir2', 'IPython.utils.wildcard', 'pygments.lexers._mapping', 'pygments.modeline', 'pygments.plugin', 'pygments.util', 'pygments.lexers', 'pygments.filter', 'pygments.token', 'pygments.filters', 'pygments.regexopt', 'pygments.lexer', 'pygments.unistring', 'pygments.lexers.python', 'pygments.formatters._mapping', 'pygments.formatters', 'pygments.styles', 'pygments.formatter', 'pygments.formatters.html', 'IPython.core.oinspect', 'IPython.core.inputtransformer2', 'IPython.core.magic', '_compat_pickle', '_pickle', 'pickle', 'pickleshare', 'IPython.core.autocall', 'IPython.core.macro', 'IPython.core.splitinput', 'IPython.core.prefilter', 'IPython.core.alias', 'IPython.core.builtin_trap', 'backcall.backcall', 'backcall', 'IPython.core.events', 'IPython.core.displayhook', 'IPython.core.displaypub', 'IPython.core.extensions', 'IPython.utils.sentinel', 'IPython.core.formatters', '_sqlite3', 'sqlite3.dbapi2', 'sqlite3', 'IPython.core.history', 'IPython.core.logger', 'IPython.core.payload', 'IPython.core.usage', 'html.entities', 'html', 'IPython.lib.display', 'IPython.display', 'IPython.utils.capture', 'IPython.utils.io', 'IPython.core.hooks', 'IPython.utils.strdispatch', 'IPython.utils.syspathcontext', 'IPython.utils.tempdir', 'IPython.utils.contexts', 'IPython.core.async_helpers', 'IPython.core.interactiveshell', 'concurrent', 'concurrent.futures._base', 'concurrent.futures', '_socket', 'socket', '_ssl', 'base64', 'ssl', 'asyncio.constants', 'asyncio.format_helpers', 'asyncio.base_futures', 'asyncio.log', 'asyncio.coroutines', '_contextvars', 'contextvars', 'asyncio.exceptions', 'asyncio.base_tasks', '_asyncio', 'asyncio.events', 'asyncio.futures', 'asyncio.protocols', 'asyncio.transports', 'asyncio.sslproto', 'asyncio.locks', 'asyncio.tasks', 'asyncio.staggered', 'asyncio.trsock', 'asyncio.base_events', 'asyncio.runners', 'asyncio.queues', 'asyncio.streams', 'asyncio.subprocess', 'asyncio.base_subprocess', 'asyncio.selector_events', 'asyncio.unix_events', 'asyncio', 'prompt_toolkit.application.current', 'prompt_toolkit.eventloop.utils', 'prompt_toolkit.eventloop.async_generator', 'wcwidth.table_wide', 'wcwidth.table_zero', 'wcwidth.unicode_versions', 'wcwidth.wcwidth', 'wcwidth', 'prompt_toolkit.utils', 'prompt_toolkit.eventloop.inputhook', 'prompt_toolkit.eventloop', 'prompt_toolkit.application.run_in_terminal', 'prompt_toolkit.selection', 'prompt_toolkit.clipboard.base', 'prompt_toolkit.clipboard.in_memory', 'prompt_toolkit.clipboard', 'prompt_toolkit.cache', 'prompt_toolkit.enums', 'prompt_toolkit.filters.base', 'prompt_toolkit.filters.app', 'prompt_toolkit.filters.cli', 'prompt_toolkit.filters.utils', 'prompt_toolkit.filters', 'prompt_toolkit.document', 'prompt_toolkit.auto_suggest', 'prompt_toolkit.data_structures', 'prompt_toolkit.styles.base', 'prompt_toolkit.styles.named_colors', 'prompt_toolkit.styles.style', 'prompt_toolkit.styles.defaults', 'prompt_toolkit.styles.pygments', 'colorsys', 'prompt_toolkit.styles.style_transformation', 'prompt_toolkit.styles', 'prompt_toolkit.output.color_depth', 'prompt_toolkit.output.base', 'prompt_toolkit.patch_stdout', 'prompt_toolkit.output.defaults', 'prompt_toolkit.output', 'array', 'prompt_toolkit.output.vt100', 'prompt_toolkit.mouse_events', 'prompt_toolkit.formatted_text.base', 'prompt_toolkit.formatted_text.ansi', 'xml', 'xml.dom.domreg', 'xml.dom', 'xml.dom.minicompat', 'xml.dom.NodeFilter', 'xml.dom.xmlbuilder', 'xml.dom.minidom', 'prompt_toolkit.formatted_text.html', 'prompt_toolkit.formatted_text.pygments', 'prompt_toolkit.formatted_text.utils', 'prompt_toolkit.formatted_text', 'prompt_toolkit.completion.base', 'prompt_toolkit.completion.filesystem', 'prompt_toolkit.completion.word_completer', 'prompt_toolkit.completion.fuzzy_completer', 'prompt_toolkit.completion.nested', 'prompt_toolkit.completion', 'prompt_toolkit.history', 'prompt_toolkit.keys', 'prompt_toolkit.key_binding.key_bindings', 'prompt_toolkit.key_binding.key_processor', 'prompt_toolkit.key_binding', 'prompt_toolkit.key_binding.vi_state', 'prompt_toolkit.search', 'prompt_toolkit.validation', 'prompt_toolkit.buffer', 'prompt_toolkit.input.base', 'prompt_toolkit.input.defaults', 'prompt_toolkit.input', 'prompt_toolkit.input.typeahead', 'prompt_toolkit.key_binding.bindings', 'prompt_toolkit.key_binding.bindings.scroll', 'prompt_toolkit.key_binding.bindings.page_navigation', 'prompt_toolkit.lexers.base', 'prompt_toolkit.lexers.pygments', 'prompt_toolkit.lexers', 'prompt_toolkit.layout.utils', 'prompt_toolkit.layout.processors', 'prompt_toolkit.layout.controls', 'prompt_toolkit.layout.dimension', 'prompt_toolkit.layout.margins', 'prompt_toolkit.layout.mouse_handlers', 'prompt_toolkit.layout.screen', 'prompt_toolkit.layout.containers', 'prompt_toolkit.layout.layout', 'prompt_toolkit.layout.menus', 'prompt_toolkit.layout', 'prompt_toolkit.key_binding.bindings.completion', 'prompt_toolkit.key_binding.bindings.named_commands', 'prompt_toolkit.key_binding.bindings.basic', 'prompt_toolkit.key_binding.bindings.cpr', 'prompt_toolkit.key_binding.bindings.emacs', 'prompt_toolkit.key_binding.bindings.mouse', 'prompt_toolkit.input.ansi_escape_sequences', 'prompt_toolkit.input.vt100_parser', 'prompt_toolkit.key_binding.digraphs', 'prompt_toolkit.key_binding.bindings.vi', 'prompt_toolkit.key_binding.defaults', 'prompt_toolkit.key_binding.emacs_state', 'prompt_toolkit.layout.dummy', 'prompt_toolkit.renderer', 'prompt_toolkit.application.application', 'prompt_toolkit.application.dummy', 'prompt_toolkit.application', 'prompt_toolkit.key_binding.bindings.focus', 'prompt_toolkit.widgets.toolbars', 'prompt_toolkit.widgets.base', 'prompt_toolkit.widgets.dialogs', 'prompt_toolkit.widgets.menus', 'prompt_toolkit.widgets', 'prompt_toolkit.shortcuts.dialogs', 'prompt_toolkit.shortcuts.progress_bar.formatters', 'prompt_toolkit.shortcuts.progress_bar.base', 'prompt_toolkit.shortcuts.progress_bar', 'prompt_toolkit.key_binding.bindings.auto_suggest', 'prompt_toolkit.key_binding.bindings.open_in_editor', 'prompt_toolkit.shortcuts.prompt', 'prompt_toolkit.shortcuts.utils', 'prompt_toolkit.shortcuts', 'prompt_toolkit', 'pygments.style', 'unicodedata', 'IPython.core.latex_symbols', 'IPython.utils.generics', 'parso._compatibility', 'parso.utils', 'parso.tree', 'parso.python', 'parso.python.token', 'parso.python.tokenize', 'parso.pgen2.grammar_parser', 'parso.pgen2.generator', 'parso.pgen2', 'parso.parser', 'difflib', 'parso.python.prefix', 'parso.python.tree', 'parso.python.parser', 'parso.python.diff', 'gc', 'parso.file_io', 'parso.cache', 'parso.normalizer', 'parso.python.errors', 'parso.python.pep8', 'parso.grammar', 'parso', 'jedi.file_io', '_queue', 'queue', 'jedi._compatibility', 'jedi.parser_utils', 'colorama.ansi', '_ctypes', 'ctypes._endian', 'ctypes', 'colorama.win32', 'colorama.winterm', 'colorama.ansitowin32', 'colorama.initialise', 'colorama', 'jedi.debug', 'jedi.settings', 'jedi.cache', 'jedi.inference.cache', 'jedi.inference.helpers', 'jedi.inference.utils', 'jedi.inference.base_value', 'jedi.common', 'jedi.inference.sys_path', 'jedi.inference.recursion', 'jedi.inference.flow_analysis', 'jedi.inference.lazy_value', 'jedi.inference.docstrings', 'jedi.plugins', 'jedi.inference.names', 'jedi.inference.filters', 'jedi.inference.compiled.getattr_static', 'jedi.inference.compiled.access', 'jedi.inference.signature', 'jedi.inference.context', 'jedi.inference.compiled.value', 'jedi.inference.compiled', 'jedi.inference.analysis', 'jedi.inference.gradual', 'jedi.inference.value.module', 'jedi.inference.value.dynamic_arrays', 'jedi.inference.value.iterable', 'jedi.inference.arguments', 'jedi.inference.parser_cache', 'jedi.inference.gradual.generics', 'jedi.inference.value.function', 'jedi.inference.value.klass', 'jedi.inference.value.instance', 'jedi.inference.value', 'jedi.inference.gradual.base', 'jedi.inference.gradual.type_var', 'jedi.inference.gradual.typing', 'jedi.inference.gradual.stub_value', 'jedi.inference.gradual.typeshed', 'jedi.inference.imports', 'jedi.inference.param', 'jedi.inference.gradual.annotation', 'jedi.inference.value.decorator', 'jedi.inference.syntax_tree', 'jedi.inference', 'jedi.inference.gradual.conversion', 'jedi.inference.compiled.mixed', 'pydoc_data', 'pydoc_data.topics', 'jedi.api.keywords', 'jedi.api.completion_cache', 'jedi.api.helpers', 'jedi.api.classes', 'jedi.api.interpreter', 'jedi.api.strings', 'jedi.api.file_name', 'jedi.api.completion', 'filecmp', 'jedi.inference.compiled.subprocess.functions', 'jedi.api.exceptions', 'jedi.inference.compiled.subprocess', 'jedi.api.environment', 'jedi.inference.references', 'jedi.api.project', 'jedi.api.errors', 'jedi.api.refactoring', 'jedi.api.refactoring.extract', 'jedi.inference.gradual.utils', 'jedi.api', 'jedi.plugins.stdlib', 'jedi.plugins.flask', 'jedi.plugins.pytest', 'jedi.plugins.django', 'jedi.plugins.registry', 'jedi', 'IPython.core.completer', 'IPython.terminal.ptutils', 'IPython.terminal.shortcuts', 'IPython.terminal.debugger', 'IPython.lib.clipboard', 'IPython.terminal.magics', 'IPython.terminal.pt_inputhooks', 'IPython.terminal.prompts', 'IPython.terminal.interactiveshell', 'IPython.core.magics.auto', 'IPython.core.magics.basic', 'email', 'http', 'email.errors', 'email.quoprimime', 'email.base64mime', 'quopri', 'email.encoders', 'email.charset', 'email.header', 'calendar', 'email._parseaddr', 'email.utils', 'email._policybase', 'email.feedparser', 'email.parser', 'uu', 'email._encoded_words', 'email.iterators', 'email.message', 'http.client', 'urllib.response', 'urllib.error', 'urllib.request', 'IPython.core.magics.code', 'IPython.core.magics.config', 'IPython.core.magics.display', 'timeit', '_lsprof', 'profile', 'cProfile', 'pstats', 'IPython.utils.module_paths', 'IPython.utils.timing', 'IPython.core.magics.execution', 'IPython.core.magics.extension', 'IPython.core.magics.history', 'IPython.core.magics.logging', 'IPython.core.magics.namespace', 'IPython.core.magics.osm', 'IPython.core.magics.packaging', 'IPython.core.pylabtools', 'IPython.core.magics.pylab', 'IPython.lib.backgroundjobs', 'IPython.core.magics.script', 'IPython.core.magics', 'IPython.core.shellapp', 'IPython.extensions', 'IPython.extensions.storemagic', 'IPython.terminal.ipapp', 'IPython.terminal.embed', 'IPython.utils.frame', 'IPython', 'jupyter_client._version', 'zmq.backend.select', 'cython_runtime', 'zmq.backend.cython.constants', '_cython_0_29_17', 'zmq.backend.cython.error', 'zmq.error', 'zmq.backend.cython.message', 'zmq.backend.cython.context', 'zmq.backend.cython.socket', 'zmq.backend.cython.utils', 'zmq.backend.cython._poll', 'zmq.backend.cython._version', 'zmq.backend.cython._device', 'zmq.backend.cython._proxy_steerable', 'zmq.backend.cython', 'zmq.backend', 'zmq.utils', 'zmq.utils.constant_names', 'zmq.sugar.constants', 'zmq.sugar.attrsettr', 'zmq.sugar.poll', 'zmq.utils.strtypes', 'numbers', '_pydecimal', 'decimal', 'simplejson.errors', 'simplejson.raw_json', 'simplejson.compat', 'simplejson._speedups', 'simplejson.scanner', 'simplejson.decoder', 'simplejson.encoder', 'simplejson', 'zmq.utils.jsonapi', 'zmq.sugar.socket', 'zmq.sugar.context', 'zmq.sugar.frame', 'zmq.sugar.tracker', 'zmq.sugar.version', 'zmq.sugar.stopwatch', 'zmq.sugar', 'zmq', 'jupyter_client.localinterfaces', 'jupyter_core.version', 'jupyter_core', 'distutils', 'distutils.errors', 'distutils.dep_util', 'distutils.debug', 'distutils.log', 'distutils.spawn', 'distutils.util', 'jupyter_core.paths', 'jupyter_client.connect', 'traitlets.log', 'jupyter_client.launcher', 'jupyter_client.channelsabc', 'jupyter_client.channels', 'jupyter_client.clientabc', 'jupyter_client.client', 'jupyter_client.kernelspec', 'jupyter_client.managerabc', 'jupyter_client.manager', 'jupyter_client.blocking.channels', 'jupyter_client.blocking.client', 'jupyter_client.blocking', 'zmq._future', 'zmq.asyncio', 'jupyter_client.asynchronous.channels', 'jupyter_client.asynchronous.client', 'jupyter_client.asynchronous', '_uuid', 'uuid', 'jupyter_client.multikernelmanager', 'jupyter_client', 'ipykernel.connect', 'ipykernel', 'tornado', 'logging.handlers', 'tornado.speedups', 'tornado.util', 'tornado.escape', '_curses', 'curses', 'tornado.log', 'tornado.concurrent', 'tornado.ioloop', 'tornado.platform', 'tornado.gen', 'tornado.platform.asyncio', 'zmq.eventloop.ioloop', 'zmq.eventloop', 'tornado.stack_context', 'zmq.eventloop.zmqstream', 'imp', 'hmac', 'dateutil._version', 'dateutil', 'dateutil._common', 'dateutil.relativedelta', 'six.moves', 'dateutil.tz._common', 'dateutil.tz._factories', 'dateutil.tz.tz', 'dateutil.tz', 'dateutil.parser._parser', 'dateutil.parser.isoparser', 'dateutil.parser', '_strptime', 'jupyter_client.jsonutil', 'jupyter_client.adapter', 'jupyter_client.session', 'ipykernel.iostream', 'ipykernel.heartbeat', 'IPython.utils.tokenutil', 'tornado.locks', 'tornado.queues', 'ipykernel.jsonutil', 'ipykernel.kernelbase', 'ipykernel.comm.comm', 'ipykernel.comm.manager', 'ipykernel.comm', 'IPython.core.payloadpage', 'ipykernel.displayhook', 'ipykernel.zmqshell', 'distutils.version', 'ipykernel.eventloops', 'ipykernel.ipkernel', 'ipykernel.parentpoller', 'ipykernel.kernelapp', 'netifaces', 'faulthandler', 'ipykernel.codeutil', 'ipykernel.pickleutil', 'ipykernel.serialize', 'ipykernel.datapub', 'IPython.core.completerlib', 'storemagic', 'micmon', 'micmon.audio', 'micmon.audio.directory', 'micmon.audio.segment', 'numpy._globals', 'numpy.__config__', 'numpy.version', 'numpy._distributor_init', 'numpy.core._multiarray_umath', 'numpy.compat._inspect', 'numpy.compat.py3k', 'numpy.compat', 'numpy.core.overrides', 'numpy.core.multiarray', 'numpy.core.umath', 'numpy.core._string_helpers', 'numpy.core._dtype', 'numpy.core._type_aliases', 'numpy.core.numerictypes', 'numpy.core._asarray', 'numpy.core._exceptions', 'numpy.core._methods', 'numpy.core.fromnumeric', 'numpy.core.shape_base', 'numpy.core._ufunc_config', 'numpy.core.arrayprint', 'numpy.core.numeric', 'numpy.core.defchararray', 'numpy.core.records', 'numpy.core.memmap', 'numpy.core.function_base', 'numpy.core.machar', 'numpy.core.getlimits', 'numpy.core.einsumfunc', 'numpy.core._multiarray_tests', 'numpy.core._add_newdocs', 'numpy.core._dtype_ctypes', 'numpy.core._internal', 'numpy._pytesttester', 'numpy.core', 'numpy.lib.mixins', 'numpy.lib.ufunclike', 'numpy.lib.type_check', 'numpy.lib.scimath', 'numpy.lib.twodim_base', 'numpy.linalg.lapack_lite', 'numpy.linalg._umath_linalg', 'numpy.linalg.linalg', 'numpy.linalg', 'numpy.matrixlib.defmatrix', 'numpy.matrixlib', 'numpy.lib.histograms', 'numpy.lib.function_base', 'numpy.lib.stride_tricks', 'numpy.lib.index_tricks', 'numpy.lib.nanfunctions', 'numpy.lib.shape_base', 'numpy.lib.polynomial', 'numpy.lib.utils', 'numpy.lib.arraysetops', 'numpy.lib.format', 'numpy.lib._datasource', 'numpy.lib._iotools', 'numpy.lib.npyio', 'numpy.lib.financial', 'numpy.lib.arrayterator', 'numpy.lib.arraypad', 'numpy.lib._version', 'numpy.lib', 'numpy.fft._pocketfft_internal', 'numpy.fft._pocketfft', 'numpy.fft.helper', 'numpy.fft', 'numpy.polynomial.polyutils', 'numpy.polynomial._polybase', 'numpy.polynomial.polynomial', 'numpy.polynomial.chebyshev', 'numpy.polynomial.legendre', 'numpy.polynomial.hermite', 'numpy.polynomial.hermite_e', 'numpy.polynomial.laguerre', 'numpy.polynomial', '_cython_0_29_21', 'numpy.random._common', 'secrets', 'numpy.random.bit_generator', 'numpy.random._bounded_integers', 'numpy.random._mt19937', 'numpy.random.mtrand', 'numpy.random._philox', 'numpy.random._pcg64', 'numpy.random._sfc64', 'numpy.random._generator', 'numpy.random._pickle', 'numpy.random', 'numpy.ctypeslib', 'numpy.ma.core', 'numpy.ma.extras', 'numpy.ma', 'numpy', 'matplotlib', 'gzip', 'matplotlib.cbook.deprecation', 'matplotlib.cbook', 'matplotlib._animation_data', 'matplotlib.animation', 'pyparsing', 'matplotlib.fontconfig_pattern', 'matplotlib.docstring', 'matplotlib._color_data', 'matplotlib.colors', 'cycler', 'matplotlib.rcsetup', 'matplotlib._version', 'matplotlib.ft2font', 'kiwisolver']\n", - "DEBUG:matplotlib:CACHEDIR=/home/blacklight/.cache/matplotlib\n", - "DEBUG:matplotlib.font_manager:Using fontManager instance from /home/blacklight/.cache/matplotlib/fontlist-v330.json\n", - "DEBUG:matplotlib.pyplot:Loaded backend module://ipykernel.pylab.backend_inline version unknown.\n", - "DEBUG:matplotlib.pyplot:Loaded backend module://ipykernel.pylab.backend_inline version unknown.\n" - ] - } - ], + "outputs": [], "source": [ "import os\n", "\n", "from micmon.audio import AudioDirectory, AudioPlayer, AudioFile\n", "from micmon.dataset import DatasetWriter\n", "\n", - "basedir = os.path.expanduser(os.path.join('~', 'projects', 'baby-monitor'))\n", - "audio_dir = os.path.join(basedir, 'data', 'audio')\n", - "datasets_dir = os.path.join(basedir, 'data', 'datasets')\n", + "basedir = os.path.expanduser(os.path.join('~', 'datasets', 'baby-monitor'))\n", + "audio_dir = os.path.join(basedir, 'audio')\n", + "datasets_dir = os.path.join(basedir, 'datasets')\n", "audio_dirs = AudioDirectory.scan(audio_dir)\n", "cutoff_frequencies = [250, 7500]" ] @@ -60,11 +42,11 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "outputs": [], "source": [ - "for audio in audio_dirs:\n", - " with AudioFile(audio, start='19:40', duration=10) as reader, \\\n", + "for audio_dir in audio_dirs:\n", + " with AudioFile(audio_dir.audio_file, start='19:40', duration=5) as reader, \\\n", " AudioPlayer() as player:\n", " for sample in reader:\n", " player.play(sample)" @@ -76,6 +58,93 @@ } } }, + { + "cell_type": "markdown", + "source": [ + "Plot the audio for each of the first 10 seconds of each audio file." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 4, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/plain": "
", + "image/png": "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\n" + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "for audio_dir in audio_dirs:\n", + " with AudioFile(audio_dir.audio_file, start=0, duration=4) as reader:\n", + " for sample in reader:\n", + " sample.plot_audio()" + ], + "metadata": { + "collapsed": false, + "pycharm": { + "name": "#%%\n" + } + } + }, { "cell_type": "markdown", "source": [ @@ -87,7 +156,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "outputs": [ { "data": { @@ -151,8 +220,8 @@ } ], "source": [ - "for audio in audio_dirs:\n", - " with AudioFile(audio, start=0, duration=4) as reader:\n", + "for audio_dir in audio_dirs:\n", + " with AudioFile(audio_dir.audio_file, start=0, duration=4) as reader:\n", " for sample in reader:\n", " sample.plot_spectrum(low_freq=cutoff_frequencies[0],\n", " high_freq=cutoff_frequencies[1])" @@ -176,24 +245,24 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 5, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Processing audio sample /home/blacklight/projects/baby-monitor/data/audio/2020-10-25_16-36-00\n", - "Processing audio sample /home/blacklight/projects/baby-monitor/data/audio/2020-10-24_19-53-00\n", - "Processing audio sample /home/blacklight/projects/baby-monitor/data/audio/2020-10-24_17-25-00\n" + "Processing audio sample /home/blacklight/datasets/baby-monitor/audio/2020-10-25_16-36-00\n", + "Processing audio sample /home/blacklight/datasets/baby-monitor/audio/2020-10-24_19-53-00\n", + "Processing audio sample /home/blacklight/datasets/baby-monitor/audio/2020-10-24_17-25-00\n" ] } ], "source": [ - "for audio in audio_dirs:\n", - " dataset_file = os.path.join(datasets_dir, os.path.basename(audio.path) + '.npz')\n", - " print(f'Processing audio sample {audio.path}')\n", + "for audio_dir in audio_dirs:\n", + " dataset_file = os.path.join(datasets_dir, os.path.basename(audio_dir.path) + '.npz')\n", + " print(f'Processing audio sample {audio_dir.path}')\n", "\n", - " with AudioFile(audio) as reader, \\\n", + " with AudioFile(audio_dir.audio_file, audio_dir.labels_file) as reader, \\\n", " DatasetWriter(dataset_file,\n", " low_freq=cutoff_frequencies[0],\n", " high_freq=cutoff_frequencies[1]) as writer:\n", diff --git a/notebooks/predict.ipynb b/notebooks/predict.ipynb index cdec553..3c95dcf 100644 --- a/notebooks/predict.ipynb +++ b/notebooks/predict.ipynb @@ -46,9 +46,7 @@ "from micmon.audio import AudioDevice, AudioPlayer\n", "from micmon.model import Model\n", "\n", - "basedir = os.path.expanduser(os.path.join('~', 'projects', 'baby-monitor'))\n", - "models_dir = os.path.join(basedir, 'models')\n", - "model_path = os.path.join(models_dir, 'baby-monitor')\n", + "model_dir = os.path.expanduser(os.path.join('~', 'models', 'baby-monitor'))\n", "audio_system = 'alsa'\n", "audio_device = 'plughw:3,0'\n", "label_names = ['negative', 'positive']" @@ -68,7 +66,7 @@ "execution_count": 2, "outputs": [], "source": [ - "model = Model.load(model_path)" + "model = Model.load(model_dir)" ], "metadata": { "collapsed": false, @@ -122,23 +120,17 @@ "name": "stdout", "output_type": "stream", "text": [ + "negative\n", + "negative\n", + "negative\n", + "negative\n", + "negative\n", + "negative\n", "negative\n", "negative\n", "negative\n", "negative\n" ] - }, - { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m", - "\u001B[0;31mKeyboardInterrupt\u001B[0m Traceback (most recent call last)", - "\u001B[0;32m\u001B[0m in \u001B[0;36m\u001B[0;34m\u001B[0m\n\u001B[1;32m 1\u001B[0m \u001B[0;32mwith\u001B[0m \u001B[0mAudioDevice\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0maudio_system\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mdevice\u001B[0m\u001B[0;34m=\u001B[0m\u001B[0maudio_device\u001B[0m\u001B[0;34m)\u001B[0m \u001B[0;32mas\u001B[0m \u001B[0msource\u001B[0m\u001B[0;34m:\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m----> 2\u001B[0;31m \u001B[0;32mfor\u001B[0m \u001B[0msample\u001B[0m \u001B[0;32min\u001B[0m \u001B[0msource\u001B[0m\u001B[0;34m:\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m\u001B[1;32m 3\u001B[0m \u001B[0msource\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mpause\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m 4\u001B[0m \u001B[0mprediction\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0mmodel\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mpredict\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0msample\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m 5\u001B[0m \u001B[0mprint\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mprediction\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n", - "\u001B[0;32m~/projects/baby-monitor/micmon/audio/source.py\u001B[0m in \u001B[0;36m__next__\u001B[0;34m(self)\u001B[0m\n\u001B[1;32m 36\u001B[0m \u001B[0;32mraise\u001B[0m \u001B[0mStopIteration\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m 37\u001B[0m \u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0;32m---> 38\u001B[0;31m \u001B[0mdata\u001B[0m \u001B[0;34m=\u001B[0m \u001B[0mself\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mffmpeg\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mstdout\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mread\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mself\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mbufsize\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[0m\u001B[1;32m 39\u001B[0m \u001B[0;32mif\u001B[0m \u001B[0mdata\u001B[0m\u001B[0;34m:\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n\u001B[1;32m 40\u001B[0m \u001B[0;32mreturn\u001B[0m \u001B[0mAudioSegment\u001B[0m\u001B[0;34m(\u001B[0m\u001B[0mdata\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0msample_rate\u001B[0m\u001B[0;34m=\u001B[0m\u001B[0mself\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0msample_rate\u001B[0m\u001B[0;34m,\u001B[0m \u001B[0mchannels\u001B[0m\u001B[0;34m=\u001B[0m\u001B[0mself\u001B[0m\u001B[0;34m.\u001B[0m\u001B[0mchannels\u001B[0m\u001B[0;34m)\u001B[0m\u001B[0;34m\u001B[0m\u001B[0;34m\u001B[0m\u001B[0m\n", - "\u001B[0;31mKeyboardInterrupt\u001B[0m: " - ] } ], "source": [ @@ -147,7 +139,7 @@ " source.pause()\n", " prediction = model.predict(sample)\n", " print(prediction)\n", - " source.resume()" + " source.resume()\n" ], "metadata": { "collapsed": false, diff --git a/notebooks/train.ipynb b/notebooks/train.ipynb index 1b72453..4afcf37 100644 --- a/notebooks/train.ipynb +++ b/notebooks/train.ipynb @@ -12,22 +12,11 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 10, "metadata": { "collapsed": true }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:root:Limited tf.compat.v2.summary API due to missing TensorBoard installation.\n", - "WARNING:root:Limited tf.compat.v2.summary API due to missing TensorBoard installation.\n", - "WARNING:root:Limited tf.compat.v2.summary API due to missing TensorBoard installation.\n", - "WARNING:root:Limited tf.summary API due to missing TensorBoard installation.\n" - ] - } - ], + "outputs": [], "source": [ "import os\n", "from keras import layers\n", @@ -35,9 +24,8 @@ "from micmon.dataset import Dataset\n", "from micmon.model import Model\n", "\n", - "basedir = os.path.expanduser(os.path.join('~', 'projects', 'baby-monitor'))\n", - "datasets_dir = os.path.join(basedir, 'data', 'datasets')\n", - "models_dir = os.path.join(basedir, 'models')\n", + "datasets_dir = os.path.expanduser(os.path.join('~', 'datasets', 'baby-monitor', 'datasets'))\n", + "model_dir = os.path.expanduser(os.path.join('~', 'models', 'baby-monitor'))\n", "epochs = 2" ] }, @@ -52,12 +40,11 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "outputs": [], "source": [ "datasets = Dataset.scan(datasets_dir, validation_split=0.3)\n", - "freq_bins = len(datasets[0].samples[0])\n", - "cutoff_frequencies = [datasets[0].low_freq, datasets[0].high_freq]" + "freq_bins = len(datasets[0].samples[0])" ], "metadata": { "collapsed": false, @@ -68,18 +55,19 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 12, "outputs": [], "source": [ "model = Model(\n", " [\n", " layers.Input(shape=(freq_bins,)),\n", - " layers.Dense(int(1.2 * freq_bins), activation='relu'),\n", - " layers.Dense(int(0.6 * freq_bins), activation='relu'),\n", + " layers.Dense(int(2.0 * freq_bins), activation='relu'),\n", + " layers.Dense(int(freq_bins), activation='relu'),\n", " layers.Dense(len(datasets[0].labels), activation='softmax'),\n", " ],\n", " labels=['negative', 'positive'],\n", - " cutoff_frequencies=cutoff_frequencies\n", + " low_freq=datasets[0].low_freq,\n", + " high_freq=datasets[0].high_freq,\n", ")" ], "metadata": { @@ -91,36 +79,36 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 13, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[epoch 1/2] [audio sample 1/3]\n", - "94/94 [==============================] - 0s 4ms/step - loss: 0.4315 - accuracy: 0.9597\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n", - "41/41 [==============================] - 0s 2ms/step - loss: 0.3499 - accuracy: 0.9651\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n", - "Validation set loss and accuracy: [0.3499242961406708, 0.9650892019271851]\n", + "94/94 [==============================] - 0s 3ms/step - loss: 0.3651 - accuracy: 0.9521\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n", + "41/41 [==============================] - 0s 2ms/step - loss: 0.3542 - accuracy: 0.9597\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n", + "Validation set loss and accuracy: [0.35424283146858215, 0.9596586227416992]\n", "[epoch 1/2] [audio sample 2/3]\n", - "108/108 [==============================] - 1s 11ms/step - loss: 0.3437 - accuracy: 0.9705\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n", - "47/47 [==============================] - 0s 4ms/step - loss: 0.3542 - accuracy: 0.9595\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n", - "Validation set loss and accuracy: [0.35424256324768066, 0.9594594836235046]\n", + "108/108 [==============================] - 1s 5ms/step - loss: 0.3494 - accuracy: 0.9644\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n", + "47/47 [==============================] - 0s 4ms/step - loss: 0.3400 - accuracy: 0.9736\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n", + "Validation set loss and accuracy: [0.3400084674358368, 0.9736486673355103]\n", "[epoch 1/2] [audio sample 3/3]\n", - "134/134 [==============================] - 1s 8ms/step - loss: 0.3619 - accuracy: 0.9516\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n", - "58/58 [==============================] - 0s 5ms/step - loss: 0.3638 - accuracy: 0.9496\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n", - "Validation set loss and accuracy: [0.36377525329589844, 0.9496442079544067]\n", + "134/134 [==============================] - 0s 4ms/step - loss: 0.3638 - accuracy: 0.9498\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n", + "58/58 [==============================] - 0s 2ms/step - loss: 0.3595 - accuracy: 0.9540\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n", + "Validation set loss and accuracy: [0.3594612181186676, 0.954023003578186]\n", "[epoch 2/2] [audio sample 1/3]\n", - "94/94 [==============================] - 1s 10ms/step - loss: 0.3536 - accuracy: 0.9597\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n", - "41/41 [==============================] - 0s 7ms/step - loss: 0.3483 - accuracy: 0.9651\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n", - "Validation set loss and accuracy: [0.34827473759651184, 0.9650892019271851]\n", + "94/94 [==============================] - 1s 10ms/step - loss: 0.3514 - accuracy: 0.9621\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n", + "41/41 [==============================] - 0s 4ms/step - loss: 0.3538 - accuracy: 0.9597\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n", + "Validation set loss and accuracy: [0.353772908449173, 0.9596586227416992]\n", "[epoch 2/2] [audio sample 2/3]\n", - "108/108 [==============================] - 1s 8ms/step - loss: 0.3429 - accuracy: 0.9705\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n", - "47/47 [==============================] - 0s 8ms/step - loss: 0.3539 - accuracy: 0.9595\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n", - "Validation set loss and accuracy: [0.35387495160102844, 0.9594594836235046]\n", + "108/108 [==============================] - 1s 9ms/step - loss: 0.3490 - accuracy: 0.9644\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n", + "47/47 [==============================] - 0s 6ms/step - loss: 0.3397 - accuracy: 0.9736\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n", + "Validation set loss and accuracy: [0.3397475779056549, 0.9736486673355103]\n", "[epoch 2/2] [audio sample 3/3]\n", - "134/134 [==============================] - 2s 14ms/step - loss: 0.3617 - accuracy: 0.9516\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n", - "58/58 [==============================] - 0s 6ms/step - loss: 0.3637 - accuracy: 0.9496\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n", - "Validation set loss and accuracy: [0.36365807056427, 0.9496442079544067]\n" + "134/134 [==============================] - 1s 7ms/step - loss: 0.3636 - accuracy: 0.9498\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n", + "58/58 [==============================] - 0s 4ms/step - loss: 0.3593 - accuracy: 0.9540\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\b\n", + "Validation set loss and accuracy: [0.35933220386505127, 0.954023003578186]\n" ] } ], @@ -150,7 +138,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 11, "outputs": [ { "name": "stdout", @@ -159,29 +147,22 @@ "WARNING:tensorflow:From /usr/lib/python3.8/site-packages/tensorflow/python/training/tracking/tracking.py:111: Model.state_updates (from tensorflow.python.keras.engine.training) is deprecated and will be removed in a future version.\n", "Instructions for updating:\n", "This property should not be used in TensorFlow 2.0, as updates are applied automatically.\n", - "WARNING:tensorflow:From /usr/lib/python3.8/site-packages/tensorflow/python/training/tracking/tracking.py:111: Layer.updates (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version.\n", - "Instructions for updating:\n", - "This property should not be used in TensorFlow 2.0, as updates are applied automatically.\n", - "INFO:tensorflow:Assets written to: /home/blacklight/projects/baby-monitor/models/baby-monitor/assets\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ "WARNING:tensorflow:From /usr/lib/python3.8/site-packages/tensorflow/python/training/tracking/tracking.py:111: Model.state_updates (from tensorflow.python.keras.engine.training) is deprecated and will be removed in a future version.\n", "Instructions for updating:\n", "This property should not be used in TensorFlow 2.0, as updates are applied automatically.\n", "WARNING:tensorflow:From /usr/lib/python3.8/site-packages/tensorflow/python/training/tracking/tracking.py:111: Layer.updates (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version.\n", "Instructions for updating:\n", "This property should not be used in TensorFlow 2.0, as updates are applied automatically.\n", - "INFO:tensorflow:Assets written to: /home/blacklight/projects/baby-monitor/models/baby-monitor/assets\n" + "WARNING:tensorflow:From /usr/lib/python3.8/site-packages/tensorflow/python/training/tracking/tracking.py:111: Layer.updates (from tensorflow.python.keras.engine.base_layer) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "This property should not be used in TensorFlow 2.0, as updates are applied automatically.\n", + "INFO:tensorflow:Assets written to: /home/blacklight/models/baby-monitor/assets\n", + "INFO:tensorflow:Assets written to: /home/blacklight/models/baby-monitor/assets\n" ] } ], "source": [ - "model_path = os.path.join(models_dir, 'baby-monitor')\n", - "model.save(model_path, overwrite=True)" + "model.save(model_dir, overwrite=True)" ], "metadata": { "collapsed": false, diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..5dd0324 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,3 @@ +numpy +tensorflow +keras diff --git a/setup.py b/setup.py new file mode 100755 index 0000000..7ac1912 --- /dev/null +++ b/setup.py @@ -0,0 +1,40 @@ +#!/usr/bin/env python +import os + +from setuptools import setup, find_packages + + +def path(fname=''): + return os.path.abspath(os.path.join(os.path.dirname(__file__), fname)) + + +def readfile(fname): + with open(path(fname)) as f: + return f.read() + + +setup( + name="micmon", + version="0.1", + author="Fabio Manganiello", + author_email="info@fabiomanganiello.com", + description="Programmable Tensorflow-based sound/noise detector", + license="MIT", + python_requires='>= 3.6', + keywords="machine-learning tensorflow sound-detection", + url="https://github.com/BlackLight/micmon", + packages=find_packages(), + include_package_data=True, + long_description=readfile('README.md'), + long_description_content_type='text/markdown', + entry_points={ + 'console_scripts': [ + 'micmon-datagen=micmon.utils.datagen:main', + ], + }, + classifiers=[ + "Topic :: Utilities", + "License :: OSI Approved :: MIT License", + "Development Status :: 3 - Alpha", + ], +)