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)