def test_conv2d_transpose(img_size, filter_size): print("Transpose convolution test for img_size={}, filter_size={}:".format(img_size, filter_size)) x = (np.arange(img_size ** 2, dtype=np.float32) + 1).reshape((1, img_size, img_size, 1)) f = (np.ones(filter_size ** 2, dtype=np.float32)).reshape((filter_size, filter_size, 1, 1)) s = reset_tf_session() conv = tf.nn.conv2d_transpose(x, f, output_shape=(1, img_size * 2, img_size * 2, 1), strides=[1, 2, 2, 1], padding='SAME') result = s.run(conv) print("input:") print(x[0, :, :, 0]) print("filter:") print(f[:, :, 0, 0]) print("output:") print(result[0, :, :, 0]) s.close()
# Flatten model.add(Flatten()) # FC model.add(Dense(256, name='fc1')) model.add(Dropout(0.5, noise_shape=None, seed=0)) # FC model.add(Dense(NUM_CLASSES)) # the last layer with neuron for each class model.add(Activation("softmax")) # output probabilities return model # describe model s = reset_tf_session() # clear default graph model = make_model() model.summary() ## GRADED PART, DO NOT CHANGE! # Number of model parameters grader.set_answer("7W4tu", grading_utils.model_total_params(model)) # you can make submission with answers so far to check yourself at this stage grader.submit(COURSERA_EMAIL, COURSERA_TOKEN) """# Train model Training of your model can take approx. 4-8 minutes per epoch. During training you should observe the decrease in reported loss on training and validation. If the loss on training is not decreasing with epochs you should revise your model definition and learning rate. """
# # Defining a recurrent neural network # # We can rewrite recurrent neural network as a consecutive application of dense layer to input $x_t$ and previous rnn state $h_t$. This is exactly what we're gonna do now. # <img src="./rnn.png" width=600> # # Since we're training a language model, there should also be: # * An embedding layer that converts character id x_t to a vector. # * An output layer that predicts probabilities of next phoneme based on h_t+1 # In[11]: # remember to reset your session if you change your graph! s = keras_utils.reset_tf_session() # In[13]: import keras from keras.layers import concatenate, Dense, Embedding rnn_num_units = 64 # size of hidden state embedding_size = 16 # for characters # Let's create layers for our recurrent network # Note: we create layers but we don't "apply" them yet (this is a "functional API" of Keras) # Note: set the correct activation (from keras.activations) to Dense layers!
encoder = keras.models.Sequential() encoder.add(L.InputLayer(img_shape)) encoder.add(L.Flatten()) #flatten image to vector encoder.add(L.Dense(code_size)) #actual encoder decoder = keras.models.Sequential() decoder.add(L.InputLayer((code_size,))) decoder.add(L.Dense(np.prod(img_shape))) #actual decoder, height*width*3 units decoder.add(L.Reshape(img_shape)) #un-flatten return encoder,decoder """Meld them together into one model:""" s = reset_tf_session() encoder, decoder = build_pca_autoencoder(IMG_SHAPE, code_size=32) inp = L.Input(IMG_SHAPE) code = encoder(inp) reconstruction = decoder(code) autoencoder = keras.models.Model(inputs=inp, outputs=reconstruction) autoencoder.compile(optimizer='adamax', loss='mse') autoencoder.fit(x=X_train, y=X_train, epochs=15, validation_data=[X_test, X_test], callbacks=[keras_utils.TqdmProgressCallback()], verbose=0)
IMG_SIZE = 299 # we take the last hidden layer of IncetionV3 as an image embedding def get_cnn_encoder(): K.set_learning_phase(False) model = keras.applications.InceptionV3(include_top=False) preprocess_for_model = keras.applications.inception_v3.preprocess_input model = keras.models.Model( model.inputs, keras.layers.GlobalAveragePooling2D()(model.output)) return model, preprocess_for_model """Features extraction takes too much time on CPU: - Takes 16 minutes on GPU. - 25x slower (InceptionV3) on CPU and takes 7 hours. - 10x slower (MobileNet) on CPU and takes 3 hours. So we've done it for you with the following code: ```python # load pre-trained model reset_tf_session() encoder, preprocess_for_model = get_cnn_encoder() # extract train features train_img_embeds, train_img_fns = utils.apply_model( "train2014.zip", encoder, preprocess_for_model, input_shape=(IMG_SIZE, IMG_SIZE)) utils.save_pickle(train_img_embeds, "train_img_embeds.pickle") utils.save_pickle(train_img_fns, "train_img_fns.pickle") # extract validation features val_img_embeds, val_img_fns = utils.apply_model(