393148881

Build Type

push

travis-pro

Committed by GitHub

Commit Message

<a href="https://github.com/ubclaunchpad/minutes/commit/<a class=hub.com/ubclaunchpad/minutes/commit/5091f86ec145dd8d14742b6a6f56ef1ea29c721b">5091f86ec<a href="https://github.com/ubclaunchpad/minutes/commit/5091f86ec145dd8d14742b6a6f56ef1ea29c721b">">Merge </a><a class="double-link" href="https://github.com/ubclaunchpad/minutes/commit/<a class="double-link" href="https://github.com/ubclaunchpad/minutes/commit/efa19f0d5d8d8430f786bcd86f26056577ee3209">efa19f0d5</a>">efa19f0d5</a><a href="https://github.com/ubclaunchpad/minutes/commit/5091f86ec145dd8d14742b6a6f56ef1ea29c721b"> into 4f385fe91">4f385fe91</a>

Run Details

41 of 41 new or added lines in 6 files covered. (100.0%)

164 of 179 relevant lines covered (91.62%)

0.92 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.83

/minutes/base.py

import json
import os

from keras import backend as K
from keras.models import Sequential, load_model
from keras.layers import Dense, Dropout, Flatten
from keras.utils import to_categorical
from keras.layers.convolutional import Conv1D, MaxPooling1D
from keras.optimizers import SGD
import numpy as np
from sklearn.model_selection import train_test_split

from minutes.models import MINUTES_BASE_MODEL_DIRECTORY


class BaseModel:
    """Utility for building base models."""

    intialization_params = {
        'name',
        'ms_per_observation',
        'test_size',
        'random_state',
    }

    @property
    def preprocessing_params(self):
        """Returns a mapping of parameters that are required to do preprocessing
        of audio data suitable for this model. Useful as kwargs to audio
        manipulation classes.
        """
        return {
            i: getattr(self, i) for i in self.intialization_params
            if i in {
                'ms_per_observation',
            }
        }

    @property
    def fitted(self):
        return self.model is not None

    @property
    def home(self):
        return os.path.join(MINUTES_BASE_MODEL_DIRECTORY, self.name)

    @classmethod
    def load_model(cls, name):
        """Loads a BaseModel from disk.

        Arguments:
            name {str} -- The name of the model; by default, will load a
            builtin Minutes base model. If the MINUTES_MODELS_DIRECTORY
            environment variable is set, then minutes will look there for
            user defined models.

        Returns:
            BaseModel -- A model collected from disk.
        """
        home = cls(name).home

        # Initialize the object with the paramters in the file.
        with open(os.path.join(home, 'params.json'), 'r') as handle:
            params = json.load(handle)
            model = cls(**params)

        # Pull the model from disk
        try:
            model.model = load_model(os.path.join(home, 'keras.h5'))
        except OSError:
            model.model = None

        return model

    def __init__(self, name, ms_per_observation=3000, test_size=0.33,
                 random_state=42):
        self.name = name
        self.speakers = []
        self.test_size = test_size
        self.random_state = random_state
        self.ms_per_observation = ms_per_observation
        self.model = None

    def add_speaker(self, speaker):
        """Add a speaker to the model.

        Arguments:
            speaker {Speaker} -- A new Speaker object to add to the model.
            Must not have a name in conflict with existing speakers in model.
        """
        if speaker in self.speakers:
            raise LookupError(f'Speaker {speaker.name} already added.')
        self.speakers.append(speaker)

    def add_speakers(self, speakers):
        """Add a collection of speakers to the model.

        Arguments:
            speakers {List[Speaker]} -- A collection of Speakers with unique
            names.
        """
        for speaker in speakers:
            self.add_speaker(speaker)

    def _generate_training_data(self):
        """Generates training data for the model.

        Returns:
            X -- an n x d matrix of observations.
            y -- a categorical one-hot encoding of different speakers
            numbered 1..k.
        """
        obs = []
        for s in self.speakers:
            _, processed = s.get_observations(**self.preprocessing_params)
            obs += processed,

        # Generate and flatten labels.
        labels = [[i] * len(o) for i, o in enumerate(obs)]
        flattened_labels = [j for i in labels for j in i]

        y = to_categorical(flattened_labels)
        X = np.concatenate(obs)

        # TODO: Propagate more configuration options to user.
        return train_test_split(X, y, test_size=self.test_size,
                                random_state=self.random_state)

    def fit(self, verbose=0):
        """Fit a model according to the speakers currently added."""
        K.set_image_dim_ordering('tf')

        X_train, X_test, y_train, y_test = self._generate_training_data()

        self.model = Sequential([
            Conv1D(32, 32, strides=2, input_shape=X_train[0].shape,
                   activation='relu'),
            MaxPooling1D(pool_size=2),
            Dropout(0.5),
            Flatten(),
            Dense(128, activation='relu'),
            Dense(y_train[0].size, activation='softmax'),
        ])

        self.model.compile(
            loss='categorical_crossentropy',
            optimizer=SGD(lr=0.001),
            metrics=['accuracy']
        )

        self.model.fit(
            X_train, y_train,
            validation_data=(X_test, y_test),
            epochs=50, batch_size=16, verbose=verbose
        )

    def save_model(self):
        """Save the model as a pickle."""
        os.makedirs(self.home, exist_ok=True)

        # Save initialization parameters.
        with open(os.path.join(self.home, 'params.json'), 'w') as handle:
            params = {
                k: v for k, v in self.__dict__.items()
                if k in self.intialization_params
            }
            json.dump(params, handle)

        # Save internal model.
        if self.model is not None:
            self.model.save(os.path.join(self.home, 'keras.h5'))

    def predict(self, observations):
        """Predict against a table of audio observations.

        Arguments:
            observations {np.array} -- A table of processed audio observations.

        Returns:
            np.array -- An array of predicted speakers.
        """
        result = self.model.predict(observations)
        y_hat_indices = np.argmax(result, axis=1)

        # Index into the speaker array using the predicted speaker indicies.
        return np.array(self.speakers)[y_hat_indices]

    def __str__(self):
        return self.name

1	import json	1✔
2	import os	1✔
3
4	from keras import backend as K	1✔
5	from keras.models import Sequential, load_model	1✔
6	from keras.layers import Dense, Dropout, Flatten	1✔
7	from keras.utils import to_categorical	1✔
8	from keras.layers.convolutional import Conv1D, MaxPooling1D	1✔
9	from keras.optimizers import SGD	1✔
10	import numpy as np	1✔
11	from sklearn.model_selection import train_test_split	1✔
12
13	from minutes.models import MINUTES_BASE_MODEL_DIRECTORY	1✔
14
15
16	class BaseModel:	1✔
17	"""Utility for building base models."""
18
19	intialization_params = {	1✔
20	'name',
21	'ms_per_observation',
22	'test_size',
23	'random_state',
24	}
25
26	@property	1✔
27	def preprocessing_params(self):
28	"""Returns a mapping of parameters that are required to do preprocessing
29	of audio data suitable for this model. Useful as kwargs to audio
30	manipulation classes.
31	"""
32	return {	1✔
33	i: getattr(self, i) for i in self.intialization_params
34	if i in {
35	'ms_per_observation',
36	}
37	}
38
39	@property	1✔
40	def fitted(self):
41	return self.model is not None	1✔
42
43	@property	1✔
44	def home(self):
45	return os.path.join(MINUTES_BASE_MODEL_DIRECTORY, self.name)	1✔
46
47	@classmethod	1✔
48	def load_model(cls, name):
49	"""Loads a BaseModel from disk.
50
51	Arguments:
52	name {str} -- The name of the model; by default, will load a
53	builtin Minutes base model. If the MINUTES_MODELS_DIRECTORY
54	environment variable is set, then minutes will look there for
55	user defined models.
56
57	Returns:
58	BaseModel -- A model collected from disk.
59	"""
60	home = cls(name).home	1✔
61
62	# Initialize the object with the paramters in the file.
63	with open(os.path.join(home, 'params.json'), 'r') as handle:	1✔
64	params = json.load(handle)	1✔
65	model = cls(**params)	1✔
66
67	# Pull the model from disk
68	try:	1✔
69	model.model = load_model(os.path.join(home, 'keras.h5'))	1✔
70	except OSError:	×
71	model.model = None	×
72
73	return model	1✔
74
75	def __init__(self, name, ms_per_observation=3000, test_size=0.33,	1✔
76	random_state=42):
77	self.name = name	1✔
78	self.speakers = []	1✔
79	self.test_size = test_size	1✔
80	self.random_state = random_state	1✔
81	self.ms_per_observation = ms_per_observation	1✔
82	self.model = None	1✔
83
84	def add_speaker(self, speaker):	1✔
85	"""Add a speaker to the model.
86
87	Arguments:
88	speaker {Speaker} -- A new Speaker object to add to the model.
89	Must not have a name in conflict with existing speakers in model.
90	"""
91	if speaker in self.speakers:	1✔
92	raise LookupError(f'Speaker {speaker.name} already added.')	1✔
93	self.speakers.append(speaker)	1✔
94
95	def add_speakers(self, speakers):	1✔
96	"""Add a collection of speakers to the model.
97
98	Arguments:
99	speakers {List[Speaker]} -- A collection of Speakers with unique
100	names.
101	"""
102	for speaker in speakers:	1✔
103	self.add_speaker(speaker)	1✔
104
105	def _generate_training_data(self):	1✔
106	"""Generates training data for the model.
107
108	Returns:
109	X -- an n x d matrix of observations.
110	y -- a categorical one-hot encoding of different speakers
111	numbered 1..k.
112	"""
113	obs = []	1✔
114	for s in self.speakers:	1✔
115	_, processed = s.get_observations(**self.preprocessing_params)	1✔
116	obs += processed,	1✔
117
118	# Generate and flatten labels.
119	labels = [[i] * len(o) for i, o in enumerate(obs)]	1✔
120	flattened_labels = [j for i in labels for j in i]	1✔
121
122	y = to_categorical(flattened_labels)	1✔
123	X = np.concatenate(obs)	1✔
124
125	# TODO: Propagate more configuration options to user.
126	return train_test_split(X, y, test_size=self.test_size,	1✔
127	random_state=self.random_state)
128
129	def fit(self, verbose=0):	1✔
130	"""Fit a model according to the speakers currently added."""
131	K.set_image_dim_ordering('tf')	1✔
132
133	X_train, X_test, y_train, y_test = self._generate_training_data()	1✔
134
135	self.model = Sequential([	1✔
136	Conv1D(32, 32, strides=2, input_shape=X_train[0].shape,
137	activation='relu'),
138	MaxPooling1D(pool_size=2),
139	Dropout(0.5),
140	Flatten(),
141	Dense(128, activation='relu'),
142	Dense(y_train[0].size, activation='softmax'),
143	])
144
145	self.model.compile(	1✔
146	loss='categorical_crossentropy',
147	optimizer=SGD(lr=0.001),
148	metrics=['accuracy']
149	)
150
151	self.model.fit(	1✔
152	X_train, y_train,
153	validation_data=(X_test, y_test),
154	epochs=50, batch_size=16, verbose=verbose
155	)
156
157	def save_model(self):	1✔
158	"""Save the model as a pickle."""
159	os.makedirs(self.home, exist_ok=True)	1✔
160
161	# Save initialization parameters.
162	with open(os.path.join(self.home, 'params.json'), 'w') as handle:	1✔
163	params = {	1✔
164	k: v for k, v in self.__dict__.items()
165	if k in self.intialization_params
166	}
167	json.dump(params, handle)	1✔
168
169	# Save internal model.
170	if self.model is not None:	1✔
171	self.model.save(os.path.join(self.home, 'keras.h5'))	1✔
172
173	def predict(self, observations):	1✔
174	"""Predict against a table of audio observations.
175
176	Arguments:
177	observations {np.array} -- A table of processed audio observations.
178
179	Returns:
180	np.array -- An array of predicted speakers.
181	"""
182	result = self.model.predict(observations)	1✔
183	y_hat_indices = np.argmax(result, axis=1)	1✔
184
185	# Index into the speaker array using the predicted speaker indicies.
186	return np.array(self.speakers)[y_hat_indices]	1✔
187
188	def __str__(self):	1✔
189	return self.name	×

ubclaunchpad / minutes / 393148881

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous