-
Notifications
You must be signed in to change notification settings - Fork 79
/
_inceptiontime.py
195 lines (163 loc) · 6.4 KB
/
_inceptiontime.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
# -*- coding: utf-8 -*-
__author__ = "James Large"
__all__ = ["InceptionTimeClassifier"]
from tensorflow import keras
from sktime_dl.classification._classifier import BaseDeepClassifier
from sktime_dl.networks._inceptiontime import InceptionTimeNetwork
from sktime_dl.utils import check_and_clean_data, \
check_and_clean_validation_data
from sklearn.utils import check_random_state
class InceptionTimeClassifier(BaseDeepClassifier, InceptionTimeNetwork):
"""InceptionTime
Parameters
----------
nb_filters: int,
use_residual: boolean,
use_bottleneck: boolean,
depth: int
kernel_size: int, specifying the length of the 1D convolution
window
batch_size: int, the number of samples per gradient update.
bottleneck_size: int,
nb_epochs: int, the number of epochs to train the model
callbacks: list of tf.keras.callbacks.Callback objects
random_state: int, seed to any needed random actions
verbose: boolean, whether to output extra information
model_name: string, the name of this model for printing and
file writing purposes
model_save_directory: string, if not None; location to save
the trained keras model in hdf5 format
Notes
-----
..[1] Fawaz et. al, InceptionTime: Finding AlexNet for Time Series
Classification, Data Mining and Knowledge Discovery, 34, 2020
Adapted from the implementation from Fawaz et. al
https://github.com/hfawaz/InceptionTime/blob/master/classifiers/inception.py
"""
def __init__(
self,
nb_filters=32,
use_residual=True,
use_bottleneck=True,
bottleneck_size=32,
depth=6,
kernel_size=41 - 1,
batch_size=64,
nb_epochs=1500,
callbacks=None,
random_state=0,
verbose=False,
model_name="inception",
model_save_directory=None,
):
super(InceptionTimeClassifier, self).__init__(
model_name=model_name, model_save_directory=model_save_directory
)
self.verbose = verbose
# predefined
self.nb_filters = nb_filters
self.use_residual = use_residual
self.use_bottleneck = use_bottleneck
self.bottleneck_size = bottleneck_size
self.depth = depth
self.kernel_size = kernel_size
self.batch_size = batch_size
self.nb_epochs = nb_epochs
self.callbacks = callbacks
self.random_state = random_state
self.verbose = verbose
self._is_fitted = False
def build_model(self, input_shape, nb_classes, **kwargs):
"""
Construct a compiled, un-trained, keras model that is ready for training
Parameters
----------
input_shape : tuple
The shape of the data fed into the input layer
nb_classes: int
The number of classes, which shall become the size of the output
layer
Returns
-------
output : a compiled Keras Model
"""
input_layer, output_layer = self.build_network(input_shape, **kwargs)
output_layer = keras.layers.Dense(nb_classes, activation="softmax")(
output_layer
)
model = keras.models.Model(inputs=input_layer, outputs=output_layer)
model.compile(
loss="categorical_crossentropy",
optimizer=keras.optimizers.Adam(),
metrics=["accuracy"],
)
# if user hasn't provided a custom ReduceLROnPlateau via init already,
# add the default from literature
if self.callbacks is None:
self.callbacks = []
if not any(
isinstance(callback, keras.callbacks.ReduceLROnPlateau)
for callback in self.callbacks
):
reduce_lr = keras.callbacks.ReduceLROnPlateau(
monitor="loss", factor=0.5, patience=50, min_lr=0.0001
)
self.callbacks.append(reduce_lr)
return model
def fit(self, X, y, input_checks=True, validation_X=None,
validation_y=None, **kwargs):
"""
Fit the classifier on the training set (X, y)
Parameters
----------
X : a nested pd.Dataframe, or (if input_checks=False) array-like of
shape = (n_instances, series_length, n_dimensions)
The training input samples. If a 2D array-like is passed,
n_dimensions is assumed to be 1.
y : array-like, shape = [n_instances]
The training data class labels.
input_checks : boolean
whether to check the X and y parameters
validation_X : a nested pd.Dataframe, or array-like of shape =
(n_instances, series_length, n_dimensions)
The validation samples. If a 2D array-like is passed,
n_dimensions is assumed to be 1.
Unless strictly defined by the user via callbacks (such as
EarlyStopping), the presence or state of the validation
data does not alter training in any way. Predictions at each epoch
are stored in the model's fit history.
validation_y : array-like, shape = [n_instances]
The validation class labels.
Returns
-------
self : object
"""
self.random_state = check_random_state(self.random_state)
X = check_and_clean_data(X, y, input_checks=input_checks)
y_onehot = self.convert_y(y)
validation_data = \
check_and_clean_validation_data(validation_X, validation_y,
self.label_encoder,
self.onehot_encoder)
# ignore the number of instances, X.shape[0],
# just want the shape of each instance
self.input_shape = X.shape[1:]
if self.batch_size is None:
self.batch_size = int(min(X.shape[0] / 10, 16))
else:
self.batch_size = self.batch_size
self.model = self.build_model(self.input_shape, self.nb_classes)
if self.verbose:
self.model.summary()
self.history = self.model.fit(
X,
y_onehot,
batch_size=self.batch_size,
epochs=self.nb_epochs,
verbose=self.verbose,
callbacks=self.callbacks,
validation_data=validation_data,
)
self.save_trained_model()
self._is_fitted = True
return self