-
Notifications
You must be signed in to change notification settings - Fork 79
/
_cnn.py
172 lines (145 loc) · 5.73 KB
/
_cnn.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
# -*- coding: utf-8 -*-
"""Time Convolutional Neural Network (CNN) for classification"""
__author__ = "James Large"
__all__ = ["CNNClassifier"]
from sktime_dl.classification._classifier import BaseDeepClassifier
from sktime_dl.networks._cnn import CNNNetwork
from sktime_dl.utils import check_and_clean_data, \
check_and_clean_validation_data
from sklearn.utils import check_random_state
from tensorflow import keras
class CNNClassifier(BaseDeepClassifier, CNNNetwork):
"""Time Convolutional Neural Network (CNN).
Parameters
----------
nb_epochs: int, the number of epochs to train the model
batch_size: int, the number of samples per gradient update.
kernel_size: int, specifying the length of the 1D convolution
window
avg_pool_size: int, size of the average pooling windows
nb_conv_layers: int, the number of convolutional plus average
pooling layers
filter_sizes: int, array of shape = (nb_conv_layers)
callbacks: list of tf.keras.callbacks.Callback objects
random_state: int, or sklearn Random.state
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] Zhao et. al, Convolutional neural networks for
time series classification, Journal of
Systems Engineering and Electronics, 28(1):2017.
Adapted from the implementation from Fawaz et. al
https://github.com/hfawaz/dl-4-tsc/blob/master/classifiers/cnn.py
"""
def __init__(
self,
nb_epochs=2000,
batch_size=16,
kernel_size=7,
avg_pool_size=3,
nb_conv_layers=2,
filter_sizes=[6, 12],
callbacks=None,
random_state=0,
verbose=False,
model_name="cnn",
model_save_directory=None,
):
super(CNNClassifier, self).__init__(
model_save_directory=model_save_directory,
model_name=model_name)
self.filter_sizes = filter_sizes
self.nb_conv_layers = nb_conv_layers
self.avg_pool_size = avg_pool_size
self.random_state = random_state
self.kernel_size = kernel_size
self.verbose = verbose
self.callbacks = callbacks
self.nb_epochs = nb_epochs
self.batch_size = batch_size
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(
units=nb_classes, activation="sigmoid"
)(output_layer)
model = keras.models.Model(inputs=input_layer, outputs=output_layer)
model.compile(
loss="mean_squared_error",
optimizer=keras.optimizers.Adam(),
metrics=["accuracy"],
)
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)
if self.callbacks is None:
self.callbacks = []
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:]
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._is_fitted = True
self.save_trained_model()
return self