) #todo esto para dar lugar a diferencias entre las imágenes
validacion_datagen = ImageDataGenerator(rescale=1. / 255)
imagen_entrenamiento = entrenamiento_datagen.flow_from_directory(
datos_entrenamiento,
target_size=(altura, longitud),
batch_size=batch_size,
class_mode='categorical') #buscará datos de entrenamiento y las procesa
class_dictionary = imagen_entrenamiento.class_indices
print class_dictionary #esto para saber qué código le pertenece a la clasificación
imagen_validacion = validacion_datagen.flow_from_directory(
datos_validacion,
target_size=(altura, longitud),
batch_size=batch_size,
class_mode='categorical')
#CREACIÓN DE LA NEURONA
neurona = Sequential()
neurona.add(
Convolution2D(
filtrosConv1,
tamanio_filtro1,
padding='same',
input_shape=(altura, longitud, 3), #CAMBIO
activation='relu'))
neurona.add(MaxPooling2D(pool_size=tamanio_pool))
neurona.add(
Convolution2D(filtrosConv2,
tamanio_filtro2,
padding='same',
activation='relu'))
neurona.add(MaxPooling2D(pool_size=tamanio_pool))
#INICIO DE LA CLASIFICACIÓN
X_train_ss = scaler.fit_transform(X_train)
X_test_ss = scaler.transform(X_test)
# reshape to be suitable for Keras
X_train_CNN = X_train_ss.reshape((X_train_ss.shape[0], 1, X_train_ss.shape[1],
1)) # shape ((867, 1, 7500, 1))
y_train_CNN = utils.to_categorical(y_train) # shape (867, 6)
X_test_CNN = X_test_ss.reshape((X_test_ss.shape[0], 1, X_test_ss.shape[1],
1)) # shape ((217, 1, 7500, 1))
y_test_CNN = y_test
y_test_CNN = utils.to_categorical(y_test) # shape (217, 6)
print(X_train_CNN.shape, X_test_CNN.shape, y_train_CNN.shape, y_test_CNN.shape)
conv = Sequential()
conv.add(
Conv2D(64, (1, 3),
activation='relu',
input_shape=(1, N_channels * 30 * FreqSample // step, 1)))
conv.add(MaxPooling2D((1, 2)))
conv.add(Conv2D(128, (1, 3), activation='relu'))
conv.add(MaxPooling2D((1, 2)))
conv.add(Conv2D(256, (1, 3), activation='relu'))
conv.add(MaxPooling2D((1, 2)))
conv.add(Flatten())
conv.add(Dense(64, activation='relu'))
conv.add(Dropout(0.5))
x_train /= 255
x_test /= 255
# print('x_train shape:', x_train.shape)
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')
# ome-hot encoding
y_train = to_categorical(y_train, num_classes)
y_test = to_categorical(y_test, num_classes)
# callbacks
mcp = ModelCheckpoint("models/mnist_pretrained.hdf5", save_best_only=True)
# model
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='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
# fit model
model.fit(x_train,
def build_vgg(img_rows: int = 224,
img_cols: int = 224,
num_classes: int = 1000):
vgg = Sequential()
vgg.add(
Conv2D(64,
kernel_size=(3, 3),
activation='relu',
padding='same',
kernel_regularizer=l2(0.0005),
input_shape=(img_rows, img_cols, 3)))
vgg.add(
Conv2D(64,
kernel_size=(3, 3),
activation='relu',
padding='same',
kernel_regularizer=l2(0.0005),
input_shape=(img_rows, img_cols, 3)))
vgg.add(MaxPooling2D()) # initial size /2
vgg.add(
Conv2D(128,
kernel_size=(3, 3),
activation='relu',
padding='same',
kernel_regularizer=l2(0.0005)))
vgg.add(
Conv2D(128,
kernel_size=(3, 3),
activation='relu',
padding='same',
kernel_regularizer=l2(0.0005)))
vgg.add(MaxPooling2D()) # initial size /4
vgg.add(
Conv2D(256,
kernel_size=(3, 3),
activation='relu',
padding='same',
kernel_regularizer=l2(0.0005)))
vgg.add(
Conv2D(256,
kernel_size=(3, 3),
activation='relu',
padding='same',
kernel_regularizer=l2(0.0005)))
vgg.add(
Conv2D(256,
kernel_size=(3, 3),
activation='relu',
padding='same',
kernel_regularizer=l2(0.0005)))
vgg.add(MaxPooling2D()) # initial size /8
vgg.add(
Conv2D(512,
kernel_size=(3, 3),
activation='relu',
padding='same',
kernel_regularizer=l2(0.0005)))
vgg.add(
Conv2D(512,
kernel_size=(3, 3),
activation='relu',
padding='same',
kernel_regularizer=l2(0.0005)))
vgg.add(
Conv2D(512,
kernel_size=(3, 3),
activation='relu',
padding='same',
kernel_regularizer=l2(0.0005)))
vgg.add(MaxPooling2D()) # initial size /16
vgg.add(
Conv2D(512,
kernel_size=(3, 3),
activation='relu',
padding='same',
kernel_regularizer=l2(0.0005)))
vgg.add(
Conv2D(512,
kernel_size=(3, 3),
activation='relu',
padding='same',
kernel_regularizer=l2(0.0005)))
vgg.add(
Conv2D(512,
kernel_size=(3, 3),
activation='relu',
padding='same',
kernel_regularizer=l2(0.0005)))
vgg.add(MaxPooling2D()) # initial size /32
vgg.add(Flatten())
vgg.add(Dense(4096, activation='relu', kernel_regularizer=l2(0.0005)))
vgg.add(Dense(4096, activation='relu', kernel_regularizer=l2(0.0005)))
vgg.add(Dropout(0.5))
vgg.add(
Dense(num_classes, activation='softmax',
kernel_regularizer=l2(0.0005)))
return vgg
def build_3d_cnn(w, h, d, s, num_outputs):
#Credit: https://github.com/jessecha/DNRacing/blob/master/3D_CNN_Model/model.py
'''
w : width
h : height
d : depth
s : n_stacked
'''
input_shape = (s, h, w, d)
model = Sequential()
#First layer
#model.add(Cropping3D(cropping=((0,0), (50,10), (0,0)), input_shape=input_shape) ) #trim pixels off top
# Second layer
model.add(
Conv3D(filters=16,
kernel_size=(3, 3, 3),
strides=(1, 3, 3),
data_format='channels_last',
padding='same',
input_shape=input_shape))
model.add(Activation('relu'))
model.add(
MaxPooling3D(pool_size=(1, 2, 2),
strides=(1, 2, 2),
padding='valid',
data_format=None))
# Third layer
model.add(
Conv3D(filters=32,
kernel_size=(3, 3, 3),
strides=(1, 1, 1),
data_format='channels_last',
padding='same'))
model.add(Activation('relu'))
model.add(
MaxPooling3D(pool_size=(1, 2, 2),
strides=(1, 2, 2),
padding='valid',
data_format=None))
# Fourth layer
model.add(
Conv3D(filters=64,
kernel_size=(3, 3, 3),
strides=(1, 1, 1),
data_format='channels_last',
padding='same'))
model.add(Activation('relu'))
model.add(
MaxPooling3D(pool_size=(1, 2, 2),
strides=(1, 2, 2),
padding='valid',
data_format=None))
# Fifth layer
model.add(
Conv3D(filters=128,
kernel_size=(3, 3, 3),
strides=(1, 1, 1),
data_format='channels_last',
padding='same'))
model.add(Activation('relu'))
model.add(
MaxPooling3D(pool_size=(1, 2, 2),
strides=(1, 2, 2),
padding='valid',
data_format=None))
# Fully connected layer
model.add(Flatten())
model.add(Dense(256))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(256))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(num_outputs))
#model.add(Activation('tanh'))
return model
from tensorflow.python.keras.models import Sequential
from tensorflow.python.keras.layers import Convolution2D
from tensorflow.python.keras.layers import MaxPooling2D
from tensorflow.python.keras.layers import Flatten
from tensorflow.python.keras.layers import Dense
import csv
import pickle
# number of letters
units = 28
# initialize the CNN
classifier = Sequential()
# Step 1: convolution
classifier.add(
Convolution2D(5,
5,
input_shape=(50, 50, 1),
padding='same',
activation='relu'))
# Step 2: pooling
classifier.add(MaxPooling2D(pool_size=(4, 4)))
# Add a convolutional layer
classifier.add(
Convolution2D(15,
5,
input_shape=(50, 50, 1),
def create_model():
import time
name = "CATS_VS_DOGS_CNN-{}".format(int(time.time()))
tensorboard = TensorBoard(log_dir='logs\\{}'.format(name))
x_train = pickle.load(open("x_train.pickle", "rb"))
y_train = pickle.load(open("y_train.pickle", "rb"))
x_test = pickle.load(open("x_test.pickle", "rb"))
y_test = pickle.load(open("y_test.pickle", "rb"))
x_train = np.array(x_train)
y_train = np.array(y_train)
x_test = np.array(x_test)
y_test = np.array(y_test)
x_train = x_train / 255.0
x_test = x_test / 255.0
base_model = keras.applications.MobileNetV2(weights='imagenet', include_top=False, input_shape=(50, 50, 1))
base_model.trainable = False
keras.applications.
# Create the model
model = Sequential()
# Add the vgg convolutional base model
model.add(base_model)
# Add new layers
model.add(keras.layers.GlobalAveragePooling2D())
model.add(Flatten())
model.add(Dropout(0.5))
model.add(Dense(1, activation='softmax'))
# Show a summary of the model. Check the number of trainable parameters
model.compile(loss="binary_crossentropy", optimizer="adam", metrics=['accuracy'])
model.summary()
base_model.trainable = True
print("Number of layers in the base model: ", len(base_model.layers))
# Fine tune from this layer onwards
fine_tune_at = 100
for layer in base_model.layers[:fine_tune_at]:
layer.trainable = False
model.compile(loss="binary_crossentropy", optimizer="adam", metrics=['accuracy'])
import time
start_time = time.time()
model.fit(x_train, y_train, batch_size=32, epochs=15, validation_split=0.35, callbacks=[tensorboard])
model.save('network.model')
print("--- %s seconds ---" % (time.time() - start_time))
print('\n# Evaluate on test data')
results = model.evaluate(x_test, y_test, batch_size=32, callbacks=[tensorboard])
print('test loss, test acc:', results)
def train(TRAIN_TSV, TRAIN_EMB_PIDS, TRAIN_EMB_DIR, EMB_PREFIX, EMB_BATCH_SIZE, epochs, model_out_path, plot_path, max_seq_length=20, n_hidden=50):
# Load training set
train_dat = []
with open(TRAIN_TSV, 'r') as tr:
first = True
for l in tr:
if first:
first = False
continue
train_dat.append([int(l.split('\t')[0]), l.split('\t')[1], l.split('\t')[2]])
test_dat = []
# Make word2vec embeddings
embedding_dim = 768
use_w2v = True
Y, X, train_pairs = make_psg_pair_embeddings(train_dat, TRAIN_EMB_PIDS, TRAIN_EMB_DIR, EMB_PREFIX, EMB_BATCH_SIZE, max_seq_length)
# Split to train validation
validation_size = int(len(X) * 0.1)
training_size = len(X) - validation_size
X_train, X_validation, Y_train, Y_validation = train_test_split(X, Y, test_size=validation_size)
# Make sure everything is ok
# --
# Model variables
gpus = 2
batch_size = 1024 * gpus
# Define the shared model
x = Sequential()
#x.add(LSTM(n_hidden))
x.add(Bidirectional(LSTM(n_hidden)))
shared_model = x
# The visible layer
left_input = Input(shape=(max_seq_length, embedding_dim,), dtype='float32')
right_input = Input(shape=(max_seq_length, embedding_dim,), dtype='float32')
# Pack it all up into a Manhattan Distance model
malstm_distance = ManDist()([shared_model(left_input), shared_model(right_input)])
# cos_distance = CosineDist()([shared_model(left_input), shared_model(right_input)])
model = Model(inputs=[left_input, right_input], outputs=[malstm_distance])
#if gpus >= 2:
# `multi_gpu_model()` is a so quite buggy. it breaks the saved model.
#model = tf.keras_code.utils.multi_gpu_model(model, gpus=gpus)
model.compile(loss='mean_squared_error', optimizer=tf.keras.optimizers.Adam(), metrics=['accuracy'])
model.summary()
shared_model.summary()
# Start trainings
training_start_time = time()
malstm_trained = model.fit([X_train[:, :, :embedding_dim], X_train[:, :, embedding_dim:]], Y_train,
batch_size=batch_size, epochs=epochs,
validation_data=([X_validation[:, :, :embedding_dim], X_validation[:, :, embedding_dim:]], Y_validation))
training_end_time = time()
print("Training time finished.\n%d epochs in %12.2f" % (epochs,
training_end_time - training_start_time))
model.save_weights(model_out_path)
# Plot accuracy
plt.subplot(211)
if 'accuracy' in malstm_trained.history.keys():
plt.plot(malstm_trained.history['accuracy'])
plt.plot(malstm_trained.history['val_accuracy'])
else:
plt.plot(malstm_trained.history['acc'])
plt.plot(malstm_trained.history['val_acc'])
plt.title('Model Accuracy')
plt.ylabel('Accuracy')
plt.xlabel('Epoch')
plt.legend(['Train', 'Validation'], loc='upper left')
# Plot loss
plt.subplot(212)
plt.plot(malstm_trained.history['loss'])
plt.plot(malstm_trained.history['val_loss'])
plt.title('Model Loss')
plt.ylabel('Loss')
plt.xlabel('Epoch')
plt.legend(['Train', 'Validation'], loc='upper right')
plt.tight_layout(h_pad=1.0)
plt.savefig(plot_path)
if 'accuracy' in malstm_trained.history.keys():
print(str(malstm_trained.history['val_accuracy'][-1])[:6] +
"(max: " + str(max(malstm_trained.history['val_accuracy']))[:6] + ")")
else:
print(str(malstm_trained.history['val_acc'][-1])[:6] +
"(max: " + str(max(malstm_trained.history['val_acc']))[:6] + ")")
print("Done.")
def VGG11(input_shape, nb_classes, dropout=False, dropout_rate=0.2):
"""
Creates a vgg11 network.
Parameters
----------
input_shape : tuple
The shape of the input tensor not including the sample axis.
Tensorflow uses the NHWC dimention ordering convention.
nb_class : int
The number of output class. The network will have this number of
output nodes for one-hot encoding.
dropout : bool
Where or not to implement dropout in the fully-connected layers.
dropout_rate : float
Dropout rate.
Returns
-------
keras.models.Sequential() :
The create vgg11 network.
"""
vgg11 = Sequential()
# sub-net 1
vgg11.add(Conv2D(filters=8,
kernel_size=3,
padding='same',
activation='relu',
input_shape=input_shape))
vgg11.add(Conv2D(filters=8,
kernel_size=3,
padding='same',
activation='relu'))
vgg11.add(MaxPool2D(pool_size=2))
# sub-net 2
vgg11.add(Conv2D(filters=12,
kernel_size=3,
padding='same',
activation='relu'))
vgg11.add(Conv2D(filters=16,
kernel_size=3,
padding='same',
activation='relu'))
vgg11.add(MaxPool2D(pool_size=2))
# sub-net 3
vgg11.add(Conv2D(filters=16,
kernel_size=3,
padding='same',
activation='relu'))
vgg11.add(Conv2D(filters=16,
kernel_size=3,
padding='same',
activation='relu'))
vgg11.add(MaxPool2D(pool_size=2))
# dense layers
vgg11.add(Flatten())
vgg11.add(Dense(units=64, activation='relu'))
vgg11.add(Dropout(dropout_rate)) if dropout else None
vgg11.add(Dense(units=64, activation='relu'))
vgg11.add(Dropout(dropout_rate)) if dropout else None
vgg11.add(Dense(units=nb_classes, activation='softmax'))
return vgg11
def main():
if sys.platform == 'darwin':
# mac
matplotlib.use('TkAgg')
print('Using Mac OS')
# get expert_data
parser = argparse.ArgumentParser()
parser.add_argument('expert_data', type=str)
parser.add_argument('envname', type=str)
parser.add_argument('--batch_size',
dest='batch_size',
type=int,
default=32)
parser.add_argument('--epoch', dest='epoch', type=int, default=100)
parser.add_argument('--lr', dest='lr', type=float, default=1e-3)
parser.add_argument('--render', action='store_true')
parser.add_argument("--max_timesteps", type=int)
parser.add_argument('--num_rollouts',
type=int,
default=5,
help='Number of expert roll outs')
args = parser.parse_args()
with open(args.expert_data, 'rb') as f:
expert_data = pickle.loads(f.read())
obs = expert_data['observations']
acts = expert_data['actions']
acts = np.squeeze(acts, axis=[1])
num_exmple = obs.shape[0]
print('number of training examples: ', num_exmple)
print('dimension of observation: ', obs[0].shape)
print('dimension of action: ', acts[0].shape)
# shuffle_list = np.arange(num_exmple)
# np.random.shuffle(shuffle_list)
# obs, acts = obs[shuffle_list], acts[shuffle_list]
obs, acts = shuffle(obs, acts, random_state=0)
split = int(0.8 * num_exmple)
obs_train, acts_train = obs[:split], acts[:split]
obs_val, acts_val = obs[split:], acts[split:]
model = Sequential()
model.add(Dense(128, activation='relu', input_shape=(obs.shape[1], )))
model.add(Dense(128, activation='relu'))
# model.add(Dense(512, activation='relu'))
# model.add(Dense(256, activation='relu'))
model.add(Dense(128, activation='relu'))
model.add(Dense(acts.shape[1], activation='linear'))
model.compile(loss='mse', optimizer='adam', metrics=['accuracy'])
model.fit(obs_train,
acts_train,
batch_size=args.batch_size,
epochs=args.epoch,
verbose=1)
score = model.evaluate(obs_val, acts_val, verbose=1)
model.save('output/' + args.envname + '_bc.h5')
# set up session
tfconfig = tf.ConfigProto()
tfconfig.gpu_options.allow_growth = True
num_train = obs_train.shape[0]
shuffle_list = np.arange(num_train)
losses = []
with tf.Session(config=tfconfig) as sess:
# model = Behavioral_clone(obs.shape[1], acts.shape[1])
# model.build_net([128, 256, 512, 256, 128], lr=args.lr)
# sess.run(tf.global_variables_initializer())
tf_util.initialize()
env = gym.make(args.envname)
max_steps = args.max_timesteps or env.spec.timestep_limit
returns = []
observations = []
actions = []
model = load_model('output/' + args.envname + '_bc.h5')
for i in range(args.num_rollouts):
print('iter', i)
obs = env.reset()
done = False
totalr = 0.
steps = 0
while not done:
# action = model.action(sess, obs[None, :])
obs = obs.reshape(1, len(obs))
action = (model.predict(obs, batch_size=64, verbose=0))
observations.append(obs)
actions.append(action)
obs, r, done, _ = env.step(action)
totalr += r
steps += 1
if args.render:
env.render()
if steps % 100 == 0:
print("%i/%i" % (steps, max_steps))
if steps >= max_steps:
break
returns.append(totalr)
print('returns', returns)
print('mean return', np.mean(returns))
print('std of return', np.std(returns))
def evaluate_model(trainX, trainy, testX, testy, testy_norm):
"""
Create, fit and evaluate a model
:param trainX: (array)
:param trainy: (array)
:param testX: (array)
:param testy: (array)
:param testy_norm: (array)
:return:
accurancy (float)
loss (float)
"""
verbose, epochs, batch_size = 1, 60, 64 # 16
trainX, testX = scale_data(trainX, testX)
# trainX, testX = Magnitude(trainX,testX)
# trainX, testX = AutoCorallation(trainX, testX)
n_timesteps, n_features, n_outputs = trainX.shape[1], trainX.shape[2], trainy.shape[1]
print(testX.shape)
print(testy.shape)
model = Sequential()
# Small structure
# model.add(Conv1D(32, 5, activation='tanh', padding='same', input_shape=(n_timesteps, n_features),kernel_regularizer=regularizers.l1(0.01))) #,kernel_regularizer=regularizers.l1(0.01))
# model.add(MaxPooling1D(pool_size=2))
# model.add(Conv1D(64, 5, activation='tanh', padding='same'))
# model.add(SpatialDropout1D(0.5))
# model.add(MaxPooling1D(pool_size=2))
# model.add(Conv1D(128, 5, activation='tanh', padding='same'))
# model.add(SpatialDropout1D(0.5))
# BatchNormalization()
# model.add(MaxPooling1D(pool_size= 2))
# model.add(Flatten())
# model.add(Dense(128, activation='tanh'))
# model.add(Dropout(0.5))
# model.add(Dense(64, activation='tanh'))
# model.add(Dropout(0.5))
#Big kernel
model.add(Conv1D(filters=32, kernel_size=32, activation='relu', input_shape=(n_timesteps, n_features),
padding='same'))
model.add(SpatialDropout1D(0.5))
model.add(MaxPooling1D(pool_size=3))
model.add(Conv1D(filters=32, kernel_size=16, activation='relu', padding='same'))
BatchNormalization()
model.add(Conv1D(filters=64, kernel_size=8, activation='relu', padding='same'))
model.add(SpatialDropout1D(0.5))
model.add(MaxPooling1D(pool_size=3))
model.add(Conv1D(filters=128, kernel_size=4, activation='relu', padding='same'))
BatchNormalization()
model.add(Conv1D(filters=128, kernel_size=3, activation='relu', padding='same'))
model.add(SpatialDropout1D(0.5))
model.add(MaxPooling1D(pool_size=3))
model.add(Conv1D(filters=128, kernel_size=2, activation='relu', padding='same'))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
BatchNormalization()
model.add(Dense(64, activation='relu'))
model.add(Dense(32, activation='relu'))
BatchNormalization()
model.add(Dense(16, activation='relu'))
model.add(Dense(6, activation='relu')) #kernel_regularizer=regularizers.l2(0.01)
model.add(Dense(n_outputs, activation='softmax'))
model.summary()
plot_model(model, 'model_info.png', show_shapes=True)
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
# fit network
tensorboard = TensorBoard(log_dir="logs_big_stand_bez_reg/{}".format(time()),histogram_freq=1,write_images=True)
history = model.fit(trainX, trainy, epochs=epochs, batch_size=batch_size, verbose=verbose, validation_split=0.15,shuffle=True,callbacks=[tensorboard])
# evaluate model
loss, accuracy = model.evaluate(testX, testy, batch_size=batch_size, verbose=0)
export_model(model)
predictions = model.predict_classes(testX)
print(metrics.classification_report(testy_norm, predictions))
confusion_matrix = metrics.confusion_matrix(y_true = testy_norm, y_pred = predictions)
print(confusion_matrix)
normalised_confusion_matrix = np.array(confusion_matrix, dtype=np.float32) / np.sum(confusion_matrix) * 100
print("")
print("Confusion matrix (normalised to % of total test data):")
print(normalised_confusion_matrix)
width = 12
height = 12
# fig, ax = plt.subplots()
plt.figure(figsize=(width, height))
plt.imshow(
normalised_confusion_matrix,
interpolation='nearest',
cmap=plt.cm.rainbow
)
plt.title("Confusion matrix \n(normalized to the entire test set [%])")
plt.colorbar()
tick_marks = np.arange(6)
LABELS= ["Walk", "Walk up", "Walk down", "Sitting", "Standing", "Laying"]
plt.xticks(tick_marks, LABELS, rotation=90)
plt.yticks(tick_marks, LABELS)
plt.tight_layout()
plt.ylabel('Real value')
plt.xlabel('Prediction value')
plt.figure()
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('Model loss')
plt.ylabel('Loss')
plt.xlabel('Epoch')
plt.legend(['Training', 'Validation'], loc='upper left')
plt.figure()
plt.plot(history.history['accuracy'])
plt.plot(history.history['val_accuracy'])
plt.title('Model accurancy')
plt.ylabel('Accurancy')
plt.xlabel('Epoch')
plt.legend(['Training', 'Validation'], loc='upper left')
plt.show()
return accuracy, loss
tamano_pool = (2, 2)
clases = 5
lr = 0.0005
entrenamiento_imagenes = ImageDataGenerator(rescale=1. / 255, )
imagen_entrenamiento = entrenamiento_imagenes.flow_from_directory(
imagenes_entrenamiento,
target_size=(altura, longitud),
batch_size=batch_size,
class_mode='categorical')
print("Indices: ")
print(imagen_entrenamiento.class_indices)
red_neuronal = Sequential()
red_neuronal.add(
Convolution2D(filtrosConv1,
tamano_filtro1,
padding='same',
input_shape=(altura, longitud, canales),
activation='relu'))
red_neuronal.add(MaxPooling2D(pool_size=tamano_pool))
red_neuronal.add(
Convolution2D(filtrosConv2,
tamano_filtro2,
padding='same',
activation='relu'))
red_neuronal.add(MaxPooling2D(pool_size=tamano_pool))
red_neuronal.add(Flatten())
train_images.append(train_image)
train_labels.append(1)
train_images = np.array(train_images)
X_train, X_test, y_train, y_test = train_test_split(
train_images, to_categorical(train_labels), test_size=0.2, random_state=42)
base_model = ResNet50(weights='imagenet',
include_top=False,
input_shape=(h, w, 3),
pooling='avg')
base_model.trainable = False
model = Sequential([base_model, Dense(2, activation='softmax')])
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
batch_size = 16
epochs = 3
datagen = ImageDataGenerator(rescale=1. / 255,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
model.fit_generator(datagen.flow(X_train, y_train, batch_size=batch_size),
validation_data=(X_test, y_test),
from sklearn.preprocessing import LabelEncoder
import pandas as pd
import tensorflow as tf
tf.set_random_seed(111)
df = pd.read_csv('sonar.csv', header=None)
dataset = df.values
x = dataset[:, 0:60]
y_data = dataset[:, 60]
e = LabelEncoder()
e.fit(y_data)
y = e.transform(y_data)
model = Sequential() #model 객체 생성
model.add(Dense(24, input_dim=60,
activation='relu')) #hidden layer 입력 60 node:24 활성화 relu
model.add(Dense(10, activation='relu')) #두 번째 hidden layer node:10
model.add(Dense(1, activation='sigmoid')) #output layer :1
model.compile(loss='mean_squared_error',
optimizer='adam',
metrics=['accuracy'])
model.fit(x, y, epochs=200, batch_size=5) #학습
print("\n Accuracy: %.4f" %
(model.evaluate(x, y)[1])) #평가 [0]:loss [1]:accuracy
validation_datagen = tf.keras.preprocessing.image.ImageDataGenerator(
rescale=1. / 255)
test_datagen = tf.keras.preprocessing.image.ImageDataGenerator(rescale=1. /
255)
# 创建训练集、验证集和测试集的生成器
train_generator = train_datagen.flow(reshaped_x_train,
train_y,
batch_size=32)
validation_generator = train_datagen.flow(reshaped_x_validation,
validation_y,
batch_size=32)
test_generator = test_datagen.flow(reshaped_x_test, test_y, batch_size=32)
# 建立模型
model2 = Sequential()
model2.add(Conv2D(64, (3, 3), activation='relu',
input_shape=(150, 150, 3)))
model2.add(MaxPool2D(pool_size=(2, 2)))
model2.add(tf.keras.layers.BatchNormalization())
model2.add(Conv2D(64, (3, 3), activation='relu'))
model2.add(MaxPool2D(pool_size=(2, 2)))
model2.add(tf.keras.layers.BatchNormalization())
model2.add(Conv2D(64, (3, 3), activation='relu'))
model2.add(MaxPool2D(pool_size=(2, 2)))
# model2.add(tf.keras.layers.BatchNormalization())
model2.add(Flatten())
model2.add(Dropout(0.5))
model2.add(Dense(64, activation='relu'))
model2.add(Dense(1, activation='sigmoid'))
model2.compile(optimizer='RMSprop',
def main_fun(args, ctx):
IMAGE_PIXELS = 28
num_classes = 10
# use Keras API to load data
from tensorflow.python.keras.datasets import mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.reshape(60000, 784)
x_test = x_test.reshape(10000, 784)
x_train = x_train.astype('float32') / 255
x_test = x_test.astype('float32') / 255
# 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)
# setup a Keras model
model = Sequential()
model.add(Dense(512, activation='relu', input_shape=(784, )))
model.add(Dropout(0.2))
model.add(Dense(512, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(10, activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer=tf.train.RMSPropOptimizer(learning_rate=0.001),
metrics=['accuracy'])
model.summary()
print("model.inputs: {}".format(model.inputs))
print("model.outputs: {}".format(model.outputs))
# convert Keras model to tf.estimator
estimator = tf.keras.estimator.model_to_estimator(model,
model_dir=args.model_dir)
# setup train_input_fn for InputMode.TENSORFLOW or InputMode.SPARK
if args.input_mode == 'tf':
# For InputMode.TENSORFLOW, just use data in memory
train_input_fn = tf.estimator.inputs.numpy_input_fn(
x={"dense_input": x_train},
y=y_train,
batch_size=128,
num_epochs=args.epochs,
shuffle=True)
hooks = []
else: # 'spark'
# For InputMode.SPARK, read data from RDD
tf_feed = TFNode.DataFeed(ctx.mgr)
def rdd_generator():
while not tf_feed.should_stop():
batch = tf_feed.next_batch(1)
if len(batch) > 0:
record = batch[0]
image = numpy.array(record[0]).astype(
numpy.float32) / 255.0
label = numpy.array(record[1]).astype(numpy.float32)
yield (image, label)
else:
return
def train_input_fn():
ds = tf.data.Dataset.from_generator(
rdd_generator, (tf.float32, tf.float32), (tf.TensorShape(
[IMAGE_PIXELS * IMAGE_PIXELS]), tf.TensorShape([10])))
ds = ds.batch(args.batch_size)
return ds
# add a hook to terminate the RDD data feed when the session ends
hooks = [StopFeedHook(tf_feed)]
# eval_input_fn ALWAYS uses data loaded in memory, since InputMode.SPARK can only feed one RDD at a time
eval_input_fn = tf.estimator.inputs.numpy_input_fn(
x={"dense_input": x_test}, y=y_test, num_epochs=1, shuffle=False)
# setup tf.estimator.train_and_evaluate() w/ FinalExporter
feature_spec = {
'dense_input': tf.placeholder(tf.float32, shape=[None, 784])
}
exporter = tf.estimator.FinalExporter(
"serving",
serving_input_receiver_fn=tf.estimator.export.
build_raw_serving_input_receiver_fn(feature_spec))
train_spec = tf.estimator.TrainSpec(input_fn=train_input_fn,
max_steps=args.steps,
hooks=hooks)
eval_spec = tf.estimator.EvalSpec(input_fn=eval_input_fn,
exporters=exporter)
# train and export model
tf.estimator.train_and_evaluate(estimator, train_spec, eval_spec)
# WORKAROUND FOR https://github.com/tensorflow/tensorflow/issues/21745
# wait for all other nodes to complete (via done files)
done_dir = "{}/done".format(ctx.absolute_path(args.model_dir))
print("Writing done file to: {}".format(done_dir))
tf.gfile.MakeDirs(done_dir)
with tf.gfile.GFile("{}/{}".format(done_dir, ctx.task_index),
'w') as done_file:
done_file.write("done")
for i in range(60):
if len(tf.gfile.ListDirectory(done_dir)) < len(
ctx.cluster_spec['worker']):
print("{} Waiting for other nodes {}".format(
datetime.now().isoformat(), i))
time.sleep(1)
else:
print("{} All nodes done".format(datetime.now().isoformat()))
break
def ffnthree(xtrain,
ytrain,
xtest,
ytest,
input_shape,
num_classes,
batch_size,
epochs,
callbacks,
ismodelsaved=False,
tl=False):
if ismodelsaved == False:
# model definition
ffn3 = Sequential()
ffn3.add(
Dense(100,
input_dim=input_shape,
kernel_initializer="lecun_uniform",
activation="relu"))
ffn3.add(BatchNormalization())
ffn3.add(Dense(50, activation="relu", kernel_initializer="uniform"))
ffn3.add(Dropout(0.5))
ffn3.add(Dense(10, activation="relu", kernel_initializer="uniform"))
ffn3.add(Dense(num_classes, activation='softmax'))
#
ffn3.compile(loss=tfkeras.losses.binary_crossentropy,
optimizer=tf.keras.optimizers.RMSprop(0.001, rho=0.9),
metrics=['accuracy'])
#
historyffn3 = ffn3.fit(xtrain,
ytrain,
batch_size=batch_size,
epochs=epochs,
verbose=0,
validation_data=(xtest, ytest),
callbacks=callbacks)
score = ffn3.evaluate(xtest, ytest, verbose=0)
p('Test loss:', score[0])
p('Test accuracy:', score[1])
#
# display learning curves
if True:
plt.figure()
plt.plot(historyffn3.history['loss'], label='train loss')
plt.plot(historyffn3.history['val_loss'], label='test loss')
plt.title('Learning Curves')
plt.xlabel('epochs')
plt.ylabel('loss')
plt.legend()
plt.show()
else:
if input_shape == 92:
ffn3 = tf.keras.models.load_model(flpath +
'saved_model_4x23/ffn3_4x23')
else:
if tl:
ffn3 = tf.keras.models.load_model(
flpath + 'saved_model_guideseq_8x23/ffn3_8x23')
else:
ffn3 = tf.keras.models.load_model(
flpath + 'saved_model_crispr_8x23/ffn3crispr_8x23')
p("FFN3: Done")
return ffn3
ax1.scatter(range(1596),ABana[j] , s=10, c=colours[j], marker=markers[j], label='Sample '.__add__(i))
plt.title(label='Sample A vs Sample B')
plt.legend();
plt.savefig('Sample A vs Sample B.png')
#CNN
df3 = "/Users/Vartika_Bisht/Desktop/df_CNN.csv"
CNN_dataframe = pd.read_csv(df3)
print(CNN_dataframe)
print(CNN_dataframe.columns)
num_col = len(CNN_dataframe.columns)
X = np.asarray(CNN_dataframe.drop(labels = 'c',axis=1))
y = np.asarray(CNN_dataframe['c'])
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3)
neural_network = Sequential()
neural_network.add(Dense(activation = 'relu', input_dim = num_col - 1, units=6))
neural_network.add(Dense(activation = 'relu', units=6))
neural_network.add(Dense(activation = 'relu', units=6))
neural_network.add(Dense(activation = 'relu', units=6))
neural_network.add(Dense(activation = 'relu', units=6))
neural_network.add(Dense(activation = 'relu', units=6))
neural_network.add(Dense(activation = 'sigmoid', units=1))
neural_network.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])
neural_network.fit(X_train, y_train, batch_size = 5, epochs = 5)
y_pred = neural_network.predict(X_test)
y_pred = (y_pred > 0.5)
print(neural_network.get_config())
cm = confusion_matrix(y_test, y_pred)
#using the reference convolution stack before doing maxpooling
model = Sequential([
Conv2D(64,
3,
padding='same',
activation='relu',
input_shape=(image_size, image_size, 1)),
Conv2D(64, 3, padding='same', activation='relu'),
MaxPooling2D(),
Conv2D(128, 3, padding='same', activation='relu'),
Conv2D(128, 3, padding='same', activation='relu'),
MaxPooling2D(),
Conv2D(256, 3, padding='same', activation='relu'),
Conv2D(256, 3, padding='same', activation='relu'),
Conv2D(256, 1, padding='same', activation='relu'),
MaxPooling2D(),
Conv2D(512, 3, padding='same', activation='relu'),
Conv2D(512, 3, padding='same', activation='relu'),
Conv2D(512, 1, padding='same', activation='relu'),
MaxPooling2D(),
Conv2D(512, 3, padding='same', activation='relu'),
Conv2D(512, 3, padding='same', activation='relu'),
Conv2D(512, 1, padding='same', activation='relu'),
MaxPooling2D(),
Flatten(),
Dense(512, activation='relu'),
Dense(1, activation="sigmoid")
])
model.compile(loss="binary_crossentropy",
def train(self, texts : List[str],target : List[int]) -> None:
from tensorflow.python.keras.models import Sequential #type: ignore
from tensorflow.python.keras.layers import Embedding, Dense, LSTM, GlobalMaxPool1D #type: ignore
from tensorflow.keras.optimizers import Adam #type: ignore
from tensorflow.keras.callbacks import History #type: ignore
if self.downsampling:
texts, target = downsample(texts,target,self.downsampling_ratio)
if self.verbose:
print('1. Vectorizing texts')
NUMBER_OF_FEATURES : int = 20000
self.tokenizer = text.Tokenizer(num_words=NUMBER_OF_FEATURES)
self.tokenizer.fit_on_texts(texts)
vocabulary : Dict[str,int] = self.tokenizer.word_index
if self._max_sequence_length == 0:
self._max_sequence_length = len(max(texts, key=len))
vectorized_texts : array = self.vectorize_texts(texts)
if self.embedding_location == '':
if self.verbose:
print('2. Skip (no embeddings)')
print('3. Skip (no embeddings)')
else:
if self.verbose:
print('2. Loading word embeddings')
embedding_dictionary : Dict[str,List[float]] = load_embedding_dictionary(self.embedding_location)
nr_of_embedding_features: int = len(list(embedding_dictionary.values())[1]) # Check how many values we have for the first word
if self.verbose:
print('3. Creating embedding matrix')
embedding_matrix : array = create_embedding_matrix_for_vocabulary(embedding_dictionary,vocabulary)
if self.verbose:
print('4. Building up model')
#Define a simple LSTM model with a pretrained embedding layer
model : Sequential = Sequential()
if self.embedding_location == '':
#Add an empty embedding layer if we have no pretrained embeddings
EMPTY_EMBEDDING_LAYER_SIZE : int = 300
model.add(Embedding(len(vocabulary)+1,EMPTY_EMBEDDING_LAYER_SIZE))
else:
model.add(Embedding(input_dim=len(vocabulary)+1,
output_dim=nr_of_embedding_features,
input_length=vectorized_texts.shape[1],
weights=[embedding_matrix],
trainable=False))
model.add(LSTM(16, return_sequences=True))
model.add(LSTM(16, return_sequences=True))
model.add(LSTM(16, return_sequences=True))
model.add(GlobalMaxPool1D())
model.add(Dense(256))
model.add(Dense(256))
model.add(Dense(1, activation='sigmoid'))
#Compile the model
optimizer : Adam = Adam(lr=self.learning_rate)
model.compile(optimizer=optimizer, loss='binary_crossentropy', metrics=['acc'])
if self.verbose:
print('5. training the model')
history : History = model.fit(vectorized_texts,
target,
epochs=self.learning_epochs,
#validation_data=(test_vectors, test_target),
verbose=1, # Logs once per epoch.
batch_size=self.learning_batch_size)
self.model = model
batch_size=batch_size)
test_gen = generator(float_data,
lookback=lookback,
delay=delay,
min_index=300001,
max_index=None,
step=step,
batch_size=batch_size)
# How many steps to draw from test, val to see the entire respective set
val_steps = (300000 - 200001 - lookback)
test_steps = (len(float_data) - 300001 - lookback)
# Model
mdl = Sequential()
mdl.add(layers.Flatten(input_shape=(lookback // step, float_data.shape[-1])))
mdl.add(layers.Dense(32, activation='relu'))
mdl.add(layers.Dense(1))
mdl.compile(optimizer=RMSprop(), loss='mae')
hist = mdl.fit_generator(train_gen,
steps_per_epoch=500,
epochs=20,
validation_data=val_gen,
validation_steps=val_steps)
# Plotting results
loss = hist.history['loss']
val_loss = hist.history['val_loss']
epochs = range(1, len(loss) + 1)
plt.plot(epochs, loss, 'bo', label='Training loss')
def neuralnet(no_model,dnafull,dna0,dna1,dna2,dna3,dna4,dna5,dna6):
"""
dna_temp[0] hid_layer_num INT 1~5
dna_temp[1] hid_layer_node INT 16~128
dna_temp[2] epoch INT 100~500
dna_temp[3] dropout FLOAT 0.00~0.20
dna_temp[4] maxlen INT 9~19
dna_temp[5] time_bias INT 1~9
dna_temp[6] layer INT 1~3
"""
"""
パラメーター設定
"""
#入力層次元
n_in = 20
#中間層次元、層数
n_hiddens = list()
for i in range(dna0):
n_hiddens.append(dna1)
n_centors = dna0
#出力層次元、層数
n_out = 5
#活性化関数
activation = 'relu'
#ドロップアウト率
p_keep = dna3
#計算回数
epochs = dna2
#EarlyStoppingするか
isEs= False
#EarlyStoppingをするまでの回数
es_patience= 60
#ミニバッチ処理のサイズ
batch_size = 1000
#最適化アルゴリズム
opt='rmsprop'
#学習率(本プログラムでは未使用でデフォルト値を使用）
# learning_rate=0.001
#Adamのパラメータ(最適化アルゴリズムがAdamの時のみ使用・本プログラムでは未使用)
# beta_1=0.9
# beta_2=0.999
#reccrentの参照数
maxlen= dna4
#Yを何秒ずらすか（=0だと過去maxlen秒参照、=maxlen/2だと前後maxlen/2秒参照、=maxlenだと未来maxlen秒参照になる)
time_bias= dna5
#RNNの種類(SimpleRNN,LSTM,GRU)
layer_int = dna6
#双方向性を使用するか
BiDir= False
#RNNの偶数層を逆向きにするか
back= False
#乱数の固定シード
# ranseed= 12345
# weight1 = 1
# weight2 = 1
#
print('No_%d' % no_model)
print(dna0,dna1,dna2,dna3,dna4,dna5,dna6)
#乱数固定
import os
os.environ['PYTHONHASHSEED']='0'
# np.random.seed(ranseed)
# rn.seed(ranseed)
#スレッド数等を１に固定(再現性に必要)
session_conf = tf.compat.v1.ConfigProto(intra_op_parallelism_threads=1, inter_op_parallelism_threads=1)
from tensorflow.python.keras import backend as K
# tf.compat.v1.set_random_seed()
sess = tf.compat.v1.Session(graph=tf.compat.v1.get_default_graph(),config=session_conf)
K.set_session(sess)
#重み初期化
init=initializers.TruncatedNormal()
#ファイルの名前
name = 'linear_data_FIR8_comAngle&AveStd_coor_s1_ntd2_26'
# number = '-2'
#ファイル読み込み
csv_input = pd.read_csv(filepath_or_buffer= name+".csv", encoding="ms932", sep=",")
array = csv_input.values
#仮の入出力値を読み取り
X=array[:,1:n_in+1].astype(np.float32)
Y=array[:,n_in+1].astype(np.int)
#タイムスタンプを読み取り
TIME=array[:,0]
leng = len(Y)
data = []
target = []
i = 0
for i in range(maxlen, leng):
#入力データを参照秒数ごとにまとめる
data.append(X[i-maxlen+1:i+1,:])
#出力データをN秒ごとの作業に変換
target.append(Y[i-time_bias])
#入出力データのshapeの調整
X = np.array(data).reshape(len(data), maxlen, n_in)
Y = np.array(target)
#タイムスタンプを入出力データと同期
TIME=TIME[maxlen-time_bias:leng-time_bias]
#学習データとテストデータの分割
x_train, x_test, y_train0, y_test0,time_train,time_test = train_test_split(X, Y,TIME, train_size=0.85,shuffle=False)
#学習データをtrainとvalidationに分割
x_train, x_validation, y_train0, y_validation0 = train_test_split(x_train, y_train0,train_size=0.9,shuffle=False)
#yを1ofKデータに変換(train,val,test)
ntr=y_train0.size
y_train=np.zeros(n_out*ntr).reshape(ntr,n_out).astype(np.float32)
for i in range(ntr):
y_train[i,y_train0[i]]=1.0
nte=y_test0.size
y_test=np.zeros(n_out*nte).reshape(nte,n_out).astype(np.float32)
for i in range(nte):
y_test[i,y_test0[i]]=1.0
y_validation=np.eye(n_out)[(y_validation0.reshape(y_validation0.size))]
# nrow=y_test0.size
# モデル設定
model = Sequential()
for i in range(n_centors):
if(i==n_centors-1):
retSeq=False
else:
retSeq=True
if(i%2==1 and back):
gBack=True
else:
gBack=False
if(i==0):
in_dir=n_in
else:
in_dir=n_hiddens[i-1]
if (layer_int==1):
if(BiDir):
model.add(Bidirectional(SimpleRNN(n_hiddens[i],activation=activation,kernel_initializer=init,recurrent_initializer=init,dropout=p_keep,recurrent_dropout=p_keep, return_sequences=retSeq,go_backwards=gBack, input_shape=(maxlen, in_dir) )))
else:
# model.add(SimpleRNN(n_hiddens[i],activation=activation,kernel_initializer=init,recurrent_initializer=init, return_sequences=retSeq,go_backwards=gBack, input_shape=(maxlen, in_dir) ))
model.add(SimpleRNN(n_hiddens[i],activation=activation,kernel_initializer=init,recurrent_initializer=init,dropout=p_keep,recurrent_dropout=p_keep, return_sequences=retSeq,go_backwards=gBack, input_shape=(maxlen, in_dir) ))
elif(layer_int==2):
if(BiDir):
model.add(Bidirectional(LSTM(n_hiddens[0],activation=activation,kernel_initializer=init,recurrent_initializer=init,dropout=p_keep,recurrent_dropout=p_keep, return_sequences=retSeq,go_backwards=gBack, input_shape=(maxlen, in_dir) )))
else:
model.add(LSTM(n_hiddens[0],activation=activation,kernel_initializer=init,recurrent_initializer=init,dropout=p_keep,recurrent_dropout=p_keep, return_sequences=retSeq,go_backwards=gBack, input_shape=(maxlen, in_dir) ))
elif(layer_int==3):
if(BiDir):
model.add(Bidirectional(GRU(n_hiddens[0],activation=activation,kernel_initializer=init,recurrent_initializer=init,dropout=p_keep,recurrent_dropout=p_keep, return_sequences=retSeq,go_backwards=gBack, input_shape=(maxlen, in_dir) )))
else:
model.add(GRU(n_hiddens[0],activation=activation,kernel_initializer=init,recurrent_initializer=init,dropout=p_keep,recurrent_dropout=p_keep, return_sequences=retSeq,go_backwards=gBack, input_shape=(maxlen, in_dir) ))
model.add(Dense(n_out,kernel_initializer=init))
model.add(Activation('softmax'))
model.compile(loss='binary_crossentropy', optimizer=opt, metrics=['accuracy'])
early_stopping =EarlyStopping(monitor='val_loss', patience=es_patience, verbose=1)
# now = datetime.now().strftime('%Y%m%d%H%M')
# flog = name+number+'.log1.csv'
#
# csv_logger=CSVLogger(flog)
if (isEs):
caBacks=[early_stopping]#,csv_logger]
else:
caBacks=[]#csv_logger]
#モデル学習
# start = time.time()
model.fit(x_train,y_train, epochs=epochs, batch_size=batch_size,validation_data=(x_validation,y_validation),callbacks=caBacks)
#hist = model.fit(x_train,y_train, epochs=epochs, batch_size=batch_size,callbacks=caBacks)
#,callbacks=[early_stopping]
# slapsed_time=time.time() - start
#
#
# val_acc = hist.history['val_acc']
# acc = hist.history['acc']
# val_loss = hist.history['val_loss']
# loss = hist.history['loss']
#
#now = datetime.now().strftime('%Y%m%d%H%M')
#
#plt.rc('font',family='serif')
#fig = plt.figure()
#plt.plot(range(len(loss)), loss, label='loss', color='r')
#plt.plot(range(len(val_loss)), val_loss, label='val_loss', color='b')
#plt.xlabel('epochs')
#plt.legend()
#plt.show()
#plt.savefig(name+number+'.loss.png')
#
##plt.rc('font',family='serif')
##fig = plt.figure()
##plt.plot(range(len(val_acc)), val_acc, label='acc', color='b')
##plt.xlabel('epochs')
##plt.show()
##plt.savefig(name+number+'.val_acc.png')
classes = model.predict_classes(x_test, batch_size=1)
#prob = model.predict_proba(x_test, batch_size=1)
#重みの出力
#L1 = model.get_weights()
#W1 = np.dot(L1[0],L1[1])+L1[2]
#W2 = np.dot(W1,L1[3])
#W3 = np.dot(W2,L1[4])
#W4 = W3+L1[5]
#weight1 = np.dot(W4,L1[6])+L1[7]
#weight = weight1.transpose()
#結果を出力
im = [[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]
ip = [0,0,0,0]
it = [0,0,0,0]
f = [0,0,0,0]
ia = [0,0,0,0]
ib = [0,0,0,0]
j = 0
for i in range(4):
for j in range(y_test0.size):
if y_test0[j]==i+1:
it[i] += 1
if classes[j] == 1:
im[i][0] += 1
if classes[j] == 2:
im[i][1] += 1
if classes[j] == 3:
im[i][2] += 1
if classes[j] == 4:
im[i][3] += 1
else:
pass
for i in range(4):
for k in range(y_test0.size):
if classes[k]==i+1:
ip[i]+=1
else:
pass
#再現率を導出
for i in range(4):
if it[i]==0:
ia[i] = 0
else:
ia[i] = im[i][i]/it[i]
#適合率を導出
for i in range(4):
if ip[i]==0:
ib[i] = 0
else:
ib[i] = im[i][i]/ip[i]
#F値を導出
for i in range(4):
if ia[i]+ib[i]==0:
f[i] = 0
else:
f[i] = 2*ia[i]*ib[i]/(ia[i]+ib[i])
# it_sum = sum(it)
# ip_sum = sum(ip)
# ii = im[0][0]+im[1][1]+im[2][2]+im[3][3]#+i5
if_ave = sum(f)/4
model.save(name+'_'+str(no_model)+".h5")
# model.save("kanno_"+str(no_model)+".model")
# =============================================================================
backend.clear_session()
# =============================================================================
return if_ave
def make_model():
# load all training reviews
positive_docs = process_docs('data/pos_train', vocab, True)
negative_docs = process_docs('data/neg_train', vocab, True)
train_docs = negative_docs + positive_docs
# create the tokenizer
tokenizer = Tokenizer()
# fit the tokenizer on the documents
tokenizer.fit_on_texts(train_docs)
with open('tokenizer.pickle', 'wb') as handle:
pickle.dump(tokenizer, handle, protocol=pickle.HIGHEST_PROTOCOL)
# sequence encode
encoded_docs = tokenizer.texts_to_sequences(train_docs)
# pad sequences
max_length = max([len(s.split()) for s in train_docs])
print("\n\n maxlenght=" + str(max_length))
from tensorflow.python.keras.preprocessing.sequence import pad_sequences
Xtrain = pad_sequences(encoded_docs, maxlen=max_length, padding='post')
# define training labels
ytrain = np.array([0 for _ in range(160)] + [1 for _ in range(160)])
# load all test reviews
positive_docs = process_docs('data/pos_test', vocab, False)
negative_docs = process_docs('data/neg_test', vocab, False)
test_docs = negative_docs + positive_docs
# sequence encode
encoded_docs = tokenizer.texts_to_sequences(test_docs)
# pad sequences
Xtest = pad_sequences(encoded_docs, maxlen=max_length, padding='post')
# define test labels
ytest = np.array([0 for _ in range(7)] + [1 for _ in range(50)])
print("\n pad_sequences : ", Xtest)
print("\n ytest : ", ytest)
# define vocabulary size (largest integer value)
vocab_size = len(tokenizer.word_index) + 1
# define model
model = Sequential()
model.add(Embedding(vocab_size, 100, input_length=max_length))
model.add(Conv1D(filters=32, kernel_size=8, activation='relu'))
model.add(MaxPooling1D(pool_size=2))
model.add(Flatten())
model.add(Dense(10, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
print(model.summary())
# compile network
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
# fit network
model.fit(Xtrain, ytrain, epochs=15, verbose=1)
# evaluate
loss, acc = model.evaluate(Xtest, ytest, verbose=0)
print('Test Accuracy: %f' % (acc * 100))
model.save("relevancy_model.h5")
print("Done!")
def onBeginTraining(self):
ue.log("starting mnist keras cnn training")
model_file_name = "mnistKerasCNN"
model_directory = ue.get_content_dir() + "/Scripts/"
model_sess_path = model_directory + model_file_name + ".tfsess"
model_json_path = model_directory + model_file_name + ".json"
my_file = Path(model_json_path)
#reset the session each time we get training calls
K.clear_session()
#let's train
batch_size = 128
num_classes = 10
epochs = 5 # lower default for simple testing
self.batch_size = batch_size # so that it can be obtained inside keras callbacks
# input image dimensions
img_rows, img_cols = 28, 28
# the data, shuffled and split between train and test sets
(x_train, y_train), (x_test, y_test) = mnist.load_data()
if K.image_data_format() == 'channels_first':
x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)
x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)
input_shape = (1, img_rows, img_cols)
else:
x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)
x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
input_shape = (img_rows, img_cols, 1)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
ue.log('x_train shape:' + str(x_train.shape))
ue.log(str(x_train.shape[0]) + 'train samples')
ue.log(str(x_test.shape[0]) + 'test samples')
#pre-fill our callEvent data to optimize callbacks
jsonPixels = {}
size = {'x':28, 'y':28}
jsonPixels['size'] = size
self.jsonPixels = jsonPixels
self.x_train = x_train
# 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)
model = Sequential()
model.add(Conv2D(64, kernel_size=(3, 3),
activation='relu',
input_shape=input_shape))
# model.add(Dropout(0.2))
# model.add(Flatten())
# model.add(Dense(512, activation='relu'))
# model.add(Dropout(0.2))
# model.add(Dense(num_classes, activation='softmax'))
#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,
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),
callbacks=[self.stopcallback])
score = model.evaluate(x_test, y_test, verbose=0)
ue.log("mnist keras cnn training complete.")
ue.log('Test loss:' + str(score[0]))
ue.log('Test accuracy:' + str(score[1]))
self.session = K.get_session()
self.model = model
stored = {'model':model, 'session': self.session}
#run a test evaluation
ue.log(x_test.shape)
result_test = model.predict(np.reshape(x_test[500],(1,28,28,1)))
ue.log(result_test)
#flush the architecture model data to disk
#with open(model_json_path, "w") as json_file:
# json_file.write(model.to_json())
#flush the whole model and weights to disk
#saver = tf.train.Saver()
#save_path = saver.save(K.get_session(), model_sess_path)
#model.save(model_path)
return stored
def create_model(learning_rate, num_dense_layers, num_dense_nodes, activation):
"""
Hyper-parameters:
learning_rate: Learning-rate for the optimizer.
num_dense_layers: Number of dense layers.
num_dense_nodes: Number of nodes in each dense layer.
activation: Activation function for all layers.
"""
# Start construction of a Keras Sequential model.
model = Sequential()
# Add an input layer which is similar to a feed_dict in TensorFlow.
# Note that the input-shape must be a tuple containing the image-size.
model.add(InputLayer(input_shape=(img_size_flat, )))
# The input from MNIST is a flattened array with 784 elements,
# but the convolutional layers expect images with shape (28, 28, 1)
model.add(Reshape(img_shape_full))
# First convolutional layer.
# There are many hyper-parameters in this layer, but we only
# want to optimize the activation-function in this example.
model.add(
Conv2D(kernel_size=5,
strides=1,
filters=16,
padding='same',
activation=activation,
name='layer_conv1'))
model.add(MaxPooling2D(pool_size=2, strides=2))
# Second convolutional layer.
# Again, we only want to optimize the activation-function here.
model.add(
Conv2D(kernel_size=5,
strides=1,
filters=36,
padding='same',
activation=activation,
name='layer_conv2'))
model.add(MaxPooling2D(pool_size=2, strides=2))
# Flatten the 4-rank output of the convolutional layers
# to 2-rank that can be input to a fully-connected / dense layer.
model.add(Flatten())
# Add fully-connected / dense layers.
# The number of layers is a hyper-parameter we want to optimize.
for i in range(num_dense_layers):
# Name of the layer. This is not really necessary
# because Keras should give them unique names.
name = 'layer_dense_{0}'.format(i + 1)
# Add the dense / fully-connected layer to the model.
# This has two hyper-parameters we want to optimize:
# The number of nodes and the activation function.
model.add(Dense(num_dense_nodes, activation=activation, name=name))
# Last fully-connected / dense layer with softmax-activation
# for use in classification.
model.add(Dense(num_classes, activation='softmax'))
# Use the Adam method for training the network.
# We want to find the best learning-rate for the Adam method.
optimizer = Adam(lr=learning_rate)
# In Keras we need to compile the model so it can be trained.
model.compile(optimizer=optimizer,
loss='categorical_crossentropy',
metrics=['accuracy'])
return model
altura, longitud = 100, 100
batch_size = 32
#pasos=1000
pasos = 1000
#pasos_validacion=200
pasos_validacion = 100
filtrosConv1 = 32
filtrosConv2 = 64
filtrosConv3 = 128
tamano_filtro1 = (3, 3)
tamano_filtro2 = (2, 2)
tamano_pool = (2, 2)
clases = 11
lr = 0.0005
cnn = Sequential()
cnn.add(
Convolution2D(filtrosConv1,
tamano_filtro1,
padding='same',
input_shape=(altura, longitud, 3),
activation='relu'))
cnn.add(MaxPooling2D(pool_size=tamano_pool))
cnn.add(
Convolution2D(filtrosConv2,
tamano_filtro2,
padding='same',
activation='relu'))
cnn.add(MaxPooling2D(pool_size=tamano_pool))
"""
Transfer learning using resnet50 without its final layer.Using sequential model.
Adding new top layer and only training this layer.
Problem: Model cannot be saved and reloaded.
"""
from tensorflow.python.keras.applications import ResNet50
from tensorflow.python.keras.models import Sequential
from tensorflow.python.keras.layers import Dense, Flatten, GlobalAveragePooling2D
num_classes = 10
resnet_weights_path = 'C://Users//kimar//Google Drev//Python programmer//Kaggle//DeepLearningTrack//Dog_Breed//data//resnet50_weights_tf_dim_ordering_tf_kernels_notop.h5'
my_new_model = Sequential()
my_new_model.add(
ResNet50(include_top=False, pooling='avg', weights=resnet_weights_path))
my_new_model.add(Dense(num_classes, activation='softmax'))
# Say not to train first layer (ResNet) model. It is already trained
my_new_model.layers[0].trainable = False
#my_new_model.compile(optimizer='sgd', loss='categorical_crossentropy', metrics=['accuracy'])
my_new_model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
my_new_model.summary()
input("")
# Fit model
def train_top_model_vgg():
# VGG16 generators
# Set up generators
train_batches = ImageDataGenerator(
preprocessing_function= \
applications.vgg16.preprocess_input).flow_from_directory(
train_path,
target_size=(image_size, image_size),
batch_size=train_batch_size)
valid_batches = ImageDataGenerator(
preprocessing_function= \
applications.vgg16.preprocess_input).flow_from_directory(
valid_path,
target_size=(image_size, image_size),
batch_size=val_batch_size)
test_batches = ImageDataGenerator(
preprocessing_function= \
applications.vgg16.preprocess_input).flow_from_directory(
test_path,
target_size=(image_size, image_size),
batch_size=test_batch_size,
shuffle=False)
my_model = applications.VGG16(include_top=True, weights='imagenet')
initial_model = Sequential()
for layer in my_model.layers[:22]:
initial_model.add(layer)
initial_model.layers.pop()
initial_model.add(Dense(1024, activation='relu'))
initial_model.add(Dropout(0.5))
initial_model.add(Dense(7, activation="softmax"))
print(initial_model.summary())
# Define Top2 and Top3 Accuracy
def top_3_accuracy(y_true, y_pred):
return top_k_categorical_accuracy(y_true, y_pred, k=3)
def top_2_accuracy(y_true, y_pred):
return top_k_categorical_accuracy(y_true, y_pred, k=2)
initial_model.compile(optimizer=optimizers.SGD(lr=0.001, momentum=0.9, decay=0.0, nesterov=True),
loss="categorical_crossentropy",
metrics=[categorical_accuracy, top_2_accuracy, top_3_accuracy, "accuracy"])
filepath = "modelVGG.h5"
# Declare a checkpoint to save the best version of the model
checkpoint = ModelCheckpoint(filepath, monitor='val_categorical_accuracy', verbose=1,
save_best_only=True, mode='max')
# Reduce the learning rate as the learning stagnates
reduce_lr = ReduceLROnPlateau(monitor='val_categorical_accuracy', factor=0.5, patience=2,
verbose=1, mode='max', min_lr=0.00001)
early_stopping = EarlyStopping(monitor='val_categorical_accuracy', patience=5,
verbose=1, mode='max')
callbacks_list = [checkpoint, reduce_lr, early_stopping]
history = initial_model.fit_generator(
train_batches,
steps_per_epoch=train_steps,
epochs=epochs,
validation_data=valid_batches,
validation_steps=val_steps,
callbacks=callbacks_list)
try:
# summarize history for accuracy
plt.plot(history.history['acc'])
plt.plot(history.history['val_acc'])
plt.title('model accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train', 'test'], loc='upper left')
plt.savefig("VGG16_accuracy_training_plot.png")
# summarize history for loss
plt.plot(history.history['loss'])
plt.plot(history.history['val_loss'])
plt.title('model loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['train', 'test'], loc='upper left')
plt.savefig("VGG16_loss_training_plot.png")
except:
print("Error")
def VGG16(save_dir):
VGG16 = Sequential()
VGG16.add(
Conv2D(64, (3, 3),
strides=(1, 1),
input_shape=(224, 224, 3),
padding='same',
activation='relu',
kernel_initializer='uniform'))
VGG16.add(
Conv2D(64, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
kernel_initializer='uniform'))
VGG16.add(MaxPooling2D(pool_size=(2, 2)))
VGG16.add(
Conv2D(128, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
kernel_initializer='uniform'))
VGG16.add(
Conv2D(128, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
kernel_initializer='uniform'))
VGG16.add(MaxPooling2D(pool_size=(2, 2)))
VGG16.add(
Conv2D(256, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
kernel_initializer='uniform'))
VGG16.add(
Conv2D(256, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
kernel_initializer='uniform'))
VGG16.add(
Conv2D(256, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
kernel_initializer='uniform'))
VGG16.add(MaxPooling2D(pool_size=(2, 2)))
VGG16.add(
Conv2D(512, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
kernel_initializer='uniform'))
VGG16.add(
Conv2D(512, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
kernel_initializer='uniform'))
VGG16.add(
Conv2D(512, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
kernel_initializer='uniform'))
VGG16.add(MaxPooling2D(pool_size=(2, 2)))
VGG16.add(
Conv2D(512, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
kernel_initializer='uniform'))
VGG16.add(
Conv2D(512, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
kernel_initializer='uniform'))
VGG16.add(
Conv2D(512, (3, 3),
strides=(1, 1),
padding='same',
activation='relu',
kernel_initializer='uniform'))
VGG16.add(MaxPooling2D(pool_size=(2, 2)))
VGG16.add(Flatten())
VGG16.add(Dense(4096, activation='relu'))
VGG16.add(Dropout(0.5))
VGG16.add(Dense(4096, activation='relu'))
VGG16.add(Dropout(0.5))
VGG16.add(Dense(1000, activation='softmax'))
VGG16.compile(loss='categorical_crossentropy',
optimizer='sgd',
metrics=['accuracy'])
VGG16.summary()
save_dir += 'VGG16.h5'
return VGG16
def construct_model():
output_parameters()
model = Sequential()
# mask_zero 在 MaxPooling 层中不能支持
model.add(Embedding(creative_id_window, embedding_size, input_length=max_len))
if model_type == 'MLP':
model.add(Flatten())
model.add(Dense(8, activation='relu', kernel_regularizer=l2(0.001)))
model.add(Dropout(0.5))
model.add(Dense(4, activation='relu', kernel_regularizer=l2(0.001)))
model.add(Dropout(0.5))
elif model_type == 'Conv1D':
model.add(Conv1D(32, 7, activation='relu', kernel_regularizer=l2(0.001)))
model.add(Conv1D(32, 7, activation='relu', kernel_regularizer=l2(0.001)))
model.add(GlobalMaxPooling1D())
elif model_type == 'GlobalMaxPooling1D':
model.add(GlobalMaxPooling1D())
elif model_type == 'GlobalMaxPooling1D+MLP':
model.add(GlobalMaxPooling1D())
model.add(Dropout(0.5))
model.add(Dense(embedding_size, kernel_regularizer=l2(0.001)))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(embedding_size, kernel_regularizer=l2(0.001)))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(embedding_size // 2, kernel_regularizer=l2(0.001)))
model.add(BatchNormalization())
model.add(Activation('softmax'))
model.add(Dropout(0.5))
model.add(Dense(embedding_size // 2, kernel_regularizer=l2(0.001)))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(embedding_size // 2, kernel_regularizer=l2(0.001)))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(embedding_size // 4, kernel_regularizer=l2(0.001)))
model.add(BatchNormalization())
model.add(Activation('softmax'))
model.add(Dropout(0.5))
model.add(Dense(embedding_size // 4, kernel_regularizer=l2(0.001)))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(embedding_size // 4, kernel_regularizer=l2(0.001)))
model.add(BatchNormalization())
model.add(Activation('relu'))
elif model_type == 'GRU+MLP':
model.add(GRU(embedding_size, dropout=0.5, recurrent_dropout=0.5))
model.add(Dropout(0.5))
model.add(Dense(embedding_size, kernel_regularizer=l2(0.001)))
model.add(BatchNormalization())
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(embedding_size, kernel_regularizer=l2(0.001)))
model.add(BatchNormalization())
model.add(Activation('relu'))
elif model_type == 'GRU':
model.add(GRU(embedding_size, dropout=0.2, recurrent_dropout=0.2))
# model.add(LSTM(128, dropout = 0.5, recurrent_dropout = 0.5))
elif model_type == 'Conv1D+LSTM':
model.add(Conv1D(32, 5, activation='relu', kernel_regularizer=l2(0.001)))
model.add(Conv1D(32, 5, activation='relu', kernel_regularizer=l2(0.001)))
model.add(LSTM(16, dropout=0.5, recurrent_dropout=0.5))
elif model_type == 'Bidirectional-LSTM':
model.add(Bidirectional(LSTM(embedding_size, dropout=0.2, recurrent_dropout=0.2)))
else:
raise Exception("错误的网络模型类型")
if label_name == "age":
model.add(Dropout(0.5))
model.add(Dense(10, kernel_regularizer=l2(0.001)))
model.add(BatchNormalization())
model.add(Activation('softmax'))
# model.add(Dense(10, activation = 'softmax', kernel_regularizer = l2(0.001)))
print("%s——模型构建完成！" % model_type)
print("* 编译模型")
# Keras 好像不能支持 report_tensor_allocations_upon_oom
# 运行时会 Python 会报错：Process finished with exit code -1073741819 (0xC0000005)
model.compile(optimizer=optimizers.RMSprop(lr=RMSProp_lr),
loss=losses.sparse_categorical_crossentropy,
metrics=[metrics.sparse_categorical_accuracy])
elif label_name == 'gender':
# model.add(Dropout(0.5))
# model.add(Dense(1, kernel_regularizer = l2(0.001)))
# model.add(BatchNormalization())
# model.add(Activation('sigmoid'))
model.add(Dense(1, activation='sigmoid', kernel_regularizer=l2(0.001)))
print("%s——模型构建完成！" % model_type)
print("* 编译模型")
model.compile(optimizer=optimizers.RMSprop(lr=RMSProp_lr),
loss=losses.binary_crossentropy,
metrics=[metrics.binary_accuracy])
else:
raise Exception("错误的标签类型！")
return model
