def create_network(network_input, n_vocab): """ create the structure of the neural network """ model = Sequential() model.add( LSTM(512, input_shape=(network_input.shape[1], network_input.shape[2]), recurrent_dropout=0.3, return_sequences=True)) model.add(LSTM( 512, return_sequences=True, recurrent_dropout=0.3, )) model.add(LSTM(512)) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(256)) model.add(Activation('relu')) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(n_vocab)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') # Load the weights to each node model.load_weights( '/content/drive/MyDrive/Colab Notebooks/beethoven/weights-improvement-19-1.0630-bigger.hdf5' ) return model
def create_network(network_input, n_vocab): """ create the structure of the neural network """ model = Sequential() model.add( Bidirectional(LSTM(256, input_shape=(network_input.shape[1], network_input.shape[2]), recurrent_dropout=0.3, return_sequences=True), merge_mode="concat")) model.add( Bidirectional(LSTM( 512, return_sequences=True, recurrent_dropout=0.3, ), merge_mode="concat")) model.add(LSTM(512)) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(256)) model.add(Activation('relu')) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(n_vocab, name="new_layer")) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') return model
def create_network(network_input, n_vocab): """ create the structure of the neural network """ model = Sequential() model.add( LSTM(args.cells, input_shape=(network_input.shape[1], network_input.shape[2]), recurrent_dropout=0.3, return_sequences=True)) model.add(LSTM( args.cells, return_sequences=True, recurrent_dropout=0.2, )) model.add(LSTM( args.cells, return_sequences=True, recurrent_dropout=0.1, )) model.add(LSTM(args.cells)) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(256)) model.add(Activation('tanh')) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(n_vocab)) model.add(Activation('softmax')) model.compile(loss=LOSS, optimizer=OPTIMIZER) # Load the weights to each node model.load_weights(args.weights) return model
def create_network(networkInput, n_vocab): """ create the structure of the neural network """ model = Sequential() model.add( LSTM(hidden_layer, input_shape=(networkInput.shape[1], networkInput.shape[2]), recurrent_dropout=dropout, return_sequences=True)) model.add( LSTM( hidden_layer, return_sequences=True, recurrent_dropout=dropout, )) model.add(LSTM(hidden_layer)) model.add(BatchNorm()) model.add(Dropout(dropout)) model.add(Dense(dense)) model.add(Activation('relu')) model.add(BatchNorm()) model.add(Dropout(dropout)) model.add(Dense(n_vocab)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='Adam', metrics=['categorical_accuracy']) return model
def create_network(network_input, n_vocab): model = Sequential() model.add( LSTM(512, input_shape=(network_input.shape[1], network_input.shape[2]), recurrent_dropout=0.3, return_sequences=True)) model.add(LSTM( 512, return_sequences=True, recurrent_dropout=0.3, )) model.add(LSTM(512)) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(256)) model.add(Activation('relu')) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(n_vocab)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') model.load_weights('weights.hdf5') return model
def create_network(network_input, n_vocab): """ create the structure of the neural network """ model = Sequential() model.add( LSTM(512, input_shape=(network_input.shape[1], network_input.shape[2]), recurrent_dropout=0.3, return_sequences=True)) model.add(LSTM( 512, return_sequences=True, recurrent_dropout=0.3, )) model.add(LSTM(512)) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(256)) model.add(Activation('relu')) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(n_vocab)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam') model.load_weights('lofi-hip-hop-weights-improvement-100-0.6290.hdf5') return model
def lstm(network_input, n_vocab): """LSTM model architecture.""" # Create LSTM network structure. model = Sequential() model.add( LSTM(128, input_shape=(network_input.shape[1], network_input.shape[2]), recurrent_dropout=0.3, return_sequences=True)) model.add(LSTM( 128, return_sequences=True, recurrent_dropout=0.3, )) model.add(LSTM(128)) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(128)) model.add(Activation('relu')) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(n_vocab)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') return model
def create_network(network_input, n_vocab, mode): #create the structure of the neural network model = Sequential() model.add(LSTM( hidden_layer, input_shape=(network_input.shape[1], network_input.shape[2]), recurrent_dropout=dropout, return_sequences=True )) model.add(LSTM(hidden_layer, return_sequences=True, recurrent_dropout=dropout,)) model.add(LSTM(hidden_layer)) model.add(BatchNorm()) model.add(Dropout(dropout)) model.add(Dense(dense)) model.add(Activation('relu')) model.add(BatchNorm()) model.add(Dropout(dropout)) model.add(Dense(n_vocab)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam') # Load the weights to each node # mode means major/minor model.load_weights(f'./data/{mode}/{progression}.hdf5') return model
def DenseNet_encoder(blocks, input_tensor, pooling=None, train_bn=False): """Instantiates the DenseNet architecture.""" bn_axis = 3 if K.image_data_format() == 'channels_last' else 1 x = ZeroPadding2D(padding=((3, 3), (3, 3)))(input_tensor) # x = Lambda(lambda x: tf.pad(x, [[0,0],[3,3],[3,3],[0,0]], mode='SYMMETRIC'))(input_tensor) x = Conv2D(64, 7, strides=2, use_bias=False, name='conv1/conv')(x) x = BatchNorm(axis=bn_axis, epsilon=1.001e-5, name='conv1/bn', )(x, training=train_bn) R1 = x = Activation('relu', name='conv1/relu')(x) x = ZeroPadding2D(padding=((1, 1), (1, 1)))(x) x = MaxPooling2D(3, strides=2, name='pool1')(x) R2 = x = dense_block(x, blocks[0], name='conv2', train_bn=train_bn) _, x = transition_block(x, 0.5, name='pool2', train_bn=train_bn) R3 = x = dense_block(x, blocks[1], name='conv3', train_bn=train_bn) _, x = transition_block(x, 0.5, name='pool3', train_bn=train_bn) R4 = x = dense_block(x, blocks[2], name='conv4', train_bn=train_bn) _, x = transition_block(x, 0.5, name='pool4', train_bn=train_bn) x = dense_block(x, blocks[3], name='conv5', train_bn=train_bn) x = BatchNorm(axis=bn_axis, epsilon=1.001e-5, name='bn')(x, training=train_bn) if pooling == 'avg': x = AveragePooling2D(7, name='avg_pool')(x) elif pooling == 'max': x = MaxPooling2D(7, name='max_pool')(x) return [R1, R2, R3, R4], x
def generate_model(model_input, n_elements, file): """ build the model """ print("Generating RNN from %s" % file) model = Sequential() model.add( LSTM(512, input_shape=(model_input.shape[1], model_input.shape[2]), recurrent_dropout=0.3, return_sequences=True)) model.add(LSTM( 512, return_sequences=True, recurrent_dropout=0.3, )) model.add(LSTM(512)) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(256)) model.add(Activation('relu')) model.add(BatchNorm()) model.add(Dense(256)) model.add(Dropout(0.3)) model.add(Dense(n_elements)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') # Load the weights from training model.load_weights(file) return model
def model_A(self, network_input, n_vocab): """ Create the structure of the neural network """ model = Sequential() model.add(LSTM( 512, input_shape=(network_input.shape[1], network_input.shape[2]), recurrent_dropout=0.3, return_sequences=True )) model.add(LSTM(512, return_sequences=True, recurrent_dropout=0.3,)) model.add(LSTM(512)) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(256)) model.add(Activation('relu')) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(n_vocab)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') if self.weights != None: model.load_weights(self.weights) else: print("Weights were not loaded, starting from nothing") return model
def create_network(network_input, n_vocab, weights): """ create the structure of the neural network """ model = Sequential() model.add( LSTM(512, input_shape=(network_input.shape[1], network_input.shape[2]), recurrent_dropout=0.3, return_sequences=True)) model.add(LSTM( 512, return_sequences=True, recurrent_dropout=0.3, )) model.add(LSTM(512)) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(256)) model.add(Activation('relu')) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(n_vocab)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') # Load the weights to each node model.load_weights(weights) return model
def create_network(network_input, n_vocab): """ create the structure of the neural network """ model = Sequential() model.add( LSTM(512, input_shape=(network_input.shape[1], network_input.shape[2]), recurrent_dropout=0.3, return_sequences=True)) model.add(LSTM( 512, return_sequences=True, recurrent_dropout=0.3, )) model.add(LSTM(512)) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(256)) model.add(Activation('relu')) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(n_vocab)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') # Load the weights to each node if os.path.exists('weights_' + name + '/'): files = [] for each in os.listdir('weights_' + name + '/'): files.append(os.path.join('weights_' + name + '/', each)) files.sort(key=lambda x: float(x[-11:-5])) model.load_weights(files[0]) print("Weight ", files[0], " Loaded...............") return model
def create_network(network_input, n_vocab): """ create the structure of the neural network """ model = Sequential() model.add( LSTM(64, input_shape=(network_input.shape[1], network_input.shape[2]), recurrent_dropout=0.3, return_sequences=True)) model.add(LSTM( 64, return_sequences=True, recurrent_dropout=0.3, )) model.add(LSTM(64)) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(10)) model.add(Activation('relu')) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(n_vocab)) model.add(Activation('softmax')) es = EarlyStopping(monitor='val_loss', mode='min') callbacks = es, model.compile(loss='categorical_crossentropy', optimizer='rmsprop') # Load the weights to each node model.load_weights('weights-improvement-666-3.4629-bigger.hdf5') return model
def generate_model(model_input, n_elements): """ Build the RNN """ model = Sequential() model.add( LSTM(512, input_shape=(model_input.shape[1], model_input.shape[2]), recurrent_dropout=0.3, return_sequences=True)) model.add(LSTM( 512, return_sequences=True, recurrent_dropout=0.3, )) model.add(LSTM(512)) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(256)) model.add(Activation('relu')) model.add(BatchNorm()) model.add(Dense(256)) model.add(Dropout(0.3)) model.add(Dense(n_elements)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') return model
def conv_block(x, growth_rate, name, train_bn): """A building block for a dense block. # Arguments x: input tensor. growth_rate: float, growth rate at dense layers. name: string, block label. # Returns output tensor for the block. import tensorflow as tf """ bn_axis = 3 if K.image_data_format() == 'channels_last' else 1 x1 = BatchNorm(axis=bn_axis, epsilon=1.001e-5, name=name + '_0_bn')(x, training=train_bn) x1 = Activation('relu', name=name + '_0_relu')(x1) x1 = Conv2D(4 * growth_rate, 1, use_bias=False, name=name + '_1_conv')(x1) x1 = BatchNorm(axis=bn_axis, epsilon=1.001e-5, name=name + '_1_bn')(x1, training=train_bn) x1 = Activation('relu', name=name + '_1_relu')(x1) x1 = ZeroPadding2D(padding=((1, 1), (1, 1)))(x1) # x1 = Lambda(lambda x: tf.pad(x, [[0,0],[1,1],[1,1],[0,0]], mode='SYMMETRIC'))(x1) x1 = Conv2D(growth_rate, 3, padding='valid', use_bias=False, name=name + '_2_conv')(x1) x = Concatenate(axis=bn_axis, name=name + '_concat')([x, x1]) return x
def lstm_model_2(window_size, dropout_rate, size_vocab, size_lstm): model = Sequential() model.add(LSTM(size_lstm, input_shape=(window_size, 1), recurrent_dropout=0.3, return_sequences=True)) # 512 model.add(LSTM(size_lstm, return_sequences=True, recurrent_dropout=0.3)) # 512 model.add(LSTM(size_lstm)) # 512 model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(256)) model.add(Activation('relu')) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(size_vocab)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy']) return model
def create_network(network_input, n_vocab): """ create the structure of the neural network """ nmodel = None if (args.weights): nmodel = load_model(args.weights) else: model = Sequential() model.add( LSTM( args.cells, input_shape=(network_input.shape[1], network_input.shape[2]), recurrent_dropout=0.3, return_sequences=True, )) model.add( LSTM( args.cells, return_sequences=True, recurrent_dropout=0.2, )) model.add( LSTM( args.cells, return_sequences=True, recurrent_dropout=0.1, )) model.add(LSTM(args.cells)) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(256)) model.add(Activation('tanh')) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(n_vocab)) model.add(Activation('softmax')) if (args.ngpus > 1): print('INFO: using %d devices' % args.ngpus) parallel_model = multi_gpu_model(model, gpus=2) parallel_model.compile(loss=LOSS, optimizer=OPTIMIZER) nmodel = parallel_model else: print('INFO: using only one device') model.compile(loss=LOSS, optimizer=OPTIMIZER) nmodel = model return nmodel
def create_network(network_input, n_vocab, Pitch): """ create the structure of the neural network """ model = Sequential() model.add( LSTM(512, input_shape=(network_input.shape[1], network_input.shape[2]), recurrent_dropout=0.3, return_sequences=True)) model.add(LSTM( 512, return_sequences=True, recurrent_dropout=0.3, )) model.add(LSTM(512)) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(256)) model.add(Activation('relu')) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(n_vocab)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') files = "" i = 0 print("Choose your weights: ex 0 or 1 or 2") files = glob.glob('weights/' + Pitch + '/*') # Load the weights to each node #讀取weights權重 minLoss = files[0].split("-")[len(files[0].split("-")) - 2] chooseWeight = "" #最後選擇哪個模型 =>loss小的 for file in files: fileX = file.split("-") if fileX[len(fileX) - 2] <= minLoss: minLoss = fileX[len(fileX) - 2] print('minLoss change') chooseWeight = file # print(str(i)+"."+file) i += 1 # x = int(input("")) print("you use :" + chooseWeight) model.load_weights(chooseWeight) # weights.hdf5 return model
def generate_model(train_samples, num_pitches): model = Sequential() model.add( LSTM(512, input_shape=(train_samples.shape[1], train_samples.shape[2]), recurrent_dropout=.3, return_sequences=True)) model.add(LSTM(512, return_sequences=True, recurrent_dropout=0.3)) model.add(LSTM(512)) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(256)) model.add(Activation('relu')) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(num_pitches)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') return model
def createNetwork(networkInput, nDiff): """ create the structure of the neural network """ #LSTM(Long Short Trem Memory) je sloj RRN koja prima sekvencu ulaza i vraca #sekvencu ili matricu (u ovom slucaju sekvencu) #aktivacioni sloj odredjuje koju ce aktivacionu fju nasa mreza koristiti za #izdracunavanje #za LSTM, Dense i Activation slojeve prvi parametar je broj cvorova u njima #dropout parametar predstavlja koliki deo ulaznih vrednosti ce biti odbacen #prilikom treniranja # input_shape daje do znjanja mrezi kakvog ce oblika biti podaci koje ce #trenirati ######treba se igrati malo sa ovim slojevima model = Sequential() model.add( LSTM(512, input_shape=(networkInput.shape[1], networkInput.shape[2]), recurrent_dropout=0.3, return_sequences=True)) model.add(LSTM( 512, return_sequences=True, recurrent_dropout=0.3, )) model.add(LSTM(512)) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(256)) model.add(Activation('relu')) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(nDiff)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='adam') #poslednji sloj mreze ima isti broj cvorova kao nas izlaz da bi se direktno #mapiralo return model
def build_model(self): self.encoder = Sequential() self.encoder.add( LSTM(self.hidden_size, input_shape=(self.inp_length, self.notes_classes), return_sequences=True, recurrent_dropout=self.dropout)) self.encoder.add( LSTM(self.hidden_size, recurrent_dropout=self.dropout, return_sequences=True)) self.encoder.add(BatchNorm()) self.encoder.add(Dropout(self.dropout)) self.encoder.add(Dense(256, activation="relu")) self.encoder.add(BatchNorm()) self.encoder.add(Dense(128, activation="relu")) self.encoder.add(BatchNorm()) self.encoder.add(Dense(64, activation="relu", name="encoder_out")) self.decoder = Sequential() # self.decoder.add(Input(shape=(128, 87))) self.decoder.add(Dense(64, name="decoder_in", activation="relu")) self.decoder.add(BatchNorm()) self.decoder.add(Dense(128, activation="relu")) self.decoder.add(BatchNorm()) self.decoder.add(Dense(256, activation="relu")) self.decoder.add( LSTM(self.hidden_size, recurrent_dropout=self.dropout, return_sequences=True)) self.decoder.add( LSTM(self.hidden_size, recurrent_dropout=self.dropout, return_sequences=True)) self.decoder.add(Dropout(self.dropout)) self.decoder.add(Dense(256, activation="relu")) self.decoder.add(Dense(128, activation="relu")) self.decoder.add(BatchNorm()) self.decoder.add(Dense(self.notes_classes, activation="softmax")) decoded_inp = Input(shape=(128, 64)) decoded_out = self.decoder(decoded_inp) self.decoder = Model(decoded_inp, decoded_out) self.model = Sequential() self.model.add(self.encoder) self.model.add(self.decoder) self.model.compile(loss="categorical_crossentropy", optimizer='rmsprop', metrics=['categorical_accuracy'])
def transition_block(x, reduction, name, train_bn): """A transition block. # Arguments x: input tensor. reduction: float, compression rate at transition layers. name: string, block label. # Returns output tensor for the block. """ bn_axis = 3 if K.image_data_format() == 'channels_last' else 1 x = BatchNorm(axis=bn_axis, epsilon=1.001e-5, name=name + '_bn')(x, training=train_bn) x = Activation('relu', name=name + '_relu')(x) skip = x = Conv2D(int(K.int_shape(x)[bn_axis] * reduction), 1, use_bias=False, name=name + '_conv')(x) x = AveragePooling2D(2, strides=2, name=name + '_pool')(x) return skip, x
def deconv_block(x, skip, network_name, fpn_d, train_bn): bn_axis = 3 if K.image_data_format() == 'channels_last' else 1 x = UpSampling2D(2, data_format=K.image_data_format())(x) if not skip is None: channel = K.int_shape(skip)[bn_axis] channel = fpn_d if channel < fpn_d else channel #x = Conv2D(channel, (1, 1), name=network_name+'_conv', #padding='same', use_bias=False)(x) #x = Add(name=network_name+'_add')([x, skip]) x = Concatenate(axis=bn_axis)([x, skip]) x = Conv2D(channel, (1, 1), name=network_name+'_conv', padding='same', use_bias=False)(x) else: channel = K.int_shape(x)[bn_axis] channel = fpn_d if channel < fpn_d else channel x = Conv2D(channel, (1, 1), name=network_name+'_conv', use_bias=False)(x) x = BatchNorm(axis=bn_axis, epsilon=1.001e-5, name=network_name+'_bn')(x, training=train_bn) x = Activation('relu', name=network_name+'_relu')(x) return x
def testing(composer, song_name, save_path, output_size, save, progress_bar): progress = 0 progress_bar.update_idletasks() with open('./data/{composer}/input.txt', 'r') as text: events = text.read().split(' ') text.close() # Define the length of each sequence of input data seq_length = 12 # Get number of unique events in the data n_vocab = len(set(events)) print(f'{n_vocab} unique events') # get all pitch names event_names = sorted(set(event for event in events)) # create a dictionary to map pitches to integers event_to_int = dict( (event, number) for number, event in enumerate(event_names)) network_input = [] network_output = [] # create input sequences and their labels for i in range(0, len(events) - seq_length, 1): seq_in = events[i:i + seq_length] seq_out = events[i + seq_length] network_input.append([event_to_int[char] for char in seq_in]) network_output.append(event_to_int[seq_out]) n_patterns = len(network_input) # reshape the input into a format compatible with LSTM layers network_input = numpy.reshape(network_input, (n_patterns, seq_length, 1)) # normalize input network_input = network_input / float(n_vocab) network_output = np_utils.to_categorical(network_output) # Define Neural Network Architecture ------------------------------------------- model = Sequential() model.add( LSTM(512, input_shape=(network_input.shape[1], network_input.shape[2]), return_sequences=True)) model.add(Dropout(0.3)) model.add(LSTM(512, return_sequences=True)) model.add(Dropout(0.3)) model.add(LSTM(512)) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(256)) model.add(Activation('relu')) model.add(BatchNorm()) model.add(Dropout(0.3)) model.add(Dense(n_vocab)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', optimizer='rmsprop') model.load_weights('./data/{composer}/weights.txt') # pick a random sequence from the input as a starting point for the prediction start = numpy.random.randint(0, len(network_input) - 1) int_to_event = dict( (number, event) for number, event in enumerate(event_names)) pattern = list(network_input[start]) prediction_output = [] # generate events for note_index in range(output_size): progress_bar['value'] = progress progress_bar.update_idletasks() prediction_input = numpy.reshape(pattern, (1, len(pattern), 1)) prediction_input = prediction_input / float(n_vocab) prediction_input = numpy.asarray(prediction_input).astype( numpy.float32) prediction = model.predict(prediction_input, verbose=0) index = numpy.argmax(prediction) result = int_to_event[index] prediction_output.append(result) print(result, end=' ') pattern.append(index) pattern = pattern[1:len(pattern)] progress += 1 with open('./outputs/{song_name}.txt', "w") as txt: for event in prediction_output: print(event, end=' ') txt.write(f'{event} ') progress = 0 progress_bar.update_idletasks()
def fusion_graph_with_rgb(fg_features, bg_features, input_rgb, output_shape=None, filters=[256, 128, 128, 64, 256], train_bn=True, network_name='fusion_', d=256): ''' :param fg_features: [b, 512, 512, d] :param bg_features: [b, 512, 512, d] :param trimap: [b, 512, 512, 1] :param backbone_r1: [b, 256, 256, 64] :param filters: :param train_bn: :param network_name: :param broadcast_trimap: :return: ''' if len(filters) == 5: nb_filter0, nb_filter1, nb_filter2, nb_filter3, nb_filter4 = filters else: nb_filter0, nb_filter1, nb_filter2, nb_filter3 = filters # TODO: input_rgb = raw_image - mean_pixel. # TODO: BatchNorm conv_rgb = KL.Conv2D(d, (3, 3), strides=1, name=network_name + 'convrgb', padding='same')(input_rgb) conv_rgb = BatchNorm(name=network_name + "bnrgb")(conv_rgb, training=train_bn) fusion_input = KL.Concatenate(axis=3, name=network_name + 'input_concate')( [fg_features, bg_features, conv_rgb]) x = KL.Conv2D(nb_filter0, (3, 3), strides=1, name=network_name + "conv0", padding='same')(fusion_input) x = BatchNorm(name=network_name + "bn0")(x, training=train_bn) conv0 = KL.Activation('relu', name=network_name + "relu0")(x) # fusion_conv1 x = KL.Conv2D(nb_filter1, (3, 3), strides=1, name=network_name + "conv1", padding='same')(conv0) x = BatchNorm(name=network_name + "bn1")(x, training=train_bn) x = KL.Activation('relu', name=network_name + "relu1")(x) conv1 = x # fusion_conv2 x = KL.Conv2D(nb_filter2, (3, 3), strides=1, name=network_name + "conv2", padding='same')(x) x = BatchNorm(name=network_name + "bn2")(x, training=train_bn) x = KL.Activation('relu', name=network_name + 'relu2')(x) conv2 = x # fusion_conv3 x = KL.Conv2D(nb_filter3, (3, 3), strides=1, name=network_name + "conv3", padding='same')(x) x = BatchNorm(name=network_name + "bn3")(x, training=train_bn) x = KL.Activation('relu', name=network_name + 'relu3')(x) conv3 = x # fusion_conv4 if len(filters) == 5: x = KL.Conv2D(nb_filter4, (3, 3), strides=1, name=network_name + "conv4", padding='same')(x) x = BatchNorm(name=network_name + "bn4")(x, training=train_bn) x = KL.Activation('relu', name=network_name + 'relu4')(x) conv4 = x # fusion_output x = KL.Conv2D(1, (1, 1), strides=1, name=network_name + "conv_output", padding='same')(x) # x = BatchNorm(name=network_name+"bn_output")(x, training=train_bn) output = KL.Activation('sigmoid', name=network_name + "sigmoid_output")(x) # output = BilinearUpsampling(output_size=(output_shape[0], output_shape[1]), name=network_name + '_upsampling')( # output) return output, [conv0, conv1, conv2, conv3]
def create_network(network_input_notes, n_vocab_notes, network_input_offsets, n_vocab_offsets, network_input_durations, n_vocab_durations): # Branch of the network that considers notes inputNotesLayer = Input(shape=(network_input_notes.shape[1], network_input_notes.shape[2])) inputNotes = LSTM(256, input_shape=(network_input_notes.shape[1], network_input_notes.shape[2]), return_sequences=True)(inputNotesLayer) inputNotes = Dropout(0.2)(inputNotes) # Branch of the network that considers note offset inputOffsetsLayer = Input(shape=(network_input_offsets.shape[1], network_input_offsets.shape[2])) inputOffsets = LSTM(256, input_shape=(network_input_offsets.shape[1], network_input_offsets.shape[2]), return_sequences=True)(inputOffsetsLayer) inputOffsets = Dropout(0.2)(inputOffsets) # Branch of the network that considers note duration inputDurationsLayer = Input(shape=(network_input_durations.shape[1], network_input_durations.shape[2])) inputDurations = LSTM(256, input_shape=(network_input_durations.shape[1], network_input_durations.shape[2]), return_sequences=True)(inputDurationsLayer) #inputDurations = Dropout(0.3)(inputDurations) inputDurations = Dropout(0.2)(inputDurations) #Concatentate the three input networks together into one branch now inputs = concatenate([inputNotes, inputOffsets, inputDurations]) # A cheeky LSTM to consider everything learnt from the three separate branches x = LSTM(512, return_sequences=True)(inputs) x = Dropout(0.3)(x) x = LSTM(512)(x) x = BatchNorm()(x) x = Dropout(0.3)(x) x = Dense(256, activation='relu')(x) #Time to split into three branches again... # Branch of the network that classifies the note outputNotes = Dense(128, activation='relu')(x) outputNotes = BatchNorm()(outputNotes) outputNotes = Dropout(0.3)(outputNotes) outputNotes = Dense(n_vocab_notes, activation='softmax', name="Note")(outputNotes) # Branch of the network that classifies the note offset outputOffsets = Dense(128, activation='relu')(x) outputOffsets = BatchNorm()(outputOffsets) outputOffsets = Dropout(0.3)(outputOffsets) outputOffsets = Dense(n_vocab_offsets, activation='softmax', name="Offset")(outputOffsets) # Branch of the network that classifies the note duration outputDurations = Dense(128, activation='relu')(x) outputDurations = BatchNorm()(outputDurations) outputDurations = Dropout(0.3)(outputDurations) outputDurations = Dense(n_vocab_durations, activation='softmax', name="Duration")(outputDurations) # Tell Keras what our inputs and outputs are model = Model( inputs=[inputNotesLayer, inputOffsetsLayer, inputDurationsLayer], outputs=[outputNotes, outputOffsets, outputDurations]) #Adam seems to be faster than RMSProp and learns better too model.compile(loss='categorical_crossentropy', optimizer='adam') # Useful to try RMSProp though # LOAD WEIGHTS HERE IF YOU WANT TO CONTINUE TRAINING! #model.load_weights(weights_name) return model
def train_CNN(X_train, Y_train): """ Builds, trains and evaluates CNN classifier :param X_train: np.ndarray (n by m by 13): features :param Y_train: np.ndarray (n by 4): target :return: saves the model weights and prints the accuracy and AUC """ # reshape input for CNN X_train = X_train.reshape((X_train.shape[0], 1, X_train.shape[1], X_train.shape[2])) # split the set on training and testing sets X_train, X_test, Y_train, Y_test = train_test_split(X_train, Y_train, test_size=0.1, random_state=15) nb_filters = 32 pool_size = (2, 2) kernel_size = (3, 3) batch_size = 16 nb_epochs = 40 nb_classes = Y_train.shape[1] input_shape = (1, X_train.shape[2], X_train.shape[3]) early_stopping = EarlyStopping(monitor='val_loss', min_delta=0.001, patience=2, verbose=1) model = Sequential() model.add(Conv2D(nb_filters, kernel_size=kernel_size, border_mode='valid', input_shape=input_shape, data_format='channels_first')) model.add(BatchNorm()) model.add(LeakyReLU(alpha=0.01)) model.add(Conv2D(nb_filters, kernel_size=kernel_size, data_format='channels_first')) model.add(BatchNorm()) model.add(LeakyReLU(alpha=0.01)) model.add(MaxPooling2D(pool_size=pool_size, strides=(1, 1))) model.add(Dropout(0.1)) model.add(Conv2D(nb_filters, kernel_size=kernel_size, data_format='channels_first')) model.add(BatchNorm()) model.add(LeakyReLU(alpha=0.01)) model.add(MaxPooling2D(pool_size=pool_size, strides=(1, 1))) model.add(Dropout(0.1)) model.add(Flatten()) model.add(Dense(128)) model.add(Activation('linear')) model.add(Dropout(0.1)) model.add(Dense(nb_classes)) model.add(Activation('softmax')) model.compile(loss='categorical_crossentropy', metrics=['categorical_accuracy'], optimizer='adam') model.fit(X_train, Y_train, batch_size=batch_size, epochs=nb_epochs, verbose=1, callbacks=[early_stopping], validation_split=0.15) print('CNN classifier performance on the testing set') evaluate_model(X_test, Y_test, model) model_name = '/data/model_CNN.h5' path = os.getcwd() temp = path.split('/') temp.pop(-1) path = '/'.join(temp) model.save(path + model_name) print('CNN classifier is saved', model_name) print('-----------------------------------------')