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(
