validation_data=(x_test, y_test),
callbacks=[TuneReportCallback({"mean_accuracy": "accuracy"})])
if __name__ == "__main__":
import ray
from ray import tune
from ray.tune.schedulers import ASHAScheduler
from ray.tune.schedulers.pb2 import PB2
import tensorflow as tf
import numpy as np
import random
print('Is cuda available for container:', tf.test.is_gpu_available())
mnist.load_data() # we do this on the driver because it's not threadsafe
ray.init(
num_cpus=8,
num_gpus=1,
include_dashboard=
True, # if you use docker use docker run -p 8265:8265 -p 6379:6379
dashboard_host='0.0.0.0')
sched_asha = ASHAScheduler(
time_attr="training_iteration",
max_t=100,
grace_period=10,
#mode='max', #find maximum, do not define here if you define in tune.run
reduction_factor=3,
brackets=1)
test_dataset = h5py.File('datasets/test_catvnoncat.h5', "r")
test_set_x_orig = np.array(
test_dataset["test_set_x"][:]) # your test set features
test_set_y_orig = np.array(
test_dataset["test_set_y"][:]) # your test set labels
classes = np.array(test_dataset["list_classes"][:]) # the list of classes
train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))
test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))
return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes
if __name__ == '__main__':
(X_train, y_train), (X_test, y_test) = mnist.load_data()
plt.imshow(X_train[0], cmap=plt.get_cmap('gray_r'))
plt.show()
X_train_flatten = flatten(X_train)
X_test_flatten = flatten(X_test)
X_train_flatten = X_train_flatten.astype('float32')
X_test_flatten = X_test_flatten.astype('float32')
X_train = X_train_flatten / 255
X_test = X_test_flatten / 255
y_train = tensorflow.keras.utils.to_categorical(y_train, 10).T
y_test = tensorflow.keras.utils.to_categorical(y_test, 10).T
from sklearn.metrics import classification_report, confusion_matrix
import os
from tensorflow.keras.datasets import mnist
import pickle
import numpy as np
from time import perf_counter
from sklearn import preprocessing
from keras.utils import to_categorical
from keras.models import Sequential
from keras.layers import Dense
from csv import DictWriter
from csv import writer
import itertools
current_dir = os.getcwd()
(X_orig, y_orig), (_,_) = mnist.load_data(path=current_dir+'/../../../Data/MNIST/mnist.npz')
#Parameters
dr = [1,2,3,4,5,6,7,8,9,10,50,100,200]
dataset = current_dir+"/../../../Data/MNIST/mnist_medium.npz"
data = np.load(dataset)
index = data['index']
index = np.append(index,np.array([i for i in range(60000) if i not in index]))
field_names = ["Dimension","Accuracy"]
with open("mppca.csv","w", newline='') as file:
filewriter = writer(file, delimiter=',')
filewriter.writerow(field_names)
default="output.png",
help="path to output visualization file")
ap.add_argument("-p",
"--plot",
type=str,
default="plot.png",
help="path to output plot file")
args = vars(ap.parse_args())
# Initialize the number of epochs to train for and batch size
EPOCHS = 25
BS = 32
# Load the MNIST dataset
print("[INFO] Loading the MNIST dataset...")
((trainX, _), (testX, _)) = mnist.load_data()
# Add a channel dimension to every image in the dataset, then scale the pixel intensities to the range [0, 1]
trainX = np.expand_dims(trainX, axis=-1)
testX = np.expand_dims(testX, axis=-1)
trainX = trainX.astype("float32") / 255.0
testX = testX.astype("float32") / 255.0
# Construct the convolutional autoencoder
print("[INFO] Building the autoencoder...")
(encoder, decoder, autoencoder) = ConvAutoEncoder.build(28, 28, 1)
opt = Adam(lr=1e-3)
autoencoder.compile(loss="mse", optimizer=opt)
# Train the convolution autoencoder
H = autoencoder.fit(trainX,
def change_hidden_units():
with tensorflow.device('/cpu:0'):
for hidden_units in hidden_units_arr:
print("\nNumber of Hidden Units", hidden_units)
starttime = datetime.now()
# Load mnist dataset
print("\nLoading MNIST dataset.")
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# Compute the number of labels
num_labels = len(np.unique(y_train))
# Convert to one-hot vectors
y_train = to_categorical(y_train)
y_test = to_categorical(y_test)
# Get the image dimensions (assumed square)
image_size = x_train.shape[1]
input_size = image_size * image_size
# Resize and normalize
x_train = np.reshape(x_train, [-1, input_size])
x_train = x_train.astype('float32') / 255
x_test = np.reshape(x_test, [-1, input_size])
x_test = x_test.astype('float32') / 255
# Setup the network parameters
batch_size = 128
hidden_units = 256
dropout = 0.45
# model is a 3-layer MLP with ReLU and dropout after each layer
model = Sequential()
model.add(Dense(hidden_units, input_dim=input_size))
model.add(Activation('relu'))
model.add(Dropout(dropout))
model.add(Dense(hidden_units))
model.add(Activation('relu'))
model.add(Dropout(dropout))
model.add(Dense(num_labels))
# this is the output for one-hot vector
model.add(Activation('softmax'))
# Print model summary and save the network image to the file specified
model.summary()
plot_model(model, to_file='mp1_nn1.png', show_shapes=True)
# loss function for one-hot vector
# use of adam optimizer
# accuracy is good metric for classification tasks
model.compile(loss='categorical_crossentropy',
optimizer='adam',
metrics=['accuracy'])
# Train the network
model.fit(x_train, y_train, epochs=20, batch_size=batch_size)
# Compute predictions (test mode) for training data
y_pred = model.predict(x_train,
batch_size=batch_size,
verbose=0)
# Convert one-hot tensors back to class labels (and make them numpy arrays)
y_train_true_class = K.argmax(y_train).numpy()
y_train_pred_class = K.argmax(y_pred).numpy()
# Students, insert code here to create CM and print confusion matrix and stats
cm_train, cm_train_acc = confusion_matrix(y_train_true_class, y_train_pred_class)
print_confusion_matrix_stats(cm_train, 'Train')
# Validate the model on test dataset to determine generalization
y_pred = model.predict(x_test,
batch_size=batch_size,
verbose=0)
# Convert one-hot tensors back to class labels (and make them numpy arrays)
y_test_true_class = K.argmax(y_test).numpy()
y_test_pred_class = K.argmax(y_pred).numpy()
# Students, insert code here to create CM and print confusion matrix and stats
cm_test, cm_test_acc = confusion_matrix(y_test_true_class, y_test_pred_class)
print_confusion_matrix_stats(cm_test, 'Test')
endtime = datetime.now()
print("Elapsed time:", endtime - starttime)
return
def get_validation_data(dataset,
normalize=True,
sort_x=True,
binarize=True,
subtract_mean=True,
balance_traits=True,
input_shape=None):
if dataset == 'mnist':
((_, _), (X, Y)) = mnist.load_data()
if K.image_data_format() == "channels_first":
X = X.reshape((X.shape[0], 1, 28, 28))
else:
X = X.reshape((X.shape[0], 28, 28, 1))
if normalize:
X = X.astype("float") / 255.0
X = X - np.mean(X, axis=0)
elif dataset == '3D-shapes':
data_path = '../data/3dshapes.h5'
parent_dir = str(pathlib.Path().absolute()).split('/')[-1]
if parent_dir == 'SimilarityGames':
data_path = data_path[3:]
dataset = h5py.File(data_path, 'r')
data = dataset['images'][:]
full_labels = dataset['labels'][:]
labels_reg, labels_relational, keeper_idxs = get_shape_color_labels(
full_labels, balance_traits=balance_traits)
if keeper_idxs is not None:
data = np.array([data[idx] for idx in keeper_idxs])
(train_data, test_data, train_labels,
test_labels) = train_test_split(data,
labels_reg,
test_size=0.25,
random_state=42)
if K.image_data_format() == "channels_first":
train_data = train_data.reshape(
(train_data.shape[0], input_shape[2], input_shape[1],
input_shape[0]))
test_data = test_data.reshape((test_data.shape[0], input_shape[2],
input_shape[1], input_shape[0]))
else:
train_data = train_data.reshape(
(train_data.shape[0], input_shape[0], input_shape[1],
input_shape[2]))
test_data = test_data.reshape((test_data.shape[0], input_shape[0],
input_shape[1], input_shape[2]))
if normalize:
train_data = train_data.astype("float32") / 255.0
test_data = test_data.astype("float32") / 255.0
if subtract_mean:
if K.image_data_format() == "channels_first":
tmp_data = train_data.reshape(train_data.shape[1], -1)
else:
tmp_data = train_data.reshape(train_data.shape[-1], -1)
mean = np.mean(tmp_data, axis=1)
# sanity check because np.mean over multiple axes seems to behave strangely some times,
# may be worth diving into
if abs(np.mean(mean) - np.mean(train_data)) > 1e-3:
raise ValueError(
"results of mean calculation suspicious, please double check before continuing"
)
print('channel means = ' + str(mean) + ', data mean = ' +
str(np.mean(train_data)))
test_data = test_data - mean
X = test_data
Y = test_labels
if sort_x:
X_sorted = sort_data(X, Y)
if binarize:
lb = LabelBinarizer()
Y = lb.fit_transform(Y)
if sort_x:
return X, Y, X_sorted
else:
return X, Y
import tensorflow as tf
from tensorflow.keras.models import Model, Sequential
from tensorflow.keras.layers import Flatten, Dense
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.losses import SparseCategoricalCrossentropy
from tensorflow.keras.metrics import SparseCategoricalAccuracy
from tensorflow.keras.datasets import mnist
(train_x, train_y), (test_x, test_y) = mnist.load_data()
train_x, test_x = train_x / 255.0, test_x / 255.0
print('train data:', train_x.shape, train_y.shape)
print('test data: ', test_x.shape, test_y.shape)
# 自定义网络
class MnistModel(Model):
def __init__(self):
super(MnistModel, self).__init__()
self.flatten = Flatten()
self.d1 = Dense(128,
activation='relu',
kernel_regularizer=tf.keras.regularizers.L2())
self.d2 = Dense(10, activation='softmax')
def call(self, x):
y = self.flatten(x)
y = self.d1(y)
y = self.d2(y)
return y
Flatten(input_shape=(28, 28)),
Dense(128, activation=relu),
Dense(64, activation=relu),
Dense(n, activation=relu),
Dense(64, activation=relu),
Dense(128, activation=relu),
Dense(28*28, activation=softmax),
Reshape((28, 28)),
])
model.compile(optimizer='adadelta', loss='binary_crossentropy')
return model
if __name__ == "__main__":
(train_in, _), (test_in, test_out) = mnist.load_data()
train_in = train_in / 255.0
test_in = test_in / 255.0
train_in = train_in.reshape((train_in.shape[0], 28, 28, 1))
test_in = test_in.reshape((test_in.shape[0], 28, 28, 1))
n = 16
model, _, _ = get_conv_ae(n)
model.summary()
x_size = 10
y_size = 4
x_epochs = 1
indices = [np.where(test_out == i)[0][0] for i in range(x_size)]
fig = plt.figure(figsize=(x_size, y_size))
out_vis = []
# based on MNIST images: 28x28 greyscale
num_rows = 28
num_cols = 28
num_channels = 1
#
latent_dim = 100
NUM_EPOCHS = 20000 # probably needs to be closer to 50k?
BATCH_SIZE = 64
DROPOUT_RATE = 0.3
LEAKY_RELU_ALPHA = 0.25
##################################################################################################
# load dataset
(train_images, train_labels), (_, _) = mnist.load_data()
# rescale -1 to 1 and normalize
# use in coordination with tanh activation
train_images = train_images.reshape(train_images.shape[0], num_rows, num_cols,
num_channels)
train_images = train_images.astype(np.float32)
train_images = (train_images - 127.5) / 127.5
##################################################################################################
# GENERATOR
g = Sequential()
g.add(
Dense(units=7 * 7 * 512,
input_dim=latent_dim,
# -*- coding: utf-8 -*-
"""
Created on Wed Feb 17 08:16:56 2021
@author: justin
"""
import tensorflow
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Conv2D, MaxPooling2D, Flatten
from tensorflow.keras.optimizers import RMSprop
(mnist_train_images,
mnist_train_labels), (mnist_test_images,
mnist_test_labels) = mnist.load_data()
from tensorflow.keras import backend as K
if K.image_data_format() == 'channels_first':
train_images = mnist_train_images.reshape(mnist_train_images.shape[0], 1,
28, 28)
test_images = mnist_test_images.reshape(mnist_test_images.shape[0], 1, 28,
28)
input_shape = (1, 28, 28)
else:
train_images = mnist_train_images.reshape(mnist_train_images.shape[0], 28,
28, 1)
test_images = mnist_test_images.reshape(mnist_test_images.shape[0], 28, 28,
1)
input_shape = (28, 28, 1)
def load_data(index):
if (index == 1):
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
num_classes = 10
# 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)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
elif (index == 2):
print("data set cifar100")
(x_train, y_train), (x_test,
y_test) = cifar100.load_data(label_mode='fine')
num_classes = 100
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
elif (index == 3):
print("data set MNIST")
# 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()
num_classes = 10
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')
# 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)
elif (index == 4):
print("data set MNIST-Fashion")
(x_train, y_train), (x_test, y_test) = fashion_mnist.load_data()
num_classes = 10
# Convert class vectors to binary class matrices.
# if we are using "channels first" ordering, then reshape the design
# matrix such that the matrix is:
# num_samples x depth x rows x columns
if K.image_data_format() == "channels_first":
x_train = x_train.reshape((x_train.shape[0], 1, 28, 28))
x_test = x_test.reshape((x_test.shape[0], 1, 28, 28))
# otherwise, we are using "channels last" ordering, so the design
# matrix shape should be: num_samples x rows x columns x depth
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))
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
elif (index == 5):
# print("probiere STL 10 data set")
import os
import urllib as urllib
import tarfile
import sys
import numpy as np
HEIGHT, WIDTH, DEPTH = 96, 96, 3
num_classes = 10
SIZE = HEIGHT * WIDTH * DEPTH
DATA_DIR = './stl10_data'
DATA_URL = 'http://ai.stanford.edu/~acoates/stl10/stl10_binary.tar.gz'
TRAIN_DATA_PATH = DATA_DIR + '/stl10_binary/train_X.bin'
TEST_DATA_PATH = DATA_DIR + '/stl10_binary/test_X.bin'
TRAIN_LABELS_PATH = DATA_DIR + '/stl10_binary/train_y.bin'
TEST_LABELS_PATH = DATA_DIR + '/stl10_binary/test_y.bin'
CLASS_NAMES_PATH = DATA_DIR + '/stl10_binary/class_names.txt'
def read_labels(path_to_labels):
with open(path_to_labels, 'rb') as f:
labels = np.fromfile(f, dtype=np.uint8)
return labels
def read_all_images(path_to_data):
with open(path_to_data, 'rb') as f:
# read whole file in uint8 chunks
everything = np.fromfile(f, dtype=np.uint8)
images = np.reshape(everything, (-1, DEPTH, WIDTH, HEIGHT))
images = np.transpose(images, (0, 3, 2, 1))
return images
def download_and_extract():
# if the dataset already exists locally, no need to download it again.
if all((
os.path.exists(TRAIN_DATA_PATH),
os.path.exists(TRAIN_LABELS_PATH),
os.path.exists(TEST_DATA_PATH),
os.path.exists(TEST_LABELS_PATH),
)):
return
dest_directory = DATA_DIR
if not os.path.exists(dest_directory):
os.makedirs(dest_directory)
filename = DATA_URL.split('/')[-1]
filepath = os.path.join(dest_directory, filename)
if not os.path.exists(filepath):
def _progress(count, block_size, total_size):
sys.stdout.write('\rDownloading %s %.2f%%' %
(filename, float(count * block_size) /
float(total_size) * 100.0))
sys.stdout.flush()
filepath, _ = urlretrieve(DATA_URL, filepath)
print('Downloaded', filename)
tarfile.open(filepath, 'r:gz').extractall(dest_directory)
def load_dataset():
# download the extract the dataset.
download_and_extract()
# load the train and test data and labels.
x_train = read_all_images(TRAIN_DATA_PATH)
y_train = read_labels(TRAIN_LABELS_PATH)
x_test = read_all_images(TEST_DATA_PATH)
y_test = read_labels(TEST_LABELS_PATH)
if K.image_data_format() == "channels_first":
x_train = x_train.reshape(
(x_train.shape[0], DEPTH, HEIGHT, WIDTH))
x_test = x_test.reshape(
(x_test.shape[0], DEPTH, HEIGHT, WIDTH))
else:
x_train = x_train.reshape(
(x_train.shape[0], HEIGHT, WIDTH, DEPTH))
x_test = x_test.reshape(
(x_test.shape[0], HEIGHT, WIDTH, DEPTH))
x_train = x_train.astype('float32')
x_train = (x_train - 127.5) / 127.5
x_test = x_test.astype('float32')
x_test = (x_test - 127.5) / 127.5
# convert the labels to be zero based.
y_train -= 1
y_test -= 1
# convert labels to hot-one vectors.
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)
(x_train, y_train), (x_test, y_test) = load_dataset()
else:
print("data set not found")
# gibt die geladenen Datensaetze an den Suchalgorithmus zurueck
return (x_train, y_train), (x_test, y_test)
from tensorflow.keras.datasets import mnist
from tensorflow.keras import models
from tensorflow.keras import layers
from tensorflow.keras.utils import to_categorical
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()
train_images = train_images.reshape((60000, 28 * 28))
train_images = train_images.astype('float32') / 255
test_images = test_images.reshape((10000, 28 * 28))
test_images = test_images.astype('float32') / 255
train_labels = to_categorical(train_labels)
test_labels = to_categorical(test_labels)
network = models.Sequential()
network.add(layers.Dense(512, activation='relu', input_shape=(28 * 28, )))
network.add(layers.Dense(10, activation='softmax'))
network.compile(optimizer='rmsprop',
loss='categorical_crossentropy',
metrics=['accuracy'])
hist = network.fit(train_images, train_labels, epochs=5, batch_size=128)
result = network.evaluate(test_images, test_labels, verbose=2)
def build_dataset(self, type):
if type == 'cifar10':
# LOAD DATA
from tensorflow.keras.datasets import cifar10
(train_image, train_label), (test_image,
test_label) = cifar10.load_data()
# PREPARE IMAGE BATCH
_image_batch = np.concatenate([train_image, test_image], axis=0)
self.image_batch = image.scale_out(_image_batch / 255.0)
# PREPARE LABEL BATCH
_label_batch = np.concatenate([train_label, test_label], axis=0)
self.label_batch = np.zeros(
shape=[_label_batch.shape[0],
_label_batch.max() + 1])
for i, label in enumerate(_label_batch):
self.label_batch[i, label] = 1
# PREPARE TRAIN INDEX
self.train_index = np.arange(start=0,
stop=self.image_batch.shape[0] -
self.batch_size,
step=self.batch_size,
dtype=int)
elif type == 'cifar100':
# LOAD DATA
from tensorflow.keras.datasets import cifar100
(train_image, train_label), (test_image,
test_label) = cifar100.load_data()
# PREPARE IMAGE BATCH
_image_batch = np.concatenate([train_image, test_image], axis=0)
self.image_batch = image.scale_out(_image_batch / 255.0)
# PREPARE LABEL BATCH
_label_batch = np.concatenate([train_label, test_label], axis=0)
self.label_batch = np.zeros(
shape=[_label_batch.shape[0],
_label_batch.max() + 1])
for i, label in enumerate(_label_batch):
self.label_batch[i, label] = 1
# PREPARE TRAIN INDEX
self.train_index = np.arange(start=0,
stop=self.image_batch.shape[0] -
self.batch_size,
step=self.batch_size,
dtype=int)
elif type == 'mnist':
# LOAD DATA
from tensorflow.keras.datasets import mnist
(train_image, train_label), (test_image,
test_label) = mnist.load_data()
# PREPARE IMAGE BATCH
_train_image, _test_image = np.pad(
train_image, ((0, 0), (2, 2), (2, 2)),
'edge'), np.pad(test_image, ((0, 0), (2, 2), (2, 2)), 'edge')
_train_image, _test_image = _train_image[
..., np.newaxis], _test_image[..., np.newaxis]
_image_batch = np.concatenate([_train_image, _test_image], axis=0)
self.image_batch = image.scale_out(_image_batch / 255.0)
# PREPARE LABEL BATCH
_label_batch = np.concatenate([train_label, test_label], axis=0)
self.label_batch = np.zeros(
shape=[_label_batch.shape[0],
_label_batch.max() + 1])
for i, label in enumerate(_label_batch):
self.label_batch[i, label] = 1
# PREPARE TRAIN INDEX
self.train_index = np.arange(start=0,
stop=self.image_batch.shape[0] -
self.batch_size,
step=self.batch_size,
dtype=int)
else:
raise ValueError('unknown dataset type: {}'.format(type))
def train(args):
if args.d == "mnist":
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.reshape(-1, 28, 28, 1)
x_test = x_test.reshape(-1, 28, 28, 1)
layers = [
Conv2D(24, (5, 5), padding="valid", input_shape=(28, 28, 1)),
Activation("relu"),
MaxPooling2D(pool_size=(2, 2)),
Conv2D(64, (5, 5), padding="valid"),
Activation("relu"),
MaxPooling2D(pool_size=(2, 2)),
Dropout(0.5),
Flatten(),
Dense(1000),
Activation("relu"),
Dropout(0.5),
Dense(10),
]
elif args.d == "cifar":
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
layers = [
Conv2D(32, (3, 3), padding="same", input_shape=(32, 32, 3)),
Activation("relu"),
Conv2D(32, (3, 3), padding="same"),
Activation("relu"),
MaxPooling2D(pool_size=(2, 2)),
Conv2D(64, (3, 3), padding="same"),
Activation("relu"),
Conv2D(64, (3, 3), padding="same"),
Activation("relu"),
MaxPooling2D(pool_size=(2, 2)),
Conv2D(128, (3, 3), padding="same"),
Activation("relu"),
Conv2D(128, (3, 3), padding="same"),
Activation("relu"),
MaxPooling2D(pool_size=(2, 2)),
Flatten(),
Dropout(0.5),
Dense(1024, kernel_regularizer=l2(0.01),
bias_regularizer=l2(0.01)),
Activation("relu"),
Dropout(0.5),
Dense(512, kernel_regularizer=l2(0.01), bias_regularizer=l2(0.01)),
Activation("relu"),
Dropout(0.5),
Dense(10),
]
x_train = x_train.astype("float32")
x_test = x_test.astype("float32")
x_train = (x_train / 255.0) - (1.0 - CLIP_MAX)
x_test = (x_test / 255.0) - (1.0 - CLIP_MAX)
y_train = np_utils.to_categorical(y_train, 10)
y_test = np_utils.to_categorical(y_test, 10)
model = Sequential()
for layer in layers:
model.add(layer)
model.add(Activation("softmax"))
opt = tf.keras.optimizers.Adam(lr=0.0002)
print(model.summary())
model.compile(loss="categorical_crossentropy",
optimizer=opt,
metrics=["accuracy"])
model.fit(
x_train,
y_train,
epochs=10,
batch_size=128,
shuffle=True,
verbose=1,
validation_data=(x_test, y_test),
)
model.save("./model/model_{}.h5".format(args.d))
def mnist_train_and_evaluate(model, batch_size=32, epochs=10, model_name=''):
# load the dataset using the builtin Keras method
(X_train, y_train), (X_test, y_test) = mnist.load_data()
# derive a validation set from the training set
# the original training set is split into
# new training set (90%) and a validation set (10%)
X_train, X_val = train_test_split(X_train,
test_size=0.10,
random_state=101)
y_train, y_val = train_test_split(y_train,
test_size=0.10,
random_state=101)
# the shape of the data matrix is NxHxW, where
# N is the number of images,
# H and W are the height and width of the images
# keras expect the data to have shape NxHxWxC, where
# C is the channel dimension
X_train = np.reshape(X_train, (-1, 28, 28, 1))
X_val = np.reshape(X_val, (-1, 28, 28, 1))
X_test = np.reshape(X_test, (-1, 28, 28, 1))
# convert the datatype to float32
X_train = X_train.astype('float32')
X_val = X_val.astype('float32')
X_test = X_test.astype('float32')
# normalize our data values to the range [0,1]
X_train /= 255
X_val /= 255
X_test /= 255
# convert 1D class arrays to 10D class matrices
y_train = to_categorical(y_train, 10)
y_val = to_categorical(y_val, 10)
y_test = to_categorical(y_test, 10)
# compile the model
model.compile(loss='categorical_crossentropy',
optimizer='sgd',
metrics=['accuracy'])
# use this variable to name your model
# model_name="my_first_model"
# create a way to monitor our model in Tensorboard (disabled)
# tensorboard = TensorBoard("logs/" + model_name)
# train the model
model.fit(X_train,
y_train,
batch_size=batch_size,
epochs=epochs,
verbose=1,
validation_data=(X_val, y_val)) # , callbacks=[tensorboard])
score = model.evaluate(X_test, y_test, verbose=0)
#print("Model '{}' performance:".format(model_name))
#print("Loss: ",score[0])
#print("Accuracy: ",score[1])
#print()
return score[1]
def train(choice, h_layers=None, neurons=None, b_size=None, eps=None):
if (choice == 1):
model = build_model(h_layers, neurons)
print("\nLoading dataset...")
(X_train, y_train), (X_test, y_test) = mnist.load_data()
print("\nLoading dataset Successful...")
print("\nNormalizing data...")
X_train = X_train / 255.0
X_test = X_test / 255.0
print("\nNormalizing data Successful...")
input("\nPress any key to start training your model...")
os.system('cls')
print("Training your model with : \nHidden Layers : ", h_layers,
"\nNeurons : ,", neurons, "\nBatch Size : ", b_size,
"\nEpochs : ", eps, "\n")
model.fit(X_train,
y_train,
batch_size=b_size,
epochs=eps,
validation_data=(X_test, y_test))
time.sleep(3)
os.system('cls')
print("Model training Successful,Your Model Details")
print("\nModel trained on ", len(X_train), " Samples and tested on ",
len(X_test), " Samples")
print("\nModel Testing Accuracy : ", model.evaluate(X_test, y_test)[1])
print("\nModel Summary :")
print(model.summary())
input(
"\nPress any key to continue...(Your trained model will be saved automatically...)"
)
print("\nSaving your model...")
model.save('DIGIT.model')
else:
model = build_cnn_model()
print("\nLoading dataset...")
(X_train, y_train), (X_test, y_test) = mnist.load_data()
print("\nLoading dataset Successful...")
print("\nNormalizing data...")
X_train = X_train / 255.0
X_test = X_test / 255.0
print("\nNormalizing data Successful...")
print("\nConverting the input Image into Volume...")
X_train = X_train.reshape(-1, 28, 28, 1)
X_test = X_test.reshape(-1, 28, 28, 1)
print("\nConvertion Successful...")
input("\nPress any key to start training your model...")
os.system('cls')
model.fit(X_train,
y_train,
batch_size=b_size,
epochs=eps,
validation_data=(X_test, y_test))
time.sleep(3)
os.system('cls')
print("Model training Successful,Your Model Details")
print("\nModel trained on ", len(X_train), " Samples and tested on ",
len(X_test), " Samples")
print("\nModel Testing Accuracy : ", model.evaluate(X_test, y_test)[1])
print("\nModel Summary :")
print(model.summary())
input(
"\nPress any key to continue...(Your trained model will be saved automatically...)"
)
print("\nSaving your model...")
model.save('DIGIT_CNN.model')
from pyimagesearch.nn.conv import LeNet
from tensorflow.keras.optimizers import SGD
from tensorflow.keras.datasets import mnist
from sklearn.preprocessing import LabelBinarizer
from sklearn.metrics import classification_report
from tensorflow.keras import backend as K
import matplotlib.pyplot as plt
import numpy as np
print("[INFO] accessing MNIST...")
((trainData, trainLabels), (testData, testLabels)) = mnist.load_data()
if K.image_data_format() == "channels_first":
trainData = trainData.reshape((trainData.shape[0], 1, 28, 28))
testData = testData.reshape((testData.shape[0], 1, 28, 28))
else:
trainData = trainData.reshape((trainData.shape[0], 28, 28, 1))
testData = testData.reshape((testData.shape[0], 28, 28, 1))
trainData = trainData.astype("float32") / 255.0
testData = testData.astype("float32") / 255.0
print(trainLabels)
le = LabelBinarizer()
trainLabels = le.fit_transform(trainLabels)
testLabels = le.transform(testLabels)
print("[INFO] compiling model...")
opt = SGD(lr=0.01)
model = LeNet.build(width=28, height=28, depth=1, classes=10)
model.compile(loss="categorical_crossentropy",
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(Conv2D(32, kernel_size=3, strides=2, padding="same"))
model.add(ZeroPadding2D(padding=((0, 1), (0, 1))))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(Conv2D(64, kernel_size=3, strides=2, padding="same"))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(Conv2D(128, kernel_size=3, strides=1, padding="same"))
model.add(BatchNormalization(momentum=0.8))
model.add(LeakyReLU(alpha=0.2))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(1))
model.summary()
img = Input(shape=self.img_shape)
validity = model(img)
return Model(inputs=img, outputs=validity)
if __name__ == "__main__":
# Load the dataset
(X_train, _), (_, _) = mnist.load_data()
wgan = WGAN(img_shape=(28, 28, 1))
wgan.train(data=X_train, epochs=400, batch_size=32, sample_interval=400)
def load_dataset(angle):
# load dataset
(trainX, trainY), (testX, testY) = mnist.load_data()
for i in [9]:
trainX = np.delete(trainX, np.where(trainY == i), axis=0)
trainY = np.delete(trainY, np.where(trainY == i))
testX = np.delete(testX, np.where(testY == i), axis=0)
testY = np.delete(testY, np.where(testY == i))
trainX = trainX.astype('float32')
testX = testX.astype('float32')
#Create two new datasets for the rotated digits
train_rot_X = np.empty((len(trainX) * 2, 28, 28))
train_rot_Y = np.empty((len(trainX) * 2, ))
test_rot_X = np.empty((len(testX) * 2, 28, 28))
test_rot_Y = np.empty((len(testY) * 2))
for i in range(len(trainY)):
train_rot_Y[i] = trainY[i]
for i in range(len(trainY)):
train_rot_Y[i + len(trainX)] = trainY[i]
for i in range(len(testY)):
test_rot_Y[i] = testY[i]
for i in range(len(testY)):
test_rot_Y[i + len(testY)] = testY[i]
for i in range(len(trainX)):
train_rot_X[i] = trainX[i]
T = measure.moments_central(train_rot_X[i])
im_2 = rotate(
train_rot_X[i],
180. -
0.5 * np.arctan2(2. * T[1, 1], T[2, 0] - T[0, 2]) / math.pi * 180.,
reshape=False,
order=3)
train_rot_X[i] = rotate(
train_rot_X[i],
-0.5 * np.arctan2(2. * T[1, 1], T[2, 0] - T[0, 2]) / math.pi *
180.,
reshape=False,
order=3)
train_rot_X[i + len(trainX)] = im_2
for i in range(len(testX)):
test_rot_X[i] = testX[i]
T = measure.moments_central(test_rot_X[i])
im_2 = rotate(
test_rot_X[i],
180. -
0.5 * np.arctan2(2. * T[1, 1], T[2, 0] - T[0, 2]) / math.pi * 180.,
reshape=False,
order=3)
test_rot_X[i] = rotate(
test_rot_X[i],
-0.5 * np.arctan2(2. * T[1, 1], T[2, 0] - T[0, 2]) / math.pi *
180.,
reshape=False,
order=3)
test_rot_X[i + len(testX)] = im_2
#reshape dataset to have a single channel
trainX = train_rot_X.reshape((train_rot_X.shape[0], 28, 28, 1))
testX = testX.reshape((testX.shape[0], 28, 28, 1))
# one hot encode target values
trainY = to_categorical(train_rot_Y)
testY = to_categorical(testY)
print(trainY.shape)
return trainX, trainY, testX, testY
# In[1]: # TensorFlow and tf.keras import tensorflow as tf from tensorflow import keras from tensorflow.keras.datasets import mnist # Helper libraries import numpy as np import matplotlib.pyplot as plt print(tf.__version__) # In[ ]: type(mnist.load_data()[0][0]) # ## Chargement du MNIST data # # La cellule ci-dessous permet de séparer la base de données MNIST, de tensorFlow, en différentes variables(train_data, train_label, test_date, test_labels) grâce à la fonction mnist.load_data() # # train_data contient des images 28X28 pixels d'un chiffre écrit à la main qui serviront à entrainer le réseau neuronal # In[ ]: print(train_data) # train_labels contient le chiffre associé à la réponse attendue lors de l'entrainement
import numpy as np
from tensorflow.keras.datasets import mnist
(x_train, _), (x_test, _) = mnist.load_data()
x_train = x_train.reshape(60000, 784).astype('float32')/255
x_test = x_test.reshape(10000, 784).astype('float32')/255
from tensorflow.keras.models import Sequential, Model
from tensorflow.keras.layers import Dense, Input
def autoencoder(hidden_layer_size):
model = Sequential()
model.add(Dense(units=hidden_layer_size, input_shape=(784,),
activation='relu'))
model.add(Dense(units=784,activation='sigmoid'))
return model
def deeplearning():
model = Sequential()
model.add(Dense(256, input_shape=(784,),activation='relu'))
model.add(Dense(128,activation='relu'))
model.add(Dense(64,activation='relu'))
model.add(Dense(32,activation='relu'))
model.add(Dense(64,activation='relu'))
model.add(Dense(128,activation='relu'))
model.add(Dense(256,activation='relu'))
model.add(Dense(units=784,activation='sigmoid'))
return model
# model = autoencoder(hidden_layer_size=154)
model = deeplearning()
def main(args):
# Horovod: initialize Horovod.
hvd.init()
if not args.use_only_cpu:
# Horovod: pin GPU to be used to process local rank (one GPU per process)
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
config.gpu_options.visible_device_list = str(hvd.local_rank())
else:
config = None
K.set_session(tf.Session(config=config))
batch_size = 128
num_classes = 10
# Horovod: adjust number of epochs based on number of GPUs.
epochs = int(math.ceil(args.num_epochs / hvd.size()))
# 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()
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")
# 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)
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"))
# Horovod: adjust learning rate based on number of GPUs.
opt = keras.optimizers.Adadelta(1.0 * hvd.size())
# Horovod: add Horovod Distributed Optimizer.
opt = hvd.DistributedOptimizer(opt)
##### Enabling SageMaker Debugger ###########
# creating hook
smd_hook = smd.KerasHook(
out_dir=args.out_dir,
save_config=smd.SaveConfig(save_interval=args.save_interval),
include_collections=["weights", "gradients"],
include_workers=args.include_workers,
)
##### Enabling SageMaker Debugger ###########
# wrapping optimizer so hook can identify gradients
opt = smd_hook.wrap_optimizer(opt)
model.compile(loss=keras.losses.categorical_crossentropy, optimizer=opt, metrics=["accuracy"])
callbacks = [
# Horovod: broadcast initial variable states from rank 0 to all other processes.
# This is necessary to ensure consistent initialization of all workers when
# training is started with random weights or restored from a checkpoint.
hvd.callbacks.BroadcastGlobalVariablesCallback(0),
##### Enabling SageMaker Debugger ###########
# adding smd hook as a callback
smd_hook,
]
# Horovod: save checkpoints only on worker 0 to prevent other workers from corrupting them.
if hvd.rank() == 0:
callbacks.append(
keras.callbacks.ModelCheckpoint(os.path.join(args.model_dir, "checkpoint-{epoch}.h5"))
)
model.fit(
x_train,
y_train,
batch_size=batch_size,
callbacks=callbacks,
epochs=epochs,
verbose=1 if hvd.rank() == 0 else 0,
validation_data=(x_test, y_test),
)
score = model.evaluate(x_test, y_test, verbose=0)
print("Test loss:", score[0])
print("Test accuracy:", score[1])
from tensorflow.keras.datasets import mnist #Библиотека с базой Mnist
from tensorflow.keras.models import Sequential, model_from_json # Подлючаем класс создания модели Sequential
from tensorflow.keras.layers import Dense # Подключаем класс Dense - полносвязный слой
from tensorflow.keras.optimizers import Adam # Подключаем оптимизатор Adam
from tensorflow.keras import utils #Утилиты для to_categorical
from tensorflow.keras.preprocessing import image #Для отрисовки изображения
import numpy as np # Подключаем библиотеку numpy
(x_train_org,
y_train_org), (x_test_org,
y_test_org) = mnist.load_data() #Загрузка данных Mnist
#Меняем формат входных картинок с 28х28 на 784х1
x_train = x_train_org.reshape(60000, 784)
x_test = x_test_org.reshape(10000, 784)
#Нормализуем входные картинки
x_train = x_train.astype(
'float32'
) # преобразовываем x_train в тип float (цифры с плавающей точкой)
x_train = x_train / 255 # делим на 255, чтобы диапазон был от 0 до 1
x_test = x_test.astype(
'float32') # преобразовываем x_test в тип float (цифры с плавающей точкой)
x_test = x_test / 255 # делим на 255, чтобы диапазон был от 0 до 1
# Преобразуем ответы в формат one_hot_encoding
y_train = utils.to_categorical(y_train_org, 10)
y_test = utils.to_categorical(y_test_org, 10)
model = Sequential() # Создаём сеть прямого распространения
model.add(Dense(800, input_dim=784, activation="relu")
# example of a cnn for image classification
from numpy import unique
from numpy import argmax
from tensorflow.keras.datasets.mnist import load_data
from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense
from tensorflow.keras.layers import Conv2D
from tensorflow.keras.layers import MaxPool2D
from tensorflow.keras.layers import Flatten
from tensorflow.keras.layers import Dropout
# load dataset
(x_train, y_train), (x_test, y_test) = load_data()
# reshape data to have a single channel
x_train = x_train.reshape(
(x_train.shape[0], x_train.shape[1], x_train.shape[2], 1))
x_test = x_test.reshape((x_test.shape[0], x_test.shape[1], x_test.shape[2], 1))
# determine the shape of the input images
in_shape = x_train.shape[1:]
# determine the number of classes
n_classes = len(unique(y_train))
print(in_shape, n_classes)
# normalize pixel values
x_train = x_train.astype('float32') / 255.0
x_test = x_test.astype('float32') / 255.0
# define model
model = Sequential()
model.add(
Conv2D(32, (3, 3),
activation='relu',
kernel_initializer='he_uniform',
input_shape=in_shape))
def Train_model(model, json_file, bot, update):
epochs = 3
#telegram callback
telegram_callback = TelegramBotCallback(bot, update)
#loading config
with open(json_file, 'r') as f:
config = json.load(f)
category = config['category']
#for classification
if category == 1:
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train = tf.keras.utils.normalize(X_train, axis=1)
X_test = tf.keras.utils.normalize(X_test, axis=1)
model.fit(X_train,y_train,\
epochs=epochs,\
validation_data=(X_test,y_test),\
verbose=1,\
callbacks=[telegram_callback])
score = model.evaluate(X_test, y_test, verbose=0)
bot.send_message('Test loss:' + str(score[0]))
bot.send_message('Test accuracy:' + str(score[1]))
#for regression
elif category == 2:
(X_train, y_train), (X_test, y_test) = boston_housing.load_data()
model.fit(X_train,y_train,\
epochs=3,\
validation_data=(X_test,y_test),\
verbose=1,\
callbacks=[telegram_callback])
score = model.evaluate(X_test, y_test, verbose=0)
bot.send_message('Test loss:' + str(score))
# bot.send_message('Test accuracy:' + str(score[1]))
elif category == 3:
num_classes = 10
(X_train, y_train), (X_test, y_test) = mnist.load_data()
X_train = X_train[:1000]
y_train = y_train[:1000]
X_test = X_test[:200]
y_test = y_test[:200]
img_rows, img_cols = 28, 28
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
y_train = tf.keras.utils.to_categorical(y_train, num_classes)
y_test = tf.keras.utils.to_categorical(y_test, num_classes)
#print(X_train.shape)
model.fit(X_train,y_train,\
epochs=3,\
batch_size=32,\
validation_data=(X_test,y_test),\
verbose=1,\
callbacks=[telegram_callback])
from tensorflow.keras import backend as K import numpy as np import tensorflow as tf from tensorflow.keras.datasets import mnist from tensorflow.keras.models import Model batch_size = 1000 num_classes = 10 epochs = 60 config = tf.ConfigProto() config.gpu_options.allow_growth = True sess = tf.Session(config=config) K.set_session(sess) img_rows, img_cols = 28, 28 (x_train, y_train_original), (x_test, y_test_original) = mnist.load_data() import numpy as np y_train_original = y_train_original.astype(np.int16) y_test_original = y_test_original.astype(np.int16) x_train = x_train / 255. x_test = x_test / 255. from mnist_model import Model as MM y_train = keras.utils.to_categorical(y_train_original, num_classes) y_test = keras.utils.to_categorical(y_test_original, num_classes) x_train = x_train.reshape((-1, 28, 28, 1)) x_test = x_test.reshape((-1, 28, 28, 1)) m = MM()
import matplotlib.pyplot as plt
import numpy as np
import argparse
# construct the argument parse and parse the arguments
ap = argparse.ArgumentParser()
ap.add_argument("-o",
"--output",
required=True,
help="path to the output loss/accuracy plot")
args = vars(ap.parse_args())
# grab the MNIST dataset (if this is your first time using this
# dataset then the 11MB download may take a minute)
print("[INFO] accessing MNIST...")
((trainX, trainY), (testX, testY)) = mnist.load_data()
# each image in the MNIST dataset is represented as a 28x28x1
# image, but in order to apply a standard neural network we must
# first "flatten" the image to be simple list of 28x28=784 pixels
trainX = trainX.reshape((trainX.shape[0], 28 * 28 * 1))
testX = testX.reshape((testX.shape[0], 28 * 28 * 1))
# scale data to the range of [0, 1]
# change from uint8 to float
# scale bewteen 0 and 1
trainX = trainX.astype("float32") / 255.0
testX = testX.astype("float32") / 255.0
# convert the labels from integers to vectors
# one hot encoding applied
@author: USER """ #colab import matplotlib.pyplot as plt import numpy as np from tensorflow.keras.utils import to_categorical from tensorflow.keras.models import Sequential #訓練模組用 from tensorflow.keras.layers import Dense, Activation from tensorflow.keras.optimizers import SGD from tensorflow.keras.datasets import mnist #https://ithelp.ithome.com.tw/articles/10191725 #https://medium.com/chiukevin0321/tensorflow%E8%88%87keras%E5%9F%BA%E6%9C%AC%E4%BB%8B%E7%B4%B9-621352fc7150 (x_train, y_train) < (x_test, y_test) = mnist.load_data() len(x_train) len(x_test) x_train.shape x_train[0] plt.imshow(x_train[0], cmap='binary') y_train[0] t1 = x_train.reshape(60000, 784) x_train = x_train.reshape(60000, -1) #轉一維 x_test = x_test.reshape(10000, -1) x_train.shape t1.shape x_train = x_train / 255 x_test = x_test / 255 y_train = to_categorical(y_train, 10) y_test = to_categorical(y_test, 10) #辨識種類
youtube_video('YRhxdVk_sIs')
"""---
# Mnist Digits
Mnist is een dataset van afbeeldingen van 28x28 pixels zwart en wit. De afbeeldingen bevatten handgeschreven cijfers van 0 tot 9. Het doel is om deze afbeeldingen te analyseren en te predicten welk cijfer er staat.
Data preprocessing
"""
from tensorflow.keras.datasets import mnist
import matplotlib.pyplot as plt
(train_data, train_labels), (test_data, test_labels) = mnist.load_data()
train_data = train_data.reshape((60000,784))
test_data = test_data.reshape((10000,784))
"""De data is al gesplitst in een train en test set. We bekijken een aantal afbeeldingen uit de dataset:"""
def show_digit(idx,network = None):
print(train_data[idx].shape)
img = train_data[idx].reshape((28,28))
lbl = train_labels[idx]
plt.imshow(img,cmap='gray')
if network != None:
pred = network.predict(img.reshape(1,784))[0]
plt.title('label: {}, Prediction: {}'.format(lbl,pred))
#!/usr/bin/env python3
import tensorflow as tf
import tensorflow.keras as keras
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout
from tensorflow.keras.layers import Flatten, MaxPooling2D, Conv2D
from tensorflow.keras.callbacks import TensorBoard
(X_train,y_train), (X_test, y_test) = mnist.load_data()
X_train = X_train.reshape(60000,28,28,1).astype('float32')
X_test = X_test.reshape(10000,28,28,1).astype('float32')
X_train /= 255
X_test /= 255
n_classes = 10
y_train = keras.utils.to_categorical(y_train, n_classes)
y_test = keras.utils.to_categorical(y_test, n_classes)
model = Sequential()
model.add(Conv2D(32, kernel_size=(3,3), activation='relu', input_shape=(28,28,1)) )
model.add(Conv2D(64, kernel_size=(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(n_classes, activation='softmax'))
kernel_size=(3, 3),
activation='relu',
padding='valid'))
model.add(UpSampling2D((14, 14)))
model.add(
Conv2D(filters=1,
kernel_size=(3, 3),
activation='sigmoid',
padding='same'))
model.summary()
return model
from tensorflow.keras.datasets import mnist
train_set, test_set = mnist.load_data()
x_train, y_train = train_set
x_test, y_test = test_set
x_train = x_train.reshape(-1, x_train.shape[1], x_train.shape[2],
1).astype('float32') / 255.
x_test = x_test.reshape(-1, x_test.shape[1], x_test.shape[2],
1).astype('float32') / 255.
print(x_train.shape, x_test.shape)
model = autoencoder()
# model.compile(optimizer='adam', loss='mse', metrics=['acc'])
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['acc'])
model.fit(x_train, x_train, epochs=10)