def test_res_net(self):
if config.x64_enabled:
raise unittest.SkipTest(
"ResNet test fails on JAX when X64 is enabled")
key = jax.random.PRNGKey(0)
shape = (224, 224, 3, 1)
init_fn, apply_fn = resnet50.ResNet50(1000)
_, params = init_fn(key, shape)
infer = functools.partial(apply_fn, params)
images = np.array(jax.random.normal(key, shape))
self.ConvertAndCompare(
infer,
images,
limitations=[
# TODO: these are some very high tolerances. Revisit once we fix
# convolutions?
jax2tf_limitations.custom_numeric(tol=0.1,
devices="tpu",
modes=("eager", "graph",
"compiled")),
jax2tf_limitations.custom_numeric(tol=1e-5,
devices="cpu",
modes=("eager", "graph",
"compiled")),
])
def test_res_net(self):
key = jax.random.PRNGKey(0)
shape = (224, 224, 3, 1)
init_fn, apply_fn = resnet50.ResNet50(1000)
_, params = init_fn(key, shape)
infer = functools.partial(apply_fn, params)
images = np.array(jax.random.normal(key, shape))
self.ConvertAndCompare(infer, images, rtol=0.5)
def test_res_net(self):
key = jax.random.PRNGKey(0)
shape = (224, 224, 3, 1)
init_fn, apply_fn = resnet50.ResNet50(1000)
_, params = init_fn(key, shape)
infer = functools.partial(apply_fn, params)
images = np.array(jax.random.normal(key, shape))
np.testing.assert_allclose(infer(images),
jax_to_tf.convert(infer)(images),
rtol=0.5)
def test_res_net(self):
if config.FLAGS.jax_enable_x64:
raise unittest.SkipTest(
"ResNet test fails on JAX when X64 is enabled")
key = jax.random.PRNGKey(0)
shape = (224, 224, 3, 1)
init_fn, apply_fn = resnet50.ResNet50(1000)
_, params = init_fn(key, shape)
infer = functools.partial(apply_fn, params)
images = np.array(jax.random.normal(key, shape))
self.ConvertAndCompare(infer, images, rtol=0.5)
def _test_train(self, execution_mode=None):
start = time.process_time()
device, data_format = device_and_data_format()
model = resnet50.ResNet50(data_format)
for i in range(10):
with tf.device(device), context.execution_mode(execution_mode):
optimizer = tf.keras.optimizers.SGD(0.1)
images, labels = random_batch(32, data_format)
apply_gradients(model, optimizer,
compute_gradients(model, images, labels))
context.async_wait()
end = time.process_time()
print("time: ", end - start)
def test_res_net(self):
if config.x64_enabled:
raise unittest.SkipTest(
"ResNet test fails on JAX when X64 is enabled")
key = jax.random.PRNGKey(0)
shape = (224, 224, 3, 1)
init_fn, apply_fn = resnet50.ResNet50(1000)
_, params = init_fn(key, shape)
infer = functools.partial(apply_fn, params)
images = np.array(jax.random.normal(key, shape))
self.ConvertAndCompare(
infer,
images,
limitations=[jax2tf_limitations.custom_numeric(tol=0.5)])
def resnet50classifier(img_dim, n_classes, wd):
drop = 0.5
model_name = "resnet"
_input = Input(shape=img_dim, name="classificator_input")
ResNet = resnet50.ResNet50(_input, Shape=img_dim, weights='imagenet')
make_trainable(ResNet, False)
x = Dropout(drop)(ResNet.output)
out = Dense(n_classes,
activation='softmax',
init="he_normal",
name='fc',
W_regularizer=l2(wd))(x)
resnet_model = Model(input=_input, output=out, name=model_name)
visualize_model(resnet_model)
return resnet_model
def build_resnet(images, labels):
# Graph building
myresnet = resnet50.ResNet50("channels_last",
classes=num_classes) # trainable=False)
logits = myresnet(images)
softmax = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=labels,
logits=logits)
loss = tf.reduce_mean(softmax, name="loss")
gradients = tf.train.GradientDescentOptimizer(
learning_rate).compute_gradients(loss)
gradient_tensors = []
for tup in gradients:
gradient_tensors.append(tup[0])
update_op = tf.train.GradientDescentOptimizer(
learning_rate).apply_gradients(gradients)
return logits, update_op
def vggvox_model_init(already_saved):
#New version for both establishing or loading model
if(already_saved = False):
os.environ['CUDA_VISIBLE_DEVICES'] = '3'
input_shape = Input((512, None, 1), name='input')
print('Start initializing model ...')
vggvox_celeb2 = res.ResNet50(input_shape)
vggvox_celeb2.summary()
print('Start loading weights ...')
vggvox_celeb2 = res.give_weight(vggvox_celeb2)
print('Finished establishing VGGVox_celeb2 model')
vggvox_celeb2.save('vggvox_celeb2.h5')
print('Model saved as vggvox_celeb2.h5')
if (already_saved = True):
vggvox_celeb2 = load_model('vggvox_celeb2.h5')
return vggvox_celeb2
def get_unet_resnet50(input_shape,
inputs,
retrain=True,
with_bottleneck=False,
renorm=False):
base_model = resnet50.ResNet50(input_shape=input_shape,
input_tensor=inputs,
include_top=False,
weights='imagenet',
renorm=renorm)
for i, layer in enumerate(base_model.layers):
layer.trainable = retrain
conv1 = base_model.get_layer("activation").output
conv2 = base_model.get_layer("activation_9").output
conv3 = base_model.get_layer("activation_21").output
conv4 = base_model.get_layer("activation_39").output
conv5 = base_model.get_layer("activation_48").output
up6 = concatenate([UpSampling2D()(conv5), conv4], axis=-1)
conv6 = conv_block_simple(up6, 256, "conv6_1", renorm=renorm)
conv6 = conv_block_simple(conv6, 256, "conv6_2", renorm=renorm)
up7 = concatenate([UpSampling2D()(conv6), conv3], axis=-1)
conv7 = conv_block_simple(up7, 192, "conv7_1", renorm=renorm)
conv7 = conv_block_simple(conv7, 192, "conv7_2", renorm=renorm)
up8 = concatenate([UpSampling2D()(conv7), conv2], axis=-1)
conv8 = conv_block_simple(up8, 128, "conv8_1", renorm=renorm)
conv8 = conv_block_simple(conv8, 128, "conv8_2", renorm=renorm)
up9 = concatenate([UpSampling2D()(conv8), conv1], axis=-1)
conv9 = conv_block_simple(up9, 64, "conv9_1", renorm=renorm)
conv9 = conv_block_simple(conv9, 64, "conv9_2", renorm=renorm)
up10 = concatenate([UpSampling2D()(conv9), base_model.input], axis=-1)
conv10 = conv_block_simple(up10, 32, "conv10_1", renorm=renorm)
conv10 = conv_block_simple(conv10, 32, "conv10_2", renorm=renorm)
if not with_bottleneck:
return conv10
else:
return conv10, conv5
def main(argv):
if len(argv) > 1:
raise app.UsageError("Too many command-line arguments.")
init_fn, apply_fn = resnet50.ResNet50(1000)
# Initialize the network.
rng = jax.random.PRNGKey(42)
input_shape = (224, 224, 3, 1)
_, params = init_fn(rng, input_shape)
# Check our JAX model.
# Note: We expect 161 parameters here but stax does not support optional bias
# in conv so we have 53 additional biases.
assert len(jax.tree_leaves(params)) == 214
# We can use JaxModule to wrap our STAX network in TensorFlow.
mod = StaxModule(apply_fn, params)
assert len(mod.trainable_variables) == 214
assert mod(tf.ones(input_shape)).shape == (1, 1000)
def load_full_model(model_name,
random_weights=False,
no_cats=2,
weight_decay=0,
activation='softmax'):
"""
Loads a model with a randomly initialized last layer
model_name: ResNet50, VGG19
random_weights: Random weights or ImageNet pre-training
no_cats: Number of outputs
weight decay: L2 weight decay for all layers
activation: Activation of the final layer (None, softmax, sigmoid)
"""
input_tensor = keras.layers.Input(shape=(224, 224, 3))
if random_weights:
weights = None
else:
weights = 'imagenet'
if model_name == 'ResNet50':
full_model = resnet50.ResNet50(weights=weights,
input_tensor=input_tensor,
weight_decay=weight_decay,
no_cats=no_cats,
activation=activation)
elif model_name == 'VGG19':
full_model = vgg19.VGG19(weights=weights,
input_tensor=input_tensor,
weight_decay=weight_decay,
no_cats=no_cats,
activation=activation)
else:
raise ValueError('Invalid model_name')
return full_model
def build_model():
"""
Builds a distance metric model using ResNet50 as a base.
Returns:
keras.Model, distance metric model.
"""
# Get base model, with classification layer removed
base_model = resnet50.ResNet50(weights=None)
shared_model = Model(
input=base_model.input,
output=base_model.get_layer('flatten_1').output,
)
# Append layers to create a 128-dim embedding
dummy_input = Input(shape=shared_model.input_shape[1:], name='dummy')
modified_model = shared_model(dummy_input)
fc = Dense(128, activation='relu', name='fc_l2')(modified_model)
l2 = Lambda(lambda x: K.l2_normalize(x, -1), name='l2_norm')(fc)
shared_model = Model(dummy_input, l2)
# Make shared across inputs
input_anc = Input(shape=shared_model.input_shape[1:], name='input_anc')
input_pos = Input(shape=shared_model.input_shape[1:], name='input_pos')
input_neg = Input(shape=shared_model.input_shape[1:], name='input_neg')
model_anc = shared_model(input_anc)
model_pos = shared_model(input_pos)
model_neg = shared_model(input_neg)
model = Model(
input=[input_anc, input_pos, input_neg],
output=[model_anc, model_pos, model_neg],
)
# Perform triplet loss function in merge layer
d = lambda x, y: K.sum(K.square(x - y), axis=-1)
loss = lambda x: K.clip(
d(x[0], x[1]) - d(x[0], x[2]) + 0.2, 0, float('inf'))
merged = merge([model_anc, model_pos, model_neg],
mode=loss,
output_shape=(1, ))
# Build the final model
model = Model(
input=[input_anc, input_pos, input_neg],
output=merged,
)
adagrad = Adagrad(lr=0.05)
# Ignore y_true in loss - labels are implicit in the inputs
model.compile(optimizer=adagrad, loss=lambda y_true, y_pred: y_pred)
return model
def main():
parser = argparse.ArgumentParser(
description='Learning convnet from ILSVRC2012 dataset')
parser.add_argument('train', help='Path to training image-label list file')
parser.add_argument('val', help='Path to validation image-label list file')
parser.add_argument('--batchsize',
'-B',
type=int,
default=32,
help='Learning minibatch size')
parser.add_argument('--epoch',
'-E',
type=int,
default=10,
help='Number of epochs to train')
parser.add_argument(
'--iteration',
'-I',
type=int,
default=None,
help='Number of iterations to train. Epoch is ignored if specified.')
parser.add_argument('--loaderjob',
'-j',
type=int,
help='Number of parallel data loading processes')
parser.add_argument('--mean',
'-m',
default='mean.npy',
help='Mean file (computed by compute_mean.py)')
parser.add_argument('--root',
'-R',
default='.',
help='Root directory path of image files')
parser.add_argument('--val_batchsize',
'-b',
type=int,
default=250,
help='Validation minibatch size')
parser.set_defaults(test=False)
parser.add_argument('--device',
'-d',
default='native',
help='Device to use')
args = parser.parse_args()
chx.set_default_device(args.device)
batch_size = args.batchsize
eval_size = args.val_batchsize
# Prepare model
model = resnet50.ResNet50()
# Prepare datasets and mean file
mean = np.load(args.mean)
train = PreprocessedDataset(args.train, args.root, mean, model.insize)
test = PreprocessedDataset(args.val, args.root, mean, model.insize, False)
train_iter = chainer.iterators.MultiprocessIterator(
train, batch_size, n_processes=args.loaderjob)
test_iter = chainer.iterators.MultiprocessIterator(
test, eval_size, n_processes=args.loaderjob)
N = len(train)
# Train
model.require_grad()
it = 0
epoch = 0
is_finished = False
start = time.time()
while not is_finished:
for i in range(0, N // batch_size):
x, t = get_imagenet(train_iter)
y = model(x)
loss = compute_loss(y, t)
loss.backward()
model.update(lr=0.01)
it += 1
if args.iteration is not None:
x_test, t_test = get_imagenet(test_iter)
mean_loss, accuracy = evaluate(model, x_test, t_test,
eval_size, batch_size)
elapsed_time = time.time() - start
print(
'iteration {}... loss={},\taccuracy={},\telapsed_time={}'.
format(it, mean_loss, accuracy, elapsed_time))
if it >= args.iteration:
is_finished = True
break
epoch += 1
if args.iteration is None:
x_test, t_test = get_imagenet(test_iter)
mean_loss, accuracy = evaluate(model, x_test, t_test, eval_size,
batch_size)
elapsed_time = time.time() - start
print('epoch {}... loss={},\taccuracy={},\telapsed_time={}'.format(
epoch, mean_loss, accuracy, elapsed_time))
if epoch >= args.epoch:
is_finished = True
imgList = [
join(path1, f) for f in listdir(path1)
if isfile(join(path1, f)) and "png" in f
]
imgList = natural_sort(imgList)
print("Images: " + str(len(imgList)))
return imgList
#carpeta con tu dataset
pathToTest = str(args.path)
# instancias la red (copiar lo que tienes)
model = resnet50.ResNet50()
optimize = rmsprop(lr=0.0001)
#model = ResNet50(weights='imagenet', include_top=False)
#model.load_weights("/home/ed/Desktop/knn-test/ep_22.hdf5")
model.load_weights(
"/home/rovit01/Escritorio/sequences_cat3/resnet50/Base/snapsep_194.hdf5")
#model.summary()
model.summary()
#model.layers.pop()
model.layers.pop()
model.outputs = [model.layers[-1].output]
# added this line in addition to zo7 solution
model.output_layers = [model.layers[-1]]
from keras.preprocessing.image import ImageDataGenerator
import numpy as np
from keras.models import Model
from keras.preprocessing import image as keras_image
import os, sys
model_path = os.path.join('..', 'models', 'keras', 'models')
sys.path.append(model_path)
import resnet50
weights_path = 'weights_resnet50.h5'
weights_path = os.path.abspath(weights_path)
model = resnet50.ResNet50(weights_path=weights_path)
model.compile(loss='categorical_crossentropy',
optimizer='rmsprop',
metrics=['accuracy'])
# this is the augmentation configuration we will use for training
train_datagen = ImageDataGenerator(rescale=1. / 255,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
# this is the augmentation configuration we will use for testing:
# only rescaling
test_datagen = ImageDataGenerator(rescale=1. / 255)
# this is a generator that will read pictures found in
def build_encoder(is_discriminator=False, pooling=None, **params):
thought_vector_size = params['thought_vector_size']
pretrained_encoder = params['pretrained_encoder']
img_width = params['img_width']
cgru_size = params['csr_size']
cgru_layers = params['csr_layers']
include_top = False
LEARNABLE_CNN_LAYERS = 1
input_shape = (img_width, img_width, IMG_CHANNELS)
input_img = layers.Input(shape=input_shape)
if pretrained_encoder:
if pretrained_encoder == 'vgg16':
cnn = applications.vgg16.VGG16(input_tensor=input_img,
include_top=include_top)
elif pretrained_encoder == 'resnet50':
# Note: This is a hacked version of resnet50 with pooling removed
cnn = resnet50.ResNet50(include_top=include_top, pooling=pooling)
for layer in cnn.layers[:-LEARNABLE_CNN_LAYERS]:
layer.trainable = False
x = cnn(input_img)
else:
x = layers.Conv2D(64, (3, 3), padding='same')(input_img)
if not is_discriminator:
x = layers.BatchNormalization()(x)
x = layers.LeakyReLU()(x)
x = layers.MaxPooling2D()(x)
x = layers.Conv2D(128, (3, 3), padding='same')(x)
if not is_discriminator:
x = layers.BatchNormalization()(x)
x = layers.LeakyReLU()(x)
if cgru_layers >= 1:
x = QuadCSR(cgru_size)(x)
else:
x = layers.Conv2D(cgru_size * 3 / 2, (3, 3), padding='same')(x)
x = layers.LeakyReLU()(x)
x = layers.MaxPooling2D()(x)
x = layers.Conv2D(256, (3, 3), padding='same')(x)
if not is_discriminator:
x = layers.BatchNormalization()(x)
x = layers.LeakyReLU()(x)
x = layers.MaxPooling2D()(x)
x = layers.Conv2D(384, (3, 3), padding='same')(x)
if not is_discriminator:
x = layers.BatchNormalization()(x)
x = layers.Activation(LeakyReLU())(x)
x = layers.Conv2D(384, (3, 3), padding='same')(x)
if not is_discriminator:
x = layers.BatchNormalization()(x)
x = layers.LeakyReLU()(x)
x = layers.MaxPooling2D()(x)
if not pooling:
x = layers.Flatten()(x)
if is_discriminator:
x = layers.Dense(1)(x)
x = layers.Activation('tanh')(x)
else:
x = layers.Dense(thought_vector_size)(x)
x = layers.BatchNormalization()(x)
return models.Model(inputs=[input_img], outputs=x)
for concept in correct:
correct_skipgram.append(skipgram[concept])
correct_skipgram_vector = np.array(correct_skipgram)
#Now we have the correct skipgram vectors
print("Done with correct Skipgram vector and its shape is: ",
correct_skipgram_vector.shape)
incorrect = []
misclassified_word = []
for item in predictions:
incorrect.append(item)
misclassified_word.append(predictions[item][0])
#We need to get the activations for the Correct words as well
#Get the activations for incorrect
model = resnet50.ResNet50(include_top=True, weights='imagenet')
layer = str(sys.argv[1])
print("The passed layer is: ", layer)
correct_cnn_vector = []
for i in range(len(paths)):
if vocab[i] not in correct:
continue
vec = get_act_vector(paths[i], model, layer)[0]
vec = vec.flatten()
vec = vec.tolist()
correct_cnn_vector.append(vec)
correct_cnn_vector = np.array(correct_cnn_vector)
print("Done with correct CNN vector activations and its shape is: ",
correct_cnn_vector.shape)
(octave_index, img_width, img_height))
if octave_index > 0:
# upscale details from the previous octave
detail_height, detail_width = detail.shape[:2]
# detail = scipy.ndimage.zoom(detail, (1.0/octave_scale, 1.0/octave_scale, 1), order=1)
print('resizing detail from %s to %s' %
(detail.shape, octave_base.shape))
detail = imresize(detail, octave_base.shape[:2])
x = preprocess_image(octave_base + detail)
dream = Input(shape=(3, img_shape[0], img_shape[1]))
if args.model == 'resnet50':
model = resnet50.ResNet50(include_top=False, input_tensor=dream)
elif args.model == 'vgg16':
model = vgg16.VGG16(include_top=False, input_tensor=dream)
elif args.model == 'vgg19':
model = vgg19.VGG19(include_top=False, input_tensor=dream)
elif args.model == 'inception_v3':
model = inception_v3.InceptionV3(include_top=False, input_tensor=dream)
else:
raise 'unknown model ' + args.model
print('Model loaded.')
loss_and_grads = create_loss_function(dream, settings, model, img_shape)
evaluator = Evaluator(loss_and_grads)
# run scipy-based optimization (L-BFGS) over the pixels of the generated image
# so as to minimize the loss
def main():
archs = {
'alex': alex.Alex,
'alex_fp16': alex.AlexFp16,
'googlenet': googlenet.GoogLeNet,
'googlenetbn': googlenetbn.GoogLeNetBN,
'googlenetbn_fp16': googlenetbn.GoogLeNetBNFp16,
'nin': nin.NIN,
'resnet50': resnet50.ResNet50,
'resnext50': resnet50.ResNeXt50,
}
parser = argparse.ArgumentParser(
description='Learning convnet from ILSVRC2012 dataset')
parser.add_argument('train', help='Path to training image-label list file')
parser.add_argument('val', help='Path to validation image-label list file')
parser.add_argument('--arch',
'-a',
choices=archs.keys(),
default='nin',
help='Convnet architecture')
parser.add_argument('--batchsize',
'-B',
type=int,
default=32,
help='Learning minibatch size')
parser.add_argument('--epoch',
'-E',
type=int,
default=10,
help='Number of epochs to train')
parser.add_argument('--gpus',
'-g',
type=int,
nargs="*",
default=[0, 1, 2, 3])
parser.add_argument('--initmodel',
help='Initialize the model from given file')
parser.add_argument('--loaderjob',
'-j',
type=int,
help='Number of parallel data loading processes')
parser.add_argument('--mean',
'-m',
default='mean.npy',
help='Mean file (computed by compute_mean.py)')
parser.add_argument('--resume',
'-r',
default='',
help='Initialize the trainer from given file')
parser.add_argument('--out',
'-o',
default='result',
help='Output directory')
parser.add_argument('--root',
'-R',
default='.',
help='Root directory path of image files')
parser.add_argument('--val_batchsize',
'-b',
type=int,
default=250,
help='Validation minibatch size')
parser.add_argument('--test', action='store_true')
### Synthetic
parser.add_argument('--dataset',
choices=['real', 'synthetic'],
default='real')
parser.add_argument('--samples', type=int, default=1000)
###
parser.set_defaults(test=False)
args = parser.parse_args()
# Initialize the model to train
model = archs[args.arch]()
if args.initmodel:
print('Load model from', args.initmodel)
chainer.serializers.load_npz(args.initmodel, model)
### Synthetic
MODELS = {'resnet50': ((3, 224, 224), 1000, lambda: resnet50.ResNet50())}
model_shape, num_classes, model_fn = MODELS[args.arch]
dataset_shape = (args.samples, ) + model_shape
model = model_fn()
if args.dataset is 'real':
# Load the datasets and mean file
mean = np.load(args.mean)
train = train_imagenet.PreprocessedDataset(args.train, args.root, mean,
model.insize)
val = train_imagenet.PreprocessedDataset(args.val, args.root, mean,
model.insize, False)
else:
train = dataset.SyntheticDataset(dataset_shape, num_classes)
###
# These iterators load the images with subprocesses running in parallel to
# the training/validation.
devices = tuple(args.gpus)
train_iters = [
chainer.iterators.MultiprocessIterator(i,
args.batchsize,
n_processes=args.loaderjob)
for i in chainer.datasets.split_dataset_n_random(train, len(devices))
]
### Synthetic
if args.dataset is 'real':
val_iter = chainer.iterators.MultiprocessIterator(
val, args.val_batchsize, repeat=False, n_processes=args.loaderjob)
####
# Set up an optimizer
optimizer = chainer.optimizers.MomentumSGD(lr=0.01, momentum=0.9)
optimizer.setup(model)
# Set up a trainer
updater = updaters.MultiprocessParallelUpdater(train_iters,
optimizer,
devices=devices)
trainer = training.Trainer(updater, (args.epoch, 'epoch'), args.out)
if args.test:
val_interval = 5, 'epoch'
log_interval = 1, 'epoch'
else:
val_interval = 100000, 'iteration'
log_interval = 1000, 'iteration'
### Synthetic
if args.dataset is 'real':
trainer.extend(extensions.Evaluator(val_iter,
model,
device=args.gpus[0]),
trigger=val_interval)
###
trainer.extend(extensions.dump_graph('main/loss'))
trainer.extend(extensions.snapshot(), trigger=val_interval)
trainer.extend(extensions.snapshot_object(
model, 'model_iter_{.updater.iteration}'),
trigger=val_interval)
# Be careful to pass the interval directly to LogReport
# (it determines when to emit log rather than when to read observations)
trainer.extend(extensions.LogReport(trigger=log_interval))
trainer.extend(extensions.observe_lr(), trigger=log_interval)
trainer.extend(extensions.PrintReport([
'epoch', 'iteration', 'main/loss', 'validation/main/loss',
'main/accuracy', 'validation/main/accuracy', 'lr'
]),
trigger=log_interval)
#trainer.extend(extensions.ProgressBar(update_interval=2))
trainer.extend(
report.MetricsReport(parallelism=len(args.gpus),
dataset_length=len(train)))
if args.resume:
chainer.serializers.load_npz(args.resume, trainer)
trainer.run()
def ResNet50(*args, **kwargs):
return resnet50.ResNet50(*args, **kwargs)
from keras.callbacks import TensorBoard
import keras
import numpy as np
import resnet50
import time
from keras.models import Model
X = np.ones((4, 100, 100, 3))
y = np.ones((4, 1000))
inputs = keras.layers.Input(shape=(None, None, 3))
model = resnet50.ResNet50(inputs)
model_name = "kaggle_cat_dog-cnn-64x2-{}".format(int(time.time()))
tensorboard = TensorBoard(log_dir='logs/{}'.format(model_name))
model.compile(loss='mse', optimizer='adam', metrics=['accuracy'])
model.fit(X, y, batch_size=4, epochs=10, callbacks=[tensorboard])
"""
查看某层的输出
"""
# layer_model = Model(inputs=model.input,
# outputs=model.get_layer('padding_conv1').output)
#
# #以这个model的预测值作为输出
# output = layer_model.predict(X)
# print(output.shape)
