def call(self, inputs): encoded_passage, merged_context, modeled_passage, span_begin_probabilities = inputs weighted_sum = K.sum( K.expand_dims(span_begin_probabilities, axis=-1) * modeled_passage, -2) passage_weighted_by_predicted_span = K.expand_dims(weighted_sum, axis=1) tile_shape = K.concatenate([[1], [K.shape(encoded_passage)[1]], [1]], axis=0) passage_weighted_by_predicted_span = K.tile( passage_weighted_by_predicted_span, tile_shape) multiply1 = modeled_passage * passage_weighted_by_predicted_span span_end_representation = K.concatenate([ merged_context, modeled_passage, passage_weighted_by_predicted_span, multiply1 ]) span_end_representation = self.bilstm_1(span_end_representation) span_end_input = K.concatenate( [merged_context, span_end_representation]) span_end_weights = TimeDistributed(self.dense_1)(span_end_input) span_end_probabilities = Softmax()(K.squeeze(span_end_weights, axis=-1)) return span_end_probabilities
def infusion_layer(x, indexer=None): conv2d_name = 'seg_conv' batchnorm_name = 'seg_batchnorm' output_name = 'seg_output' if indexer: conv2d_name += '_' + str(indexer) batchnorm_name += '_' + str(indexer) output_name += '_' + str(indexer) y_seg = compose( Conv2D(2,(1,1), name=conv2d_name, kernel_initializer='he_normal', bias_initializer='constant', kernel_regularizer = l2(5e-4), activity_regularizer = l2(5e-4) ), # BatchNormalization(name=output_name), # BatchNormalization(name=batchnorm_name), # ReLU(name=output_name, max_value=1.0), # BatchNormalization(name=batchnorm_name), # Activation('sigmoid',name=output_name, ), BatchNormalization(name=batchnorm_name), Softmax(name=output_name, axis=-1) )(x) return y_seg
def get_model(cls) -> Model: model = Sequential() model.add(Dense(10, input_shape=(4, ), activation='relu', name='fc1')) model.add(Dense(10, activation='relu', name='fc2')) model.add(Dense(3, activation='linear', name='fc4')) model.add(Softmax(name='output', axis=1)) # Adam optimizer with learning rate of 0.001 optimizer = Adam(lr=0.001) model.compile(optimizer, loss='categorical_crossentropy', metrics=['accuracy']) print('Neural Network Model Summary: ') print(model.summary()) # Train the model model.fit(train_x, train_y, verbose=2, batch_size=5, epochs=200) # Test on unseen data results = model.evaluate(test_x, test_y) print('Final test set loss: {:4f}'.format(results[0])) print('Final test set accuracy: {:4f}'.format(results[1])) return model
def call(self, inputs): merged_context, modeled_passage = inputs span_begin_input = K.concatenate([merged_context, modeled_passage]) span_begin_weights = TimeDistributed(Dense(units=1))(span_begin_input) span_begin_probabilities = K.squeeze(Softmax()(span_begin_weights), axis=-1) return span_begin_probabilities
def call(self, inputs): encoded_passage, merged_context, modeled_passage, span_begin_probabilities = inputs weighted_sum = K.sum( K.expand_dims(span_begin_probabilities, axis=-1) * modeled_passage, -2) passage_weighted_by_predicted_span = K.expand_dims(weighted_sum, axis=1) tile_shape = K.concatenate([[1], [K.shape(encoded_passage)[1]], [1]], axis=0) passage_weighted_by_predicted_span = K.tile( passage_weighted_by_predicted_span, tile_shape) multiply1 = modeled_passage * passage_weighted_by_predicted_span span_end_representation = K.concatenate([ merged_context, modeled_passage, passage_weighted_by_predicted_span, multiply1 ]) emdim = K.int_shape(encoded_passage)[-1] // 2 span_end_representation = Bidirectional( LSTM(emdim, return_sequences=True))(span_end_representation) span_end_input = K.concatenate( [merged_context, span_end_representation]) span_end_weights = TimeDistributed(Dense(units=1))(span_end_input) span_end_probabilities = Softmax()(K.squeeze(span_end_weights, axis=-1)) return span_end_probabilities
def call(self, inputs): similarity_matrix, encoded_question = inputs context_to_query_attention = Softmax(axis=-1)(similarity_matrix) encoded_question = K.expand_dims(encoded_question, axis=1) return K.sum( K.expand_dims(context_to_query_attention, axis=-1) * encoded_question, -2)
def build(height, width, depth, classes): inputShape = (height, width, depth) chanDim = -1 # if we are using "channel first", update the input shape if K.image_data_format() == "channels_first": inputShape = (depth, height, width) chanDim = 1 # initialize the model model = Sequential() # CONV => RELU => POOL model.add(Conv2D(32, (3, 3), padding="same", input_shape=inputShape)) model.add(Activation("relu")) model.add(BatchNormalization(axis=chanDim)) model.add(MaxPooling2D(pool_size=(3, 3))) model.add(Dropout(0.25)) # (CONV => RELU) * 2 => POOL model.add(Conv2D(64, (3, 3), padding="same", input_shape=inputShape)) model.add(Activation("relu")) model.add(BatchNormalization(axis=chanDim)) model.add(Conv2D(64, (3, 3), padding="same", input_shape=inputShape)) model.add(Activation("relu")) model.add(BatchNormalization(axis=chanDim)) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.25)) # (CONV => RELU) * 2 => POOL model.add(Conv2D(128, (3, 3), padding="same", input_shape=inputShape)) model.add(Activation("relu")) model.add(BatchNormalization(axis=chanDim)) model.add(Conv2D(128, (3, 3), padding="same", input_shape=inputShape)) model.add(Activation("relu")) model.add(BatchNormalization(axis=chanDim)) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Dropout(0.25)) # first (and only) set of FC => RELU layers model.add(Flatten()) model.add(Dense(1024)) model.add(Activation("relu")) model.add(BatchNormalization()) model.add(Dropout(0.5)) # softmax classifier model.add(Dense(classes)) # model.add(Activation("softmax")) model.add(Softmax()) # return the constructed network architecture return model pass
def call(self, inputs): similarity_matrix, encoded_context = inputs max_similarity = K.max(similarity_matrix, axis=-1) # by default, axis = -1 in Softmax context_to_query_attention = Softmax()(max_similarity) weighted_sum = K.sum(K.expand_dims(context_to_query_attention, axis=-1) * encoded_context, -2) expanded_weighted_sum = K.expand_dims(weighted_sum, 1) num_of_repeatations = K.shape(encoded_context)[1] return K.tile(expanded_weighted_sum, [1, num_of_repeatations, 1])
def build(width, height, depth, classes): model = Sequential() inputShape = (height, width, depth) chanDim = -1 if K.image_data_format == "channels_first": inputShape = (depth, height, width) chanDim = 1 model = Sequential([ Conv2D(32, (3, 3), padding="same", kernel_initializer="he_normal", input_shape=inputShape), ELU(), BatchNormalization(axis=chanDim), Conv2D(32, (3, 3), kernel_initializer="he_normal", padding="same"), ELU(), BatchNormalization(axis=chanDim), MaxPooling2D(pool_size=(2, 2)), Dropout(0, 25), Conv2D(64, (3, 3), padding="same", kernel_initializer="he_normal", input_shape=inputShape), ELU(), BatchNormalization(axis=chanDim), Conv2D(64, (3, 3), kernel_initializer="he_normal", padding="same"), ELU(), BatchNormalization(axis=chanDim), MaxPooling2D(pool_size=(2, 2)), Dropout(0, 25), Conv2D(64, (3, 3), padding="same", kernel_initializer="he_normal", input_shape=inputShape), ELU(), BatchNormalization(axis=chanDim), Conv2D(64, (3, 3), kernel_initializer="he_normal", padding="same"), ELU(), BatchNormalization(axis=chanDim), MaxPooling2D(pool_size=(2, 2)), Dropout(0, 25), Flatten(), Dense(64, kernel_initializer="he_normal"), ELU(), BatchNormalization(), Dropout(0.25), Dense(64, kernel_initializer="he_normal"), ELU(), BatchNormalization(), Dropout(0.25), Dense(classes, kernel_initializer="he_normal"), Softmax() ]) return model
def __call__(self, answer_encodings): score_matrix = tf.matmul(answer_encodings, tf.transpose(answer_encodings, perm=(0, 2, 1))) mask = tf.cast(tf.logical_not(tf.cast(tf.matrix_diag([1] * 5), tf.bool)), tf.float32) score_matrix = K.dot(score_matrix, mask) weights = Softmax()(score_matrix) answer_encoding_hat = tf.matmul(weights, answer_encodings) answer_representation = K.concatenate([answer_encodings, answer_encoding_hat, answer_encodings*answer_encoding_hat]) answer_probability = Dense(1, activation="softmax")(answer_representation) return K.squeeze(answer_probability, axis=-1)
def run_model(): iris_data = load_iris() # load the iris dataset print('Example data: ') print(iris_data.data[:5]) print('Example labels: ') print(iris_data.target[:5]) x = iris_data.data y_ = iris_data.target.reshape(-1, 1) # Convert data to a single column # One Hot encode the class labels encoder = OneHotEncoder(sparse=False) y = encoder.fit_transform(y_) # Split the data for training and testing train_x, test_x, train_y, test_y = train_test_split(x, y, test_size=0.20) # Build the model model = Sequential() model.add(Dense(10, input_shape=(4, ), activation='relu', name='fc1')) model.add(Dense(10, activation='relu', name='fc2')) model.add(Dense(3, activation='linear', name='fc4')) model.add(Softmax(name='output', axis=1)) # Adam optimizer with learning rate of 0.001 optimizer = Adam(lr=0.001) model.compile(optimizer, loss='categorical_crossentropy', metrics=['accuracy']) print('Neural Network Model Summary: ') print(model.summary()) # Train the model model.fit(train_x, train_y, verbose=2, batch_size=5, epochs=200) # Test on unseen data results = model.evaluate(test_x, test_y) print('Final test set loss: {:4f}'.format(results[0])) print('Final test set accuracy: {:4f}'.format(results[1])) print('X for testing:') print(test_x[:3, :]) print('Y for testing:') print(test_y[:3, :]) model.save('../../artifacts/iris.h5')
def add_context2query_layer(query_embedding, biattention_matrix, attention_level, max_query_len, max_doc_len): # Following the context-to-query implementation of BiDAF model # query_embedding: batch_size * max_query_len * nb_filters # biattention_matrix: batch_size * max_query_len * max_doc_len norm_biattention = Softmax(axis=-2)(biattention_matrix) # Activation('softmax', axis=-2)(biattention_matrix) reshape_norm_biatt = Reshape(( max_doc_len, max_query_len, ))(norm_biattention) context_embedding = Dot(axes=[-1, -2], name="context2query-%d" % attention_level)( [reshape_norm_biatt, query_embedding]) return context_embedding
def build_mechanism(self): model = Sequential() model.add(Flatten(input_shape=self.vote_shape)) model.add(Dense(512)) model.add(LeakyReLU(alpha=0.2)) model.add(Dense(256)) model.add(LeakyReLU(alpha=0.2)) model.add(Dense(self.n_alters)) model.add(Softmax(axis=-1)) print("\n\n\nMechanism model summary") model.summary() vote = Input(shape=self.vote_shape) winner = model(vote) return Model(vote, winner)
def dense_cnn(input_, nclass): _weight_decay = 1e-4 _nb_filter = 64 # conv 64 5*5 s=2 x = Conv2D(32 * 2, (3, 3), activation='relu')(input_) x = Conv2D(32 * 2, (3, 3), activation='relu')(x) x = Flatten(name='flatten')(x) x = Dense(1, name='out')(x) y_pred = Dense(nclass, name='out', activation='sigmoid')(x) y_pred = Reshape((10, nclass // 10))(y_pred) y_pred = Softmax(axis=-1)(y_pred) # basemodel = Model(inputs=input, outputs=y_pred) # basemodel.summary() return y_pred
def dense_cnn2(input_, nclass): _dropout_rate = 0.2 _weight_decay = 1e-4 _nb_filter = 64 # conv 64 5*5 s=2 x = Conv2D(_nb_filter, (5, 5), strides=(2, 2), kernel_initializer='he_normal', padding='same', use_bias=False, kernel_regularizer=l2(_weight_decay))(input_) # 64 + 8 * 8 = 128 x, _nb_filter = dense_block(x, 8, _nb_filter, 8, None, _weight_decay) # 128 x, _nb_filter = transition_block(x, 128, _dropout_rate, 2, _weight_decay) # 128 + 8 * 8 = 192 x, _nb_filter = dense_block(x, 8, _nb_filter, 8, None, _weight_decay) # 192 -> 128 x, _nb_filter = transition_block(x, 128, _dropout_rate, 2, _weight_decay) # 128 + 8 * 8 = 192 x, _nb_filter = dense_block(x, 8, _nb_filter, 8, None, _weight_decay) x = BatchNormalization(axis=-1, epsilon=1.1e-5)(x) x = Activation('relu')(x) x = Permute((2, 1, 3), name='permute')(x) #x = TimeDistributed(Flatten(), name='flatten')(x) x = Flatten(name='flatten')(x) y_pred = Dense(nclass, name='out', activation='sigmoid')(x) y_pred = Reshape((10, nclass // 10))(y_pred) y_pred = Softmax(axis=-1)(y_pred) # basemodel = Model(inputs=input, outputs=y_pred) # basemodel.summary() return y_pred
def selfAttention(self, x, n_channels, k=8): x_shape = K.int_shape(x) f = Reshape( (-1, x_shape[-1]))(ConvSN2D(n_channels // k, 1, padding='same')(x)) # [b, n, c/k] g = Reshape( (-1, x_shape[-1]))(ConvSN2D(n_channels // k, 1, padding='same')(x)) # [b, n, c/k] g = Permute((1, 2))(g) # [b,c/k,n] s = multiply([f, g]) s = Softmax(axis=-1)(s) #[b,n,n] h = Reshape((-1, x_shape[-1]))(ConvSN2D(n_channels // k, 1, padding='same')(x)) #[b,n,c/k] v = multiply([s, h]) #[b,n,c/k] v = Reshape((x_shape[1], x_shape[2], n_channels // k))(v) o = ConvSN2D(n_channels, 1, padding='same')(v) #[b,h,w,c] gamma = K.variable(value=0) ret = Lambda(lambda x: x * gamma)(o) ret = Add()([ret, x]) return ret
def Generator(dim): model = Sequential() model.add(Dense(256, activation='linear', input_shape=noise_shape)) model.add(Reshape((-1, 2, 128))) model.add(ResBlock(dim)) model.add(ResBlock(dim)) model.add(ResBlock(dim)) model.add(ResBlock(dim)) model.add(ResBlock(dim)) model.add(Reshape((1, 32, 8))) model.add(Conv1D(64, 32, 1, padding='valid')) model.add(Flatten()) model.add(Dense(np.product(pass_shape), activation='linear')) model.add(Softmax(axis=1)) model.add(Reshape(pass_shape)) noise = Input(shape=noise_shape) password = model(noise) model.summary() return Model(noise, password)
def build_vote_generator(self): model = Sequential() model.add(Dense(256, input_dim=self.latent_dim)) model.add(LeakyReLU(alpha=0.2)) model.add(BatchNormalization(momentum=0.8)) model.add(Dense(256)) model.add(LeakyReLU(alpha=0.2)) model.add(BatchNormalization(momentum=0.8)) model.add(Dense(np.prod(self.vote_shape))) model.add(Reshape(self.vote_shape)) model.add(Softmax(axis=-1)) print("build_vote_generator model summary") model.summary() noise = Input(shape=(self.latent_dim, )) votes = model(noise) return Model(noise, votes)
def DilatedCNN2D_002(inputDim=(116, 177, 1), nClasses=33, perms=100): def bn_block(x): return BatchNormalization()(x) def conv_block(x, nb_filter, filter_size, atrous_rate=(1, 1)): x = Conv2D(nb_filter, filter_size, dilation_rate=atrous_rate, kernel_initializer='he_normal', padding='same')(x) x = bn_block(x) x = ReLU()(x) return x atrousRates = [(1,1), (1,1), (2,2), (3,3), (5,5), (8,8), (13,13), (21,21)] numFilters = [32, 64, 64, 128, 64, 64, 64, 128] featList = [] i = Input(shape=inputDim) # learnabale remapping x = Dense(perms)(i) x = bn_block(x) # convolutional blocks for idx, (nFilter, dilationRate) in enumerate(zip(numFilters, atrousRates)): x = conv_block(x, nFilter, (3,3), dilationRate) if idx % 2 ==0 and idx > 0: x = MaxPooling2D()(x) # bottlenecking x = conv_block(x, 32, (3, 3)) x = conv_block(x, 128, (1,1)) x = SpatialDropout2D(0.25)(x) # classifying x = conv_block(x, nClasses, (1, 1)) x = GlobalMaxPooling2D()(x) o = Softmax()(x) model = Model(inputs=i, outputs=o) return model
def discriminator_model(shp): # model = Graph() input = Input(shape=shp) x = Convolution2D(64, (5, 5), border_mode='same', data_format="channels_first")(input) x = Activation('tanh')(x) x = MaxPooling2D((2, 2), data_format="channels_first")(x) x = Convolution2D(128, (5, 5), border_mode='same', data_format="channels_first")(x) x = Activation('tanh')(x) # x = MaxPooling2D(2, 2)(x) x = Flatten()(x) x = Dense(1024, activation='tanh')(x) # x = Activation('tanh')(x) d = Dense(1, activation='sigmoid')(x) # d = Activation('sigmoid')(d) cls = Dense(15)(x) x = Softmax()(x) model = Model(inputs=input, outputs=[d, cls]) return model
weights=None, pooling=None) output = inception.layers[-1].output # add last layers net = AveragePooling2D( pool_size=(8, 8), # K.int_shape(output), strides=(2, 2), padding='valid', data_format='channels_last', name='pool')(output) net = Dropout(rate=0.2, name='dropout')(net) net = Flatten(data_format='channels_last', name='flatten')(net) logits = Dense(NUM_CLASSES, activation=None, name="logits")(net) predictions = Softmax(name='predictions')(logits) # aux net if args.with_aux: output = inception.get_layer(name="mixed7").output aux_logits = AveragePooling2D(pool_size=(5, 5), strides=(3, 3), padding='valid')(output) aux_logits = Conv2D(128, (1, 1), name='proj')(aux_logits) aux_logits = Conv2D( 768, K.int_shape(aux_logits)[1:3], kernel_initializer=initializers.TruncatedNormal(stddev=0.001), padding='valid')(aux_logits) aux_logits = Flatten(data_format='channels_last')(aux_logits) aux_logits = Dense(NUM_CLASSES,
x = BatchNormalization()(x) x = layers.Conv2D(512, (3, 3), activation='relu', padding='same', name='block6_conv2')(x) x = BatchNormalization()(x) x = layers.Conv2D(512, (3, 3), activation='softmax', padding='same', name='block6_conv3')(x) x = BatchNormalization()(x) # Block 7 skip_connection = Conv2D(64, (1,1), strides=(1,1), padding='same', name='conv_21', use_bias=False)(skip_connection) skip_connection = BatchNormalization()(skip_connection) skip_connection = Softmax(axis=-1)(skip_connection) skip_connection = Lambda(space_to_depth_x2)(skip_connection) # Merge x = concatenate([skip_connection, x]) # Block 8 x = Conv2D(BOX * (4 + 1 + CLASS), (1,1), strides=(1,1), padding='same', name='conv_23')(x) output = Reshape((GRID_H, GRID_W, BOX, 4 + 1 + CLASS))(x) # small hack to allow true_boxes to be registered when Keras build the model # for more information: https://github.com/fchollet/keras/issues/2790
def build_strategic_vote_generator(self): model = Sequential() model.add(Flatten(input_shape=self.vote_shape)) model.add(Dense(256)) model.add(LeakyReLU(alpha=0.2)) model.add(BatchNormalization(momentum=0.8)) model.add(Dense(256)) model.add(LeakyReLU(alpha=0.2)) model.add(BatchNormalization(momentum=0.8)) model.add(Dense(256)) model.add(LeakyReLU(alpha=0.2)) model.add(BatchNormalization(momentum=0.8)) print("\n\n\nStrategic_vote_generator base model summary") model.summary() model1 = Sequential() model1.add(Dense(256, input_dim=256)) model1.add(LeakyReLU(alpha=0.2)) model1.add(BatchNormalization(momentum=0.8)) model1.add(Dense(self.n_alters)) model1.add(Reshape((1, self.n_alters))) model1.add(Softmax(axis=-1)) print("\n\n\nStrategic_vote_generator derived model1 summary") model1.summary() model2 = Sequential() model2.add(Dense(256, input_dim=256)) model2.add(LeakyReLU(alpha=0.2)) model2.add(BatchNormalization(momentum=0.8)) model2.add(Dense(self.n_agents)) model2.add(Softmax(axis=-1)) print("\n\n\nStrategic_vote_generator derived model2 summary") model2.summary() votes = Input(shape=self.vote_shape) intermediate_votes = model(votes) # Gets the strategic vote. strategic_vote = model1(intermediate_votes) # Gets the probability dist for voter. strategic_voter = model2(intermediate_votes) # Custom layer for strategic vote generator def strategic_vote_generator_layer(tensors): votes = tensors[0] strategic_vote = tensors[1] strategic_votes = [] for i in range(self.n_agents): strategic_votes.append( K.concatenate( [votes[:, :i, :], strategic_vote, votes[:, i + 1:, :]], axis=1)) # print(strategic_votes[i].shape) # Seperating the votes by the weights. all_votes = [votes] + [tensors[2]] + strategic_votes return all_votes def strategic_vote_generator_layer_output_shape(input_shapes): return [input_shapes[0]] + [input_shapes[2] ] + [input_shapes[0]] * self.n_agents layer = Lambda(strategic_vote_generator_layer, strategic_vote_generator_layer_output_shape) all_votes = layer([votes, strategic_vote, strategic_voter]) final_model = Model(votes, all_votes) print("\n\n\nStrategic_vote_generator final model summary") final_model.summary() return final_model
def main(): import pynvml pynvml.nvmlInit() # 这里的0是GPU id handle2 = pynvml.nvmlDeviceGetHandleByIndex(2) handle3 = pynvml.nvmlDeviceGetHandleByIndex(3) # meminfo = pynvml.nvmlDeviceGetMemoryInfo(handle) # print(meminfo.used) parser = argparse.ArgumentParser( description='simple 3D convolution for action recognition') parser.add_argument('--batch', type=int, default=128) parser.add_argument('--epoch', type=int, default=100) parser.add_argument('--videos', type=str, default='UCF101', help='directory where videos are stored') parser.add_argument('--nclass', type=int, default=101) parser.add_argument('--output', type=str, required=True) parser.add_argument('--color', type=bool, default=False) parser.add_argument('--skip', type=bool, default=True) parser.add_argument('--depth', type=int, default=10) parser.add_argument('--dataset', type=str, default='ucf101') args = parser.parse_args() img_rows, img_cols, frames = 64, 64, args.depth channel = 3 if args.color else 1 fname_npz = 'dataset_{}_{}_{}_{}.npz'.format(args.dataset, args.nclass, args.depth, args.skip) vid3d = videoto3d.Videoto3D(img_rows, img_cols, frames, args.dataset) nb_classes = args.nclass if os.path.exists(fname_npz): loadeddata = np.load(fname_npz) X, Y = loadeddata["X"], loadeddata["Y"] else: x, y = loaddata(args.videos, vid3d, args.nclass, args.output, args.dataset, frames, args.color, args.skip) X = x.reshape((x.shape[0], img_rows, img_cols, frames, channel)) Y = np_utils.to_categorical(y, nb_classes) X = X.astype('float32') np.savez(fname_npz, X=X, Y=Y) print('Saved dataset to dataset.npz.') print('X_shape:{}\nY_shape:{}'.format(X.shape, Y.shape)) # Define model # conv3D + Relu + Conv3D + Softmax + Pooling3D + DropOut input_x = Input(shape=(img_rows, img_cols, frames, channel)) # # # C3D-conv1 # convLayer = Conv3D(32, kernel_size= (3, 3, 3),padding='same')(input_x) # convLayer = ReLU()(convLayer) # # convLayer = Conv3D(32, kernel_size= (3, 3, 3), padding='same')(convLayer) # convLayer = Softmax()(convLayer) # convLayer = MaxPooling3D(pool_size=(3,3,3), padding='same')(convLayer) # convLayer = Dropout(0.25)(convLayer) # # # C3D-conv2 # convLayer = Conv3D(64, kernel_size= (3, 3, 3),padding='same')(convLayer) # convLayer = ReLU()(convLayer) # # convLayer = Conv3D(64, kernel_size= (3, 3, 3), padding='same')(convLayer) # convLayer = Softmax()(convLayer) # convLayer = MaxPooling3D(pool_size=(3,3,3), padding='same')(convLayer) # convLayer = Dropout(0.25)(convLayer) # # # maskLayer = Conv3D(64*frames, kernel_size=(3,3,2), padding='same')(convLayer) # maskLayer = Lambda(mean_filter)(maskLayer) # [None,1, 64], each point represent a mask of input region of 8x8 points # # maskLayer = BatchNormalization()(maskLayer) # maskLayer = Lambda(K.sigmoid)(maskLayer) # # maskLayer = ReLU()(maskLayer) # # maskLayer = Lambda(bi_trans, arguments={'th':0.5})(maskLayer) # maskLayer = Reshape(( 8, 8, frames, 1))(maskLayer) #reshape_filter(maskLayer, shape=[None,8,8,1,1]) # # maskLayer = Lambda(normalize)(maskLayer) # maskLayerForLoss = maskLayer # maskLayer = Lambda(repeat_filter,arguments={'rep':8, 'axis':1})(maskLayer) # maskLayer = Lambda(repeat_filter,arguments={'rep':8, 'axis':2})(maskLayer) # # maskLayer = Lambda(repeat_filter,arguments={'rep':frames, 'axis':3})(maskLayer) # maskLayer = Lambda(repeat_filter,arguments={'rep':channel, 'axis':4})(maskLayer) # # # maskLayer = Lambda(repeat_filter,arguments={'rep':2, 'axis':3})(maskLayer) # # maskLayer = Lambda(repeat_filter,arguments={'rep':64, 'axis':4})(maskLayer) # # # convLayer = Multiply()([maskLayer,input_x]) # # # C3D-conv1 convLayer = Conv3D(32, kernel_size=(3, 3, 3), padding='same')(input_x) convLayer = ReLU()(convLayer) convLayer = Conv3D(32, kernel_size=(3, 3, 3), padding='same')(convLayer) convLayer = Softmax()(convLayer) convLayer = MaxPooling3D(pool_size=(3, 3, 3), padding='same')(convLayer) convLayer = Dropout(0.25)(convLayer) # C3D-conv2 convLayer = Conv3D(64, kernel_size=(3, 3, 3), padding='same')(convLayer) convLayer = ReLU()(convLayer) convLayer = Conv3D(64, kernel_size=(3, 3, 3), padding='same')(convLayer) convLayer = Softmax()(convLayer) convLayer = MaxPooling3D(pool_size=(3, 3, 3), padding='same')(convLayer) convLayer = Dropout(0.25)(convLayer) fc1 = Flatten()(convLayer) fc = Dense(512, activation='sigmoid')(fc1) fc = Dropout(0.5)(fc) dense_out = Dense(nb_classes, activation='softmax')(fc) dense_out_converse = Dense(nb_classes)(fc) # model = Model(input_x, [dense_out, dense_out_converse]) model = Model(input_x, [dense_out, dense_out_converse]) # loss of 2 parts losses = {'dense_2': K.categorical_crossentropy, 'dense_3': unlikely_loss} lossWeights = {'dense_2': 1, 'dense_3': 1} model.compile(loss=losses, loss_weights=lossWeights, optimizer=Adam(lr=0.001), metrics=['accuracy']) # model.compile(loss=categorical_crossentropy, optimizer=Adam(lr=0.001),metrics=['accuracy']) model.summary() plot_model(model, show_shapes=True, to_file=os.path.join(args.output, 'model.png')) X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.1, random_state=43) X_train, X_val, Y_train, Y_val = train_test_split(X_train, Y_train, test_size=0.1, random_state=43) # history = model.fit_generator(myGenerator(X_train, X_test, Y_train, Y_test, nb_classes, args.batch), # samples_per_epoch=X_train.shape[0], epochs=args.epoch, verbose=1, # callbacks=callbacks_list, # shuffle=True) # check GPUs status , once a GPU is available, change os environment parameters and break # is none of the GPUs are ready ,sleep for 2 secs and retry. cnt = 0 while True: cnt += 1 processinfo = pynvml.nvmlDeviceGetComputeRunningProcesses(handle2) if len(processinfo) == 0: os.environ['CUDA_VISIBLE_DEVICES'] = '2' print('GPU 2 is available, use GPU 2\n') break processinfo = pynvml.nvmlDeviceGetComputeRunningProcesses(handle3) if len(processinfo) == 0: os.environ['CUDA_VISIBLE_DEVICES'] = '3' print('GPU 3 is available, use GPU 3\n') break sleep(2) print('\rretry time: {}'.format(cnt), end='') history = model.fit(X_train, [Y_train, Y_train], validation_data=(X_val, [Y_val, Y_val]), batch_size=args.batch, epochs=args.epoch, verbose=1, shuffle=True) # history = model.fit(X_train, Y_train, # validation_data=(X_val, Y_val), # batch_size=args.batch, # epochs=args.epoch, verbose=1, shuffle=True) # loss, acc = model.evaluate(X_test, Y_test, verbose=0) model_json = model.to_json() if not os.path.isdir(args.output): os.makedirs(args.output) with open( os.path.join( args.output, '{}_{}_{}_ucf101_3dcnnmodel.json'.format( current_time, nb_classes, args.depth)), 'w') as json_file: json_file.write(model_json) model.save_weights( os.path.join( args.output, '{}_{}_{}_ucf101_3dcnnmodel.hd5'.format(current_time, nb_classes, args.depth))) loss = model.evaluate(X_test, [Y_test, Y_test], verbose=0) # loss, acc = model.evaluate(X_test, Y_test, verbose=0) print('Test loss:', loss) plot_history(history, args.output) save_history(history, args.output) print('Test loss:', loss)