# # set all layers (i.e., SAE encoder) to non-trainable (weights will not be updated)
# for layer in model.layers[:]:
# layer.trainable = False
# save the model for later use
model.save(path_sae_model)
### build and train a complete model with the trained SAE encoder and a new classifier
print("\nPart 2: buidling a complete model ...")
# append a classifier to the model
# class_weight = {
# 0: building_weight, 1: building_weight, 2: building_weight, # buildings
# 3: floor_weight, 4: floor_weight, 5: floor_weight, 6:floor_weight, 7: floor_weight # floors
# }
model.add(Dropout(dropout))
for units in classifier_hidden_layers:
model.add(Dense(units, activation=CLASSIFIER_ACTIVATION, use_bias=CLASSIFIER_BIAS))
model.add(Dropout(dropout))
model.add(Dense(OUTPUT_DIM, activation='sigmoid', use_bias=CLASSIFIER_BIAS)) # 'sigmoid' for multi-label classification
model.compile(optimizer=CLASSIFIER_OPTIMIZER, loss=CLASSIFIER_LOSS, metrics=['accuracy'])
# train the model
startTime = timer()
model.fit(x_train, y_train, validation_data=(x_val, y_val), batch_size=batch_size, epochs=epochs, verbose=VERBOSE)
# model.fit(x_train, y_train, validation_data=(x_val, y_val), batch_size=batch_size, epochs=epochs, class_weight=class_weight, verbose=VERBOSE)
elapsedTime = timer() - startTime
print("Model trained in %e s." % elapsedTime)
# turn the given validation set into a testing set
test_df = pd.read_csv(path_validation, header=0)
restnet.trainable = True
set_trainable = False
for layer in restnet.layers:
if layer.name in ['res5c_branch2b', 'res5c_branch2c', 'activation_49']:
set_trainable = True
if set_trainable:
layer.trainable = True
else:
layer.trainable = False
layers = [(layer, layer.name, layer.trainable) for layer in restnet.layers]
pd.DataFrame(layers, columns=['Layer Type', 'Layer Name', 'Layer Trainable'])
model_finetuned = Sequential()
model_finetuned.add(restnet)
model_finetuned.add(Dense(512, activation='relu', input_dim=(300, 300, 3)))
model_finetuned.add(Dropout(0.3))
model_finetuned.add(Dense(512, activation='relu'))
model_finetuned.add(Dropout(0.3))
model_finetuned.add(Dense(1, activation='sigmoid'))
model_finetuned.compile(loss='binary_crossentropy',
optimizer=optimizers.RMSprop(lr=1e-5),
metrics=['accuracy'])
model_finetuned.summary()
history_1 = model_finetuned.fit_generator(train_generator,
steps_per_epoch=100,
epochs=2,
validation_data=val_generator,
validation_steps=100,
verbose=1)
model_finetuned.save('men_women_tlearn_finetune_img_aug_restnet50.h5')
parser = argparse.ArgumentParser()
parser.add_argument("--datapath",help="path to the pickled data",default=save_path)
args = parser.parse_args()
data_path = args.datapath
with open(data_path,"r") as f:
(X,y) = pickle.load(f)
(X,y) = shuffle(X,y)
s=720
Xtr,ytr = X[:s],y[:s]
Xt,yt = X[s:],y[s:]
input_shape = X.shape[1:]
model = Sequential()
model.add(Conv2D(16,(7,7),strides=(3,3),activation="relu", input_shape=input_shape))
model.add(Dropout(0.1))
model.add(Conv2D(16,(3,3),strides=(1,1),activation="relu"))
model.add(Dropout(0.5))
model.add(Flatten())
model.add(Dense(1,activation="sigmoid"))
model.compile(loss="binary_crossentropy",optimizer=Adam(),metrics=["accuracy"])
roc_curves,safeset_percents = k_fold_crossvalidation(X,y,10,model,epochs=14)
aucs = [area_under_curve(f,p) for (f,p) in roc_curves.values()]
print("Got average safeset % of {:.2f}. min :{:.2f}, max: {:.2f}, std: {:.2f}".format(np.mean(safeset_percents),min(safeset_percents),max(safeset_percents),np.std(safeset_percents)))
print("Got average ROC AUC of {:.2f}. min :{:.2f}, max: {:.2f}, std: {:.2f}".format(np.mean(aucs),min(aucs),max(aucs),np.std(aucs)))
plot_crossval_auc(roc_curves)
def doc_inputs_siam_part(prefix="",
n_siz=1,
neighbours=0,
shapes_inp=None,
use_pic=False,
siam_layer=None,
emb_size=640,
n_att=1):
if siam_layer is None:
siam_layer = lambda layer, name: layer
inp_text_f = Input(shape=shapes_inp[0]['wb-text-features'],
name=prefix + 'wb-text-features')
inp_text_chars = Input(shape=shapes_inp[0]['wb-text-onehot'],
name=prefix + 'wb-text-onehot')
inp_bbox = Input(shape=shapes_inp[0]['wb-bbox'], name=prefix + 'wb-bbox')
inp_poso = Input(shape=shapes_inp[0]['wb-poso'], name=prefix + 'wb-poso')
if neighbours > 0:
inp_neighs = Input(shape=shapes_inp[0]['neighbours-ids'],
name=prefix + 'neighbours-ids',
dtype=tf.int32)
else:
inp_neighs = None
positions_embedded = siam_layer(
SinCosPositionalEmbedding(
4 * n_siz,
embeddings=['sin', 'cos', 'lin'],
from_inputs_features=[0, 1, 2, 3],
# embedd all 4 integers
pos_divisor=10000,
keep_ndim=True),
'posemb-pos')(inp_poso)
bboxes_embedded = siam_layer(
SinCosPositionalEmbedding(
4 * n_siz,
embeddings=['sin', 'cos', 'lin'],
from_inputs_features=[0, 1, 2, 3],
# embedd all 4 integers
pos_divisor=10000,
keep_ndim=True),
'posemb-bb')(inp_bbox)
# "channels_last"
chars_emb = siam_layer(Conv2D(filters=50 * n_siz, kernel_size=(1, 3),
strides=1, padding='same', activation='relu'), 'chars_emb1') \
(inp_text_chars)
chars_emb = siam_layer(Conv2D(filters=50 * n_siz, kernel_size=(1, 3),
strides=1, padding='same', activation='relu'), 'chars_emb2') \
(chars_emb)
# custom maxpooling of feaures:
chars_feats_emb = siam_layer(
Lambda(lambda x: [
K.max(x, axis=-2, keepdims=False),
K.mean(x, axis=-2, keepdims=False)
]), 'meanmaxpool')(chars_emb)
all_features = siam_layer(Concatenate(axis=-1), 'concatall') \
([positions_embedded, bboxes_embedded, inp_text_f] + chars_feats_emb)
if use_pic:
pic_input = Input(shape=(pic_inpgrid_width, pic_inpgrid_height, 1),
name=prefix + 'pic')
'''
The text W/H ratios have mean 3.58996720367 and median 2.625
The text Ws have mean 71.3550074689 and median 54.0
The text Hs have mean 20.1268264316 and median 21.0
so 20 is the 'average' height text box in coordinates of RENDER_WIDTH = 1240x(RENDER_WIDTH * 1.414)
- h - 0,011406671 -> w = 0,02994251
'''
pic_conv_kernel_size = 5
lookup_layer = 5
global_pic = True
pic_1 = siam_layer(
Conv2D(64,
pic_conv_kernel_size,
padding='same',
strides=1,
activation='relu'), 'picconv')(pic_input)
pic_2 = siam_layer(MaxPooling2D(pool_size=4),
'picpool')(pic_1) # 155x219
pic_3 = siam_layer(
Conv2D(32,
pic_conv_kernel_size,
padding='same',
strides=1,
activation='relu'), 'picconv2')(pic_2)
'''
if we take the crops from here, that would mean, that we crop average thing:
height: 219×0.011406671 ~ 2.5 (w corresponding by the median is 6.56)
The morphological dilation takes the mean height and adds it to all sides of the bbox, so we end up with:
w: 11.56 h: 7.5, lets take 12x8 in 'keras_crop_and_resize_batches_of_arrays'
(note that it originally sees 48x32 pixels)
'''
pic_4 = siam_layer(MaxPooling2D(pool_size=4),
'picpool2')(pic_3) # 38x54
pic_5 = siam_layer(
Conv2D(32,
pic_conv_kernel_size,
padding='same',
dilation_rate=3,
activation='relu'), 'picconv3')(pic_4)
'''
if we take it from here, the 12x8 changes to 4x downsample -> 3x2
'''
pic_6 = siam_layer(MaxPooling2D(pool_size=4), 'picpool3')(pic_5)
pic_7 = siam_layer(
Conv2D(32,
pic_conv_kernel_size,
padding='same',
dilation_rate=3,
activation='relu'), 'picconv4')(pic_6)
pic_8 = siam_layer(MaxPooling2D(pool_size=4), 'picpool4')(pic_7)
pic_9 = Flatten()(pic_8)
pic_final = siam_layer(Dense(32, activation='relu'), 'picfinal')(pic_9)
# bboxes ltrb are at first positions:
def extract_bbox_apply_fov_f(boxes_input):
# lets use as 'dilation' (the distance to see everything around) the mean height of the bbox
# ... mean - across the batch.
bboxes = boxes_input[..., 0:4]
dilate = K.mean(K.abs(bboxes[:, 3] - bboxes[:, 1]))
return bboxes + [-dilate, -dilate, dilate, dilate]
boxes_input_bigger_fov = TimeDistributed(
Lambda(extract_bbox_apply_fov_f))(inp_bbox)
if lookup_layer == 3:
boxes_cuts = keras_crop_and_resize_batches_of_arrays(
pic_3, boxes_input_bigger_fov, crop_size=(12, 8))
boxes_cuts = siam_layer(
Conv3D(10 * n_siz,
[1, pic_conv_kernel_size, pic_conv_kernel_size],
padding='valid',
activation='relu'), 'piclookconv')(boxes_cuts)
boxes_cuts = TimeDistributed(Flatten())(boxes_cuts)
elif lookup_layer == 5:
boxes_cuts = keras_crop_and_resize_batches_of_arrays(
pic_5, boxes_input_bigger_fov, crop_size=(3, 2))
# dim 3x2*32
boxes_cuts = TimeDistributed(Flatten())(boxes_cuts)
boxes_cuts = siam_layer(Dense(64 * n_siz, activation='relu'),
'piclookdense')(boxes_cuts)
else:
raise ValueError("lookup layer can be only 3 or 5")
boxes_cuts = siam_layer(
Conv1D(100 * n_siz,
kernel_size=1,
padding='same',
activation='relu'), 'picconvcuts')(boxes_cuts)
# should be the same as size of boxes ...
if global_pic is not None:
def timedistributed_concat(packed):
x, pic = packed
return K.concatenate([x, K.repeat(pic,
K.shape(x)[-2])],
axis=-1)
merged_result_one = Lambda(timedistributed_concat)(
[all_features, pic_final])
else:
merged_result_one = all_features
# merged_result_one = Concatenate()([boxes, pic_final])
merged_result = Concatenate(axis=-1)([merged_result_one, boxes_cuts])
# dimensionality should be now bigger
else:
merged_result = all_features
pic_input = None
# gather neighbours so that we will see them and can operate on them also:
boxes_input_with_neighbours = GatherFromIndices(mask_value=0,
include_self=True, flatten_indices_features=True) \
([merged_result, inp_neighs]) if neighbours > 0 else merged_result
feat_ext = siam_layer(Dense(256 * n_siz, activation='relu'),
'denseall')(boxes_input_with_neighbours)
feat_regulariz = siam_layer(Dropout(0.15), 'dropoutall')(feat_ext)
seq_conv = siam_layer(
Conv1D(128 * n_siz, kernel_size=5, padding='same', activation='relu'),
'convall')(feat_regulariz)
densflat = siam_layer(Dense(64 * n_siz, activation='relu'),
'denseflatbefatt')(seq_conv)
att = siam_layer(
AttentionTransformer(usesoftmax=True,
usequerymasks=False,
num_heads=8 * n_siz,
num_units=64 * n_siz,
causality=False),
'atrafo1')([densflat, densflat, densflat])
if n_att == 2:
att = siam_layer(
AttentionTransformer(usesoftmax=True,
usequerymasks=False,
num_heads=8 * n_siz,
num_units=64 * n_siz,
causality=False), 'atrafo1')([att, att, att])
emb_perbox = siam_layer(Dense(emb_size * n_siz, activation='sigmoid'),
'sigmemb')(att)
inputs_all = [
input for input in [
inp_text_f, inp_text_chars, inp_bbox, inp_poso, inp_neighs,
pic_input
] if input is not None
]
return inputs_all, emb_perbox
batch_token_ids = sequence_padding(batch_token_ids)
batch_segment_ids = sequence_padding(batch_segment_ids)
batch_labels = sequence_padding(batch_labels)
yield [batch_token_ids, batch_segment_ids], batch_labels
batch_token_ids, batch_segment_ids, batch_labels = [], [], []
# 加载预训练模型
bert = build_transformer_model(
config_path=config_path,
checkpoint_path=checkpoint_path,
with_pool=True,
return_keras_model=False,
)
output = Dropout(rate=0.1)(bert.model.output)
output = Dense(
units=2, activation='softmax', kernel_initializer=bert.initializer
)(output)
model = keras.models.Model(bert.model.input, output)
model.summary()
model.compile(
loss='sparse_categorical_crossentropy',
optimizer=Adam(2e-5), # 用足够小的学习率
# optimizer=PiecewiseLinearLearningRate(Adam(5e-5), {10000: 1, 30000: 0.1}),
metrics=['accuracy'],
)
# 转换数据集
kernel_size = 3
dropout = 0.4
n_filters = 32
# left branch of Y network
left_inputs = Input(shape=input_shape)
x = left_inputs
filters = n_filters
# 3 layers of Conv2D-Dropout-MaxPooling2D
# number of filters doubles after each layer (32-64-128)
for i in range(3):
x = Conv2D(filters=filters,
kernel_size=kernel_size,
padding='same',
activation='relu')(x)
x = Dropout(dropout)(x)
x = MaxPooling2D()(x)
filters *= 2
# right branch of Y network
right_inputs = Input(shape=input_shape)
y = right_inputs
filters = n_filters
# 3 layers of Conv2D-Dropout-MaxPooling2D
# number of filters doubles after each layer (32-64-128)
for i in range(3):
y = Conv2D(filters=filters,
kernel_size=kernel_size,
padding='same',
activation='relu',
dilation_rate=2)(y)
def define_model(weight_path=None):
input = Input(shape=(224, 224, 3))
conv1_7x7_s2 = Conv2D(filters=64,
kernel_size=(7, 7),
strides=(2, 2),
padding='same',
activation='relu',
kernel_regularizer=l2(0.01))(input)
maxpool1_3x3_s2 = MaxPooling2D(pool_size=(3, 3),
strides=(2, 2),
padding='same')(conv1_7x7_s2)
conv2_3x3_reduce = Conv2D(filters=64,
kernel_size=(1, 1),
padding='same',
activation='relu',
kernel_regularizer=l2(0.01))(maxpool1_3x3_s2)
conv2_3x3 = Conv2D(filters=192,
kernel_size=(3, 3),
padding='same',
activation='relu',
kernel_regularizer=l2(0.01))(conv2_3x3_reduce)
maxpool2_3x3_s2 = MaxPooling2D(pool_size=(3, 3),
strides=(2, 2),
padding='same')(conv2_3x3)
inception_3a = inception_model(input=maxpool2_3x3_s2,
filters_1x1=64,
filters_3x3_reduce=96,
filters_3x3=128,
filters_5x5_reduce=16,
filters_5x5=32,
filters_pool_proj=32)
inception_3b = inception_model(input=inception_3a,
filters_1x1=128,
filters_3x3_reduce=128,
filters_3x3=192,
filters_5x5_reduce=32,
filters_5x5=96,
filters_pool_proj=64)
maxpool3_3x3_s2 = MaxPooling2D(pool_size=(3, 3),
strides=(2, 2),
padding='same')(inception_3b)
inception_4a = inception_model(input=maxpool3_3x3_s2,
filters_1x1=192,
filters_3x3_reduce=96,
filters_3x3=208,
filters_5x5_reduce=16,
filters_5x5=48,
filters_pool_proj=64)
inception_4b = inception_model(input=inception_4a,
filters_1x1=160,
filters_3x3_reduce=112,
filters_3x3=224,
filters_5x5_reduce=24,
filters_5x5=64,
filters_pool_proj=64)
inception_4c = inception_model(input=inception_4b,
filters_1x1=128,
filters_3x3_reduce=128,
filters_3x3=256,
filters_5x5_reduce=24,
filters_5x5=64,
filters_pool_proj=64)
inception_4d = inception_model(input=inception_4c,
filters_1x1=112,
filters_3x3_reduce=144,
filters_3x3=288,
filters_5x5_reduce=32,
filters_5x5=64,
filters_pool_proj=64)
inception_4e = inception_model(input=inception_4d,
filters_1x1=256,
filters_3x3_reduce=160,
filters_3x3=320,
filters_5x5_reduce=32,
filters_5x5=128,
filters_pool_proj=128)
maxpool4_3x3_s2 = MaxPooling2D(pool_size=(3, 3),
strides=(2, 2),
padding='same')(inception_4e)
inception_5a = inception_model(input=maxpool4_3x3_s2,
filters_1x1=256,
filters_3x3_reduce=160,
filters_3x3=320,
filters_5x5_reduce=32,
filters_5x5=128,
filters_pool_proj=128)
inception_5b = inception_model(input=inception_5a,
filters_1x1=384,
filters_3x3_reduce=192,
filters_3x3=384,
filters_5x5_reduce=48,
filters_5x5=128,
filters_pool_proj=128)
averagepool1_7x7_s1 = AveragePooling2D(pool_size=(7, 7),
strides=(7, 7),
padding='same')(inception_5b)
drop1 = Dropout(rate=0.4)(averagepool1_7x7_s1)
linear = Dense(units=1000,
activation='softmax',
kernel_regularizer=l2(0.01))(
keras.layers.core.Flatten(drop1))
last = linear
model = Model(inputs=input, outputs=last)
model.summary()
y_test = np.array(y_test)
# LSTM层的输入必须是三维的
x_train = np.reshape(x_train, (x_train.shape[0], x_train.shape[1], 13))
x_test = np.reshape(x_test, (x_test.shape[0], x_test.shape[1], 13))
print(x_train)
# Neural Network model
HIDDEN_DIM = 32
LAYER_NUM = 2
model = Sequential()
model.add(
LSTM(16,
input_shape=(x_train.shape[1], x_train.shape[2]),
return_sequences=True))
model.add(Dropout(0.3))
model.add(LSTM(32, return_sequences=True))
model.add(Dropout(0.3))
model.add(LSTM(32, return_sequences=True))
model.add(Dropout(0.3))
model.add(LSTM(32, return_sequences=True))
model.add(Dropout(0.3))
model.add(LSTM(32, return_sequences=True))
model.add(Dropout(0.3))
model.add(LSTM(16, return_sequences=False))
model.add(Dropout(0.3))
model.add(Dense(1))
model.add(Activation('linear'))
model.compile(loss="mse", optimizer="rmsprop", lr=0.00001)
model.summary()
BATCH_SIZE = 32
random_state=42)
# Turn X_train and y_train to numpy arrays
# Import keras classes
from keras.models import Sequential
from keras.layers import Dense, Activation
from keras.optimizers import Adadelta
from keras.layers import Dropout
classifier = Sequential()
classifier.add(
Dense(units=4,
kernel_initializer='uniform',
activation='relu',
input_shape=(44, )))
classifier.add(Dropout(0.3))
# adding the 2nd hidden layer.
classifier.add(Dense(units=8, kernel_initializer='uniform', activation='relu'))
classifier.add(Dropout(0.3))
#Adding the output layer
classifier.add(
Dense(units=29, kernel_initializer='uniform', activation='softmax'))
#Compiling the ANN
classifier.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
#Fitting the ANN to training set
#model.summary()
## it is observed that after each run, the names of the model input and output layers are changed,
## so creating a dictionary to map layer names to the respective layers, rather than hardcoding the label names
layer_dict = dict([(layer.name, layer) for layer in model.layers])
## The VGG16 has a very dense architecture, so I decide to just include first few layers, and keep them freezed from weight updation.
## Taking the layers till block2_pool only
x = layer_dict['block2_pool'].output
## Defining the customized convolutional network on top of it
x = Convolution2D(filters=64, kernel_size=(3, 3), activation='relu')(x)
x = MaxPooling2D(pool_size=(2, 2))(x)
x = Flatten()(x)
x = Dense(256, activation='relu')(x)
x = Dropout(0.5)(x)
x = Dense(5, activation='softmax')(x)
# Creating a new (non-sequential) model.
custom_model = Model(input=model.input, output=x)
# Freezing the pre-trained bottom layers, so they are not trainable(all the layers till the block2_pool)
for layer in custom_model.layers[:7]:
layer.trainable = False
#print(custom_model.layers[6].trainable)
# Learning rate is changed to 0.001
#sgd = SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
custom_model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
def build_cnn_blstm_vec(input_set_size, width, height, mul_nb_classes, matrix):
print('cnn-blstm-vec model building...')
inputs = Input(shape=(height, ), dtype='int32')
#embedd = Embedding(input_set_size, width, input_length=height)(inputs)
embedd = Embedding(input_set_size,
width,
weights=[matrix],
input_length=height,
trainable=False)(inputs)
# conv
conv1_1 = Convolution1D(64, 3, border_mode='same',
activation='relu')(embedd)
bn1 = BatchNormalization(mode=1)(conv1_1)
pool1 = MaxPooling1D(pool_length=2)(bn1)
drop1 = Dropout(0.2)(pool1)
# 2 conv
conv2_1 = Convolution1D(128, 2, border_mode='same',
activation='relu')(drop1)
bn2 = BatchNormalization(mode=1)(conv2_1)
pool2 = MaxPooling1D(pool_length=2)(bn2)
drop2 = Dropout(0.2)(pool2)
# 3 conv
conv3_1 = Convolution1D(192, 2, border_mode='same',
activation='relu')(drop2)
bn3 = BatchNormalization(mode=1)(conv3_1)
#pool3 = MaxPooling1D(pool_length=2)(bn3)
drop3 = Dropout(0.1)(bn3)
'''
# 4 conv
conv4_1 = Convolution1D(192, 2, border_mode='same', activation='relu')(drop3)
bn4 = BatchNormalization(mode=1)(conv4_1)
#pool4 = MaxPooling1D(pool_length=2)(bn4)
drop4 = Dropout(0.1)(bn4)
'''
#b = merge([bn4, drop3], mode='concat')
# blstm
blstm = Bidirectional(LSTM(256, return_sequences=False),
merge_mode='sum')(drop3)
drop = Dropout(0.5)(blstm)
# highway
#highway = Highway(128)(drop)
'''
# 3 conv
conv3_1 = Convolution1D(64, 2, border_mode='same', activation='relu')(dropb)
bn3 = BatchNormalization(mode=1)(conv3_1)
pool3 = MaxPooling1D(pool_length=2)(bn3)
drop3 = Dropout(0.1)(bn3)
#flat = Flatten()(drop3)
'''
# output
out1 = Dense(mul_nb_classes[0], activation='sigmoid')(drop)
merged1 = merge([out1, drop], mode='concat')
out2 = Dense(mul_nb_classes[1], activation='sigmoid')(merged1)
merged2 = merge([out2, drop], mode='concat')
out3 = Dense(mul_nb_classes[2], activation='sigmoid')(merged2)
merged3 = merge([out3, drop], mode='concat')
out4 = Dense(mul_nb_classes[3], activation='sigmoid')(merged3)
out = [out1, out2, out3, out4]
model = Model(input=[inputs], output=out)
model.summary()
model.compile(
loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'],
)
print("cnn-blstm-vec model has built.")
return model
#Feature Scaling
X_train = X_train / 255
X_test = X_test / 255
X_train = X_train.reshape((59999, 28, 28, 1))
X_test = X_test.reshape((9999, 28, 28, 1))
#Model
from keras.models import Sequential
from keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout
cnn = Sequential()
cnn.add(Conv2D(64, (3, 3), activation="relu", input_shape=(28, 28, 1)))
cnn.add(MaxPooling2D(2, 2))
cnn.add(Dropout(0.3))
cnn.add(Conv2D(128, (3, 3), activation="relu"))
cnn.add(MaxPooling2D(2, 2))
cnn.add(Dropout(0.3))
cnn.add(Flatten())
cnn.add(Dense(units=512, activation="relu"))
cnn.add(Dense(units=512, activation="relu"))
cnn.add(Dropout(0.3))
cnn.add(Dense(units=512, activation="relu"))
cnn.add(Dense(units=10, activation="softmax"))
cnn.compile(optimizer="adam",
loss="sparse_categorical_crossentropy",
emb_d = Embedding(max_d, emb_n)(in_d)
in_wd = Input(shape=[1], name='wd')
emb_wd = Embedding(max_wd, emb_n)(in_wd)
in_qty = Input(shape=[1], name='qty')
emb_qty = Embedding(max_qty, emb_n)(in_qty)
in_c1 = Input(shape=[1], name='c1')
emb_c1 = Embedding(max_c1, emb_n)(in_c1)
in_c2 = Input(shape=[1], name='c2')
emb_c2 = Embedding(max_c2, emb_n)(in_c2)
in_nc = Input(shape=[1], name='nc')
fe = concatenate([(emb_app), (emb_ch), (emb_dev), (emb_os), (emb_h), (emb_d),
(emb_wd), (emb_qty), (emb_c1), (emb_c2)])
s_dout = SpatialDropout1D(0.2)(fe)
conv = Conv1D(100, kernel_size=4, strides=1, padding='same')(s_dout)
concat = concatenate([Flatten()(s_dout), Flatten()(conv), (in_nc)])
x = Dropout(0.2)(Dense(dense_n, activation='relu')(concat))
x = Dropout(0.2)(Dense(dense_n, activation='relu')(x))
outp = Dense(1, activation='sigmoid')(x)
model = Model(inputs=[
in_app, in_ch, in_dev, in_os, in_h, in_d, in_wd, in_qty, in_c1, in_c2,
in_nc
],
outputs=outp)
batch_size = 50000
epochs = 2
exp_decay = lambda init, fin, steps: (init / fin)**(1 / (steps - 1)) - 1
steps = int(len(list(train_df)[0]) / batch_size) * epochs
lr_init, lr_fin = 0.002, 0.0002
lr_decay = exp_decay(lr_init, lr_fin, steps)
optimizer_adam = Adam(lr=0.002, decay=lr_decay)
# plt.figure(figsize=[8,6])
# plt.plot(history.history['acc'],'r',linewidth=3.0)
# plt.plot(history.history['val_acc'],'b',linewidth=3.0)
# plt.legend(['Training Accuracy', 'Validation Accuracy'],fontsize=18)
# plt.xlabel('Epochs ',fontsize=16)
# plt.ylabel('Accuracy',fontsize=16)
# plt.title('Accuracy Curves',fontsize=16)
[test_loss, test_acc] = model.evaluate(test_data, test_labels_one_hot)
print("Evaluation result on Test Data : Loss = {}, accuracy = {}".format(test_loss, test_acc))
model_reg = Sequential()
model_reg.add(Dense(512, activation='relu', input_shape=(dimData,)))
model_reg.add(Dropout(0.5))
model_reg.add(Dense(512, activation='relu'))
model_reg.add(Dropout(0.5))
model_reg.add(Dense(nClasses, activation='softmax'))
model_reg.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics=['accuracy'])
history_reg = model_reg.fit(train_data, train_labels_one_hot, batch_size=256, epochs=20, verbose=1,
validation_data=(test_data, test_labels_one_hot))
plt.figure(figsize=[8,6])
plt.plot(history_reg.history['loss'],'r',linewidth=3.0)
plt.plot(history_reg.history['val_loss'],'b',linewidth=3.0)
plt.legend(['Training loss', 'Validation Loss'],fontsize=18)
plt.xlabel('Epochs ',fontsize=16)
plt.ylabel('Loss',fontsize=16)
def build_net_and_learn(xunlianflag, biaozhunhua_flag):
inputs = Input(shape=(40, ))
activation = 'relu'
arfa = 1
kernel_initializer = keras.initializers.RandomNormal(mean=0.0,
stddev=0.05,
seed=None)
# a layer instance is callable on a tensor, and returns a tensor
output_1 = Dense(hidden_dims * 16 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(inputs)
output_1 = Dropout(0.05)(output_1)
output_4 = Dense(hidden_dims * 32 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_1)
# output_21 = Dropout(0.05)(output_21)
# output_22 = Dense(hidden_dims*8, activation=activation,kernel_initializer=kernel_initializer)(output_21)
# # output_22 = Dropout(0.05)(output_22)
#
# output_23 = Dense(hidden_dims*16, activation=activation,kernel_initializer=kernel_initializer)(output_22)
# output_23=Dropout(0.05)(output_23)
#
# output_2_ = Dense(hidden_dims*32, activation=activation,kernel_initializer=kernel_initializer)(output_23)
# # output_2_ = Dropout(0.05)(output_2_)
#
# output_3 = Dense(hidden_dims*64, activation=activation,kernel_initializer=kernel_initializer)(output_2_)
# # output_3 = Dropout(0.05)(output_3)
#
# output_4 = Dense(hidden_dims*64, activation=activation,kernel_initializer=kernel_initializer)(output_3) #隐藏层
# # output_4=Dropout(0.05)(output_4)
output_5 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_4) #第1个头
output_5_2 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_5) #第1个头
output_5_3 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(
output_5_2) #第1个头
output_5_3 = Dense(hidden_dims * 128 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(
output_5_3) #第1个头
output_5_3 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(
output_5_3) #第1个头
output_5_4 = Dense(hidden_dims * 32 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(
output_5_3) #第1个头
output_5_5 = Dense(hidden_dims * 16 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(
output_5_4) #第1个头
output_5_6 = Dense(hidden_dims * 8 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(
output_5_5) #第1个头
output_5_7 = Dense(hidden_dims * 4 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(
output_5_6) #第1个头
output_6 = Dense(hidden_dims * 2 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_5_7)
output_7 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_4) #第2个头
output_7_1 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_7)
output_7_2 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_7_1)
output_7_2 = Dense(hidden_dims * 128 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_7_2)
output_7_2 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_7_2)
output_7_3 = Dense(hidden_dims * 32 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_7_2)
output_7_4 = Dense(hidden_dims * 16 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_7_3)
output_7_5 = Dense(hidden_dims * 8 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_7_4)
output_7_6 = Dense(hidden_dims * 4 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_7_5)
output_8 = Dense(hidden_dims * 2 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_7_6)
output_9 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_4) #第3个头
output_9_1 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_9)
output_9_2 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_9_1)
output_9_2 = Dense(hidden_dims * 128 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_9_2)
output_9_2 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_9_2)
output_9_3 = Dense(hidden_dims * 32 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_9_2)
output_9_4 = Dense(hidden_dims * 16 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_9_3)
output_9_5 = Dense(hidden_dims * 8 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_9_4)
output_9_6 = Dense(hidden_dims * 4 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_9_5)
output_10 = Dense(hidden_dims * 2 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_9_6)
output_11 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_4) #第4个头
output_11_1 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_11)
output_11_2 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_11_1)
output_11_2 = Dense(hidden_dims * 128 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_11_2)
output_11_2 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_11_2)
output_11_3 = Dense(hidden_dims * 32 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_11_2)
output_11_4 = Dense(hidden_dims * 16 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_11_3)
output_11_5 = Dense(hidden_dims * 8 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_11_4)
output_11_6 = Dense(hidden_dims * 4 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_11_5)
output_12 = Dense(hidden_dims * 2 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_11_6)
output_13 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_4) #第5个头
output_13_1 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_13)
output_13_2 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_13_1)
output_13_2 = Dense(hidden_dims * 128 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_13_2)
output_13_2 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_13_2)
output_13_3 = Dense(hidden_dims * 32 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_13_2)
output_13_4 = Dense(hidden_dims * 16 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_13_3)
output_13_5 = Dense(hidden_dims * 8 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_13_4)
output_13_6 = Dense(hidden_dims * 4 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_13_5)
output_14 = Dense(hidden_dims * 2 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_13_6)
output_15 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_4) #第6个头
output_15_1 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_15)
output_15_2 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_15_1)
output_15_2 = Dense(hidden_dims * 128 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_15_2)
output_15_2 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_15_2)
output_15_3 = Dense(hidden_dims * 32 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_15_2)
output_15_4 = Dense(hidden_dims * 16 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_15_3)
output_15_5 = Dense(hidden_dims * 8 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_15_4)
output_15_6 = Dense(hidden_dims * 4 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_15_5)
output_16 = Dense(hidden_dims * 2 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_15_6)
output_17 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_4) #第7个头
output_17_1 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_17)
output_17_2 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_17_1)
output_17_2 = Dense(hidden_dims * 128 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_17_2)
output_17_2 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_17_2)
output_17_3 = Dense(hidden_dims * 32 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_17_2)
output_17_4 = Dense(hidden_dims * 16 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_17_3)
output_17_5 = Dense(hidden_dims * 8 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_17_4)
output_17_6 = Dense(hidden_dims * 4 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_17_5)
output_18 = Dense(hidden_dims * 2 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_17_6)
output_19 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_4) #第8个头
output_19_1 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_19)
output_19_2 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_19_1)
output_19_2 = Dense(hidden_dims * 128 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_19_2)
output_19_2 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_19_2)
output_19_3 = Dense(hidden_dims * 32 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_19_2)
output_19_4 = Dense(hidden_dims * 16 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_19_3)
output_19_5 = Dense(hidden_dims * 8 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_19_4)
output_19_6 = Dense(hidden_dims * 4 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_19_5)
output_20 = Dense(hidden_dims * 2 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_19_6)
output_21 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_4) #第9个头
output_21_1 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_21)
output_21_2 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_21_1)
output_21_2 = Dense(hidden_dims * 128 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_21_2)
output_21_2 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_21_2)
output_21_3 = Dense(hidden_dims * 32 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_21_2)
output_21_4 = Dense(hidden_dims * 16 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_21_3)
output_21_5 = Dense(hidden_dims * 8 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_21_4)
output_21_6 = Dense(hidden_dims * 4 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_21_5)
output_22 = Dense(hidden_dims * 2 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_21_6)
output_23 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_4) #第10个头
output_23_1 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_23)
output_23_2 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_23_1)
output_23_2 = Dense(hidden_dims * 128 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_23_2)
output_23_2 = Dense(hidden_dims * 64 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_23_2)
output_23_3 = Dense(hidden_dims * 32 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_23_2)
output_23_4 = Dense(hidden_dims * 16 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_23_3)
output_23_5 = Dense(hidden_dims * 8 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_23_4)
output_23_6 = Dense(hidden_dims * 4 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_23_5)
output_24 = Dense(hidden_dims * 2 * arfa,
activation=activation,
kernel_initializer=kernel_initializer)(output_23_6)
#3批次，一个空批次
predictions1 = Dense(pici_size, activation='softmax',
name='output1')(output_6)
predictions2 = Dense(pici_size, activation='softmax',
name='output2')(output_8)
predictions3 = Dense(pici_size, activation='softmax',
name='output3')(output_10)
predictions4 = Dense(pici_size, activation='softmax',
name='output4')(output_12)
predictions5 = Dense(pici_size, activation='softmax',
name='output5')(output_14)
predictions6 = Dense(pici_size, activation='softmax',
name='output6')(output_16)
predictions7 = Dense(pici_size, activation='softmax',
name='output7')(output_18)
predictions8 = Dense(pici_size, activation='softmax',
name='output8')(output_20)
predictions9 = Dense(pici_size, activation='softmax',
name='output9')(output_22)
predictions10 = Dense(pici_size, activation='softmax',
name='output10')(output_24)
model = Model(inputs=inputs,
outputs=[
predictions1, predictions2, predictions3, predictions4,
predictions5, predictions6, predictions7, predictions8,
predictions9, predictions10
])
model.compile(
optimizer='sgd',
loss=[
'categorical_crossentropy', 'categorical_crossentropy',
'categorical_crossentropy', 'categorical_crossentropy',
'categorical_crossentropy', 'categorical_crossentropy',
'categorical_crossentropy', 'categorical_crossentropy',
'categorical_crossentropy', 'categorical_crossentropy'
],
metrics=['accuracy'],
)
##测试模块
data = get_input_data(get_data())
if (biaozhunhua_flag):
zuida, zuixiao, data = biaozhunhua(data)
X = []
# print(len(data))
for i in range(int(len(data) * 0.8)):
# if(i==0):
# print(data[i])
X.append(data[i])
X = np.array(X) #一个一维数组 np格式
# Y1=np.array([[1,0,0,0]for i in range(5)]) #训练集的数据
# Y2=np.array([[0,0,1,0]for i in range(5)])
# Y3=np.array([[0,0,1,0]for i in range(5)])
# Y4=np.array([[0,1,0,0]for i in range(5)])
# Y5=np.array([[0,1,0,0]for i in range(5)])
# Y6=np.array([[0,0,0,1]for i in range(5)])
# Y7=np.array([[0,0,0,1]for i in range(5)])
# Y8=np.array([[0,0,1,0]for i in range(5)])
# Y9=np.array([[0,0,0,1]for i in range(5)])
# Y10=np.array([[0,0,0,1]for i in range(5)])
# split = int(len(X_old) * 0.8)
# ##删除不好的数据
# xunlianflag=[]
# X=[]
# yichuan_xunlian_time = Utils.load("xunliantime.npy")
# yichuan_xunlian_time = yichuan_xunlian_time[0:split]
# random_xunlian_time = Utils.load("random_xunlian80.npy")
# for i in range(len(yichuan_xunlian_time)):
# if yichuan_xunlian_time[i]<random_xunlian_time[i]:
# xunlianflag.append(xunlianflag_old[i])
# X.append(X_old[i])
# xunlianflag=np.array(xunlianflag)
# X=np.array(X)
Y1 = [xunlianflag[i][0:4] for i in range(len(xunlianflag))]
Y2 = [xunlianflag[i][4:8] for i in range(len(xunlianflag))]
Y3 = [xunlianflag[i][8:12] for i in range(len(xunlianflag))]
Y4 = [xunlianflag[i][12:16] for i in range(len(xunlianflag))]
Y5 = [xunlianflag[i][16:20] for i in range(len(xunlianflag))]
Y6 = [xunlianflag[i][20:24] for i in range(len(xunlianflag))]
Y7 = [xunlianflag[i][24:28] for i in range(len(xunlianflag))]
Y8 = [xunlianflag[i][28:32] for i in range(len(xunlianflag))]
Y9 = [xunlianflag[i][32:36] for i in range(len(xunlianflag))]
Y10 = [xunlianflag[i][36:40] for i in range(len(xunlianflag))]
##开始训练
print('Training -----------')
history = model.fit(X, [Y1, Y2, Y3, Y4, Y5, Y6, Y7, Y8, Y9, Y10],
epochs=100,
batch_size=32)
# plot_x=[]
# plot_y=[]
# for step in range(1000):
# cost = model.train_on_batch(X, [Y1, Y2,Y3, Y4,Y5, Y6,Y7, Y8,Y9, Y10]) # 训练的数据的输入，输出。。Keras有很多开始训练的函数，这里用train_on_batch（）
# # cost = model.train_on_batch(X, [Y2]) # Keras有很aiyaya多开始训练的函数，这里用train_on_batch（）
# if step % 10 == 0:
# plot_x.append(step)
# plot_y.append(cost[0])
# print('train cost: ',cost)
# # if(step!=0 and step%100==0):
# # # 画图
# plt.plot(plot_x, plot_y)
# plt.savefig("cost.png")
# plt.show()
#保存训练好的模型 save model to single file
## 可视化
# from keras.utils import plot_model
# plot_model(model, to_file='model.png')
##训练可视化
# 绘制训练 & 验证的准确率值
history_dict = history.history
# print(history_dict.keys())
# accuracy=history.history['output1_accuracy']+history.history['output2_accuracy']+history.history['output3_accuracy']+history.history['output4_accuracy']+history.history['output5_accuracy']+history.history['output6_accuracy']+history.history['output7_accuracy']+history.history['output8_accuracy']+history.history['output9_accuracy']+history.history['output10_accuracy']
# print(accuracy)
# print(type(accuracy[0]))
plt.figure()
plt.plot(history.history['output1_accuracy'])
plt.title('Train Model accuracy')
plt.ylabel('Accuracy')
plt.xlabel('ca Epoch')
plt.legend(['Train'], loc='upper right')
plt.savefig("accuracy.png")
plt.show()
# 绘制训练 & 验证的损失值
plt.figure()
plt.plot(history.history['loss'])
plt.title('Train Model loss')
plt.ylabel('Loss')
plt.xlabel('Epoch')
plt.legend(['Train'], loc='upper right')
plt.savefig("loss.png")
plt.show()
#
model.save('model.h5')
##处理输出数据
# process_pre_data()
#计算总的使用时间
if (biaozhunhua_flag):
Utils.save("stand_max.npy", np.array([zuida]))
Utils.save("stand_min.npy", np.array([zuixiao]))
def compute(self, config, budget, working_directory, *args, **kwargs):
"""
Simple example for a compute function using a feed forward network.
It is trained on the MNIST dataset.
The input parameter "config" (dictionary) contains the sampled configurations passed by the bohb optimizer
"""
model = Sequential()
# The Input Layer :
model.add(
Dense(config['num_filters_1'],
kernel_initializer='uniform',
input_dim=self.input_shape,
activation='relu'))
# # The Hidden Layers :
#if config['num_conv_layers'] > 1:
model.add(
Dense(config['num_filters_2'],
kernel_initializer='uniform',
activation='relu'))
model.add(Dropout(config['dropout_rate']))
#if config['num_conv_layers'] > 2:
model.add(
Dense(config['num_filters_3'],
kernel_initializer='uniform',
activation='relu'))
model.add(Dropout(config['dropout_rate']))
# The Output Layer :
model.add(Dense(1, kernel_initializer='uniform', activation='linear'))
if config['optimizer'] == 'Adam':
optimizer = keras.optimizers.Adam(lr=config['lr'])
else:
optimizer = keras.optimizers.SGD(lr=config['lr'],
momentum=config['sgd_momentum'])
model.compile(loss=root_mean_squared_error,
optimizer=optimizer,
metrics=[root_mean_squared_error])
model.fit(self.x_train,
self.y_train,
batch_size=config['batch_size'],
epochs=int(budget),
verbose=1,
validation_data=(self.x_test, self.y_test))
train_score = model.evaluate(self.x_train, self.y_train, verbose=0)
# val_score = model.evaluate(
# self.x_validation, self.y_validation, verbose=0)
test_score = model.evaluate(self.x_test, self.y_test, verbose=0)
return ({
'loss':
1 - test_score[1], # remember: HpBandSter always minimizes!
'info': {
'test accuracy': test_score[1],
'train accuracy': train_score[1],
# 'validation accuracy': val_score[1],
'number of parameters': model.count_params()
}
})
def fit_model(train_data, valid_data, vocab_size, train_portion, time_step = 30, batch_size = 30):
train_data = train_data[0:int(train_data.shape[0]*train_portion)]
train_x, train_y = train_data[0:-1], train_data[1:]
trunc_step = time_step*batch_size
trun_index = train_x.shape[0]//trunc_step*trunc_step
train_x = train_x[0:trun_index]
train_y = train_y[0:trun_index]
#split subsequence and reshape
train_x = np.reshape(train_x, (1, len(train_x)))
train_y = np.reshape(train_y, (1, len(train_y)))
train_x = np.split(train_x, batch_size, axis = 1)
train_y = np.split(train_y, batch_size, axis = 1)
for i in range(batch_size):
train_x[i] = np.split(train_x[i], train_x[i].shape[1]//time_step, axis = 1)
train_y[i] = np.split(train_y[i], train_y[i].shape[1]//time_step, axis = 1)
train_x = np.concatenate(train_x, axis = 1)
train_y = np.concatenate(train_y, axis = 1)
train_x = train_x.reshape(train_x.shape[0]*train_x.shape[1], train_x.shape[2])
#train_x = train_x.reshape(train_x.shape[0]*train_x.shape[1], train_x.shape[2], 1)
#train_y = train_y.reshape(train_y.shape[0]*train_y.shape[1], train_y.shape[2], 1)
train_y = train_y.reshape(train_y.shape[0]*train_y.shape[1], train_y.shape[2])
train_y = np.array([train_y[i][len(train_y[i])-1] for i in range(train_y.shape[0])])
train_y = train_y.reshape(len(train_y), 1)
#validation data prepare
valid_x, valid_y = valid_data[0:-1], valid_data[1:]
trun_index = valid_x.shape[0]//trunc_step*trunc_step
valid_x = valid_x[0:trun_index]
valid_y = valid_y[0:trun_index]
valid_x = np.reshape(valid_x, (1, len(valid_x)))
valid_y = np.reshape(valid_y, (1, len(valid_y)))
valid_x = np.split(valid_x, batch_size, axis = 1)
valid_y = np.split(valid_y, batch_size, axis = 1)
for i in range(batch_size):
valid_x[i] = np.split(valid_x[i], valid_x[i].shape[1]//time_step, axis = 1)
valid_y[i] = np.split(valid_y[i], valid_y[i].shape[1]//time_step, axis = 1)
valid_x = np.concatenate(valid_x, axis = 1)
valid_y = np.concatenate(valid_y, axis = 1)
valid_x = valid_x.reshape(valid_x.shape[0]*valid_x.shape[1], valid_x.shape[2])
#valid_x = valid_x.reshape(valid_x.shape[0]*valid_x.shape[1], valid_x.shape[2], 1)
#valid_y = valid_y.reshape(valid_y.shape[0]*valid_y.shape[1], valid_y.shape[2], 1)
valid_y = valid_y.reshape(valid_y.shape[0]*valid_y.shape[1], valid_y.shape[2])
valid_y = np.array([valid_y[i][len(valid_y[i])-1] for i in range(valid_y.shape[0])])
valid_y = valid_y.reshape(len(valid_y), 1)
print(train_x.shape)
print(valid_x.shape)
print(train_y.shape)
print(valid_y.shape)
model = Sequential()
model.add(Embedding(vocab_size, 120, batch_input_shape = (batch_size, train_x.shape[1])))
model.add(CuDNNLSTM(256, stateful = True))
#model.add(CuDNNLSTM(256, batch_input_shape = (batch_size, train_x.shape[1], 1), return_sequences = True, stateful = True))
model.add(Dropout(0.2))
model.add(Dense(vocab_size, activation = "softmax"))
csv_logger = CSVLogger("ptb_words.csv", append=True, separator=',')
checkpoint = ModelCheckpoint('ptb_words_best.h5', monitor = 'loss', verbose=1, save_best_only = True, mode='min')
adam_opt = Adam(lr = 0.001)
model.compile(loss='sparse_categorical_crossentropy',optimizer=adam_opt,metrics=['accuracy', perplexity])
model.summary()
for i in range(100):
model.fit(train_x, train_y, validation_data=(valid_x, valid_y), batch_size=batch_size, epochs=1, verbose=1, shuffle=False, callbacks=[csv_logger, checkpoint])
model.reset_states()
def build_LSTM_model(trainData, trainBatches, testData, testBatches,
windowSize, class_count, numCalls, batch_size):
# Specify number of units
# https://stackoverflow.com/questions/37901047/what-is-num-units-in-tensorflow-basiclstmcell#39440218
num_units = 128
embedding_size = 256
# https://keras.io/callbacks/#earlystopping
early_stop = cb.EarlyStopping(monitor='sparse_categorical_accuracy',
min_delta=0.0001,
patience=3)
model = Sequential()
# We need to add an embedding layer because LSTM (at this moment) that the API call indices (numbers)
# are of some mathematical significance. E.g., system call 2 is "closer" to system calls 3 and 4.
# But system call numbers have nothing to do with their semantic meaning and relation to other
# system calls. So we transform it using an embedding layer so the LSTM can figure these relationships
# out for itself.
# https://blog.keras.io/a-ten-minute-introduction-to-sequence-to-sequence-learning-in-keras.html
# https://stackoverflow.com/questions/40695452/stateful-lstm-with-embedding-layer-shapes-dont-match
api_count = numCalls + 1 # +1 because 0 is our padding number
model.add(
Embedding(input_dim=api_count, output_dim=256,
input_length=windowSize))
# https://keras.io/layers/recurrent/#lstm
# model.add(LSTM(num_units,input_shape=(windowSize, api_count),return_sequences=False))
#TODO - GPU stuffs
model.add(
CuDNNLSTM(num_units,
input_shape=(windowSize, api_count),
return_sequences=False))
# NOTE: If I want to add more layers
# https://stackoverflow.com/questions/40331510/how-to-stack-multiple-lstm-in-keras
# https://keras.io/layers/core/#dense
model.add(Dense(128))
# https://keras.io/activations/
model.add(Activation('relu'))
# https://keras.io/layers/core/#dropout
model.add(Dropout(0.5))
model.add(Dense(class_count, name='logits'))
model.add(Activation('softmax'))
# Which optimizer to use
# https://keras.io/optimizers/
opt = optimizers.RMSprop(lr=0.01, decay=0.001)
# https://keras.io/models/model/#compile
model.compile(
loss='sparse_categorical_crossentropy',
optimizer=opt,
# Metrics to print
# We use sparse_categorical_accuracy as opposed to categorical_accuracy
# because: https://stackoverflow.com/questions/44477489/keras-difference-between-categorical-accuracy-and-sparse-categorical-accuracy
# I.e., since we don't use hot-encoding, we use sparse_categorical_accuracy
metrics=['sparse_categorical_accuracy'])
# https://keras.io/models/model/#fit_generator
hist = model.fit_generator(
# Data to train
trainData,
# Use multiprocessing because python Threading isn't really
# threading: https://docs.python.org/3/glossary.html#term-global-interpreter-lock
use_multiprocessing=True,
# Number of steps per epoch (this is how we train our large
# number of samples dataset without running out of memory)
steps_per_epoch=trainBatches,
#TODO
# Number of epochs
epochs=100,
# Validation data (will not be trained on)
validation_data=testData,
validation_steps=testBatches,
# Do not shuffle batches.
shuffle=False,
# List of callbacks to be called while training.
callbacks=[early_stop])
return model, hist
def train_rnn(config, data, tokens, number):
"""
Train one RNN, keep the best weights of the model and stop it when it doesnt learn anymore
:param config: config to use
:type config: dict
:param data: data to use to train the RNN
:type data: list of list of str
:param tokens: list of tokens used to train the RNN
:type tokens: list of str
:param number: id of the model
:type number: int
:return: None
"""
print("Model : " + str(number))
x_train, y_train = convert_data_to_numbers(tokens, data)
print("SMILES converted to numbers")
maxlen = 81
x = sequence.pad_sequences(x_train, maxlen=maxlen, dtype='int32',
padding='post', truncating='pre', value=0.)
y = sequence.pad_sequences(y_train, maxlen=maxlen, dtype='int32',
padding='post', truncating='pre', value=0.)
print("Loading y_train_one_hot")
y_train_one_hot = np.array([to_categorical(y_i, num_classes=len(tokens)) for y_i in y])
print(y_train_one_hot.shape)
n = x.shape[1]
model = Sequential()
model.add(Embedding(input_dim=len(tokens), output_dim=len(tokens), input_length=n, mask_zero=False))
model.add(GRU(units=256, return_sequences=True, activation="tanh", input_shape=(81, 26)))
model.add(Dropout(0.2))
model.add(GRU(256, activation='tanh', return_sequences=True))
model.add(Dropout(0.2))
model.add(TimeDistributed(Dense(len(tokens), activation='softmax')))
optimizer = Adam(lr=config['learning_rate'])
model.summary()
save_directory = 'rnn_models/' + config['configuration_name'] + '/'
log = save_directory + 'log'
model_weights = save_directory + 'model_weights_' + str(number) + '.h5'
model_architecture = save_directory + 'model_architecture_' + str(number) + '.json'
if not os.path.isdir(save_directory):
os.mkdir(save_directory)
if not os.path.isdir(log):
os.mkdir(log)
tensorboard = TensorBoard(log_dir=log + "/{}".format(str(datetime.datetime.now()) + '_model' + str(number)))
early_stopping = EarlyStopping(monitor='val_loss', patience=10, verbose=0, mode='min')
mcp_save = ModelCheckpoint(model_weights, save_best_only=True, monitor='val_loss', mode='min')
model.compile(loss='categorical_crossentropy', optimizer=optimizer, metrics=['accuracy'])
model.fit(x, y_train_one_hot, epochs=config['epochs'], batch_size=512,
validation_split=0.1, callbacks=[tensorboard, early_stopping, mcp_save])
model_json = model.to_json()
with open(model_architecture, "w") as json_file:
json_file.write(model_json)
print("Model saved")
with open(save_directory + "config.json", 'w') as conf:
json.dump(config, conf)
batch_size = 28
original_dim = data.shape[1]
latent_dim = 128
intermediate_dim1 = 512
epsilon_std = 0.01
nb_epoch = 100
kl_coef = 0
print("-------------define network model---------")
#Define VAE
x = Input(shape=(original_dim, ), name='input')
h1 = Dense(intermediate_dim1,
activation='relu',
kernel_initializer='lecun_uniform',
kernel_regularizer=l2(0.05))(x)
h1_do = Dropout(0.5)(h1)
z_mean = Dense(latent_dim)(h1_do)
z_log_std = Dense(latent_dim)(h1_do)
z = Lambda(sampling, output_shape=(latent_dim, ))([z_mean, z_log_std])
z_do = Dropout(0.5)(z)
decoder_h = Dense(intermediate_dim1,
activation='relu',
kernel_initializer='lecun_uniform',
kernel_regularizer=l2(0.05))
h_decoded = decoder_h(z_do)
decoder_mean = Dense(original_dim,
activation='relu',
name='vae_output',
kernel_initializer='lecun_uniform',
from keras.layers import Dense, Conv2D, MaxPool2D, Dropout, Softmax, Flatten
model = Sequential()
model.add(
Conv2D(input_shape=(28, 28, 1),
filters=32,
kernel_size=(5, 5),
strides=1,
padding='same',
use_bias=True,
activation='relu'))
model.add(MaxPool2D(pool_size=(2, 2)))
model.add(
Conv2D(filters=64,
kernel_size=(5, 5),
strides=1,
padding='same',
use_bias=True,
activation='relu'))
model.add(MaxPool2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(1024))
model.add(Dropout(rate=0.5))
model.add(Dense(10, activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='sgd',
metrics=['accuracy'])
model.fit(xl.reshape(-1, 28, 28, 1), yl, epochs=5, batch_size=500)
y_train_small = y_train[:1000]
# DEFINE THE NEURAL NETWORK WITH KERAS
# hidden layers = 3 and output
model_1 = Sequential([
Dense(units=128, input_dim=TOTAL_Inputs, activation='relu', name='hidden_1'),
Dense(units=64, activation='relu', name='hidden_2'), #no need to input dimensions, keras can get it anyway
Dense(16, activation='relu', name='hidden_3'), #16 = units(neurons), its more often in docs. so good practice
Dense(10,activation='softmax', name='output') #output
])
model_1.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy'])
display(model_1.summary())
model_2 = Sequential() # adding dropout - its randomly taking out a neuron
model_2.add(Dropout(0.2, seed=42, input_shape=(TOTAL_Inputs,)))
model_2.add(Dense(128, activation='relu', name='Model_2_hidden_1'))
model_2.add(Dense(64, activation='relu', name='Model_2_hidden_2'))
model_2.add(Dense(16, activation='relu', name='Model_2_hidden_3'))
model_2.add(Dense(10, activation='softmax', name='Model_2_output'))
model_2.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy'])
model_3 = Sequential()
model_3.add(Dropout(0.2, seed=42, input_shape=(TOTAL_Inputs,)))
model_3.add(Dense(128, activation='relu', name='Model_3_hidden_1'))
model_3.add(Dropout(0.25, seed=42))
model_3.add(Dense(64, activation='relu', name='Model_3_hidden_2'))
model_3.add(Dense(16, activation='relu', name='Model_3_hidden_3'))
model_3.add(Dense(10, activation='softmax', name='Model_3_output'))
model_3.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy'])
bigram_branch = GlobalMaxPooling1D()(bigram_branch)
trigram_branch = Conv1D(filters=100,
kernel_size=3,
padding='valid',
activation='relu',
strides=1)(tweet_encoder)
trigram_branch = GlobalMaxPooling1D()(trigram_branch)
fourgram_branch = Conv1D(filters=100,
kernel_size=4,
padding='valid',
activation='relu',
strides=1)(tweet_encoder)
fourgram_branch = GlobalMaxPooling1D()(fourgram_branch)
merged = concatenate([bigram_branch, trigram_branch, fourgram_branch], axis=1)
merged = Dense(256, activation='relu')(merged)
merged = Dropout(0.2)(merged)
merged = Dense(1)(merged)
output = Activation('sigmoid')(merged)
model = Model(inputs=[tweet_input], outputs=[output])
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
print('Model summary')
print(model.summary())
# %%
filepath = "CNN_best_weights.{epoch:02d}-{val_acc:.4f}.hdf5"
checkpoint = ModelCheckpoint(filepath,
monitor='val_acc',
verbose=1,
save_best_only=True,
def third_phase(trained=False, third_phase_train_reps=third_phase_train_reps):
global resnet_model, new_resnet_model, optimizer
tensorboard = TensorBoard(log_dir=third_phase_folder + 'tb_logs', batch_size=batch_size)
if not trained:
resnet_model = load_model(data_folder + '1st_phase_resnet_model.h5')
else:
resnet_model = load_model(data_folder + '3rd_phase_resnet_model.h5')
# # add regularizers to the convolutional layers
# trainable_layers_ratio = 1 / 2.0
# trainable_layers_index = int(len(resnet_model.layers) * (1 - trainable_layers_ratio))
# for layer in resnet_model.layers[:trainable_layers_index]:
# layer.trainable = False
# for layer in resnet_model.layers[trainable_layers_index:]:
# layer.trainable = True
for layer in resnet_model.layers:
layer.trainable = True
if isinstance(layer, keras.layers.convolutional.Conv2D):
layer.kernel_regularizer = regularizers.l2(0.001)
layer.activity_regularizer = regularizers.l1(0.001)
# add dropout and regularizer to the penultimate Dense layer
predictions = resnet_model.layers[-1]
dropout = Dropout(0.2)
fc = resnet_model.layers[-2]
fc.kernel_regularizer = regularizers.l2(0.001)
fc.activity_regularizer = regularizers.l1(0.001)
x = dropout(fc.output)
predictors = predictions(x)
new_resnet_model = Model(inputs=resnet_model.input, outputs=predictors)
optimizer = Adam(lr=0.1234)
start_lr = 0.0001
end_lr = 0.00001
step_lr = (end_lr - start_lr) / (third_phase_train_reps - 1)
new_resnet_model.compile(optimizer=optimizer, loss='categorical_crossentropy', metrics=['acc'])
if not os.path.exists(third_phase_folder):
os.makedirs(third_phase_folder)
for i in range(third_phase_train_reps):
lr = start_lr + step_lr * i
K.set_value(new_resnet_model.optimizer.lr, lr)
print(i, 'out of ', third_phase_train_reps, '\nlearning rate ', K.eval(new_resnet_model.optimizer.lr))
history = new_resnet_model.fit_generator(train_img_class_gen,
steps_per_epoch=steps_per_small_epoch,
epochs=small_epochs, verbose=2,
validation_data=val_img_class_gen, validation_steps=val_steps_per_small_epoch,
workers=4, callbacks=[tensorboard])
# history = new_resnet_model.fit_generator(train_img_class_gen,
# steps_per_epoch=steps_per_small_epoch,
# epochs=small_epochs, verbose=2,
# validation_data=val_img_class_gen, validation_steps=val_steps_per_small_epoch,
# workers=4, callbacks=[LosswiseKerasCallback(tag='keras xcpetion model')])
print("iteration",i)
if i % saves_per_epoch == 0:
print('{} epoch completed'.format(int(i / saves_per_epoch)))
if i>=5:
ts = calendar.timegm(time.gmtime())
new_resnet_model.save(third_phase_folder + str(ts) + '_resnet_model.h5')
save_obj(history.history, str(ts) + '_xcpetion_history.h5', folder=third_phase_folder)
new_resnet_model.save(data_folder + '3rd_phase_resnet_model.h5')
w2i = defaultdict(lambda: UNK, w2i) # freeze
X_dev_num = [[w2i[word] for word in sentence.split(" ")] for sentence in X_dev]
X_test_num = [[w2i[word] for word in sentence.split(" ")] for sentence in X_test]
vocab_size = len(w2i)
X_train_nhot = convert_to_n_hot(X_train_num, vocab_size)
X_dev_nhot = convert_to_n_hot(X_dev_num, vocab_size)
X_test_nhot = convert_to_n_hot(X_test_num, vocab_size)
np.random.seed(113) #set seed before any keras import
model = Sequential()
model.add(Dense(200, input_shape=(vocab_size,), kernel_initializer='he_uniform', kernel_constraint=maxnorm(5)))
model.add(Activation('relu'))
model.add(Dropout(0.4))
model.add(Dense(1))
model.add(Activation('sigmoid'))
optimizer =Adadelta(lr=0.22)
model.compile(loss='binary_crossentropy', optimizer=optimizer, metrics=['accuracy'])
print(model.summary())
model.fit(X_train_nhot, y_train,validation_split=0.1 , epochs=15, verbose=1, batch_size=128)
loss, accuracy = model.evaluate(X_test_nhot,y_test)
EarlyStopping(monitor='val_loss',
min_delta=0,
patience=2,
verbose=0, mode='auto')
print("Accuracy: ", accuracy *100)
def _build(self,
input_shape,
num_outputs,
block_fn,
repetitions,
with_detector=None,
activation=True,
Dropout=Dropout):
"""Builds a custom ResNet like architecture.
Args:
input_shape: The input shape in the form (nb_channels, nb_rows, nb_cols)
num_outputs: The number of outputs at final softmax layer
block_fn: The block function to use. This is either `basic_block` or `bottleneck`.
The original paper used basic_block for layers < 50
repetitions: Number of repetitions of various block units.
At each block unit, the number of filters are doubled and the input size is halved
Returns:
The keras `Model`.
"""
self._handle_dim_ordering()
if len(input_shape) != 3:
raise Exception("Input shape should be a tuple (nb_channels, nb_rows, nb_cols)")
# Permute dimension order if necessary
if K.image_dim_ordering() == 'tf':
input_shape = (input_shape[1], input_shape[2], input_shape[0])
# Load function from str if needed.
block_fn = self._get_block(block_fn)
tmp = []
input = Input(shape=input_shape)
tmp.append(input)
conv1 = self._conv_bn_relu(filters=16, kernel_size=(3, 3))(input)
tmp.append(conv1)
block = conv1
filters = 16
for i, r in enumerate(repetitions):
with tf.variable_scope("block"+str(i)):
block = self._residual_block(block_fn, filters=filters, repetitions=r, is_first_layer=(i == 0))(block)
tmp.append(block)
filters *= 2
# Last activation
block = self._bn_relu(block)
block = Dropout(0.5)(block)
# Classifier block
block_shape = K.int_shape(block)
pool2 = AveragePooling2D(pool_size=(block_shape[ROW_AXIS], block_shape[COL_AXIS]),
strides=(1, 1))(block)
flatten1 = Flatten()(pool2)
dense = Dense(units=num_outputs, kernel_initializer="he_normal",
activation="softmax" if activation else 'linear', name='classifier')(flatten1)
outs = [dense]
model = Model(inputs=input, outputs=outs)
return model
values = reframed.values
n_train_hours = int(len(values) * 0.80)
train = values[:n_train_hours, :]
test = values[n_train_hours:, :]
# split into input and outputs
train_X, train_y = train[:, :-1], train[:, -1]
test_X, test_y = test[:, :-1], test[:, -1]
# reshape input to be 3D [samples, timesteps, features]
train_X = train_X.reshape((train_X.shape[0], 1, train_X.shape[1]))
test_X = test_X.reshape((test_X.shape[0], 1, test_X.shape[1]))
# Keras Network
model = Sequential()
model.add(Dense(180, input_shape=(train_X.shape[1], train_X.shape[2]),\
activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(180, activation='relu'))
model.add(Dense(180, activation='relu'))
model.add(Dense(1))
model.compile(loss='mae', optimizer='adam')
# fit network
filepath = "/data/best_weights3m.hdf5"
checkpoint = ModelCheckpoint(filepath,
monitor='loss',
verbose=1,
save_best_only=True,
mode='min')
callbacks_list = [checkpoint]
train_y = np.expand_dims(np.expand_dims(train_y, -1), -1)
#model shaping
im_rows=28
im_cols=28
batch_size=512
im_shape=(im_rows,im_cols,1)
x_train=x_train.reshape(x_train.shape[0],*im_shape)
x_test=x_test.reshape(x_test.shape[0],*im_shape)
x_validation=x_validation.reshape(x_validation.shape[0],*im_shape)
#creating the model
cnn_model=Sequential([
Conv2D(filters=32,kernel_size=3, activation="relu",input_shape=im_shape),
MaxPooling2D(pool_size=(2,2)),
Dropout(0.2),
Flatten(),
Dense(32,activation="relu"),
Dense(10,activation="softmax")
])
#compiling
cnn_model.compile(
loss="sparse_categorical_crossentropy",
optimizer=adam(lr=0.001),
metrics=["accuracy"]
)
# training the model
cnn_model.fit(
x_train,y_train,batch_size=batch_size,epochs=3 ,
# convert class vectors to binary class matrices
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)
test_loss = []
test_accuracy = []
for i in range(0,50):
model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3),
activation='relu',
input_shape=input_shape))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation='softmax'))
model.compile(loss=keras.losses.categorical_crossentropy,#keras.losses.mean_squared_error,
optimizer=keras.optimizers.Adadelta(),
metrics=['accuracy'])
model.fit(x_train, y_train,
batch_size=batch_size,
epochs=epochs,
verbose=1,
validation_data=(x_test, y_test))
score = model.evaluate(x_test, y_test, verbose=0)
# Modelimizi yapılandırıyoruz
model = Sequential()
model.add(
Conv2D(64, kernel_size=(3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(64, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(64, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.20))
model.add(Dense(num_classes, activation='softmax'))
model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=keras.optimizers.Adam(),
metrics=['accuracy'])
datagen = ImageDataGenerator(featurewise_center=False,
samplewise_center=False,
featurewise_std_normalization=False,
samplewise_std_normalization=False,
zca_whitening=False,
rotation_range=0.5,
zoom_range=0.5,
width_shift_range=0.5,
height_shift_range=0.5,
