Ejemplo n.º 1
0
def main():
    model = EEGNet(nb_classes=2,
                   Chans=25,
                   Samples=176,
                   dropoutRate=0.5,
                   kernLength=32,
                   F1=8,
                   D=2,
                   F2=16,
                   dropoutType='Dropout')

    model.load_weights(f'BCICIV2a/weights/all.h5')
    model._make_predict_function()
    stream(model)
Ejemplo n.º 2
0
                   kernLength=64,
                   F1=8,
                   D=2,
                   F2=16,
                   dropoutType='Dropout')

    # compile model
    model.compile(loss='categorical_crossentropy',
                  optimizer='adam',
                  metrics=['accuracy'])

    # train model and save weights
    # train(model, {"x": comp_trainX, "y": comp_trainY}, {"x": comp_valX, "y": comp_valY}, weight_file, epochs=EPOCHS)

    # load weights from file
    model.load_weights(weight_file)

    # test competition data
    comp_eval = test_model(model, comp_testX, comp_testY)

    # cross validate transfer learning
    print(f'fold {i+1}')
    pilot_fold_avg = {'acc': 0, 'bal': 0, 'kap': 0}
    for i, (train_index, test_index) in enumerate(skf.split(_pilotX, _pilotY)):
        # reset weights
        model.load_weights(weight_file)

        # stratified train-val-test split for pilot data
        pilot_trainX, pilot_testX = _pilotX[train_index], _pilotX[test_index]
        pilot_trainY, pilot_testY = _pilotY[train_index], _pilotY[test_index]
        pilot_trainX, pilot_valX, pilot_trainY, pilot_valY = train_test_split(
Ejemplo n.º 3
0
def get_model(transfer_paths=None):
    K.clear_session()

    model = EEGNet(nb_classes=3,
                   Chans=9,
                   Samples=250,
                   dropoutRate=0.5,
                   kernLength=64,
                   F1=8,
                   D=2,
                   F2=16,
                   dropoutType='Dropout')

    # compile model loss function and optimizer for transfer learning
    model.compile(loss='categorical_crossentropy',
                  optimizer='adam',
                  metrics=['accuracy'])

    # load base model
    model.load_weights(BASE_WEIGHTS)

    # K.clear_session()

    print(transfer_paths)

    if not transfer_paths or len(transfer_paths) is 0:
        return (model, True)
    print(len(transfer_paths))
    try:
        transfer_raw = read_raw_brainvision(transfer_paths[0], preload=True)
        if len(transfer_paths) > 1:
            for i in range(1, len(transfer_paths)):
                print(i)
                transfer_raw = concatenate_raws([
                    transfer_raw,
                    read_raw_brainvision(transfer_paths[i], preload=True)
                ])
    except Exception as e:
        print('failed', e)
        return (model, None)

    transX, transY = epoch_pilot(transfer_raw,
                                 n_classes=3,
                                 good_channels=GOODS,
                                 resample=RESAMPLE,
                                 trange=T_RANGE,
                                 l_freq=LO_FREQ,
                                 h_freq=HI_FREQ)

    # separate 4:1 train:validation
    transX, transY = stratify(transX, transY, 5)

    trans_trainX, trans_valX = add_kernel_dim(get_fold(transX, 5, 0,
                                                       test_rest_split),
                                              kernels=1)
    trans_trainY, trans_valY = onehot(get_fold(transY, 5, 0, test_rest_split))
    trans_valY, _ = onehot((trans_valY, []))

    # perform transfer learning on the base model and selected transfer file
    train(model, {
        "x": trans_trainX,
        "y": trans_trainY
    }, {
        "x": trans_valX,
        "y": trans_valY
    },
          epochs=EPOCHS)

    return (model, False)