[已解决]Inception Time 中组合Inception网络

125404629

第一段代码包含inception网络；第二段代码包含集成一组 Inception 网络的代码。请问如何将自己的数据应用于NNE,有train和test两个数据集。

1. class Classifier_INCEPTION:
   
2. 
   
3.     def __init__(self, output_directory, input_shape, nb_classes, verbose=True, build=True, batch_size=64,
   
4.                  nb_filters=32, use_residual=True, use_bottleneck=True, depth=6, kernel_size=41, nb_epochs=15):
   
5. 
   
6.         self.output_directory = output_directory
   
7.         self.nb_filters = nb_filters
   
8.         self.use_residual = use_residual
   
9.         self.use_bottleneck = use_bottleneck
   
10.         self.depth = depth
    
11.         self.kernel_size = kernel_size - 1
    
12.         self.callbacks = None
    
13.         self.batch_size = batch_size
    
14.         self.bottleneck_size = 32
    
15.         self.nb_epochs = nb_epochs
    
16. 
    
17.         if build == True:
    
18.             self.model = self.build_model(input_shape, nb_classes)
    
19.             if (verbose == True):
    
20.                 self.model.summary()
    
21.             self.verbose = verbose
    
22.             self.model.save_weights(self.output_directory + 'model_init.hdf5')
    
23. 
    
24.     def _inception_module(self, input_tensor, stride=1, activation='linear'):
    
25. 
    
26.         if self.use_bottleneck and int(input_tensor.shape[-1]) > 1:
    
27.             input_inception = keras.layers.Conv1D(filters=self.bottleneck_size, kernel_size=1,
    
28.                                                   padding='same', activation=activation, use_bias=False)(input_tensor)
    
29.         else:
    
30.             input_inception = input_tensor
    
31. 
    
32.         # kernel_size_s = [3, 5, 8, 11, 17]
    
33.         kernel_size_s = [self.kernel_size // (2 ** i) for i in range(3)]
    
34. 
    
35.         conv_list = []
    
36. 
    
37.         for i in range(len(kernel_size_s)):
    
38.             conv_list.append(keras.layers.Conv1D(filters=self.nb_filters, kernel_size=kernel_size_s[i],
    
39.                                                  strides=stride, padding='same', activation=activation, use_bias=False)(
    
40.                 input_inception))
    
41. 
    
42.         max_pool_1 = keras.layers.MaxPool1D(pool_size=3, strides=stride, padding='same')(input_tensor)
    
43. 
    
44.         conv_6 = keras.layers.Conv1D(filters=self.nb_filters, kernel_size=1,
    
45.                                      padding='same', activation=activation, use_bias=False)(max_pool_1)
    
46. 
    
47.         conv_list.append(conv_6)
    
48. 
    
49.         x = keras.layers.Concatenate(axis=2)(conv_list)
    
50.         x = keras.layers.BatchNormalization()(x)
    
51.         x = keras.layers.Activation(activation='relu')(x)
    
52.         return x
    
53. 
    
54.     def _shortcut_layer(self, input_tensor, out_tensor):
    
55.         shortcut_y = keras.layers.Conv1D(filters=int(out_tensor.shape[-1]), kernel_size=1,
    
56.                                          padding='same', use_bias=False)(input_tensor)
    
57.         shortcut_y = keras.layers.BatchNormalization()(shortcut_y)
    
58. 
    
59.         x = keras.layers.Add()([shortcut_y, out_tensor])
    
60.         x = keras.layers.Activation('relu')(x)
    
61.         return x
    
62. 
    
63.     def build_model(self, input_shape, nb_classes):
    
64.         input_layer = keras.layers.Input(input_shape)
    
65. 
    
66.         x = input_layer
    
67.         input_res = input_layer
    
68. 
    
69.         for d in range(self.depth):
    
70. 
    
71.             x = self._inception_module(x)
    
72. 
    
73.             if self.use_residual and d % 3 == 2:
    
74.                 x = self._shortcut_layer(input_res, x)
    
75.                 input_res = x
    
76. 
    
77.         gap_layer = keras.layers.GlobalAveragePooling1D()(x)
    
78. 
    
79.         output_layer = keras.layers.Dense(nb_classes, activation='softmax')(gap_layer)
    
80. 
    
81.         model = keras.models.Model(inputs=input_layer, outputs=output_layer)
    
82. 
    
83.         model.compile(loss='categorical_crossentropy', optimizer=keras.optimizers.Adam(),
    
84.                       metrics=['acc'])
    
85. 
    
86.         reduce_lr = keras.callbacks.ReduceLROnPlateau(monitor='loss', factor=0.5, patience=50,
    
87.                                                       min_lr=0.0001)
    
88. 
    
89.         file_path = self.output_directory + 'best_model.hdf5'
    
90. 
    
91.         model_checkpoint = keras.callbacks.ModelCheckpoint(filepath=file_path, monitor='loss',
    
92.                                                            save_best_only=True)
    
93. 
    
94.         self.callbacks = [reduce_lr, model_checkpoint]
    
95. 
    
96.         return model
    
97. 
    
98.     def fit(self, x_train, y_train, x_val, y_val, y_true, plot_test_acc=True):
    
99.         if self.batch_size is None:
    
100.             mini_batch_size = int(min(x_train.shape[0] / 10, 16))
     
101.         else:
     
102.             mini_batch_size = self.batch_size
     
103. 
     
104.         start_time = time.time()
     
105. 
     
106.         if plot_test_acc:
     
107. 
     
108.             hist = self.model.fit(x_train, y_train, batch_size=mini_batch_size, epochs=self.nb_epochs,
     
109.                                   verbose=self.verbose, validation_data=(x_val, y_val), callbacks=self.callbacks)
     
110.         else:
     
111. 
     
112.             hist = self.model.fit(x_train, y_train, batch_size=mini_batch_size, epochs=self.nb_epochs,
     
113.                                   verbose=self.verbose, callbacks=self.callbacks)
     
114. 
     
115.         duration = time.time() - start_time
     
116. 
     
117.         self.model.save(self.output_directory + 'last_model.hdf5')
     
118. 
     
119.         y_pred = self.predict(x_val, y_true, x_train, y_train, y_val,
     
120.                               return_df_metrics=False)
     
121. 
     
122.         # save predictions
     
123.         np.save(self.output_directory + 'y_pred.npy', y_pred)
     
124. 
     
125.         # convert the predicted from binary to integer
     
126.         y_pred = np.argmax(y_pred, axis=1)
     
127. 
     
128.         df_metrics = save_logs(self.output_directory, hist, y_pred, y_true, duration,
     
129.                                plot_test_acc=plot_test_acc)
     
130. 
     
131.         keras.backend.clear_session()
     
132. 
     
133.         return df_metrics
     
134. 
     
135.     def predict(self, x_test, y_true, x_train, y_train, y_test, return_df_metrics=True):
     
136.         start_time = time.time()
     
137.         model_path = self.output_directory + 'best_model.hdf5'
     
138.         model = keras.models.load_model(model_path)
     
139.         y_pred = model.predict(x_test, batch_size=self.batch_size)
     
140.         if return_df_metrics:
     
141.             y_pred = np.argmax(y_pred, axis=1)
     
142.             df_metrics = calculate_metrics(y_true, y_pred, 0.0)
     
143.             return df_metrics
     
144.         else:
     
145.             test_duration = time.time() - start_time
     
146.             save_test_duration(self.output_directory + 'test_duration.csv', test_duration)
     
147.             return y_pred
     
148.         
     
149. 
     
150. df1 = pd.read_csv("train.csv")
     
151. df1 = np.array(df1)
     
152. X = np.expand_dims(df1[:, 1:891].astype(float), axis=2)  # 对数据进行增维并转化为32为
     
153. #X = np.expand_dims(df1[:, 1:891].astype(float), axis=1)
     
154. Y = df1[:, 0]
     
155. X_train, X_val, y_train, y_val = train_test_split(X, Y, test_size=0.2, random_state=42)
     
156. 
     
157. y_train, y_val = transform_labels(y_train, y_val)
     
158. # save orignal y because later we will use binary
     
159. y_true = y_val.astype(np.int64)
     
160. y_true_train = y_train.astype(np.int64)
     
161. # transform the labels from integers to one hot vectors
     
162. enc = sklearn.preprocessing.OneHotEncoder()
     
163. enc.fit(np.concatenate((y_train, y_val), axis=0).reshape(-1, 1))
     
164. y_train = enc.transform(y_train.reshape(-1, 1)).toarray()
     
165. y_val = enc.transform(y_val.reshape(-1, 1)).toarray()
     
166. 
     
167. '''y_train = to_categorical(y_train)  # one-hot encoding
     
168. y_val= to_categorical(y_val)
     
169. y_true = y_val'''
     
170. df2 = pd.read_csv("test.csv")
     
171. df2 = np.array(df1)
     
172. X_test = np.expand_dims(df2[:, 1:891].astype(float), axis=2)
     
173. y_test=df2[:, 0]
     
174. y_true1 = y_test.astype(np.int64)
     
175. y_test = enc.transform(y_test.reshape(-1, 1)).toarray()
     
176. # 创建模型
     
177. model = Classifier_INCEPTION(output_directory='output_directory', input_shape=X_train.shape[1:], nb_classes=8)
     
178. 
     
179. # 训练模型
     
180. model.fit(X_train, y_train, X_val, y_val,y_true)
     
181. df_metrics=model.predict(X_test, y_true1, X_train, y_train, y_test)
     
182. print(df_metrics)

复制代码

1. import keras
   
2. import numpy as np
   
3. from utils.utils import calculate_metrics
   
4. from utils.utils import create_directory
   
5. from utils.utils import check_if_file_exits
   
6. import gc
   
7. from utils.constants import UNIVARIATE_ARCHIVE_NAMES  as ARCHIVE_NAMES
   
8. import time
   
9. 
   
10. 
    
11. class Classifier_NNE:
    
12. 
    
13.     def create_classifier(self, model_name, input_shape, nb_classes, output_directory, verbose=False,
    
14.                           build=True):
    
15.         if self.check_if_match('inception*', model_name):
    
16.             from classifiers import inception
    
17.             return inception.Classifier_INCEPTION(output_directory, input_shape, nb_classes, verbose,
    
18.                                                   build=build)
    
19. 
    
20.     def check_if_match(self, rex, name2):
    
21.         import re
    
22.         pattern = re.compile(rex)
    
23.         return pattern.match(name2)
    
24. 
    
25.     def __init__(self, output_directory, input_shape, nb_classes, verbose=False, nb_iterations=5,
    
26.                  clf_name='inception'):
    
27.         self.classifiers = [clf_name]
    
28.         out_add = ''
    
29.         for cc in self.classifiers:
    
30.             out_add = out_add + cc + '-'
    
31.         self.archive_name = ARCHIVE_NAMES[0]
    
32.         self.iterations_to_take = [i for i in range(nb_iterations)]
    
33.         for cc in self.iterations_to_take:
    
34.             out_add = out_add + str(cc) + '-'
    
35.         self.output_directory = output_directory.replace('nne',
    
36.                                                          'nne' + '/' + out_add)
    
37.         create_directory(self.output_directory)
    
38.         self.dataset_name = output_directory.split('/')[-2]
    
39.         self.verbose = verbose
    
40.         self.models_dir = output_directory.replace('nne', 'classifier')
    
41. 
    
42.     def fit(self, x_train, y_train, x_test, y_test, y_true):
    
43.         # no training since models are pre-trained
    
44.         start_time = time.time()
    
45. 
    
46.         y_pred = np.zeros(shape=y_test.shape)
    
47. 
    
48.         ll = 0
    
49. 
    
50.         # loop through all classifiers
    
51.         for model_name in self.classifiers:
    
52.             # loop through different initialization of classifiers
    
53.             for itr in self.iterations_to_take:
    
54.                 if itr == 0:
    
55.                     itr_str = ''
    
56.                 else:
    
57.                     itr_str = '_itr_' + str(itr)
    
58. 
    
59.                 curr_archive_name = self.archive_name + itr_str
    
60. 
    
61.                 curr_dir = self.models_dir.replace('classifier', model_name).replace(
    
62.                     self.archive_name, curr_archive_name)
    
63. 
    
64.                 model = self.create_classifier(model_name, None, None,
    
65.                                                curr_dir, build=False)
    
66. 
    
67.                 predictions_file_name = curr_dir + 'y_pred.npy'
    
68.                 # check if predictions already made
    
69.                 if check_if_file_exits(predictions_file_name):
    
70.                     # then load only the predictions from the file
    
71.                     curr_y_pred = np.load(predictions_file_name)
    
72.                 else:
    
73.                     # then compute the predictions
    
74.                     curr_y_pred = model.predict(x_test, y_true, x_train, y_train, y_test,
    
75.                                                 return_df_metrics=False)
    
76.                     keras.backend.clear_session()
    
77. 
    
78.                     np.save(predictions_file_name, curr_y_pred)
    
79. 
    
80.                 y_pred = y_pred + curr_y_pred
    
81. 
    
82.                 ll += 1
    
83. 
    
84.         # average predictions
    
85.         y_pred = y_pred / ll
    
86. 
    
87.         # save predictions
    
88.         np.save(self.output_directory + 'y_pred.npy', y_pred)
    
89. 
    
90.         # convert the predicted from binary to integer
    
91.         y_pred = np.argmax(y_pred, axis=1)
    
92. 
    
93.         duration = time.time() - start_time
    
94. 
    
95.         df_metrics = calculate_metrics(y_true, y_pred, duration)
    
96. 
    
97.         df_metrics.to_csv(self.output_directory + 'df_metrics.csv', index=False)
    
98. 
    
99.         gc.collect()

复制代码

最佳答案

月排行榜 / 总排行榜

陶远航

2023-10-13 21:36:34

这段代码中，首先定义了一个名为Classifier_INCEPTION的类，该类实现了Inception网络的构建和训练。然后，通过读取训练集和测试集的数据，将数据应用到Inception网络中进行训练和预测。

以下是如何将自己的数据应用于这个网络的步骤：

1. 数据准备：首先，你需要准备你的数据。在这个例子中，数据是从CSV文件中读取的。你需要将你的数据格式化为一个可以被网络接受的形式。在这个例子中，输入数据被转换为一个三维的numpy数组，其中第一维是样本数，第二维是特征数，第三维是1（因为这是一个单变量的时间序列分类任务）。标签被转换为one-hot编码的形式。

1. df1 = pd.read_csv("train.csv")
   
2. df1 = np.array(df1)
   
3. X = np.expand_dims(df1[:, 1:891].astype(float), axis=2)  # 对数据进行增维并转化为32为
   
4. Y = df1[:, 0]
   
5. X_train, X_val, y_train, y_val = train_test_split(X, Y, test_size=0.2, random_state=42)
   
6. 
   
7. y_train, y_val = transform_labels(y_train, y_val)
   
8. # save orignal y because later we will use binary
   
9. y_true = y_val.astype(np.int64)
   
10. y_true_train = y_train.astype(np.int64)
    
11. # transform the labels from integers to one hot vectors
    
12. enc = sklearn.preprocessing.OneHotEncoder()
    
13. enc.fit(np.concatenate((y_train, y_val), axis=0).reshape(-1, 1))
    
14. y_train = enc.transform(y_train.reshape(-1, 1)).toarray()
    
15. y_val = enc.transform(y_val.reshape(-1, 1)).toarray()
    

复制代码

2. 模型创建：然后，你需要创建你的模型。在这个例子中，我们创建了一个Inception网络的实例。

1. model = Classifier_INCEPTION(output_directory='output_directory', input_shape=X_train.shape[1:], nb_classes=8)
   

复制代码

3. 模型训练：接下来，你需要训练你的模型。在这个例子中，我们使用训练数据和验证数据来训练我们的模型。

1. model.fit(X_train, y_train, X_val, y_val,y_true)
   

复制代码

4. 模型预测：最后，你可以使用你的模型进行预测。在这个例子中，我们使用测试数据来进行预测，并打印出预测的结果。

1. df_metrics=model.predict(X_test, y_true1, X_train, y_train, y_test)
   
2. print(df_metrics)
   

复制代码

请注意，你需要根据你自己的数据来调整这些步骤。例如，你可能需要调整数据的读取和预处理方式，以适应你自己的数据格式。你也可能需要调整模型的参数，以适应你的任务需求。

跳转到最佳答案楼层

陶远航

这段代码中，首先定义了一个名为Classifier_INCEPTION的类，该类实现了Inception网络的构建和训练。然后，通过读取训练集和测试集的数据，将数据应用到Inception网络中进行训练和预测。

以下是如何将自己的数据应用于这个网络的步骤：

1. 数据准备：首先，你需要准备你的数据。在这个例子中，数据是从CSV文件中读取的。你需要将你的数据格式化为一个可以被网络接受的形式。在这个例子中，输入数据被转换为一个三维的numpy数组，其中第一维是样本数，第二维是特征数，第三维是1（因为这是一个单变量的时间序列分类任务）。标签被转换为one-hot编码的形式。

1. df1 = pd.read_csv("train.csv")
   
2. df1 = np.array(df1)
   
3. X = np.expand_dims(df1[:, 1:891].astype(float), axis=2)  # 对数据进行增维并转化为32为
   
4. Y = df1[:, 0]
   
5. X_train, X_val, y_train, y_val = train_test_split(X, Y, test_size=0.2, random_state=42)
   
6. 
   
7. y_train, y_val = transform_labels(y_train, y_val)
   
8. # save orignal y because later we will use binary
   
9. y_true = y_val.astype(np.int64)
   
10. y_true_train = y_train.astype(np.int64)
    
11. # transform the labels from integers to one hot vectors
    
12. enc = sklearn.preprocessing.OneHotEncoder()
    
13. enc.fit(np.concatenate((y_train, y_val), axis=0).reshape(-1, 1))
    
14. y_train = enc.transform(y_train.reshape(-1, 1)).toarray()
    
15. y_val = enc.transform(y_val.reshape(-1, 1)).toarray()
    

复制代码

2. 模型创建：然后，你需要创建你的模型。在这个例子中，我们创建了一个Inception网络的实例。

1. model = Classifier_INCEPTION(output_directory='output_directory', input_shape=X_train.shape[1:], nb_classes=8)
   

复制代码

3. 模型训练：接下来，你需要训练你的模型。在这个例子中，我们使用训练数据和验证数据来训练我们的模型。

1. model.fit(X_train, y_train, X_val, y_val,y_true)
   

复制代码

4. 模型预测：最后，你可以使用你的模型进行预测。在这个例子中，我们使用测试数据来进行预测，并打印出预测的结果。

1. df_metrics=model.predict(X_test, y_true1, X_train, y_train, y_test)
   
2. print(df_metrics)
   

复制代码

请注意，你需要根据你自己的数据来调整这些步骤。例如，你可能需要调整数据的读取和预处理方式，以适应你自己的数据格式。你也可能需要调整模型的参数，以适应你的任务需求。