├── .gitattributes
├── .gitignore
├── LICENSE
├── Segmentor.m
├── data_format.m
├── download_QTDB.m
├── paper_models_codes
    ├── ECGNet.py
    ├── ECGNet_dropout.py
    ├── denseNet_P_R_localization.py
    └── utils.py
├── readme.md
└── src
    ├── datafix.csv
    ├── keras_test.py
    └── utils.py


/.gitattributes:
--------------------------------------------------------------------------------
1 | # Auto detect text files and perform LF normalization
2 | * text=auto
3 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | # Byte-compiled / optimized / DLL files
  2 | __pycache__/
  3 | *.py[cod]
  4 | *$py.class
  5 | 
  6 | # C extensions
  7 | *.so
  8 | 
  9 | 
 10 | # data
 11 | *.mat
 12 | ./data/*.mat
 13 | 
 14 | # idea
 15 | .idea/
 16 | 
 17 | # Distribution / packaging
 18 | .Python
 19 | build/
 20 | develop-eggs/
 21 | dist/
 22 | downloads/
 23 | eggs/
 24 | .eggs/
 25 | lib/
 26 | lib64/
 27 | parts/
 28 | sdist/
 29 | var/
 30 | wheels/
 31 | pip-wheel-metadata/
 32 | share/python-wheels/
 33 | *.egg-info/
 34 | .installed.cfg
 35 | *.egg
 36 | MANIFEST
 37 | 
 38 | # PyInstaller
 39 | #  Usually these files are written by a python script from a template
 40 | #  before PyInstaller builds the exe, so as to inject date/other infos into it.
 41 | *.manifest
 42 | *.spec
 43 | 
 44 | # Installer logs
 45 | pip-log.txt
 46 | pip-delete-this-directory.txt
 47 | 
 48 | # Unit test / coverage reports
 49 | htmlcov/
 50 | .tox/
 51 | .nox/
 52 | .coverage
 53 | .coverage.*
 54 | .cache
 55 | nosetests.xml
 56 | coverage.xml
 57 | *.cover
 58 | *.py,cover
 59 | .hypothesis/
 60 | .pytest_cache/
 61 | 
 62 | # Translations
 63 | *.mo
 64 | *.pot
 65 | 
 66 | # Django stuff:
 67 | *.log
 68 | local_settings.py
 69 | db.sqlite3
 70 | db.sqlite3-journal
 71 | 
 72 | # Flask stuff:
 73 | instance/
 74 | .webassets-cache
 75 | 
 76 | # Scrapy stuff:
 77 | .scrapy
 78 | 
 79 | # Sphinx documentation
 80 | docs/_build/
 81 | 
 82 | # PyBuilder
 83 | target/
 84 | 
 85 | # Jupyter Notebook
 86 | .ipynb_checkpoints
 87 | 
 88 | # IPython
 89 | profile_default/
 90 | ipython_config.py
 91 | 
 92 | # pyenv
 93 | .python-version
 94 | 
 95 | # pipenv
 96 | #   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
 97 | #   However, in case of collaboration, if having platform-specific dependencies or dependencies
 98 | #   having no cross-platform support, pipenv may install dependencies that don't work, or not
 99 | #   install all needed dependencies.
100 | #Pipfile.lock
101 | 
102 | # celery beat schedule file
103 | celerybeat-schedule
104 | 
105 | # SageMath parsed files
106 | *.sage.py
107 | 
108 | # Environments
109 | .env
110 | .venv
111 | env/
112 | venv/
113 | ENV/
114 | env.bak/
115 | venv.bak/
116 | 
117 | # Spyder project settings
118 | .spyderproject
119 | .spyproject
120 | 
121 | # Rope project settings
122 | .ropeproject
123 | 
124 | # mkdocs documentation
125 | /site
126 | 
127 | # mypy
128 | .mypy_cache/
129 | .dmypy.json
130 | dmypy.json
131 | 
132 | # Pyre type checker
133 | .pyre/
134 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2019 BusyDataForFS
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/Segmentor.m:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/busyyang/ECGNet/617bee344b22c9ad393a7b335cdd46ee5a621542/Segmentor.m


--------------------------------------------------------------------------------
/data_format.m:
--------------------------------------------------------------------------------
 1 | function  [sig_out,offset]=data_format(sig_in)
 2 | % format  sig_in to fixed length of 300 points.
 3 | % return fixed data and added points before sig_in.
 4 | % 2019/11/26    YANG Jie    Init
 5 |     valid_len=length(sig_in);
 6 |     total_len=300;
 7 |     if valid_len<total_len
 8 |         %random padding
 9 |         padding_len=total_len-valid_len;
10 |         offset=unidrnd(padding_len);
11 |         sig_out=[ones(1,offset)*sig_in(1),sig_in',ones(1,padding_len-offset)*sig_in(end)];
12 |     else
13 |         % resample
14 |         offset=0;
15 |         sig_out=resample(sig_in,total_len,valid_len)';
16 |     end
17 | end


--------------------------------------------------------------------------------
/download_QTDB.m:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/busyyang/ECGNet/617bee344b22c9ad393a7b335cdd46ee5a621542/download_QTDB.m


--------------------------------------------------------------------------------
/paper_models_codes/ECGNet.py:
--------------------------------------------------------------------------------
 1 | import keras
 2 | import keras.backend as K
 3 | from keras.layers import Dense, Conv1D, MaxPool1D, Flatten
 4 | import numpy as np
 5 | import scipy.io as scio
 6 | import matplotlib.pyplot as plt
 7 | 
 8 | from utils import *
 9 | 
10 | 
11 | def build_model():
12 |     """
13 |     build a LeNet-style model
14 |     2019/11/26      YANG Jie    Init
15 |     :return: None
16 |     """
17 |     model = keras.Sequential()
18 |     model.add(Conv1D(16, 5, strides=3, padding='same', input_shape=(get_sample_length(), 1)))
19 |     model.add(MaxPool1D(2))
20 |     model.add(Conv1D(32, 5, strides=3, padding='same'))
21 |     model.add(MaxPool1D(2))
22 |     model.add(Flatten())
23 |     model.add(Dense(100))
24 |     model.add(Dense(2))
25 |     return model
26 | 
27 | 
28 | def lr_scheduler(epoch):
29 |     """
30 |     learning rate scheduler
31 |     :param epoch:
32 |     :return:
33 |     """
34 |     if epoch % 200 == 0 and epoch != 0:
35 |         lr = K.get_value(model.optimizer.lr)
36 |         K.set_value(model.optimizer.lr, lr * 0.2)
37 |         print('lr changed to {}'.format(lr * 0.2))
38 |     return K.get_value(model.optimizer.lr)
39 | 
40 | 
41 | if __name__ == '__main__':
42 |     # load data
43 |     X, Y = load_data('../data/segmentors.mat')
44 |     # data normalization
45 |     X = data_normalization(X)
46 |     X, Y = data_shuffle(X, Y)
47 |     # format X for keras input
48 |     X = np.expand_dims(X, axis=2)
49 |     # split set to train and test
50 |     X_train, Y_train, X_test, Y_test = data_split(X, Y, radio=0.95)
51 |     # build a model
52 |     model = build_model()
53 |     # print model information
54 |     model.summary()
55 |     # set learning rate and optimizer
56 |     opt = keras.optimizers.adam(lr=1e-3)
57 |     # set lr reduce scheduler
58 |     reduce_lr = keras.callbacks.LearningRateScheduler(lr_scheduler)
59 |     model.compile(loss=loss_func, optimizer=opt, metrics=[acc_localization])
60 |     # train the model
61 |     hist = model.fit(X, Y, validation_split=0.1, epochs=500, verbose=2, batch_size=4096, callbacks=[reduce_lr])
62 |     print('=' * 50)
63 |     # plot loss
64 |     plt.plot(hist.history['loss'])
65 |     plt.plot(hist.history['val_loss'])
66 |     plt.legend(['loss', 'val_loss'])
67 |     plt.show()
68 |     # predict the model
69 |     Y_pre = model.predict(X_test, verbose=2)
70 |     # show errors in graph
71 |     errors = np.abs(Y_test - Y_pre)
72 |     plt.plot(errors[:, 0])
73 |     plt.plot(errors[:, 1])
74 |     plt.legend(['P-err', 'R-err'])
75 |     plt.show()
76 | 


--------------------------------------------------------------------------------
/paper_models_codes/ECGNet_dropout.py:
--------------------------------------------------------------------------------
 1 | import keras
 2 | import keras.backend as K
 3 | from keras.layers import Dense, Conv1D, MaxPool1D, Flatten, Dropout
 4 | import numpy as np
 5 | import matplotlib.pyplot as plt
 6 | from ultis import *
 7 | 
 8 | def build_model():
 9 |     """
10 |     build a LeNet-style model
11 |     2019/11/26      YANG Jie    Init
12 |     :return: None
13 |     """
14 |     model = keras.Sequential()
15 |     model.add(Conv1D(16, 5, strides=3, padding='same', input_shape=(get_sample_length(), 1)))
16 |     model.add(MaxPool1D(2))
17 |     model.add(Dropout(0.2))
18 |     model.add(Conv1D(32, 5, strides=3, padding='same'))
19 |     model.add(MaxPool1D(2))
20 |     model.add(Dropout(0.2))
21 |     model.add(Flatten())
22 |     model.add(Dense(100))
23 |     model.add(Dense(2))
24 |     return model
25 | 
26 | 
27 | 
28 | 
29 | 
30 | def lr_scheduler(epoch):
31 |     """
32 |     learning rate scheduler
33 |     :param epoch:
34 |     :return:
35 |     """
36 |     if epoch % 600 == 0 and epoch != 0:
37 |         lr = K.get_value(model.optimizer.lr)
38 |         K.set_value(model.optimizer.lr, lr * 0.2)
39 |         print('lr changed to {}'.format(lr * 0.2))
40 |     return K.get_value(model.optimizer.lr)
41 | 
42 | 
43 | if __name__ == '__main__':
44 |     # load data
45 |     X, Y = load_data('../data/segmentors.mat')
46 |     # data normalization
47 |     X = data_normalization(X)
48 |     X, Y = data_shuffle(X, Y)
49 |     # format X for keras input
50 |     X = np.expand_dims(X, axis=2)
51 |     # split set to train and test
52 |     X_train, Y_train, X_test, Y_test = data_split(X, Y, radio=0.95)
53 |     # build a model
54 |     model = build_model()
55 |     # print model information
56 |     model.summary()
57 |     # set learning rate and optimizer
58 |     opt = keras.optimizers.adam(lr=1e-5)
59 |     # set lr reduce scheduler
60 |     reduce_lr = keras.callbacks.LearningRateScheduler(lr_scheduler)
61 |     model.compile(loss=loss_func, optimizer=opt)
62 |     # train the model
63 |     hist = model.fit(X, Y, validation_split=0.1, epochs=1000, verbose=2, batch_size=2048, callbacks=[reduce_lr])
64 |     print('=' * 50)
65 |     # plot loss
66 |     plt.plot(hist.history['loss'])
67 |     plt.plot(hist.history['val_loss'])
68 |     plt.legend(['loss', 'val_loss'])
69 |     plt.show()
70 |     # predict the model
71 |     Y_pre = model.predict(X_test, verbose=2)
72 |     # show errors in graph
73 |     errors = np.abs(Y_test - Y_pre)
74 |     plt.plot(errors[:, 0])
75 |     plt.plot(errors[:, 1])
76 |     plt.legend(['P-err', 'R-err'])
77 |     plt.show()
78 | 


--------------------------------------------------------------------------------
/paper_models_codes/denseNet_P_R_localization.py:
--------------------------------------------------------------------------------
 1 | import keras
 2 | import keras.backend as K
 3 | from keras.layers import Dense
 4 | import numpy as np
 5 | import matplotlib.pyplot as plt
 6 | 
 7 | from ultis import *
 8 | 
 9 | 
10 | 
11 | def build_model():
12 |     """
13 |     build a dense model
14 |     2019/11/26      YANG Jie    Init
15 |     :return: None
16 |     """
17 |     model = keras.Sequential()
18 |     model.add(Dense(256, input_dim=get_sample_length(), activation='relu'))
19 |     model.add(Dense(128, activation='relu'))
20 |     model.add(Dense(64, activation='relu'))
21 |     model.add(Dense(2))
22 |     return model
23 | 
24 | 
25 | def lr_scheduler(epoch):
26 |     """
27 |     learning rate scheduler
28 |     :param epoch:
29 |     :return:
30 |     """
31 |     if epoch % 300 == 0 and epoch != 0:
32 |         lr = K.get_value(model.optimizer.lr)
33 |         K.set_value(model.optimizer.lr, lr * 0.2)
34 |         print('lr changed to {}'.format(lr * 0.2))
35 |     return K.get_value(model.optimizer.lr)
36 | 
37 | 
38 | if __name__ == '__main__':
39 |     # load data
40 |     X, Y = load_data('../data/segmentors.mat')
41 |     # data normalization
42 |     X = data_normalization(X)
43 |     X, Y = data_shuffle(X, Y)
44 |     # split set to train and test
45 |     X_train, Y_train, X_test, Y_test = data_split(X, Y, radio=0.95)
46 |     # build a model
47 |     model = build_model()
48 |     # print model information
49 |     model.summary()
50 |     # set learning rate and optimizer
51 |     opt = keras.optimizers.sgd(lr=0.001)
52 |     # set lr reduce scheduler
53 |     reduce_lr = keras.callbacks.LearningRateScheduler(lr_scheduler)
54 |     model.compile(loss=loss_func, optimizer=opt, metrics=[acc_localization])
55 |     # train the model
56 |     hist = model.fit(X, Y, validation_split=0.2, epochs=1000, verbose=2, batch_size=2048, callbacks=[reduce_lr])
57 |     print('=' * 100)
58 |     # plot loss
59 |     plt.plot(hist.history['loss'])
60 |     plt.plot(hist.history['val_loss'])
61 |     plt.legend(['loss', 'val_loss'])
62 |     plt.show()
63 |     # predict the model
64 |     Y_pre = model.predict(X_test, verbose=2)
65 |     # show errors in graph
66 |     errors = np.abs(Y_test - Y_pre)
67 |     plt.plot(errors[:, 0], '*')
68 |     plt.plot(errors[:, 1], 'o')
69 |     plt.legend(['P-err', 'R-err'])
70 |     plt.show()
71 | 


--------------------------------------------------------------------------------
/paper_models_codes/utils.py:
--------------------------------------------------------------------------------
 1 | import scipy.io as scio
 2 | import keras.backend as K
 3 | import numpy as np
 4 | 
 5 | LEN_SAMPLING = 300
 6 | 
 7 | 
 8 | def get_sample_length():
 9 |     """
10 |     return length of record
11 |     2019/11/26      YANG Jie    Init
12 |     :return:
13 |     """
14 |     return LEN_SAMPLING
15 | 
16 | 
17 | def load_data(path_file):
18 |     """
19 |     load data from .mat file. Preprocessed in matlab.
20 |     2019/11/26      YANG Jie    Init
21 |     :param path_file: segmentor.mat
22 |     :return: data(X), ann(Y)
23 |     """
24 |     file = scio.loadmat(path_file)
25 |     data = file['segs']
26 |     ann = file['anns']
27 |     return data, ann
28 | 
29 | 
30 | def loss_func(y_true, y_pre):
31 |     """
32 |     user loss function in equation of RMSE (equation 1)
33 |     2019/11/26      YANG Jie    Init
34 |     :param y_true:
35 |     :param y_pre:
36 |     :return:
37 |     """
38 |     return K.sqrt(K.mean(K.pow(y_true - y_pre, 2)))
39 | 
40 | 
41 | def acc_localization(y_true, y_pre):
42 |     """
43 |     return accuracy defined equation 3 in paper
44 |     :param y_true:
45 |     :param y_pre:
46 |     :return:
47 |     """
48 |     cost = loss_func(y_true, y_pre)
49 |     return (LEN_SAMPLING / 2. - cost) / (LEN_SAMPLING / 2.)
50 | 
51 | 
52 | def data_normalization(data):
53 |     """
54 |     normalization data in row direction.
55 |     return a output with mean of 0 and std of 1
56 |     2019/11/26      YANG Jie    Init
57 |     :param data:
58 |     :return:
59 |     """
60 |     data_mean = data.mean(axis=1)
61 |     data_mean = data_mean.reshape(data_mean.shape[0], 1)
62 |     data_std = data.std(axis=1)
63 |     data_std = data_std.reshape(data_std.shape[0], 1)
64 |     return (data - data_mean) / data_std
65 | 
66 | 
67 | def data_shuffle(X, Y):
68 |     """
69 |     shuffle data. Get random order output.
70 |     2019/11/26      YANG Jie    Init
71 |     :param X:
72 |     :param Y:
73 |     :return:
74 |     """
75 |     per = np.random.permutation(len(Y))
76 |     X = X[per, :]
77 |     Y = Y[per, :]
78 |     return X, Y
79 | 
80 | 
81 | def data_split(X, Y, radio=0.7):
82 |     """
83 |     split set into train set and test set according to radio
84 |     :param X:
85 |     :param Y:
86 |     :param radio:
87 |     :return:
88 |     """
89 |     length = Y.shape[0]
90 |     X_train = X[:int(length * radio), :]
91 |     Y_train = Y[:int(length * radio), :]
92 |     X_test = X[int(length * radio):, :]
93 |     Y_test = Y[int(length * radio):, :]
94 |     return X_train, Y_train, X_test, Y_test
95 | 


--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
 1 | ECG R-wave and P-wave localization in paper:
 2 | ~~~
 3 | @InProceedings{Abrishami2018,
 4 |   author    = {H. {Abrishami} and M. {Campbell} and C. {Han} and R. {Czosek} and X. {Zhou}},
 5 |   title     = {P-{QRS}-T localization in {ECG} using deep learning},
 6 |   booktitle = {Proc. IEEE EMBS Int. Conf. Biomedical Health Informatics (BHI)},
 7 |   year      = {2018},
 8 |   pages     = {210--213},
 9 |   month     = mar,
10 |   doi       = {10.1109/BHI.2018.8333406}
11 | }
12 | ~~~
13 | Since the code of this paper is not open, I implemented the code according this paper with `keras` framework.
14 | # Data preprocess
15 | Data preprocessed in MATLAB. Download data files from `https://www.physionet.org/content/qtdb/1.0.0/` with `download_QTDB.m`. PC will get `xxxann.mat` for Y and `xxxdata.mat` for X.\
16 | For input data to keras conveniently, `Segmentor.m` will segment all recording into complexes and position of P-wave and R-wave is also saved in `segmentors.mat`.\
17 | if you load `segmentor.mat` into matlab. You will get `segs` with 96863 by 300 and `anns` with dimention of 96863 by 2 in workspace. That mean there are 96863 complexes with length of 300 sampling points.\
18 | `ann[:,1]` presents position of P-wave. `ann[:,2]` presents position of R-wave. More detail can be found in paper. 
19 | 
20 | # models
21 | for fully-connected net usage:
22 | ~~~python
23 |     python ./paper_models_codes/denseNet_P_R_localization.py
24 | ~~~
25 | for 1D CNN usage:
26 | ~~~python
27 |     python ./paper_models_codes/ECGNet.py
28 | ~~~
29 | for 1D CNN with dropout usage:
30 | ~~~python
31 |     python ./paper_models_codes/ECGNet_Dropout.py
32 | ~~~
33 | 


--------------------------------------------------------------------------------
/src/keras_test.py:
--------------------------------------------------------------------------------
 1 | """
 2 | 使用keras进行深度学习模型搭建的方式，keras学习测试文件
 3 | 2019/11/18  YANG Jie    Init
 4 | """
 5 | import numpy as np
 6 | import keras
 7 | from keras.layers import Dense, Dropout
 8 | from keras.models import Sequential, load_model
 9 | import matplotlib.pyplot as plt
10 | 
11 | 
12 | class LossHistory(keras.callbacks.Callback):
13 |     def on_train_begin(self, logs={}):
14 |         self.losses = {'batch': [], 'epoch': []}
15 |         self.accuracy = {'batch': [], 'epoch': []}
16 |         self.val_loss = {'batch': [], 'epoch': []}
17 |         self.val_acc = {'batch': [], 'epoch': []}
18 | 
19 |     def on_batch_end(self, batch, logs={}):
20 |         self.losses['batch'].append(logs.get('loss'))
21 |         self.accuracy['batch'].append(logs.get('acc'))
22 |         self.val_loss['batch'].append(logs.get('val_loss'))
23 |         self.val_acc['batch'].append(logs.get('val_acc'))
24 | 
25 |     def on_epoch_end(self, batch, logs={}):
26 |         self.losses['epoch'].append(logs.get('loss'))
27 |         self.accuracy['epoch'].append(logs.get('acc'))
28 |         self.val_loss['epoch'].append(logs.get('val_loss'))
29 |         self.val_acc['epoch'].append(logs.get('val_acc'))
30 | 
31 |     def loss_plot(self, loss_type):
32 |         iters = range(len(self.losses[loss_type]))
33 |         # 创建一个图
34 |         plt.figure()
35 |         # acc
36 |         plt.plot(iters, self.accuracy[loss_type], 'r', label='train acc')  # plt.plot(x,y)，这个将数据画成曲线
37 |         # loss
38 |         plt.plot(iters, self.losses[loss_type], 'g', label='train loss')
39 |         if loss_type == 'epoch':
40 |             # val_acc
41 |             plt.plot(iters, self.val_acc[loss_type], 'b', label='val acc')
42 |             # val_loss
43 |             plt.plot(iters, self.val_loss[loss_type], 'k', label='val loss')
44 |         plt.grid(True)  # 设置网格形式
45 |         plt.xlabel(loss_type)
46 |         plt.ylabel('acc-loss')  # 给x，y轴加注释
47 |         plt.legend(loc="upper right")  # 设置图例显示位置
48 |         plt.show()
49 | 
50 | 
51 | # 随机种子
52 | seed = 7
53 | np.random.seed(seed)
54 | # 加载保存在csv文件中的数据
55 | dataset = np.loadtxt('datafix.csv', delimiter=',')
56 | Y = dataset[:, 0]
57 | X = dataset[:, 1:]
58 | 
59 | # 创建模型
60 | model = Sequential()
61 | model.add(Dense(64, input_dim=25, init='uniform', activation='relu'))
62 | model.add(Dropout(0.8))
63 | model.add(Dense(32, activation='relu'))
64 | model.add(Dropout(0.8))
65 | model.add(Dense(1, activation='sigmoid'))
66 | 
67 | # 打印模型
68 | model.summary()
69 | 
70 | # 历史记录
71 | lossHistory = LossHistory()
72 | 
73 | # 编译模型，训练模型的方式
74 | model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
75 | 
76 | # 训练模型
77 | model.fit(X, Y, epochs=200, batch_size=512, verbose=1, callbacks=[lossHistory])
78 | scores = model.evaluate(X, Y)
79 | print("%s: %.2f%%" % (model.metrics_names[1], scores[1] * 100))
80 | lossHistory.loss_plot('epoch')
81 | # model.save('test.h5')
82 | 


--------------------------------------------------------------------------------
/src/utils.py:
--------------------------------------------------------------------------------
 1 | import scipy.io as scio
 2 | 
 3 | 
 4 | def loadmatfile(filename):
 5 |     mat = scio.loadmat(filename)
 6 |     return mat
 7 | 
 8 | 
 9 | def loadann(filename):
10 |     return scio.loadmat(filename)
11 | 
12 | 
13 | if __name__ == '__main__':
14 |     mat = loadmatfile('../data/sel30data.mat')
15 |     ann = loadann('../data/sel30ann.mat')
16 | 


--------------------------------------------------------------------------------