def get_data(dataset):
""" Prepare the mnist or fashion-mnist data to feed to the model.
Args:
dataset (string): one of the possible_datasets
Returns:
A tuple with the clean training data, clean testing data, and noisy
testing data.
"""
if dataset not in possible_datasets:
datasets_output = ', '.join(possible_datasets)
raise ValueError('dataset must be one of: {}'.format(datasets_output))
if dataset == 'mnist':
(clean_train, __), (clean_test, __) = mnist.load_data()
elif dataset == 'fashion-mnist':
(clean_train, __), (clean_test, __) = fashion_mnist.load_data()
clean_train = clean_train.astype('float32') / 255.
clean_train = clean_train.reshape(data_shape)
clean_test = clean_test.astype('float32') / 255.
clean_test = clean_test.reshape(data_shape)
noisy_test = add_gaussian_noise_np(clean_test, 0.0, 0.4)
return clean_train, clean_test, noisy_test
def main():
(x_train, y_train), (x_test, y_test) = fashion_mnist.load_data()
pixels = x_train[object_to_predict]
y_train = utils.to_categorical(y_train, 10)
x_train = x_train / 255
classes = [
"t-shirt", "trouser", "pullover", "dress", "coat", "sandal", "shirt",
"sneaker", "bag", "ankle boot"
]
model = load_model("fashion_model.h5")
image = Image.fromarray(pixels, "L")
prediction = model.predict(
numpy.reshape(x_train[object_to_predict], (1, 784)))
print("Object", classes[numpy.argmax(y_train[object_to_predict])],
"recognised as", classes[numpy.argmax(prediction)], "with accuracy",
numpy.max(prediction * 100), "percents")
image.show()
def main():
(x_train, y_train), (x_test, y_test) = fashion_mnist.load_data()
x_train = x_train.reshape(60000, 784)
x_train = x_train / 255
x_test = x_test.reshape(10000, 784)
x_test = x_test / 255
y_train = utils.to_categorical(y_train, 10)
y_test = utils.to_categorical(y_test, 10)
model = Sequential()
model.add(Dense(784, input_dim=784, activation="relu"))
model.add(Dense(10, activation="softmax"))
model.compile(loss="categorical_crossentropy",
optimizer="SGD",
metrics=["accuracy"])
model.summary()
callback = [
TensorBoard(log_dir='logs', histogram_freq=1, write_images=True)
]
model.fit(x_train,
y_train,
batch_size=200,
epochs=300,
verbose=1,
validation_split=0.2,
callbacks=callback)
model.save("fashion_model.h5")
score = model.evaluate(x_test, y_test, verbose=1)
print("Accuracy on test data is", score[1] * 100, "percent")
def prepare_data(self):
(x_train, y_train), (_, _) = fashion_mnist.load_data()
x_train = x_train.reshape((-1, 28, 28, 1))
x_train, y_train = x_train.astype('float32') / 255.0, \
tf.keras.utils.to_categorical(y_train.astype('float32'), 10)
(x_train, x_eval) = x_train[5000:], x_train[:5000]
(y_train, y_eval) = y_train[5000:], y_train[:5000]
train_data, eval_data = (x_train, y_train), (x_eval, y_eval)
return train_data, eval_data
def load_real_samples():
# load dataset
(trainX, trainy), (_, _) = load_data()
# expand to 3d, e.g. add channels
X = expand_dims(trainX, axis=-1)
# convert from ints to floats
X = X.astype('float32')
# scale from [0,255] to [-1,1]
X = (X - 127.5) / 127.5
# trainy = expand_dims(trainy, axis=-1)
print(X.shape, trainy.shape)
return [X, trainy]
def load_image_dataset(dataset_name='mnist'):
"""
Loads the dataset by name.
Args:
dataset_name: string, either "mnist", "cifar10", "cifar100", "fmnist"
Returns:
(X_train, y_train), (X_test, y_test)
"""
allowed_names = ['mnist', 'cifar10', 'cifar100', 'fmnist']
if dataset_name not in allowed_names:
raise ValueError("Dataset name provided is wrong. Must be one of ",
allowed_names)
# print(directory)
if dataset_name == 'mnist':
(X_train, y_train), (X_test, y_test) = mnist.load_data()
elif dataset_name == 'fmnist':
(X_train, y_train), (X_test, y_test) = fashion_mnist.load_data()
elif dataset_name == 'cifar10':
(X_train, y_train), (X_test, y_test) = cifar10.load_data()
elif dataset_name == 'cifar100':
(X_train, y_train), (X_test, y_test) = cifar100.load_data()
else:
raise ValueError(
'%s is not a valid dataset name. Available choices are : %s' %
(dataset_name, str(allowed_names)))
if dataset_name in ['mnist', 'fmnist']:
X_train = X_train.reshape(X_train.shape[0], 28, 28, 1)
X_test = X_test.reshape(X_test.shape[0], 28, 28, 1)
X_train = X_train.astype('float32') / 255.
X_test = X_test.astype('float32') / 255.
elif dataset_name in ['cifar10', 'cifar100']:
X_train = X_train.astype('float32') / 255.
X_test = X_test.astype('float32') / 255.
if dataset_name == 'cifar100':
num_classes = 100
else:
num_classes = 10
y_train = tf.keras.utils.to_categorical(y_train, num_classes)
y_test = tf.keras.utils.to_categorical(y_test, num_classes)
return (X_train, y_train), (X_test, y_test)
def main(args):
if args.dataset == "mnist":
from tensorflow.python.keras.datasets import mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
elif args.dataset == "fashion_mnist":
from tensorflow.python.keras.datasets import fashion_mnist
(x_train, y_train), (x_test, y_test) = fashion_mnist.load_data()
elif args.dataset == "cifar10":
from tensorflow.python.keras.datasets import cifar10
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
else:
sys.exit("Unknown dataset {}".format(args.dataset))
convert(x_train, y_train, args, "train")
convert(x_test, y_test, args, "test")
def train(model_name):
# load the data
(train_images, train_labels), (test_images,
test_labels) = fashion_mnist.load_data()
# create a TensorBoard callback
model_dir = root_dir(os.path.join('training', model_name))
tensorboard_callback = TensorBoard(log_dir=model_dir)
# create a checkpoint callback
checkpoint_path = root_dir(os.path.join(model_dir, 'weights.ckpt'))
checkpoint_callback = ModelCheckpoint(checkpoint_path,
save_weights_only=True)
# train the model
model = create_model()
model.fit(train_images,
train_labels,
epochs=5,
callbacks=[checkpoint_callback, tensorboard_callback],
validation_data=(test_images, test_labels))
def __init__(self):
num_classes = 10
img_rows, img_cols = 28, 28
(x_train, y_train), (x_test, y_test) = fashion_mnist.load_data()
if K.image_data_format() == 'channels_first':
x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)
x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)
input_shape = (1, img_rows, img_cols)
else:
x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)
x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
input_shape = (img_rows, img_cols, 1)
x_train = x_train.astype('float32') / 255
x_test = x_test.astype('float32') / 255
y_train = to_categorical(y_train, num_classes)
y_test = to_categorical(y_test, num_classes)
super().__init__(x_train, x_test, y_train, y_test, input_shape,
num_classes, 'fashion_mnist')
# Initialize wandb
wandb.init(project="example")
config = wandb.config
# Track hyperparameters
config.dropout = 0.2
config.hidden_layer_size = 128
config.layer_1_size = 16
config.layer_2_size = 32
config.learn_rate = 0.01
config.decay = 1e-6
config.momentum = 0.9
config.epochs = 8
(X_train_orig, y_train_orig), (X_test, y_test) = fashion_mnist.load_data()
# Reducing the dataset size to 10,000 examples for faster train time
true = list(
map(lambda x: True if random.random() < 0.167 else False, range(60000)))
ind = []
for i, x in enumerate(true):
if x == True: ind.append(i)
X_train = X_train_orig[ind, :, :]
y_train = y_train_orig[ind]
img_width = 28
img_height = 28
labels = [
"T-shirt/top", "Trouser", "Pullover", "Dress", "Coat", "Sandal", "Shirt",
# >The original labels are integers from 0 to 9, so, for example, a label of 5 becomes 0000010000 when onehot encoded, but note the difference between the index and the label stored at that index: # In[66]: import tensorflow as tf from tensorflow.python.keras.datasets import fashion_mnist width, height, = 28, 28 # total classes n_classes = 10 # #### loading the dataset # In[ ]: (x_train, y_train), (x_test, y_test) = fashion_mnist.load_data() # #### Split feature training set into training and validation sets # In[ ]: split = 50000 (y_train, y_valid) = y_train[:split], y_train[split:] # #### one-hot encode the labels using TensorFlow then convert back to numpy for display # In[68]: y_train_ohe = tf.one_hot(y_train, depth=n_classes).numpy() y_valid_ohe = tf.one_hot(y_valid, depth=n_classes).numpy() y_test_ohe = tf.one_hot(y_test, depth=n_classes).numpy()
def train(self):
# Load the dataset
if 'mnist' in self.img_dataset:
(X_train, y_train), (_, _) = mnist.load_data()
elif 'cifar' in self.img_dataset:
(X_train, y_train), (_, _) = cifar.load_data('fine')
X_train = X_train / 255.0
classes2labels = {c: l for c, l in enumerate(self.train_labels)}
else:
raise ValueError(
"Unknown dataset {}! Please use either 'fasion_mnist' or 'cifar100'."
.format(self.img_dataset))
# Configure input
X_train = (X_train.astype(np.float32) - 127.5) / 127.5
# if self.channels == 1:
# X_train = np.expand_dims(X_train, axis=3)
for n, i in enumerate(self.index):
y_train = np.where(y_train == n, i, y_train)
y_train = y_train.reshape(-1, 1)
# Adversarial ground truths
true = np.ones((self.batch_size, 1))
fake = np.zeros((self.batch_size, 1))
for epoch in range(self.epochs):
# ---------------------
# Train Discriminator
# ---------------------
# Select a random half batch of images
idx = np.random.randint(0, X_train.shape[0], self.batch_size)
# with np.random.randint we can pick the same image more than once: is this a feature or a bug?
imgs, labels = X_train[idx], y_train[idx]
shuffled_labels = np.zeros_like(labels)
for i, label in enumerate(labels):
modified_index = np.delete(self.index,
np.where(self.index == label))
shuffled_labels[i, 0] = np.random.choice(modified_index, 1)
# Sample noise as generator input
noise = np.random.normal(0, 1,
(self.batch_size, self.embeddings_dim))
# Generate a half batch of new images
gen_imgs = self.generator.predict([noise, labels])
"""
Train the discriminator to do three tasks:
1. recognize real images for a concept as true images for that concept
2. recognize generated images for a concept as fake images for that concept
3. recognize real images for a concept as fake for a different concept
this way the generator cannot just fool the discriminator by generating sensible images in the abstract,
but has to generate credible images for a specific concept.
"""
d_loss_real = self.discriminator.train_on_batch([imgs, labels],
true)
d_loss_fake = self.discriminator.train_on_batch([gen_imgs, labels],
fake)
d_loss_unrelated = self.discriminator.train_on_batch(
[imgs, shuffled_labels], fake)
# this is the original loss, which could be extended to
# d_loss = np.add(d_loss_real, d_loss_fake, d_loss_unrelated) / 3
# to keep its spirit.
# d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
# this is the loss proposed in Reed et al 2018
d_loss = np.log(d_loss_real) + (np.log(1 - d_loss_unrelated) +
np.log(1 - d_loss_fake)) / 2
# ---------------------
# Train Generator
# ---------------------
# Condition on labels
sampled_labels = np.random.choice(self.index,
self.batch_size).reshape(-1, 1)
# Train the generator
g_loss = self.gan.train_on_batch([noise, sampled_labels], true)
# If at save interval => save generated image samples
if epoch % self.sample_interval == 0:
print("%d [D loss: %f, acc.: %.2f%%] [G loss: %f]" %
(epoch, d_loss[0], 100 * d_loss[1], g_loss))
self.sample_images(epoch)
self.save()
generator.summary()
save_file = osp.join(osp.abspath(osp.dirname(__file__)), args.saver)
checkpoint = tf.train.Checkpoint(discriminator=discriminator, generator=generator)
opti_d = tf.keras.optimizers.Adam(0.0001)
opti_g = tf.keras.optimizers.Adam(0.0001)
summary_file = osp.join(osp.abspath(osp.dirname(__file__)), args.logs)
summary = tf.summary.create_file_writer(os.path.join(summary_file, args.log_file))
latent_dim = args.l_dim
batch_size = args.b_size
epochs = args.epoch
(train_x, train_y), (test_x, test_y) = load_data()
train_x = (train_x - 127.0) / 127.0
test_x = (test_x - 127.0) / 127.0
train_x, test_x = np.expand_dims(train_x, axis=-1), np.expand_dims(test_x, axis=-1)
train_y, test_y = np.expand_dims(train_y, axis=-1), np.expand_dims(test_y, axis=-1)
train_data = tf.data.Dataset.from_tensor_slices((train_x, train_y)).shuffle(1000).batch(batch_size)
train_d_loss = tf.keras.metrics.Mean(name='train_d_loss')
train_g_loss = tf.keras.metrics.Mean(name='train_g_loss')
for itr in range(epochs):
train_d_loss.reset_states()
train_g_loss.reset_states()
for (x, y) in train_data:
def __init__(self):
# 返回两个元组
# x_train: (60000, 784), y_train:(60000, 1)
(self.x_train, self.y_train), (self.x_test, self.y_test) = fashion_mnist.load_data()
