def main():
training_images, training_labels, test_images, test_labels = load_dataset()
# plt.imshow(training_images[:,:,0], cmap='gray')
# plt.show()
perm_train = np.random.permutation(training_labels.size)
training_labels = training_labels[perm_train]
training_images = training_images[perm_train, :, :] / 255.0
training_images = np.expand_dims(training_images, -1)
print(training_images.shape)
test_images = test_images / 255.0
test_images = np.expand_dims(test_images, -1)
# pdb.set_trace()
# training_labels = to_categorical(training_labels, NUM_CLASSES)
# test_labels = to_categorical(test_labels, NUM_CLASSES)
BATCH_SIZE = 32 * 8
WIDTH, HEIGHT = 28, 28
# Defiining the network
input_layer = Input(shape=(HEIGHT, WIDTH, 1), name='input_layer')
cnn1 = Conv2D(filters=32,
kernel_size=3,
strides=(1, 1),
padding='same',
activation='relu')(input_layer)
maxpool = MaxPooling2D(pool_size=2)(cnn1)
cnn2 = Conv2D(filters=32,
kernel_size=3,
strides=(1, 1),
padding='valid',
activation='relu')(maxpool)
maxpool = MaxPooling2D(pool_size=2)(cnn2)
flat = Flatten()(maxpool)
dense1 = Dense(units=128, activation='relu')(flat)
dropout = Dropout(.5)(dense1)
output_layer = Dense(units=NUM_CLASSES, activation='softmax')(dropout)
model = Model(inputs=input_layer, outputs=output_layer)
model.compile(optimizer=tf.train.AdamOptimizer(),
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
# pdb.set_trace()
print(model.summary())
model.fit(x=training_images,
y=training_labels,
batch_size=BATCH_SIZE,
epochs=30,
verbose=1,
validation_data=(test_images, test_labels))
accuracy = model.evaluate(x=test_images,
y=test_labels,
batch_size=BATCH_SIZE)
print('test score = {}'.format(accuracy))
x = Dropout(0.3)(x)
x = Conv2D(64, (8, 1), padding='same', use_bias=False)(inputs)
x = Conv2D(64, (8, 1), padding='same', use_bias=False, activation='relu')(x)
x = BatchNormalization(axis=1)(x)
x = Dropout(0.3)(x)
x = Conv2D(64, (1, 5), padding='valid', use_bias=False, activation='relu')(x)
x = Reshape((128, 64))(x)
x = Bidirectional(LSTM(20, dropout=0.2, return_sequences=False))(x)
#x = Flatten()(x)
x = Dense(256, use_bias=False, activation='relu')(x)
x = BatchNormalization(axis=-1)(x)
x = Dropout(0.5)(x)
logits = Dense(2, use_bias=False)(x)
model = Model(inputs=inputs, outputs=logits)
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])
model.summary()
history = model.fit(train,
train_label,
validation_split=2 / 7,
batch_size=batch_size,
epochs=epochs,
shuffle=True)
Important Tips:
Contemplating the following two tips deeply and patiently !!!!!!!!!!
Compare model.summary() and pp model.trainable_weights, we can see that how Conv1D weights or filters are used to screen embedding_1 tensor
In fact, for all layers, either weights of Conv1D, Dense, or that of Conv2D, consider them to be filters, to screen previous layer's tensor
How embedding weights transform input_1 (?, 1000) to embedding_1 (?, 1000, 100)? deserve research later
"""
model_path = "/Users/Natsume/Downloads/data_for_all/word_embeddings/pretrainedWordEmbedding_2.h5"
if os.path.isfile(model_path):
model = load_model(
"/Users/Natsume/Downloads/data_for_all/word_embeddings/pretrainedWordEmbedding_2.h5"
)
model.fit(x_train, y_train, batch_size=128, epochs=1, validation_split=0.2)
# validation_data=(x_val, y_val))
model.save(
"/Users/Natsume/Downloads/data_for_all/word_embeddings/pretrainedWordEmbedding_3.h5"
)
loss, accuracy = model.evaluate(x_test,
y_test,
batch_size=len(x_test),
verbose=1)
preds = model.predict(x_test)
preds_integer = np.argmax(preds, axis=1)
from tensorflow.contrib.keras.python.keras.layers import Dropout, BatchNormalization, Input, Dense from tensorflow.contrib.keras.python.keras.models import Model import numpy as np from tensorflow.contrib.keras.python.keras import backend as K from tensorflow.contrib.keras.python.keras import losses x = np.random.random((100,10))*2 y = np.random.randint(2, size=(100,1)) input_tensor = Input(shape=(10,)) bn_tensor = BatchNormalization()(input_tensor) dp_tensor = Dropout(0.7)(bn_tensor) final_tensor = Dense(1)(dp_tensor) model = Model(input_tensor, final_tensor) model.compile(optimizer='SGD', loss='mse', metrics=['accuracy']) from tensorflow.contrib.keras.python.keras import callbacks from tensorflow.contrib.keras.python.keras.callbacks import EarlyStopping early_stopping = EarlyStopping(monitor='val_loss', patience=5) # patience=2 hist1=model.fit(x, y, validation_split=0.2, callbacks=[early_stopping], epochs=100) print(hist1.history) hist2=model.fit(x, y, validation_split=0.3, epochs=10) # checkout all the losses and metrics print(hist2.history)
' class_weight: optional dictionary mapping\n' ' class indices (integers) to\n' " a weight (float) to apply to the model's loss for the samples\n" ' from this class during training.\n' ' This can be useful to tell the model to "pay more attention" to\n' ' samples from an under-represented class.\n' '\n' 'Returns:\n' ' Scalar training loss\n' ' (if the model has a single output and no metrics)\n' ' or list of scalars (if the model has multiple outputs\n' ' and/or metrics). The attribute `model.metrics_names` will give you\n' ' the display labels for the scalar outputs.') """ # fit_loop() will help split x, y into batches for training in batches hist = model.fit(x, y, validation_split=0.1, batch_size=2, epochs=5) hist.history # a dict of val_loss and loss hist.history['val_loss'] hist.history['loss'] """ ([' def fit(self,\n', ' x=None,\n', ' y=None,\n', ' batch_size=32,\n', ' epochs=1,\n', ' verbose=1,\n', ' callbacks=None,\n', ' validation_split=0.,\n', ' validation_data=None,\n', ' shuffle=True,\n', ' class_weight=None,\n',
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import confusion_matrix
# In[22]:
# use logistic regression as the model
model = LogisticRegression()
# In[23]:
model.fit(trainData, trainLabels)
# In[24]:
# use rank-1 and rank-5 predictions
f = open('output/flowers_17/xception/results.txt', "w")
rank_1 = 0
rank_5 = 0
# In[25]:
# loop over test data
flatten_layer_output = K.function([model.layers[0].input], [model.layers[2].output]) flatten_out = flatten_layer_output([x])[0] flatten_weights = K.batch_get_value(model.layers[2].weights) ## get dense layer output with real values dense_layer_output = K.function([model.layers[0].input], [model.layers[3].output]) dense_out = dense_layer_output([x])[0] dense_weights = K.batch_get_value(model.layers[3].weights) ### Start to train num_epochs = 2 for epoch in range(num_epochs): # train 50 samples for once model.fit(val_img_array, val_lab_array, batch_size=10, epochs=1, verbose=1) """ def fit(self,\n', ' x=None,\n', ' y=None,\n', ' batch_size=32,\n', ' epochs=1,\n', ' verbose=1,\n', ' callbacks=None,\n', ' validation_split=0.,\n', ' validation_data=None,\n', ' shuffle=True,\n', ' class_weight=None,\n', ' sample_weight=None,\n',
# Training
sequence_input = Input(shape=(MAX_SEQUENCE_LENGTH, ), dtype='int32')
embedded_sequences = embedding_layer(sequence_input)
x = Conv1D(128, 5, activation='relu')(embedded_sequences)
print('sequence_input: ', sequence_input)
print('embedded_sequences: ', embedded_sequences)
print('x: ', x)
x = MaxPooling1D(5)(x)
x = Conv1D(128, 5, activation='relu')(x)
x = MaxPooling1D(5)(x)
x = Conv1D(128, 5, activation='relu')(x)
x = MaxPooling1D(35)(x) # global max pooling
x = Flatten()(x)
x = Dense(128, activation='relu')(x)
preds = Dense(len(labels_index), activation='softmax')(x)
model = Model(sequence_input, preds)
model.compile(loss='categorical_crossentropy',
optimizer='rmsprop',
metrics=['acc'])
# happy learning!
model.fit(x_train,
y_train,
validation_data=(x_val, y_val),
epochs=2,
batch_size=128)
ntrain = 10000
trainidx = random.sample(range(0, X_train.shape[0]), ntrain)
XT = X_train[trainidx, :, :, :]
# Pre-train the discriminator network ...
noise_gen = np.random.uniform(0, 1, size=[XT.shape[0], 100])
generated_images = generator.predict(noise_gen)
X = np.concatenate((XT, generated_images))
n = XT.shape[0]
y = np.zeros([2 * n, 2])
y[:n, 1] = 1
y[n:, 0] = 1
make_trainable(discriminator, True)
discriminator.fit(X, y, epochs=1, batch_size=128)
y_hat = discriminator.predict(X)
# Measure accuracy of pre-trained discriminator network
y_hat_idx = np.argmax(y_hat, axis=1)
y_idx = np.argmax(y, axis=1)
diff = y_idx - y_hat_idx
n_tot = y.shape[0]
n_rig = (diff == 0).sum()
acc = n_rig * 100.0 / n_tot
print("Accuracy: %0.02f pct (%d of %d) right" % (acc, n_rig, n_tot))
# set up loss storage vector
losses = {"d": [], "g": []}
import numpy as np
input_tensor = Input(shape=(32, ))
layer = Dense(5)
layer.trainable = False
tensor_no_train = layer(input_tensor)
frozen_model = Model(input_tensor, tensor_no_train)
# in the model below, the weights of `layer` will not be updated during training
frozen_model.compile(optimizer='rmsprop', loss='mse')
layer.trainable = True
tensor_do_train = layer(input_tensor)
trainable_model = Model(input_tensor, tensor_do_train)
# with this model the weights of the layer will be updated during training
# (which will also affect the above model since it uses the same layer instance)
trainable_model.compile(optimizer='rmsprop', loss='mse')
# create dataset
data = np.random.random((100, 32)) # check on source
labels = np.random.randint(5, size=(100, 5)) # check source
frozen_model.fit(data, labels, epochs=5) # no validation_set, then no val_loss
frozen_model.fit(
data, labels, validation_split=0.3, epochs=5
) # this does NOT update the weights of `layer`, therefore, loss stays the same
trainable_model.fit(
data, labels, validation_split=0.3, epochs=5
) # this updates the weights of `layer`, therefore, loss keeps changing
# Create a model needs an input tensor and an output tensor
model = Model(inputs=inputs, outputs=predictions)
# before training, a model has to have optimizer, loss and metrics
model.compile(optimizer='rmsprop',
loss='categorical_crossentropy',
metrics=['accuracy'])
# Generate dummy data
import numpy as np
data = np.random.random((1000, 784))
labels = np.random.randint(10, size=(1000, 1))
labels = to_categorical(labels, num_classes=10)
model.fit(data, labels, validation_split=0.2) # starts training
"""
Use_2: model as layer
## All models are callable, just like layers
1. you can treat any model as if it were a layer, by calling it on a tensor.
2. calling a model is use both its architecture and latest weights
"""
x = Input(shape=(784, ))
# This works, and returns the 10-way softmax we defined above.
# like doing forward pass
y = model(x)
"""
# This defines a model with two inputs and two outputs:
model = Model(inputs=[main_input, auxiliary_input],
outputs=[main_output, auxiliary_output])
# We compile the model and assign a weight of 0.2 to the auxiliary loss.
# To specify different `loss_weights` or `loss` for each different output, you can use a list or a dictionary.
# Here we pass a single loss as the `loss` argument, so the same loss will be used on all outputs.
model.compile(optimizer='rmsprop',
loss='binary_crossentropy',
loss_weights=[1., 0.2])
# We can train the model by passing it lists of input arrays and target arrays:
model.fit([main_input_array, auxiliary_input_array],
[main_output_array, auxiliary_output_array],
validation_split=0.2,
epochs=2,
batch_size=32)
# Since our inputs and outputs are named (we passed them a "name" argument),
# We could also have compiled the model via:
model.compile(optimizer='rmsprop',
loss={
'main_output': 'binary_crossentropy',
'aux_output': 'binary_crossentropy'
},
loss_weights={
'main_output': 1.,
'aux_output': 0.2
})