def load_data(filename):
# load mnist data set
if filename == "data/mnist.train":
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train = X_train.reshape(60000, 784)
X_train = X_train.astype('float32')
X_train /= 255
Y_train = np_utils.to_categorical(y_train, 10)
return X_train, Y_train
if filename == "data/mnist2d.train":
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train = X_train.reshape(X_train.shape[0], 28, 28, 1)
X_train = X_train.astype('float32')
X_train /= 255
Y_train = np_utils.to_categorical(y_train, 10)
return X_train, Y_train
if filename == "data/mnist.test":
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_test = X_test.reshape(10000, 784)
X_test = X_test.astype('float32')
X_test /= 255
Y_test = np_utils.to_categorical(y_test, 10)
return X_test, Y_test
if filename == "data/mnist2d.test":
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_test = X_test.reshape(10000, 28, 28, 1)
X_test = X_test.astype('float32')
X_test /= 255
Y_test = np_utils.to_categorical(y_test, 10)
return X_test, Y_test
# load sensor data from csv file
data = pd.read_csv(filename, sep=';')
X = data[data.columns[:-1]].as_matrix()
y = data[data.columns[-1]].as_matrix()
y = y.reshape(y.shape[0], 1)
return X, y
def main():
""" Test SVM from scikit learn on mnist data set."""
(X_train, Y_train), (X_test, Y_test) = mnist.load_data()
# preprocess data
X_train = X_train.reshape(60000, 784)
X_test = X_test.reshape(10000, 784)
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_test /= 255
print(X_train.shape[0], 'train samples')
print(X_test.shape[0], 'test samples')
model = SVC(kernel='rbf', gamma=0.02, C=10)
model.fit(X_train, Y_train)
train_yy = model.predict(X_train)
test_yy = model.predict(X_test)
train_err = 100*mean_squared_error(train_yy, Y_train)
test_err = 100*mean_squared_error(test_yy, Y_test)
print("Train. err:", train_err)
print("Test err:", test_err)
train_acc = accuracy_score(Y_train, train_yy)
test_acc = accuracy_score(Y_test, test_yy)
pickle.dump(model, open("svm_rbf", "wb"))
def test_mnist(self):
print('mnist')
(X_train, y_train), (X_test, y_test) = mnist.load_data()
print(X_train.shape)
print(X_test.shape)
print(y_train.shape)
print(y_test.shape)
def reference():
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Flatten, Dense, Activation, Convolution2D, MaxPooling2D
from keras.utils import np_utils
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.astype('float32').reshape(x_train.shape + (1, )) / 255.
x_test = x_test.astype('float32').reshape(x_test.shape + (1, )) / 255.
y_train = np_utils.to_categorical(y_train)
y_test = np_utils.to_categorical(y_test)
rows, cols = x_train.shape[1:3]
model = Sequential()
model.add(Convolution2D(9, 3, 3, border_mode='same',
dim_ordering='tf', activation='relu',
batch_input_shape=(16, rows, cols, 1)))
model.add(MaxPooling2D((2, 2), dim_ordering='tf'))
model.add(Convolution2D(16, 3, 3, border_mode='same',
dim_ordering='tf', activation='relu'))
model.add(Flatten())
model.add(Dense(10, activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='rmsprop')
model.fit(x_train, y_train, batch_size=16, show_accuracy=True,
validation_data=(x_test, y_test), nb_epoch=20)
def __init__(self, **kwargs):
super(MNIST, self).__init__(**kwargs)
# data_path = osp.abspath( osp.join(__file__, osp.pardir, osp.pardir, osp.pardir, osp.pardir,
# 'datasets/mnist/keras/mnist.pkl.gz') )
# with gzip.open(data_path, 'rb') as f:
# (X_train, y_train), (X_test, y_test) = pickle.load(f)
#
(X_train, y_train), (X_test, y_test) = mnist.load_data()
if self.data_set == 'train':
X = X_train
y = y_train
elif self.data_set == 'train-small':
X = X_train[:2000]
y = y_train[:2000]
elif self.data_set == 'test':
X = X_test
y = y_test
elif self.data_set == 'test-small':
X = X_test[:1000]
y = y_test[:1000]
elif self.data_set == 'all':
X = np.vstack((X_train, X_test))
y = np.vstack((y_train, y_test))
else:
raise ValueError('MNIST Unsupported data_set: ', self.data_set)
# normalization
if self.norm:
X = X.astype(np.float32) / 255
X = X[:,np.newaxis,:,:]
X = self.init_layout_X(X)
y = self.init_layout_y(y)
self.X = X
self.y = y
def load(dataset, inside_labels, unknown_labels, with_unknown):
if dataset == 'mnist':
from keras.datasets import mnist as data
elif dataset == 'cifar10':
from keras.datasets import cifar10 as data
elif dataset == 'svhn':
data = SVHN()
inside_labels.sort()
unknown_labels.sort()
(X_train, y_train), (X_test, y_test) = data.load_data()
y_train = y_train.reshape(-1)
y_test = y_test.reshape(-1)
X_train_all = X_train.copy()
y_train_all = y_train.copy()
idxs_labels = defaultdict(list)
for i, label in enumerate(y_train):
idxs_labels[label].append(i)
idxs_train = []
if with_unknown:
total = sum(len(idxs_labels[label]) for label in idxs_labels if label in inside_labels)
per_labels = total//(len(inside_labels) + len(unknown_labels))
for label in idxs_labels:
if label in inside_labels + unknown_labels:
idxs_train += idxs_labels[label][:per_labels]
else:
for label in idxs_labels:
if label in inside_labels:
idxs_train += idxs_labels[label]
X_train = X_train[idxs_train]/255
X_train_all = X_train_all/255
if len(X_train.shape[1:]) == 2:
X_train = np.expand_dims(X_train, axis=1)
X_train_all = np.expand_dims(X_train_all, axis=1)
y_train = y_train[idxs_train]
y_train = y_train.reshape(y_train.shape[0])
idxs_inside = [i for i, l in enumerate(y_train) if l in inside_labels]
idxs_unknown = [i for i, l in enumerate(y_train) if l in unknown_labels]
label_key = {l: i for i, l in enumerate(inside_labels + unknown_labels)}
y_train_int = np.array([label_key[l] for l in y_train])
y_train = np.zeros([len(y_train_int), len(inside_labels)])
y_train[idxs_inside, :] = np_utils.to_categorical(y_train_int[idxs_inside])
y_train[idxs_unknown, :] = np.array([1.0/len(inside_labels)]*len(inside_labels))
X_test = X_test/255
if len(X_test.shape[1:]) == 2:
X_test = np.expand_dims(X_test, axis=1)
y_test = y_test.reshape(y_test.shape[0])
assert y_train.shape[1] == len(inside_labels)
return (X_train_all, y_train_all), (X_train, y_train) , (X_test, y_test),
def get_mnist_data(train_size, binarize, add_noise, noise_proportion,
test=False):
print('Loading MNIST dataset')
(X_train, y_train), (X_test, y_test) = mnist.load_data()
print('Splitting data into training and validation')
X_val = np.copy(X_train[train_size:])
y_val = np.copy(y_train[train_size:])
X_train = np.copy(X_train[:train_size])
y_train = np.copy(y_train[:train_size])
print('Training shape = {}, Validation shape = {}, Test shape = {}'.format(
X_train.shape, X_val.shape, X_test.shape))
print('Preprocessing data: classes = {}, binarize = {}, add noise = {}'.format(
nb_classes, binarize, add_noise))
X_train, Y_train = preprocess_data(X_train, y_train, nb_classes=nb_classes,
binarize=binarize, noise=add_noise, proportion=noise_proportion)
X_val, Y_val = preprocess_data(X_val, y_val, nb_classes=nb_classes,
binarize=binarize, noise=add_noise, proportion=noise_proportion)
if test:
X_test, Y_test = preprocess_data(X_test, y_test, nb_classes=nb_classes,
binarize=binarize, noise=add_noise, proportion=noise_proportion)
return (X_train, Y_train), (X_val, Y_val), (X_test, Y_test)
else:
return (X_train, Y_train), (X_val, Y_val)
def main():
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# Transform data to a list of 1D arrays
dim_product = x_train.shape[1] * x_train.shape[2]
x_train = x_train.reshape(x_train.shape[0], dim_product)
x_test = x_test.reshape(x_test.shape[0], dim_product)
# Normalize data so that every point is between 0 and 1
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
# Turn labels to categories
y_train = np_utils.to_categorical(y_train, 10)
y_test = np_utils.to_categorical(y_test, 10)
model = Sequential()
model.add(Dense(1200, input_dim=dim_product, init="normal",
activation='tanh'))
# model.add(Dense(400, init="normal", activation="relu"))
model.add(Dense(10, init="normal", activation="softmax"))
model.compile(loss="categorical_crossentropy", optimizer="SGD",
metrics=['accuracy'])
print(f"Models summary: {model.summary()}")
model.fit(x_train, y_train, batch_size=200, nb_epoch=60,
validation_split=0.3, verbose=1)
score = model.evaluate(x_test, y_test, verbose=0)
print(f"Final score: {score[1]*100}")
model.save('simple-mnist.h5')
def load_mnist_rnn(max_train_items=None, max_test_items=None, normalize=True):
#(X_train, y_train), (X_test, y_test) = cifar10.load_data()
(X_train, y_train), (X_test, y_test) = mnist.load_data()
if max_train_items is not None:
skip_every_trn = int(X_train.shape[0] / max_train_items)
X_train = X_train[::skip_every_trn,:,:]
y_train = y_train[::skip_every_trn]
if max_test_items is not None:
skip_every_tst = int(X_test.shape[0] / max_test_items)
X_test = X_test[::skip_every_tst,:,:]
y_test = y_test[::skip_every_tst]
X_train = X_train.astype('float32') / 255.0
if normalize:
X_train -= X_train.mean(axis=0)[None,:]
X_test = X_test.astype('float32') / 255.0
if normalize:
X_test -= X_test.mean(axis=0)[None,:]
X_train = X_train[:,8:,:].reshape([len(X_train), -1, 28*4])
trn=RegressionData(X=np.squeeze(X_train[:,0,:]), Y=X_train)
trn.ids = y_train
X_test = X_test[:,8:,:].reshape([len(X_test), -1, 28*4])
tst=RegressionData(X=np.squeeze(X_test[:,0,:]), Y=X_test)
tst.ids = y_test
return Datasets(trn, tst)
def keras_mnist_data():
"""
retrieve the MNIST database for keras
"""
# the data, shuffled and split between train and test sets
(X_train, y_train), (X_test, y_test) = mnist.load_data()
img_rows, img_cols = 28, 28 # should be cmputed from the data
if K.image_dim_ordering() == 'th':
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)
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)
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_test /= 255
# convert class vectors to binary class matrices
nb_classes = len(set(y_train))
Y_train = np_utils.to_categorical(y_train, nb_classes)
Y_test = np_utils.to_categorical(y_test, nb_classes)
return (X_train, Y_train), (X_test, Y_test)
def tsting_and_show(no_images = 100):
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_test = to_normal(X_test)
generator = generator_model()
generator.compile(loss='binary_crossentropy', optimizer="SGD")
generator.load_weights('generator')
noise = X_test[:,:,::2,::2]
generated_images = generator.predict(noise, verbose=1)
im = combine_images(generated_images[:no_images])
im_org = combine_images(X_test[:no_images])
im_dec = combine_images(noise[:no_images])
figure(figsize=(4*3+2,4))
subplot(1,3,1)
imshow(im_org, cmap='gray')
axis('off')
title('Original')
subplot(1,3,2)
imshow(im_dec, cmap='gray')
axis('off')
title('Input 1/2x1/2 with Interpol')
subplot(1,3,3)
imshow(im, cmap='gray')
axis('off')
title('Expansion by AE-GANS')
def load_mnist(image_dim_ordering):
(X_train, y_train), (X_test, y_test) = mnist.load_data()
if image_dim_ordering == 'th':
X_train = X_train.reshape(X_train.shape[0], 1, 28, 28)
X_test = X_test.reshape(X_test.shape[0], 1, 28, 28)
else:
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')
X_test = X_test.astype('float32')
X_train = normalization(X_train)
X_test = normalization(X_test)
nb_classes = len(np.unique(np.hstack((y_train, y_test))))
Y_train = np_utils.to_categorical(y_train, nb_classes)
Y_test = np_utils.to_categorical(y_test, nb_classes)
print X_train.shape, X_test.shape, Y_train.shape, Y_test.shape
return X_train, Y_train, X_test, Y_test
def evaluate(lr, pos):
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train = (X_train.astype("float32")).reshape((60000, 784))
X_test = (X_test.astype("float32")).reshape((10000, 784))
X_train /= 255
X_test /= 255
Y_train = np_utils.to_categorical(y_train, 10)
Y_test = np_utils.to_categorical(y_test, 10)
model = Sequential()
model.add(Dense(output_dim=layer1, input_dim=784))
if pos == 0:
model.add(BatchNormalization())
model.add(Activation("relu"))
model.add(Dense(output_dim=layer2, input_dim=layer1))
if pos == 1:
model.add(BatchNormalization())
model.add(Activation("relu"))
model.add(Dense(output_dim=10, input_dim=layer2))
if pos == 2:
model.add(BatchNormalization())
model.add(Activation("softmax"))
model.compile(
loss="categorical_crossentropy", optimizer=SGD(lr=lr, momentum=0.9, nesterov=True), metrics=["accuracy"]
)
model.fit(X_train, Y_train, batch_size=batch_size, nb_epoch=nb_epoch, verbose=0, validation_data=(X_test, Y_test))
score = model.evaluate(X_test, Y_test, verbose=0)
return score[1]
def __init__(self):
"""
By invoke run(), all code is executed.
"""
(X_train, y_train), (X_test, y_test) = mnist.load_data()
self.Org = (X_train, y_train), (X_test, y_test)
self.Data = self.Org
def test():
(X_train, Y_train), (X_test, Y_test) = mnist.load_data()
# preprocess data
X_train = X_train.reshape(60000, 784)
X_test = X_test.reshape(10000, 784)
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_test /= 255
model = pickle.load(open("svm_rbf.pickle","rb"))
train_yy = model.predict(X_train)
test_yy = model.predict(X_test)
train_err = 100*mean_squared_error(train_yy, Y_train)
test_err = 100*mean_squared_error(test_yy, Y_test)
print("Train. err:", train_err)
print("Test err:", test_err)
train_acc = accuracy_score(Y_train, train_yy)
test_acc = accuracy_score(Y_test, test_yy)
print("Train acc:", train_acc)
print("Test acc:", test_acc)
def reconstruct():
inputs = tf.placeholder(
shape=(None, 28, 28),
dtype=tf.float32,
name='inputs',
)
encoder = Encoder(tf.reshape(inputs, [-1, 784]))
latent = encoder.outputs
decoder = Decoder(latent)
reconstruction = tf.reshape(decoder.outputs, [-1, 28, 28])
sess = tf.Session()
encoder.load(sess, 'saved_models/encoder/', verbose=True)
decoder.load(sess, 'saved_models/decoder/', verbose=True)
(x_train, _), (x_test, _) = mnist.load_data()
sample = np.expand_dims(x_test[np.random.choice(len(x_test))], axis=0)
generated_sample = sess.run(reconstruction, {inputs: sample / 256.}) * 256.
image = np.concatenate([sample[0], generated_sample[0]], axis=1)
PIL.Image.fromarray(image).resize((200, 100)).show()
def construct_randomly_split_mnist(nb_splits=10, mode='train'):
"""Split MNIST dataset by labels.
Args:
nb_splits: numer of splits
mode: whether to use train or testing data
Returns:
List of (X, y) tuples representing each dataset
"""
# Load MNIST data and normalize
nb_classes = 10
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train = X_train.reshape(-1, 784)
X_test = X_test.reshape(-1, 784)
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_test /= 255
if mode == 'train':
X, y = X_train, y_train
else:
X, y = X_test, y_test
return split_dataset_randomly(X, y, nb_splits, nb_classes)
def train(batch_size):
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train = (X_train - 127.5) / 127.5
X_train = X_train[:, :, :, None]
X_test = X_test[:, :, :, None]
d = discriminator_model()
g = generator_model()
d_on_g = generator_containing_discriminator(g, d)
d_optim = SGD(lr=0.0005, momentum=0.9, nesterov=True) # nesterov?
g_optim = SGD(lr=0.0005, momentum=0.9, nesterov=True)
g.compile(loss='binary_crossentropy', optimizer='SGD')
d_on_g.compile(loss='binary_crossentropy', optimizer=g_optim)
d.trainable = True
d.compile(loss='binary_crossentropy', optimizer=d_optim)
for epoch in range(100):
for index in range(X_train.shape[0]//batch_size):
noise = np.random.uniform(-1, 1, size=(batch_size, 100))
image_batch = X_train[index*batch_size:(index+1)*batch_size]
generated_image = g.predict(noise, verbose=0)
X = np.concatenate((image_batch, generated_image)) # 元画像 + 生成した画像
y = [1] * batch_size + [0] * batch_size # 正解画像に対するラベル => 1, 生成画像 => 0
# discriminatorは, 元の画像を1, 生成された画像を0として学習していく
d_loss = d.train_on_batch(X, y)
noise = np.random.uniform(-1, 1, (batch_size, 100))
d.trainable = False
# generatorは, 本当の画像
g_loss = d_on_g.train_on_batch(noise, [1] * batch_size)
print("batch {} d_loss {}".format(index, d_loss))
d.trainable = True
print("batch {} g_loss: {}".format(index, g_loss))
if index % 10 == 9:
g.save_weights('generator', True)
d.save_weights('discriminator', True)
def construct_split_mnist(task_labels, split='train', multihead=False):
"""Split MNIST dataset by labels.
Args:
task_labels: list of list of labels, one for each dataset
split: whether to use train or testing data
Returns:
List of (X, y) tuples representing each dataset
"""
# Load MNIST data and normalize
nb_classes = 10
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train = X_train.reshape(-1, 784)
X_test = X_test.reshape(-1, 784)
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_test /= 255
if split == 'train':
X, y = X_train, y_train
else:
X, y = X_test, y_test
return split_dataset_by_labels(X, y, task_labels, nb_classes, multihead)
def load_mnist():
(X_train, Y_train), (X_test, Y_test) = mnist.load_data()
X_train = X_train.reshape(-1, 784)
X_test = X_test.reshape(-1, 784)
X_train = X_train.astype("float32") / 255.0
X_test = X_test.astype("float32") / 255.0
return (X_train, Y_train), (X_test, Y_test)
def data_mix(self):
# randomly choose dataset
dataset = random.choice(['mnist', 'cifar10', 'cifar100'])#
n_labels = 10
if dataset == "mnist":
data = mnist.load_data()
if dataset == "cifar10":
data = cifar10.load_data()
if dataset == "cifar100":
data = cifar100.load_data()
n_labels = 100
# Choose dataset size. This affects regularization needed
r = np.random.rand()
# not using full dataset to make regularization more important and
# speed up testing a little bit
data_size = int( 2000 * (1-r) + 40000 * r )
# I do not use test data for validation, but last 10000 instances in dataset
# so that trained models can be compared to results in literature
(CX, CY), (CXt, CYt) = data
if dataset == "mnist":
CX = np.expand_dims(CX, axis=1)
data = CX[:data_size], CY[:data_size], CX[-10000:], CY[-10000:];
return data, n_labels
def use_tflearn():
import tflearn
# Data loading and preprocessing
import tflearn.datasets.mnist as mnist
X, Y, testX, testY = mnist.load_data(one_hot=True)
# Building deep neural network
input_layer = tflearn.input_data(shape=[None, 784])
dense1 = tflearn.fully_connected(input_layer, 64, activation='tanh',
regularizer='L2', weight_decay=0.001)
dropout1 = tflearn.dropout(dense1, 0.8)
dense2 = tflearn.fully_connected(dropout1, 64, activation='tanh',
regularizer='L2', weight_decay=0.001)
dropout2 = tflearn.dropout(dense2, 0.8)
softmax = tflearn.fully_connected(dropout2, 10, activation='softmax')
# Regression using SGD with learning rate decay and Top-3 accuracy
sgd = tflearn.SGD(learning_rate=0.1, lr_decay=0.96, decay_step=1000)
top_k = tflearn.metrics.Top_k(3)
net = tflearn.regression(softmax, optimizer=sgd, metric=top_k,
loss='categorical_crossentropy')
# Training
model = tflearn.DNN(net, tensorboard_verbose=0)
model.fit(X, Y, n_epoch=20, validation_set=(testX, testY),
show_metric=True, run_id="dense_model")
def load_mnist_dataset():
from keras.datasets import mnist
num_classes = 10
# input image dimensions
img_rows, img_cols = 28, 28
# the data, shuffled and split between train and test sets
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# qui modifica la forma nel caso i canali siano la 2 dimensione o la 4
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')
x_test = x_test.astype('float32')
x_train /= 255 # normalizing?
x_test /= 255
print('x_train shape:', x_train.shape)
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')
# convert class vectors to binary class matrices
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)
return x_train, y_train, x_test, y_test
def get_mnist_data(): # Use keras dataset instead. # conda install keras (X_train, y_train), (X_test, y_test) = mnist.load_data() # Reshape data once for training, again for test. # X_train 50Kx28x28 matrix -> 50Kx784x1 matrix # y_train 10Kx1 array -> 10Kx10x1 matrix (hot-encoded vector) images_train = [x.reshape(784,1) / 255.0 for x in X_train] labels_encoded_train = [np.zeros((10,1)) for y in y_train] for i, l in enumerate(y_train): labels_encoded_train[i][l] = 1 # Reshape for test, same as training images_test = [x.reshape(784,1) / 255.0 for x in X_test] labels_encoded_test = [np.zeros((10,1)) for y in y_test] for i, l in enumerate(y_test): labels_encoded_test[i][l] = 1 # training is a list of (image, hot-encoded label vector) tuples. # test is a list of (image, label) tuples. train = [(x,y) for x,y in zip(images_train, labels_encoded_train)] test =[(x,y) for x,y in zip(images_test, labels_encoded_test)] # test = [(x,y) for x,y in zip(images_test, y_test)] validate = test[8000:] test = test[:8000] return train, test, validate
def setUpClass(cls):
# MNIST dataset used for building pre_trained_models/mnist_cnn/model_mnist_cnn_epoch_3
cls.batch_size = 128
cls.num_classes = 10
cls.epochs = 2
# input image dimensions
cls.img_rows, cls.img_cols = 28, 28
# shuffled and split between train and test sets
(cls.x_train, cls.y_train), (cls.x_test, cls.y_test) = mnist.load_data()
if K.image_data_format() == 'channels_first':
cls.x_train = cls.x_train.reshape(cls.x_train.shape[0], 1, cls.img_rows, cls.img_cols)
cls.x_test = cls.x_test.reshape(cls.x_test.shape[0], 1, cls.img_rows, cls.img_cols)
cls.input_shape = (1, cls.img_rows, cls.img_cols)
else:
cls.x_train = cls.x_train.reshape(cls.x_train.shape[0], cls.img_rows, cls.img_cols, 1)
cls.x_test = cls.x_test.reshape(cls.x_test.shape[0], cls.img_rows, cls.img_cols, 1)
cls.input_shape = (cls.img_rows, cls.img_cols, 1)
cls.x_train = cls.x_train.astype('float32')
cls.x_test = cls.x_test.astype('float32')
cls.x_train /= 255
cls.x_test /= 255
cls.x_train = (cls.x_train - 0.5) * 2
cls.x_test = (cls.x_test - 0.5) * 2
# convert class vectors to binary class matrices
cls.y_train = keras.utils.to_categorical(cls.y_train, cls.num_classes)
cls.y_test = keras.utils.to_categorical(cls.y_test, cls.num_classes)
def mnist_dataset():
(X_train, _), (X_test, _) = mnist.load_data()
X_train = X_train.astype('float32') / 256.
X_test = X_test.astype('float32') / 256.
X_train = X_train.reshape((len(X_train), np.prod(X_train.shape[1:])))
X_test = X_test.reshape((len(X_test), np.prod(X_test.shape[1:])))
return X_train, X_test
def run_mlp(n_epochs = 20):
np.random.seed(1234)
nb_inputs = 28*28
nb_classes = 10
model = Sequential()
model.add(Dense(512, input_shape=(nb_inputs,), activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(512, activation='relu'))
model.add(Dropout(0.2))
model.add(Dense(nb_classes, activation='softmax'))
# RMSProp works way faster than SGD
model.compile(loss='categorical_crossentropy', optimizer=RMSprop())
(X_train, Y_train), (X_test, Y_test) = mnist.load_data()
X_train = X_train.reshape(60000, 28*28).astype("float32")/255
X_test = X_test.reshape(10000, 28*28).astype("float32")/255
Y_train = np_utils.to_categorical(Y_train, nb_classes)
Y_test = np_utils.to_categorical(Y_test, nb_classes)
model.fit(X_train, Y_train, nb_epoch=n_epochs, batch_size=128,
show_accuracy=True, verbose=2,
validation_split=0.1)
loss, accuracy = model.evaluate(X_test, Y_test,
show_accuracy=True, verbose=0)
return accuracy
def train(self, epochs, batch_size=128, save_interval=50):
# Load the dataset
(X_train, _), (_, _) = mnist.load_data()
# Rescale -1 to 1
X_train = (X_train.astype(np.float32) - 127.5) / 127.5
X_train = np.expand_dims(X_train, axis=3)
half_batch = int(batch_size / 2)
for epoch in range(epochs):
# ---------------------
# Train Discriminator
# ---------------------
# Sample noise and generate img
z = np.random.normal(size=(half_batch, self.latent_dim))
imgs_ = self.generator.predict(z)
# Select a random half batch of images and encode
idx = np.random.randint(0, X_train.shape[0], half_batch)
imgs = X_train[idx]
z_ = self.encoder.predict(imgs)
valid = np.ones((half_batch, 1))
fake = np.zeros((half_batch, 1))
# Train the discriminator (img -> z is valid, z -> img is fake)
d_loss_real = self.discriminator.train_on_batch([z_, imgs], valid)
d_loss_fake = self.discriminator.train_on_batch([z, imgs_], fake)
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
# ---------------------
# Train Generator
# ---------------------
# Sample gaussian noise
z = np.random.normal(size=(batch_size, self.latent_dim))
# Select a random half batch of images
idx = np.random.randint(0, X_train.shape[0], batch_size)
imgs = X_train[idx]
valid = np.ones((batch_size, 1))
fake = np.zeros((batch_size, 1))
# Train the generator (z -> img is valid and img -> z is is invalid)
g_loss = self.bigan_generator.train_on_batch([z, imgs], [valid, fake])
# Plot the progress
print ("%d [D loss: %f, acc: %.2f%%] [G loss: %f]" % (epoch, d_loss[0], 100*d_loss[1], g_loss[0]))
# If at save interval => save generated image samples
if epoch % save_interval == 0:
# Select a random half batch of images
self.save_imgs(epoch)
def train_aegans(BATCH_SIZE, disp=True):
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train = (X_train.astype(np.float32) - 127.5) / 127.5
X_train = X_train.reshape((X_train.shape[0], 1) + X_train.shape[1:])
discriminator = discriminator_model()
generator = generator_model()
discriminator_on_generator = \
generator_containing_discriminator_ae(generator, discriminator)
d_optim = SGD(lr=0.0005, momentum=0.9, nesterov=True)
g_optim = SGD(lr=0.0005, momentum=0.9, nesterov=True)
generator.compile(loss='binary_crossentropy', optimizer="SGD")
discriminator_on_generator.compile(loss=merge_bc_mse, optimizer=g_optim)
discriminator.trainable = True
discriminator.compile(loss='binary_crossentropy', optimizer=d_optim)
noise = np.zeros((BATCH_SIZE, 100))
for epoch in range(100):
if disp:
print("Epoch is", epoch)
print("Number of batches", int(X_train.shape[0] / BATCH_SIZE))
for index in range(int(X_train.shape[0] / BATCH_SIZE)):
# for i in range(BATCH_SIZE):
#noise[i, :] = np.random.uniform(-1, 1, 100)
# noise[i, :] = X_train[i, :].reshape(-1)[np.round(np.linspace(0,783,100)).astype(int)]
image_batch = X_train[index * BATCH_SIZE:(index + 1) * BATCH_SIZE]
noise = image_batch[:, :, ::2, ::2].copy()
generated_images = generator.predict(noise, verbose=0)
if index % 30 == 0:
image = combine_images(generated_images)
image = image * 127.5 + 127.5
Image.fromarray(image.astype(np.uint8)).save(
str(epoch) + "_" + str(index) + ".png")
X = np.concatenate((image_batch, generated_images))
y = [1] * BATCH_SIZE + [0] * BATCH_SIZE
d_loss = discriminator.train_on_batch(X, y)
if disp and index % 30 == 0:
print("batch %d d_loss : %f" % (index, d_loss))
noise = image_batch[:, :, ::2, ::2].copy()
discriminator.trainable = False
target_left = np.array([1] * BATCH_SIZE).reshape(BATCH_SIZE, 1)
target_right = image_batch.reshape(BATCH_SIZE, -1)
target = np.concatenate([target_left, target_right], axis=1)
# Debuging code
# print("epoch, index, target.shape -->", epoch, index, target.shape)
g_loss = discriminator_on_generator.train_on_batch(
noise, target)
discriminator.trainable = True
if disp and index % 30 == 0:
print("batch %d g_loss : %f" % (index, g_loss))
if index % 10 == 9:
generator.save_weights('generator', True)
discriminator.save_weights('discriminator', True)
def train(self, epochs, batch_size=128, save_interval=50):
# Load the dataset
(X_train, _), (_, _) = mnist.load_data()
# Rescale -1 to 1
X_train = (X_train.astype(np.float32) - 127.5) / 127.5
X_train = np.expand_dims(X_train, axis=3)
half_batch = int(batch_size / 2)
for epoch in range(epochs):
# ---------------------
# Train Discriminator
# ---------------------
# Select a random half batch of images
idx = np.random.randint(0, X_train.shape[0], half_batch)
imgs = X_train[idx]
# Generate a half batch of embedded images
latent_fake = self.encoder.predict(imgs)
latent_real = np.random.normal(size=(half_batch, self.encoded_dim))
valid = np.ones((half_batch, 1))
fake = np.zeros((half_batch, 1))
# Train the discriminator
d_loss_real = self.discriminator.train_on_batch(latent_real, valid)
d_loss_fake = self.discriminator.train_on_batch(latent_fake, fake)
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
# ---------------------
# Train Generator
# ---------------------
# Select a random half batch of images
idx = np.random.randint(0, X_train.shape[0], batch_size)
imgs = X_train[idx]
# Generator wants the discriminator to label the generated representations as valid
valid_y = np.ones((batch_size, 1))
# Train the generator
g_loss = self.adversarial_autoencoder.train_on_batch(imgs, [imgs, valid_y])
# Plot the progress
print ("%d [D loss: %f, acc: %.2f%%] [G loss: %f, mse: %f]" % (epoch, d_loss[0], 100*d_loss[1], g_loss[0], g_loss[1]))
# If at save interval => save generated image samples
if epoch % save_interval == 0:
# Select a random half batch of images
idx = np.random.randint(0, X_train.shape[0], 25)
imgs = X_train[idx]
self.save_imgs(epoch, imgs)
from keras.utils import np_utils from keras.datasets import mnist (train_feature, train_label), (test_feature, test_label) = mnist.load_data() print(train_label[0:5]) train_label_onehot = np_utils.to_categorical(train_label) print(train_label_onehot[0:5])
def model_train(bot,update):
import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Dropout, Flatten
from keras.layers import Conv2D, MaxPooling2D
from keras import backend as K
##################################################################################################
from dl_bot import DLBot
from telegram_bot_callback import TelegramCallback
# bot = DLBot(token=telegram_token, user_id=telegram_user_id)
telegram_callback = TelegramCallback(bot, update)
###################################################################################################
batch_size = 128
num_classes = 10
epochs = 5
img_rows, img_cols = 28, 28
(x_train, y_train), (x_test, y_test) = 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')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
print('x_train shape:', x_train.shape)
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)
model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3),
activation='relu',
input_shape=input_shape))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation='softmax'))
model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=keras.optimizers.Adadelta(),
metrics=['accuracy'])
model.fit(x_train[:1000], y_train[:1000],
batch_size=batch_size,
epochs=epochs,
verbose=1,
validation_data=(x_test, y_test),
callbacks=[telegram_callback])
score = model.evaluate(x_test, y_test, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
return score
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Dense, Flatten
from keras.utils import to_categorical
import wandb
from wandb.keras import WandbCallback
# logging code
run = wandb.init()
config = run.config
# load data
(X_train, y_train), (X_test, y_test) = mnist.load_data()
img_width = X_train.shape[1]
img_height = X_train.shape[2]
# one hot encode outputs
y_train = to_categorical(y_train)
y_test = to_categorical(y_test)
labels = range(10)
num_classes = y_train.shape[1]
# create model
model = Sequential()
model.add(Flatten(input_shape=(img_width, img_height)))
model.add(Dense(num_classes, activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
def train(self, epochs, batch_size=128, sample_interval=50):
# Load the dataset
(X_train, y_train), (_, _) = mnist.load_data()
# Rescale -1 to 1
X_train = (X_train.astype(np.float32) - 127.5) / 127.5
X_train = np.expand_dims(X_train, axis=3)
y_train = y_train.reshape(-1, 1)
half_batch = int(batch_size / 2)
for epoch in range(epochs):
# ---------------------
# Train Discriminator
# ---------------------
# Select a random half batch of images
idx = np.random.randint(0, X_train.shape[0], half_batch)
imgs = X_train[idx]
noise = np.random.normal(0, 1, (half_batch, 100))
# The labels of the digits that the generator tries to create an
# image representation of
sampled_labels = np.random.randint(0, 10, half_batch).reshape(-1, 1)
# Generate a half batch of new images
gen_imgs = generator.predict([noise, sampled_labels])
valid = np.ones((half_batch, 1))
fake = np.zeros((half_batch, 1))
# Image labels. 0-9 if image is valid or 10 if it is generated (fake)
img_labels = y_train[idx]
fake_labels = 10 * np.ones(half_batch).reshape(-1, 1)
# Train the discriminator
d_loss_real = discriminator.train_on_batch(imgs, [valid, img_labels])
d_loss_fake = discriminator.train_on_batch(gen_imgs,
[fake, fake_labels])
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
# ---------------------
# Train Generator
# ---------------------
# Sample generator input
noise = np.random.normal(0, 1, (batch_size, 100))
valid = np.ones((batch_size, 1))
# Generator wants discriminator to label the generated images as the intended
# digits
sampled_labels = np.random.randint(0, 10, batch_size).reshape(-1, 1)
# Train the generator
g_loss = combined.train_on_batch([noise, sampled_labels],
[valid, sampled_labels])
# Plot the progress
print("%d [D loss: %f, acc.: %.2f%%, op_acc: %.2f%%] [G loss: %f]" %
(epoch, d_loss[0], 100 * d_loss[3], 100 * d_loss[4], g_loss[0]))
# If at save interval => save generated image samples
if epoch % sample_interval == 0:
save_model()
sample_images(epoch)
def sample_images(self, epoch):
r, c = 10, 10
noise = np.random.normal(0, 1, (r * c, 100))
sampled_labels = np.array([num for _ in range(r) for num in range(c)])
gen_imgs = generator.predict([noise, sampled_labels])
# Rescale images 0 - 1
gen_imgs = 0.5 * gen_imgs + 0.5
fig, axs = plt.subplots(r, c)
cnt = 0
for i in range(r):
for j in range(c):
axs[i, j].imshow(gen_imgs[cnt, :, :, 0], cmap='gray')
axs[i, j].axis('off')
cnt += 1
fig.savefig("images/%d.png" % epoch)
plt.close()
def save_model(self):
def save(model, model_name):
model_path = "saved_model/%s.json" % model_name
weights_path = "saved_model/%s_weights.hdf5" % model_name
options = {"file_arch": model_path, "file_weight": weights_path}
json_string = model.to_json()
open(options['file_arch'], 'w').write(json_string)
model.save_weights(options['file_weight'])
save(generator, "mnist_acgan_generator")
save(discriminator, "mnist_acgan_discriminator")
save(combined, "mnist_acgan_adversarial")
def load_mnist_data():
return mnist.load_data()
"""Program 2&3.ipynb
Automatically generated by Colaboratory.
Original file is located at
https://colab.research.google.com/drive/13xtHNr4RITYpAKZwHeN7gdXYXUjEPf6-
"""
from keras import Sequential
from keras.datasets import mnist
import numpy as np
import matplotlib.pyplot as plt
from keras.layers import Dense
from keras.utils import to_categorical
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
#display the first image in the training data
plt.imshow(train_images[0, :, :], cmap='gray')
plt.title('Ground Truth : {}'.format(train_labels[0]))
plt.show()
#process the data
#1. convert each image of shape 28*28 to 784 dimensional
dimData = np.prod(train_images.shape[1:])
print("Dim data:", dimData)
train_data = train_images.reshape(train_images.shape[0], dimData)
test_data = test_images.reshape(test_images.shape[0], dimData)
#convert data and scale values between 0 and 1
train_data = train_data.astype('float')
test_data = test_data.astype('float')
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
"""
Created on Tue Mar 31 17:14:02 2020
@author: yurifarod
"""
import matplotlib.pyplot as plt
import numpy as np
from keras.datasets import mnist
from keras.models import Model, Sequential
from keras.layers import Input, Dense, Conv2D, MaxPooling2D, UpSampling2D, Flatten, Reshape
(previsores_treinamento, _), (previsores_teste, _) = mnist.load_data()
previsores_treinamento = previsores_treinamento.reshape(
(len(previsores_treinamento), 28, 28, 1))
previsores_teste = previsores_teste.reshape((len(previsores_teste), 28, 28, 1))
previsores_treinamento = previsores_treinamento.astype('float32') / 255
previsores_teste = previsores_teste.astype('float32') / 255
autoencoder = Sequential()
# Encoder
autoencoder.add(
Conv2D(filters=16,
kernel_size=(3, 3),
activation='relu',
input_shape=(28, 28, 1)))
autoencoder.add(MaxPooling2D(pool_size=(2, 2)))
def train_model(batch_size=1000,
epochs=1005,
num_samples=10000,
var1=0.99,
var2=0.01):
num_classes = 10
print('var1:', var1)
print('var2:', var2)
# input image dimensions
img_rows, img_cols = 28, 28
# the data, split between train and test sets
(x_train, y_train), (x_test, y_test) = 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')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
x_train = x_train[0:num_samples]
print('x_train shape:', x_train.shape)
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')
# convert class vectors to binary class matrices
y_train = keras.utils.to_categorical(y_train, num_classes)[0:num_samples]
y_test = keras.utils.to_categorical(y_test, num_classes)
model = Sequential()
model.add(Flatten(input_shape=(28, 28, 1)))
model.add(Dense(64, activation='tanh'))
model.add(Dense(64, activation='tanh'))
model.add(Dense(64, activation='tanh'))
model.add(Dense(64, activation='tanh'))
model.add(Dense(64, activation='tanh'))
model.add(Dense(64, activation='tanh'))
model.add(Dense(64, activation='tanh'))
model.add(Dense(64, activation='tanh'))
model.add(Dense(64, activation='tanh'))
model.add(Dense(num_classes, activation='softmax'))
model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=keras.optimizers.sgd(),
metrics=['accuracy'])
model.summary()
n_pop = 10
n_para = 84170
fit = np.zeros((n_pop, 1))
pop = np.random.normal(0, 0.01, (n_pop, n_para))
count_update = 0
flag_add = 0
flag_stop = 0
minibatches = random_mini_batches(x_train, y_train, batch_size)
len_batch = len(minibatches)
record = np.zeros((epochs, 4))
count_non_update = 0
for i in range(epochs):
print(i,
'th iteration------------------------------------------------')
count_batches = 0
for minibatch in minibatches:
(minibatch_X, minibatch_Y) = minibatch
model.train_on_batch(minibatch_X, minibatch_Y)
for n in range(10):
a = np.array(model.get_weights())
score_old = model.evaluate(minibatch_X, minibatch_Y,
verbose=0)[0]
b = np.array(model.get_weights())
if flag_add == 0:
j = np.random.randint(0, len(b))
adding_random = np.random.normal(0, 0.01, b[j].shape)
b[j] = b[j] + adding_random
model.set_weights(b)
score_new = model.evaluate(minibatch_X, minibatch_Y,
verbose=0)[0]
if score_new < score_old * (var1 + i * var2 / epochs):
a = copy.deepcopy(b)
score_old = score_new
count_update = count_update + 1
flag_add = 1
break
else:
model.set_weights(a)
flag_add = 0
count_batches = count_batches + 1
score = model.evaluate(x_train, y_train, verbose=0)
# with K.Session() as sess:
#
# outputTensor = model.output # Or model.layers[index].output
# listOfVariableTensors = model.trainable_weights
# gradients =K.gradients(outputTensor, listOfVariableTensors)
record[i, 0], record[i, 1] = model.evaluate(x_train,
y_train,
verbose=0)
record[i, 2], record[i, 3] = model.evaluate(x_test, y_test, verbose=0)
print('Train loss:', record[i, 0])
print('Train accuracy:', record[i, 1])
print('Test loss:', record[i, 2])
print('Test accuracy', record[i, 3])
print('count_update:', count_update)
if i > 999 and i % 500 == 0:
df = pd.DataFrame(
record,
columns=['train_loss', 'train_acc', 'test_loss', 'test_acc'])
df.to_csv('minist_ga' + str(i) + str(num_samples) + str(var1) +
str(var2) + '.csv',
index=None,
header=True)
from keras.layers import Input, Dense
from keras.models import Model
from keras.datasets import mnist
from keras import regularizers
import numpy as np
import matplotlib.pyplot as plt
from keras.layers import Input, Dense, Conv2D, MaxPooling2D, UpSampling2D
from keras.models import Model
from keras import backend as K
(x_train, _), (x_test, _) = mnist.load_data()
x_train = x_train.astype('float32') / 255.
x_test = x_test.astype('float32') / 255.
x_train = np.reshape(x_train, (len(x_train), 28, 28, 1)) # adapt this if using `channels_first` image data format
x_test = np.reshape(x_test, (len(x_test), 28, 28, 1)) # adapt this if using `channels_first` image data format
print x_train.shape
print x_test.shape
input_img = Input(shape=(28, 28, 1))
x = Conv2D(16, (3, 3), activation='relu', padding='same')(input_img)
x = MaxPooling2D((2, 2), padding='same')(x)
x = Conv2D(8, (3, 3), activation='relu', padding='same')(x)
x = MaxPooling2D((2, 2), padding='same')(x)
x = Conv2D(8, (3, 3), activation='relu', padding='same')(x)
encoded = MaxPooling2D((2, 2), padding='same')(x)
# at this point the representation is (4, 4, 8) i.e. 128-dimensional
#loading the dataset
from keras.datasets import mnist
dataset = mnist.load_data('mymnist.db')
train, test = dataset
X_train, y_train = train
X_test, y_test = test
X_train = X_train.reshape(60000, 28, 28, 1)
X_test = X_test.reshape(10000, 28, 28, 1)
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
from keras.utils.np_utils import to_categorical
y_train_cat = to_categorical(y_train)
y_test = to_categorical(y_test)
#Adding layers
from keras.layers import Convolution2D
from keras.layers import MaxPooling2D
from keras.layers import Flatten
from keras.layers import Dense
from keras.models import Sequential
from keras.optimizers import adam
model = Sequential()
i = 1
n = 6
for i in range(i):
model.add(
Convolution2D(filters=n,
kernel_size=(3, 3),
activation='relu',
import keras
from tflearn.layers.core import fully_connected
from keras.datasets import mnist
from keras.layers import Input, Dense
from keras.models import Model
from keras import backend as K
num_classes = 10
img_rows, img_cols = 28, 28
(trainX, trainY), (testX, testY) = mnist.load_data()
trainX = trainX.reshape(trainX.shape[0], img_rows * img_cols)
testX = testX.reshape(testX.shape[0], img_rows * img_cols)
# 将图像像素转换为0到1之间的实数
trainX = trainX.astype('float32')
testX = testX.astype('float32')
trainX /= 255.0
testX /= 255.0
# 将标准答案转化为需要的格式(one-hot编码)
trainY = keras.utils.to_categorical(trainY, num_classes)
testY = keras.utils.to_categorical(testY, num_classes)
# 定义两个输入，一个输入为原始的图片信息，另一个输入为正确答案
input1 = Input(shape=(784, ), name='input1')
input2 = Input(shape=(10, ), name='input2')
# 定义一个只有一个隐藏节点的全连接网络
x = Dense(1, activation='relu')(input1)
def load_data(op_path, vid_path):
"""Load training data from MNIST, the given operators image and the digits/operators in the video.
Args:
op_path: Path to the operator image.
vid_path: Path to the video.
Return:
tuple: training data.
tuple: testing data.
"""
# load MNIST data
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# load the given operators image, crop it for each operator and generate more data
operators = cv2.imread(op_path)
operators = cv2.cvtColor(operators, cv2.COLOR_RGB2GRAY)
plus = cv2.resize(~operators[:, :316], (28, 28)).reshape(1, 28, 28, 1)
equal = cv2.resize(~operators[:, 340:340 + 316], (28, 28)).reshape(1, 28, 28, 1)
minus = cv2.resize(~operators[:, 710:710 + 316], (28, 28)).reshape(1, 28, 28, 1)
divide = cv2.resize(~operators[:, 1079:1079 + 316], (28, 28)).reshape(1, 28, 28, 1)
multiply = cv2.resize(~operators[:, 1420:1420 + 316], (28, 28)).reshape(1, 28, 28, 1)
op_datagen = ImageDataGenerator(
rotation_range=360,
zoom_range=[0.9, 1.6],
vertical_flip=True,
horizontal_flip=True)
plus_numpy = np.array([list(op_datagen.flow(plus)) for _ in range(10000)])
equal_numpy = np.array([list(op_datagen.flow(equal)) for _ in range(10000)])
minus_numpy = np.array([list(op_datagen.flow(minus)) for _ in range(10000)])
divide_numpy = np.array([list(op_datagen.flow(divide)) for _ in range(10000)])
multiply_numpy = np.array([list(op_datagen.flow(multiply)) for _ in range(10000)])
x_op = np.concatenate((plus_numpy, minus_numpy, multiply_numpy, divide_numpy, equal_numpy))
y_op = np.concatenate((9 * np.ones(len(plus)), 10 * np.ones(len(minus)), 11 * np.ones(len(multiply)), 12 * np.ones(len(divide)), 13 * np.ones(len(equal))))
rand_perm = np.random.permutation(len(y_op))
x_op = x_op[rand_perm]
y_op = y_op[rand_perm]
x_op_train = x_op[:27000]
x_op_test = x_op[27000:]
y_op_train = y_op[:27000]
y_op_test = y_op[27000:]
# load digits and operators in the video
cap = cv2.VideoCapture(vid_path)
frames = []
while cap.isOpened():
ret, frame = cap.read()
# if frame is read correctly ret is True
if not ret:
break
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
frames.append(frame)
cap.release()
two = []
three = []
seven = []
plus = []
multiply = []
divide = []
equal = []
angles = [0, 45, 100, 185, 228, 274, 350]
for ang in angles:
M = cv2.getRotationMatrix2D((360, 240), ang, 1.0)
tmp = cv2.warpAffine(frames[0], M, (720, 480))
tip, center = find_red_arrow(tmp)
elements, _ = find_math_elements(tmp, center, 18)
plus.append(255. - normalize(elements[0]))
three.append(255. - normalize(elements[1]))
two.append(255. - normalize(elements[2]))
divide.append(255. - normalize(elements[3]))
seven.append(255. - normalize(elements[4]))
seven.append(255. - normalize(elements[5]))
equal.append(255. - normalize(elements[6]))
multiply.append(255. - normalize(elements[7]))
three.append(255. - normalize(elements[8]))
two.append(255. - normalize(elements[9]))
two_numpy = np.array([np.array(img) for img in two])
three_numpy = np.array([np.array(img) for img in three])
seven_numpy = np.array([np.array(img) for img in seven])
plus_numpy = np.array([np.array(img) for img in plus])
multiply_numpy = np.array([np.array(img) for img in multiply])
divide_numpy = np.array([np.array(img) for img in divide])
equal_numpy = np.array([np.array(img) for img in equal])
x_vid = np.concatenate((two_numpy, three_numpy, seven_numpy, plus_numpy, multiply_numpy, divide_numpy, equal_numpy))
y_vid = np.concatenate((2 * np.ones(len(two)), 3 * np.ones(len(three)), 7 * np.ones(len(seven)), 9 * np.ones(len(plus)), 11 * np.ones(len(multiply)), 12 * np.ones(len(divide)), 13 * np.ones(len(equal))))
rand_perm = np.random.permutation(len(y_vid))
x_vid = x_vid[rand_perm]
y_vid = y_vid[rand_perm]
x_vid_train = x_vid[:50]
x_vid_test = x_vid[50:]
y_vid_train = y_vid[:50]
y_vid_test = y_vid[50:]
x_train = np.concatenate((x_train, x_op_train, x_vid_train))
y_train = np.concatenate((y_train, y_op_train, y_vid_train))
x_test = np.concatenate((x_test, x_op_test, x_vid_test))
y_test = np.concatenate((y_test, y_op_test, y_vid_test))
return (x_train, y_train), (x_test, y_test)
model_file = sys.argv[1]
nums_to_check = [float(n) for n in sys.argv[2].strip('[]').split(',')]
ds = sys.argv[3]
# Load original model
full_model = load_model(os.path.join('./models',model_file), compile=False)
full_model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['categorical_accuracy'])
# Load appropriate dataset
if(ds == 'fashion_mnist'):
(train_data, train_labels), (test_data, test_labels) = fashion_mnist.load_data()
train_data = train_data.reshape((train_data.shape[0], 28, 28, 1)).astype('float32')/255
test_data = test_data.reshape((test_data.shape[0], 28, 28, 1)).astype('float32')/255
elif(ds == 'mnist'):
(train_data, train_labels), (test_data, test_labels) = mnist.load_data()
train_data = train_data.reshape((train_data.shape[0], 28, 28, 1)).astype('float32')/255
test_data = test_data.reshape((test_data.shape[0], 28, 28, 1)).astype('float32')/255
else:
raise NotImplementedError('Dataset not understood.')
# Seed the generator.
np.random.seed()
# Evaluate original model.
test_labels = to_categorical(test_labels)
results_full = full_model.evaluate(test_data, test_labels)
# Keep as oracle all layers but the last two.
oracle_model = Sequential()
for layer in full_model.layers[:-2]:
# MNIST classifier.
# Instalar la base de datos del MNIST.
from tensorflow import keras
from PIL import ImageTk, Image
from numpy import asarray, argmax
from keras.datasets import mnist
(X_train_raw, Y_train_raw), (X_test_raw, Y_test_raw) = mnist.load_data()
# Normalizar el DATASET.
X_train = X_train_raw.reshape(60000, 784)
X_test = X_test_raw.reshape(10000, 784)
X_train = X_train / 255
X_test = X_test / 255
# Asignarle la forma vectorial.
Y_train = keras.utils.to_categorical(Y_train_raw, 10)
Y_test = keras.utils.to_categorical(Y_test_raw, 10)
# Generar la red neuronal.
from keras.layers.core import Dense, Dropout, Activation
model = keras.Sequential()
model.add(Dense(100, activation="relu"))
model.add(Dense(10, activation="softmax"))
# Compilar y entrenar la red neuronal.
print("Entrenando red neuronal...")
model.compile(loss='categorical_crossentropy', metrics=['accuracy'])
result = model.fit(X_train,
Y_train,
batch_size=200,
def train(self, epochs, batch_size=128, sample_interval=50):
# Load the dataset
(X_train, y_train), (_, _) = mnist.load_data()
# Rescale MNIST to 32x32
X_train = np.array([
scipy.misc.imresize(x, [self.img_rows, self.img_cols])
for x in X_train
])
# Rescale -1 to 1
X_train = (X_train.astype(np.float32) - 127.5) / 127.5
X_train = np.expand_dims(X_train, axis=3)
y_train = y_train.reshape(-1, 1)
half_batch = int(batch_size / 2)
for epoch in range(epochs):
# ------------------------
# Train Discriminator
# ------------------------
# Sample half batch of images
idx = np.random.randint(0, X_train.shape[0], half_batch)
imgs = X_train[idx]
labels = y_train[idx]
masked_imgs = self.mask_randomly(imgs)
# Generate a half batch of new images
gen_imgs = self.generator.predict(imgs)
valid = np.ones((half_batch, 4, 4, 1))
fake = np.zeros((half_batch, 4, 4, 1))
labels = to_categorical(labels, num_classes=self.num_classes + 1)
fake_labels = to_categorical(np.full((half_batch, 1),
self.num_classes),
num_classes=self.num_classes + 1)
# Train the discriminator
d_loss_real = self.discriminator.train_on_batch(
imgs, [valid, labels])
d_loss_fake = self.discriminator.train_on_batch(
gen_imgs, [fake, fake_labels])
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
# ----------------------
# Train Generator
# ----------------------
# Select a random half batch of images
idx = np.random.randint(0, X_train.shape[0], batch_size)
imgs = X_train[idx]
masked_imgs = self.mask_randomly(imgs)
# Generator wants the discriminator to label the generated images as valid
valid = np.ones((batch_size, 4, 4, 1))
# Train the generator
# print("------------------------------")
# print(masked_imgs.shape)
# print(valid.shape)
# print("------------------------------")
g_loss = self.combined.train_on_batch(masked_imgs, valid)
# Plot the progress
print("%d [D loss: %f, op_acc: %.2f%% [G loss: %f]" %
(epoch, d_loss[0], 100 * d_loss[4], g_loss))
# If at save interval => save generated image samples
if epoch % sample_interval == 0:
# Select a random half batch of images
idx = np.random.randint(0, X_train.shape[0], 6)
imgs = X_train[idx]
self.sample_images(epoch, imgs)
self.save_model()
parser.add_argument('weight_nc', help="weight hyperparm to control neuron coverage", type=float)
parser.add_argument('step', help="step size of gradient descent", type=float)
parser.add_argument('seeds', help="number of seeds of input", type=int)
parser.add_argument('grad_iterations', help="number of iterations of gradient descent", type=int)
parser.add_argument('threshold', help="threshold for determining neuron activated", type=float)
parser.add_argument('-t', '--target_model', help="target model that we want it predicts differently",
choices=[0, 1, 2], default=0, type=int)
parser.add_argument('-sp', '--start_point', help="occlusion upper left corner coordinate", default=(0, 0), type=tuple)
parser.add_argument('-occl_size', '--occlusion_size', help="occlusion size", default=(10, 10), type=tuple)
args = parser.parse_args()
# input image dimensions
img_rows, img_cols = 28, 28
# the data, shuffled and split between train and test sets
(_, _), (x_test, _) = mnist.load_data()
x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
input_shape = (img_rows, img_cols, 1)
x_test = x_test.astype('float32')
x_test /= 255
# define input tensor as a placeholder
input_tensor = Input(shape=input_shape)
# load multiple models sharing same input tensor
model1 = Model1(input_tensor=input_tensor)
model2 = Model2(input_tensor=input_tensor)
model3 = Model3(input_tensor=input_tensor)
import pandas as pd
import numpy as np
from keras.preprocessing import image
from keras.models import Sequential
from keras.layers import Conv2D, Lambda
from keras.layers import MaxPooling2D
from keras.layers import Flatten
from keras.layers import Dense, Dropout
from keras.layers.normalization import BatchNormalization
from keras.utils.np_utils import to_categorical
from keras.datasets import mnist
#Load data from MNIST database
(train_x, train_y), (test_x, ) = mnist.load_data()
train_x = train_x.reshape(train_x.shape[0], 28, 28, 1).astype("float32")
test_x = test_x.reshape(test_x.shape[0], 28, 28, 1).astype("float32")
#one-hot encoding
train_y = to_categorical(train_y)
test_y = to_categorical(test_y)
num_classes = test_y.shape[1]
#augment data
newData = image.ImageDataGenerator()
batches = newData.flow(train_x, train_y, batch_size=64)
#normalize data
m = np.mean(train_x)
s = np.std(train_x)
from keras.datasets import mnist
from keras.preprocessing.image import ImageDataGenerator
from matplotlib import pyplot as plt
from keras import backend
backend.set_image_data_format('channels_first')
# 导入数据
(X_train, y_train), (X_validation, y_validation) = mnist.load_data()
X_train = X_train.reshape(X_train.shape[0], 1, 28, 28).astype('float32')
X_validation = X_validation.reshape(X_validation.shape[0], 1, 28,
28).astype('float32')
# ZCA白化
imgGen = ImageDataGenerator(zca_whitening=True)
imgGen.fit(X_train)
for X_batch, y_batch in imgGen.flow(X_train, y_train, batch_size=9):
for i in range(0, 9):
plt.subplot(331 + i)
plt.imshow(X_batch[i].reshape(28, 28), cmap=plt.get_cmap('gray'))
plt.show()
break
import numpy as np
import keras
from keras import backend
from keras.datasets import mnist
from keras.models import load_model
from keras import backend as K
from cleverhans.attacks import FastGradientMethod
from cleverhans.utils_keras import KerasModelWrapper
from sklearn.decomposition import PCA
#Perturbation magnitude. Adjust and run to observe behavior for various bounds.
eta = 0.25
#Load training and testing data and normalize in [0, 1]
(data_train, labels_train), (data_test, labels_test) = mnist.load_data()
data_train = data_train / 255.0
data_test = data_test / 255.0
#Flatten dataset (New shape for training and testing set is (60000,784) and (10000, 784))
data_train = data_train.reshape(
(len(data_train), np.prod(data_train.shape[1:])))
data_test = data_test.reshape((len(data_test), np.prod(data_test.shape[1:])))
#Create labels as one-hot vectors
labels_train = keras.utils.np_utils.to_categorical(labels_train,
num_classes=10)
labels_test = keras.utils.np_utils.to_categorical(labels_test, num_classes=10)
#Import trained classifers
backend.set_learning_phase(False)
import os
import os.path
import tempfile
import matplotlib.pyplot as plt
import keras
from keras.datasets import mnist
# Construct a location in /tmp dir to hold cached data
dataPath = os.path.join(tempfile.gettempdir(), str(os.getuid()))
print(dataPath)
if not os.path.exists(dataPath):
os.mkdir(dataPath)
filenameWithPath = os.path.join(dataPath, "mnist")
# Get training and testing sets
(x_train, y_train), (x_test, y_test) = mnist.load_data(path=filenameWithPath)
# Save single image to a file to view
plt.imshow(x_train[0], cmap='Greys')
plt.savefig('digit.png')
import numpy as np
import matplotlib.pyplot as plt
from keras.datasets import mnist # keras에서 제공되는 예제 파일
mnist.load_data() # mnist파일 불러오기
(x_train, y_train), (
x_test,
y_test) = mnist.load_data() # mnist에서 이미 x_train, y_train으로 나눠져 있는 값 가져오기
print(x_train[0]) # 0 ~ 255까지의 숫자가 적혀짐 (color에 대한 수치)
print('y_train: ', y_train[0]) # 5
print(x_train.shape) # (60000, 28, 28)
print(x_test.shape) # (10000, 28, 28)
print(y_train.shape) # (60000,) : 10000개의 xcalar를 가진 vector(1차원)
print(y_test.shape) # (10000,)
print(x_train[0].shape) # (28, 28)
# plt.imshow(x_train[0], 'gray') # '2차원'을 집어넣어주면 수치화된 것을 이미지로 볼 수 있도록 해줌
# # plt.imshow(x_train[0]) # 색깔로 나옴
# plt.show() # 그림으로 보여주기
# 데이터 전처리 1. 원핫인코딩 : 당연하다 => y 값
from keras.utils import np_utils
y_train = np_utils.to_categorical(y_train)
y_test = np_utils.to_categorical(y_test)
print(y_train.shape) # (60000, 10)
# 데티어 전처리 2. 정규화( MinMaxScalar ) => x 값
from keras.datasets import mnist
from keras.utils import to_categorical
from keras.models import Sequential
from keras.initializers import RandomUniform
from keras.layers import Dense, Activation
from keras.optimizers import SGD
TRN_SIZE = 60000
TST_SIZE = 10000
BATCH_SIZE = 128
CLASSES = 10
EPOCHS = 5
IMAGE_SIZE = 28
(trn_images, trn_labels), (tst_images, tst_labels) = mnist.load_data()
trn_images = trn_images.reshape(TRN_SIZE, IMAGE_SIZE**2)
tst_images = tst_images.reshape(TST_SIZE, IMAGE_SIZE**2)
tst_labels = to_categorical(tst_labels, CLASSES)
trn_labels = to_categorical(trn_labels, CLASSES)
trn_images = trn_images.astype("float32")
tst_images = tst_images.astype("float32")
trn_images /= 255
tst_images /= 255
ru = RandomUniform(minval=-0.1, maxval=0.1, seed=None)
model = Sequential()
model.add(
Dense(256,
input_shape=(IMAGE_SIZE**2, ),
kernel_initializer=ru,
from keras.layers.wrappers import TimeDistributed
from keras.layers.convolutional import Convolution2D
from keras.layers.core import Dense, Flatten
from keras.layers.recurrent import GRU
from keras.utils.np_utils import to_categorical
# for reproducibility
np.random.seed(2017)
SEQ_LENGTH = 8
EPOCHS = 30
EXAMPLES_PER_EPOCH = 500
BATCH_SIZE = 32
# the data, shuffled and split between train and test sets
(X_train_raw, y_train_temp), (X_test_raw, y_test_temp) = mnist.load_data()
# basic image processing
# convert images to float
X_train_raw = X_train_raw.astype('float32')
X_test_raw = X_test_raw.astype('float32')
X_train_raw /= 255
X_test_raw /= 255
# encode output
y_train_raw = to_categorical(y_train_temp, 10)
y_test_raw = to_categorical(y_test_temp, 10)
train_size, height, width = X_train_raw.shape
depth = 1
def mnist_data():
data = mnist.load_data()
return [mnist_process(*d) for d in data]
import keras
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers import Conv2D, MaxPooling2D, Dense, Dropout, Flatten
pixel_width = 28
pixel_height = 28
batch_size = 32
epochs = 10
num_of_classes = 10
(features_train, labels_train), (features_test,
labels_test) = mnist.load_data()
features_train = features_train.reshape(features_train.shape[0], pixel_width,
pixel_height, 1)
features_test = features_test.reshape(features_test.shape[0], pixel_width,
pixel_height, 1)
input_shape = (pixel_width, pixel_height, 1)
features_train = features_train.astype('float32')
features_test = features_test.astype('float32')
features_train /= 255
features_test /= 255
labels_train = keras.utils.to_categorical(labels_train, num_of_classes)
labels_test = keras.utils.to_categorical(labels_test, num_of_classes)
import numpy as np
import tensorflowjs as tfjs
from keras.models import Sequential
from keras.layers import Dense
from keras.datasets import mnist
BATCH_SIZE = 64
EPOCHS = 6
IMAGE_LENGTH = 28
INPUT_NODE = 784
OUTPUT_NODE = 10
NUM_CHANNELS = 1
LEARNING_RATE = 0.15
# data, split between train and validate sets
(x_train, y_train), (x_eval, y_eval) = mnist.load_data("mnist")
x_train = x_train.reshape(x_train.shape[0], INPUT_NODE)
x_eval = x_eval.reshape(x_eval.shape[0], INPUT_NODE)
x_train = x_train.astype(np.float32) / 255 - 0.5
x_eval = x_eval.astype(np.float32) / 255 - 0.5
# convert class vector to binary class matrices (one-hot representation)
y_train = keras.utils.to_categorical(y_train, OUTPUT_NODE)
y_eval = keras.utils.to_categorical(y_eval, OUTPUT_NODE)
model = Sequential()
def init(num, size):
model.add(Dense(input_shape=(INPUT_NODE, ), units=size, activation="relu"))
def main(args):
# parameters
batch_size = 128
epochs = 30
learning_rate = 5e-4
train_size_data = 2000
# load data
(X_train,
y_train), (X_valid,
y_valid) = mnist.load_data() # (60000, 28, 28) (10000,)
if K.image_data_format() == "channels_first":
# X_train = X_train.reshape(X_train.shape[0], 1, 28, 28)
X_train = X_train.reshape(X_train.shape[0], 1 * 28 * 28)
else:
# X_train = X_train.reshape(X_train.shape[0], 28, 28, 1)
X_train = X_train.reshape(X_train.shape[0], 1 * 28 * 28)
X_train = X_train.astype("float32") / 255.
y_train = tf.keras.utils.to_categorical(y_train, 10)
# random data order
random_order = np.arange(len(X_train))
np.random.shuffle(random_order)
X_train = X_train[random_order][0:train_size_data]
y_train = y_train[random_order][0:train_size_data]
print("x_train shape:", X_train.shape)
print(X_train.shape[0], "train samples")
# define graph
with tf.name_scope("Inputs"):
X_placeholder = tf.placeholder(tf.float32, [None, 28 * 28 * 1])
Y_placeholder = tf.placeholder(tf.float32, [None, 10])
predict = dnn_medium_model(X_placeholder)
with tf.name_scope("Cross_entropy_loss"):
cross_entropy = tf.reduce_mean(-tf.reduce_sum(
Y_placeholder * tf.log(predict), reduction_indices=[1]))
tf.summary.scalar("cross_entropy",
cross_entropy) # In tensorboard event
with tf.name_scope("train"):
train_step = tf.train.AdamOptimizer(learning_rate).minimize(
cross_entropy)
# train
with tf.Session() as sess:
# Merge all the summaries and write them out to ./logs/Tensorboard/train/
merged = tf.summary.merge_all()
train_writer = tf.summary.FileWriter(
os.path.join(args.LOG_DIR_PATH,
"Visulize_grads/Tensorboard/train/"), sess.graph)
sess.run(tf.global_variables_initializer())
nbrof_batch = int(len(X_train) / batch_size)
cross_entropy_steps = []
accuracy_steps = []
grads_steps = []
for e in range(epochs):
for i in range(nbrof_batch):
step_start = time.time()
batch_x, batch_y = X_train[i * batch_size:(i + 1) *
batch_size], y_train[i * batch_size:
(i + 1) *
batch_size]
feed_dict = {X_placeholder: batch_x, Y_placeholder: batch_y}
_, summary, cross_entropy_ = sess.run(
[train_step, merged, cross_entropy], feed_dict=feed_dict)
y_predict_ = sess.run(predict, feed_dict=feed_dict)
correct_prediction_ = tf.equal(tf.argmax(y_predict_, 1),
tf.argmax(batch_y, 1))
tensor_accuracy = tf.reduce_mean(
tf.cast(correct_prediction_, tf.float32))
accuracy = sess.run(tensor_accuracy, feed_dict=feed_dict)
train_writer.add_summary(summary, e)
grads_total = 0
for variable in tf.trainable_variables():
[grad] = sess.run(tf.gradients(ys=cross_entropy,
xs=variable),
feed_dict=feed_dict) # [] 是取 list 中的值
grad_norm = np.sum(grad**2)
grads_total += grad_norm
grads_total = grads_total**0.5
step_end = time.time()
if i % 10 == 0:
print(
"time:{} sec, epochs:{}, steps:{}, loss={}, accuracy={}, grads_norm={}"
.format(step_end - step_start, e,
(e * nbrof_batch) + i, cross_entropy_,
accuracy, grads_total))
cross_entropy_steps.append(cross_entropy_)
accuracy_steps.append(accuracy)
grads_steps.append(grads_total)
# save loss process
cross_entropy_steps = np.asarray(cross_entropy_steps)
loss_save_path = os.path.join(args.LOG_DIR_PATH, "Visulize_grads",
"loss.npy")
if not os.path.exists(os.path.dirname(loss_save_path)):
os.makedirs(os.path.dirname(loss_save_path))
np.save(loss_save_path, cross_entropy_steps)
print("Loss process to path: ", loss_save_path)
# save accuracy process
accuracy_steps = np.asarray(accuracy_steps)
accuracy_save_path = os.path.join(args.LOG_DIR_PATH, "Visulize_grads",
"accuracy.npy")
if not os.path.exists(os.path.dirname(accuracy_save_path)):
os.makedirs(os.path.dirname(accuracy_save_path))
np.save(accuracy_save_path, accuracy_steps)
print("Accuracy process to path: ", accuracy_save_path)
# save grads process
grads_steps = np.asarray(grads_steps)
grads_save_path = os.path.join(args.LOG_DIR_PATH, "Visulize_grads",
"grads.npy")
if not os.path.exists(os.path.dirname(grads_save_path)):
os.makedirs(os.path.dirname(grads_save_path))
np.save(grads_save_path, grads_steps)
print("Accuracy process to path: ", grads_save_path)
# save model
saver = tf.train.Saver()
save_model_dir_path = os.path.join(args.SAVE_MODLE_DIR_PATH,
"Visulize_grads", "model")
if not os.path.exists(os.path.dirname(save_model_dir_path)):
os.makedirs(os.path.dirname(save_model_dir_path))
save_path = saver.save(sess, save_model_dir_path)
print("Save model to path: {}".format(
os.path.dirname(save_model_dir_path)))
def load_mnist(max_shift):
(x_train, y_train), (x_test, y_test) = mnist.load_data()
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')
x_test = x_test.astype('float32')
y_train = utils.to_categorical(y_train, 10)
y_test = utils.to_categorical(y_test, 10)
idx_tr = range(len(x_train))
np.random.shuffle(idx_tr)
X_train = np.zeros(x_train.shape)
X_train0 = np.zeros(x_train.shape)
X_train1 = np.zeros(x_train.shape)
for i in xrange(x_train.shape[0]):
shifti = np.random.randint(-max_shift, max_shift, size=[2, 2])
x_train_0 = shift_2d(x_train[i, :, :, 0], shifti[0], max_shift)
x_train_1_bis = shift_2d(x_train[idx_tr[i], :, :, 0], shifti[1],
max_shift)
x_train_1 = x_train[idx_tr[i], :, :, 0]
X_train[i] = np.minimum(
np.expand_dims(np.add(x_train_0, x_train_1), axis=2), 255)
X_train0[i] = np.expand_dims(x_train_0, -1)
X_train1[i] = np.expand_dims(x_train_1, -1)
Y_train1 = np.vstack([y_train.argmax(1), y_train[idx_tr].argmax(1)]).T
X_train = X_train[Y_train1[:, 0] != Y_train1[:, 1]]
X_train0 = X_train0[Y_train1[:, 0] != Y_train1[:, 1]]
X_train1 = X_train1[Y_train1[:, 0] != Y_train1[:, 1]]
Y_train1 = Y_train1[Y_train1[:, 0] != Y_train1[:, 1]]
Y_train = K.eval(K.one_hot(Y_train1, 10))
idx_te = range(len(x_test))
np.random.shuffle(idx_te)
X_test = np.zeros(x_test.shape)
X_test0 = np.zeros(x_test.shape)
X_test1 = np.zeros(x_test.shape)
for i in xrange(x_test.shape[0]):
shifti = np.random.randint(-max_shift, max_shift, size=[2, 2])
x_test_0 = shift_2d(x_test[i, :, :, 0], shifti[0], max_shift)
x_test_1_bis = shift_2d(x_test[idx_te[i], :, :, 0], shifti[1],
max_shift)
x_test_1 = x_test[idx_te[i], :, :, 0]
X_test[i] = np.minimum(
np.expand_dims(np.add(x_test_0, x_test_1), axis=2), 255)
X_test0[i] = np.expand_dims(x_test_0, -1)
X_test1[i] = np.expand_dims(x_test_1, -1)
Y_test1 = np.vstack([y_test.argmax(1), y_test[idx_te].argmax(1)]).T
X_test = X_test[Y_test1[:, 0] != Y_test1[:, 1]]
X_test0 = X_test0[Y_test1[:, 0] != Y_test1[:, 1]]
X_test1 = X_test1[Y_test1[:, 0] != Y_test1[:, 1]]
Y_test1 = Y_test1[Y_test1[:, 0] != Y_test1[:, 1]]
Y_test = K.eval(K.one_hot(Y_test1, 10))
X_train /= 255
X_test /= 255
X_train0 /= 255
X_train1 /= 255
X_test0 /= 255
X_test1 /= 255
return (X_train, Y_train), (X_test,
Y_test), (X_train0,
X_train1), (X_test0,
X_test1), (Y_train1,
Y_test1)
def mnist_data():
(xtrain, ytrain), (xtest, ytest) = mnist.load_data()
return mnist_process(xtrain), mnist_process(xtest)
def LoadData():
# the data, shuffled and split between train and test sets
(X_train, y_train), (X_test, y_test) = mnist.load_data()
return X_train, y_train, X_test, y_test
