def load_data(data_type,label):
if label == 'fine':
classes = 100
(x_train, y_train), (x_test, y_test) = cifar100.load_data('fine')
y_train, y_test = one_hot_encoding(y_train, y_test, classes)
width, height, channels = x_train.shape[1], x_train.shape[2], x_train.shape[3]
x_train = x_train.reshape((x_train.shape[0], width, height, channels))
width, height, channels = x_test.shape[1], x_test.shape[2], x_test.shape[3]
x_test = x_test.reshape((x_test.shape[0], width, height, channels))
x_train = x_train.astype("float32")
x_test = x_test.astype("float32")
x_train /= 255.0
x_test /= 255.0
else:
classes = 20
(x_train, y_train), (x_test, y_test) = cifar100.load_data('coarse')
y_train, y_test = one_hot_encoding(y_train, y_test, classes)
width, height, channels = x_train.shape[1], x_train.shape[2], x_train.shape[3]
x_train = x_train.reshape((x_train.shape[0], width, height, channels))
width, height, channels = x_test.shape[1], x_test.shape[2], x_test.shape[3]
x_test = x_test.reshape((x_test.shape[0], width, height, channels))
x_train = x_train.astype("float32")
x_test = x_test.astype("float32")
x_train /= 255.0
x_test /= 255.0
if data_type == 'act':
data = x_test
data_shape = data.shape
return data, data_shape
if data_type == 'test':
return x_test, y_test
def Cifar100(home_path):
from tensorflow.keras.datasets.cifar100 import load_data
(train_images, train_labels), (val_images, val_labels) = load_data()
teacher = sio.loadmat(home_path + '/pre_trained/ResNet32.mat')
def pre_processing(image, is_training):
with tf.variable_scope('preprocessing'):
image = tf.cast(image, tf.float32)
image = (image - np.array([112.4776, 124.1058, 129.3773])
) / np.array([70.4587, 65.4312, 68.2094])
def augmentation(image):
image = tf.image.random_flip_left_right(
image) # tf.__version__ > 1.10
sz = tf.shape(image)
image = tf.pad(image, [[0, 0], [4, 4], [4, 4], [0, 0]],
'REFLECT')
image = tf.random_crop(image, sz)
return image
image = tf.cond(is_training, lambda: augmentation(image),
lambda: image)
return image
return train_images, train_labels, val_images, val_labels, pre_processing, teacher
def _cifar100_dataset(self, partition):
"""Returns a partition of the CIFAR-100 `Dataset`."""
cifar100_data = None
try:
cifar100_data = cifar100.load_data()
tf.logging.info('Loaded cifar100.')
except: # pylint: disable=bare-except
tf.logging.info(
'Can not load cifar100 from internet. Creating dummy data for '
'testing.')
data = np.zeros((3, 32, 32, 3))
labels = np.array([[47], [52], [5]])
data[:, 0, 0] = [220, 25, 47]
data[:, -1, 0, 0] = 128
cifar100_data = ((data, labels), (data, labels))
(x_train, y_train), (x_test, y_test) = cifar100_data
x = None
y = None
if partition == 'train':
x, y = x_train, y_train
else:
x, y = x_test, y_test
dataset = tf.data.Dataset.from_tensor_slices((x, y.astype(np.int32)))
return dataset.cache()
def cifar100_val_generator(data_generator, ds_metainfo, batch_size):
"""
Create image generator for validation subset.
Parameters:
----------
data_generator : ImageDataGenerator
Image transform sequence.
ds_metainfo : DatasetMetaInfo
ImageNet-1K dataset metainfo.
batch_size : int
Batch size.
Returns:
-------
Sequential
Image transform sequence.
"""
assert (ds_metainfo is not None)
_, (x_test, y_test) = cifar100.load_data()
generator = data_generator.flow(x=x_test,
y=y_test,
batch_size=batch_size,
shuffle=False)
return generator
def download_dataset():
print("Downloading dataset of %d samples to:\n\t%s" %
(DATASET_SIZE, DATASET_DIR))
print("and corrupting the data (%d%% duplicates)" %
(100 * CORRUPTION_RATE))
# if not empty, delete current contents
etau.ensure_empty_dir(DATASET_DIR, cleanup=True)
(_, _), (x_test, y_test) = cifar100.load_data(label_mode="fine")
dataset_size = min(DATASET_SIZE, 10000)
x = x_test[:dataset_size, :]
y = y_test[:dataset_size, :]
for i in range(x.shape[0]):
if random.random() > 0.95:
# pick a random sample 5% of the time
idx = random.randint(0, x.shape[0])
else:
idx = i
# get label
fine_label = FINE_CLASSES[y[idx, 0]]
# read image
img = x[idx, :]
rel_img_path = os.path.join(fine_label, "%d.jpg" % i)
abs_img_path = os.path.join(DATASET_DIR, rel_img_path)
etai.write(img, abs_img_path)
print("Download successful")
def __init__(self):
print("===Loading cifar100 Dataset===")
(self.images_train,
self.labels_train), (self.images_test,
self.labels_test) = cifar100.load_data()
#self.images_train = np.expand_dims(self.images_train, axis=3) / 255.0
#self.images_test = np.expand_dims(self.images_test, axis=3) / 255.0
self.images_train, self.images_test = self.images_train / 255.0, self.images_test / 255.0
self.labels_train = np.expand_dims(self.labels_train, axis=1)
self.unique_train_label = np.unique(self.labels_train)
self.unique_test_label = np.unique(self.labels_test)
self.map_train_label_indices = {
label: np.flatnonzero(self.labels_train == label)
for label in self.unique_train_label
}
self.map_test_label_indices = {
label: np.flatnonzero(self.labels_test == label)
for label in self.unique_test_label
}
self.n_classes, self.n_examples, self.w, self.h = self.images_train.shape
self.n_val, self.n_ex_val, _, _ = self.images_test.shape
print("Test shape: ", self.images_test.shape)
print("Images train :", self.images_train.shape)
print("Labels train :", self.labels_train.shape)
print("Images test :", self.images_test.shape)
print("Labels test :", self.labels_test.shape)
print("Unique label :", self.unique_train_label)
def __init__(self, extended, datagen_kwargs, batch_size, seed=None):
if extended:
(_, _), (X_test, Y_test) = cifar100.load_data()
self.nclasses = 100
else:
(_, _), (X_test, Y_test) = cifar10.load_data()
self.nclasses = 10
# All our images are floats from [0, 1)
X_test = X_test.astype(np.float32) / 255
# All our labels are categorical
Y_test = to_categorical(Y_test)
datagen = ImageDataGenerator(**datagen_kwargs)
clean_datagen = ImageDataGenerator()
self.test_datagen = datagen.flow(X_test,
Y_test,
batch_size=batch_size,
seed=seed)
self.clean_test_datagen = clean_datagen.flow(X_test,
Y_test,
batch_size=batch_size,
seed=seed)
self.input_shape = X_test.shape[1:]
self.steps_per_epoch = X_test.shape[0] // batch_size
self.validation_steps = X_test.shape[0] // batch_size
def load_dataset():
(x_train, y_train), (x_test, y_test) = cifar100.load_data()
fs_generator = ImageDataGenerator(
width_shift_range=5. / 32.,
height_shift_range=5. / 32.,
fill_mode='reflect',
horizontal_flip=True,
)
generator = ImageDataGenerator(
width_shift_range=5. / 32.,
height_shift_range=5. / 32.,
fill_mode='reflect',
horizontal_flip=True,
)
y_train = np.reshape(y_train, [-1, 1])
y_test = np.reshape(y_test, [-1, 1])
x_train = x_train / 127.5 - 1.
x_test = x_test / 127.5 - 1.
output = {
'train': {
'data': x_train,
'label': y_train
},
'test': {
'data': x_test,
'label': y_test
},
'generator': generator,
'fs_generator': fs_generator
}
return output
def __init__(self, extended, datagen_kwargs, batch_size, val_split=0.1):
if extended:
(X_train, Y_train), (_, _) = cifar100.load_data()
self.nclasses = 100
else:
(X_train, Y_train), (_, _) = cifar10.load_data()
self.nclasses = 10
# Divide train/val
X_train, X_test, Y_train, Y_test = train_test_split(
X_train,
Y_train,
test_size=val_split,
stratify=Y_train,
random_state=2)
X_train = X_train / 255
X_test = X_test / 255
# All our labels are categorical and all our images are floats
Y_train = to_categorical(Y_train)
Y_test = to_categorical(Y_test)
datagen = ImageDataGenerator(**datagen_kwargs)
datagen_for_test = ImageDataGenerator()
self.input_shape = X_train.shape[1:]
self.train_dataset = datagen.flow(X_train,
Y_train,
batch_size=batch_size)
self.test_dataset = datagen_for_test.flow(X_test,
Y_test,
batch_size=batch_size)
self.steps_per_epoch = X_train.shape[0] // batch_size
self.validation_steps = X_test.shape[0] // batch_size
def load_CIFAR_data(data_type="CIFAR10",
label_mode="fine",
standarized=False,
verbose=False):
if data_type == "CIFAR10":
(X_train, y_train), (X_test, y_test) = cifar10.load_data()
elif data_type == "CIFAR100":
(X_train,
y_train), (X_test, y_test) = cifar100.load_data(label_mode=label_mode)
else:
print("Unknown Data type. Stopped!")
return None
y_train = np.squeeze(y_train)
y_test = np.squeeze(y_test)
# substract mean and normalized to [-1/2,1/2]
if standarized:
X_train = X_train / 255
X_test = X_test / 255
mean_image = np.mean(X_train, axis=0)
X_train -= mean_image
X_test -= mean_image
if verbose == True:
print("X_train shape :", X_train.shape)
print("X_test shape :", X_test.shape)
print("y_train shape :", y_train.shape)
print("y_test shape :", y_test.shape)
return X_train, y_train, X_test, y_test
def save_cifar100():
OUT_DIR = 'cifar100'
# Load data from keras API
(x_train, y_train), (x_test, y_test) = cifar100.load_data()
# define class names from ex: https://github.com/keras-team/keras/issues/2653
class_list = [
'apple', 'aquarium_fish', 'baby', 'bear', 'beaver', 'bed', 'bee',
'beetle', 'bicycle', 'bottle', 'bowl', 'boy', 'bridge', 'bus',
'butterfly', 'camel', 'can', 'castle', 'caterpillar', 'cattle',
'chair', 'chimpanzee', 'clock', 'cloud', 'cockroach', 'couch', 'crab',
'crocodile', 'cup', 'dinosaur', 'dolphin', 'elephant', 'flatfish',
'forest', 'fox', 'girl', 'hamster', 'house', 'kangaroo', 'keyboard',
'lamp', 'lawn_mower', 'leopard', 'lion', 'lizard', 'lobster', 'man',
'maple_tree', 'motorcycle', 'mountain', 'mouse', 'mushroom',
'oak_tree', 'orange', 'orchid', 'otter', 'palm_tree', 'pear',
'pickup_truck', 'pine_tree', 'plain', 'plate', 'poppy', 'porcupine',
'possum', 'rabbit', 'raccoon', 'ray', 'road', 'rocket', 'rose', 'sea',
'seal', 'shark', 'shrew', 'skunk', 'skyscraper', 'snail', 'snake',
'spider', 'squirrel', 'streetcar', 'sunflower', 'sweet_pepper',
'table', 'tank', 'telephone', 'television', 'tiger', 'tractor',
'train', 'trout', 'tulip', 'turtle', 'wardrobe', 'whale',
'willow_tree', 'wolf', 'woman', 'worm'
]
# make train/test dirs and class dirs
for cid, class_name in enumerate(class_list):
os.makedirs(os.path.join(OUT_DIR, 'train',
'{:02d}_{}'.format(cid, class_name)),
exist_ok=True)
os.makedirs(os.path.join(OUT_DIR, 'test',
'{:02d}_{}'.format(cid, class_name)),
exist_ok=True)
# convert train data
for num, (x_data, y_data) in enumerate(zip(x_train, y_train)):
cid = y_data[0] # y_data is an 1 element array
# make file path
fpath = os.path.join(OUT_DIR, 'train',
'{:02d}_{}'.format(cid, class_list[cid]),
'train_{:05d}.png'.format(num))
# convert numpy to pillow and save
Image.fromarray(x_data).save(fpath)
# convert test data
for num, (x_data, y_data) in enumerate(zip(x_test, y_test)):
cid = y_data[0] # y_data is an 1 element array
# make file path
fpath = os.path.join(OUT_DIR, 'test',
'{:02d}_{}'.format(cid, class_list[cid]),
'test_{:05d}.png'.format(num))
# convert numpy to pillow and save
Image.fromarray(x_data).save(fpath)
print()
print('Saved to ' + OUT_DIR + '/')
print()
def load_cifar100():
# load dataset
(trainX10, trainY10), (testX10, testY10) = cifar10.load_data()
(trainX100,
trainY100), (testX100, testY100) = cifar100.load_data(label_mode='coarse')
(trainX100,
trainY100f), (testX100, testY100f) = cifar100.load_data(label_mode='fine')
trainIndecies = []
testIndecies = []
for i in range(len(trainY100)):
if trainY100[i] != 7:
trainIndecies.append(i)
for i in range(len(testY100)):
if testY100[i] != 7:
testIndecies.append(i)
# delete other super classes data
trainY100f = np.delete(trainY100f, trainIndecies, 0)
trainX100 = np.delete(trainX100, trainIndecies, 0)
testY100f = np.delete(testY100f, testIndecies, 0)
testX100 = np.delete(testX100, testIndecies, 0)
trainY100f = np.where(trainY100f == 6, 10, trainY100f)
trainY100f = np.where(trainY100f == 7, 11, trainY100f)
trainY100f = np.where(trainY100f == 14, 12, trainY100f)
trainY100f = np.where(trainY100f == 18, 13, trainY100f)
trainY100f = np.where(trainY100f == 24, 14, trainY100f)
testY100f = np.where(testY100f == 6, 10, testY100f)
testY100f = np.where(testY100f == 7, 11, testY100f)
testY100f = np.where(testY100f == 14, 12, testY100f)
testY100f = np.where(testY100f == 18, 13, testY100f)
testY100f = np.where(testY100f == 24, 14, testY100f)
trainX = np.concatenate((trainX10, trainX100), axis=0)
trainY = np.concatenate((trainY10, trainY100f), axis=0)
testX = np.concatenate((testX10, testX100), axis=0)
testY = np.concatenate((testY10, testY100f), axis=0)
# one hot encode data
trainY = to_categorical(trainY)
testY = to_categorical(testY)
return trainX, trainY, testX, testY
def read_train_data(self, sample_count):
from tensorflow.keras.datasets import cifar100
data = cifar100.load_data()
data = (
self.preprocess(*data[0], sample_count),
self.preprocess(*data[1], None),
)
return data
def load_cifar100_images():
""" Loads 0-1 normalized CIFAR images
"""
(cifar_x, cifar_y), (cifar_x_test, cifar_y_test) = cifar100.load_data()
# Scale everything to 0-1
cifar_x, cifar_x_test, = normalize_0_1([cifar_x, cifar_x_test])
return (cifar_x, transform_to_one_hot(
cifar_y, depth=100)), (cifar_x_test,
transform_to_one_hot(cifar_y_test, depth=100))
def main():
parser = make_parser()
args = parser.parse_args()
in_shape = [3, 32, 32]
if args.dataset.lower() == "cifar10":
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
nClasses = 10
else:
assert (args.dataset.lower() == "cifar100"
), "Only cifar10 and cifar100 are supported"
(x_train, y_train), (x_test, y_test) = cifar100.load_data()
nClasses = 100
# Switch from channel_last to channel_first
x_train = np.moveaxis(x_train, 3, 1)
x_test = np.moveaxis(x_test, 3, 1)
assert x_train.shape[1] == 3, x_train.shape
assert x_test.shape[1] == 3, x_test.shape
# (x_train, y_train), (x_test, y_test) = cifar10.load_data()
# Some pre-processing differences from the original
# TODO fit it on the data to do featurewise centering, and normalization
datagen = ImageDataGenerator(
horizontal_flip=True,
featurewise_center=True,
featurewise_std_normalization=True,
data_format="channels_first",
)
def get_model(args):
model = iRevNet(
nBlocks=args.nBlocks,
nStrides=args.nStrides,
nChannels=args.nChannels,
nClasses=nClasses,
init_ds=args.init_ds,
dropout_rate=0.1,
affineBN=True,
in_shape=in_shape,
mult=args.bottleneck_mult,
)
fname = "i-revnet-" + str(sum(args.nBlocks) + 1)
return model, fname
model, fname = get_model(args)
train(
(model, fname),
(x_train, y_train),
datagen,
epochs=args.epochs,
batch_size=args.batch,
learning_rate=args.lr,
)
def get_data(self):
(x_train, y_train), (x_test, y_test) = cifar100.load_data(label_mode='fine')
# 出力データをone-hotベクトルによる表現にする
y_train = to_categorical(y_train, self.num_classes)
y_test = to_categorical(y_test, self.num_classes)
# 各データが0~1の値となるように調整
x_train = x_train.astype('float32') / 255
x_test = x_test.astype('float32') / 255
# 画像データの平滑化
x_train = x_train.reshape([len(x_train), self.num_input])
x_test = x_test.reshape([len(x_test), self.num_input])
return x_train, y_train, x_test, y_test
def load_images():
(train_images, train_labels), (test_images,
test_labels) = cifar100.load_data()
train_images = train_images.astype(np.float32)
test_images = test_images.astype(np.float32)
(train_images, test_images) = normalization(train_images, test_images)
train_labels = to_categorical(train_labels, 100)
test_labels = to_categorical(test_labels, 100)
return train_images, train_labels, test_images, test_labels
def main(argv):
batch_size = 50
epochs = 51
#(x_train, y_train), (x_test, y_test) = cifar100.load_data(label_mode='fine')
(x_train, y_train), (x_test, y_test) = cifar100.load_data()
#(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.astype('float32') / 255.0
x_test = x_test.astype('float32') / 255.0
input_shape = x_train.shape[1:]
num_classes = len(np.unique(y_train))
num_train_samples = x_train.shape[0]
# Convert y to categorical one-hot vectors
y_train = to_categorical(y_train, num_classes=num_classes)
y_test = to_categorical(y_test, num_classes=num_classes)
# Create and compile model
model = dense_model1(input_shape=input_shape,
n_classes=num_classes,
dropout=0.5,
model_name=get_project_name(argv[0]))
model.compile(loss=categorical_crossentropy,
optimizer='adam',
metrics=['accuracy'])
# Print summary and save model as plot and node-link-graph
project_paths = get_project_paths(argv[0], to_tmp=False)
#save_graph_plot(model, project_paths["plots"] + "/model.ps")
#save_graph_json(model, project_paths["weights"] + "/model.json")
weight = model.get_weights()
logs = project_paths["weights"] + "/mod_hist_U5_mnist_acc.csv"
#np.savetxt('weight.csv' , weight , fmt='%s', delimiter=',')
csv_logger = CSVLogger(logs, append=True)
# Train model while saving weights as checkpoints after each epoch
model.fit(
x_train,
y_train,
steps_per_epoch=num_train_samples / batch_size /
5, # 5 epochs per full dataset rotation
batch_size=batch_size,
epochs=epochs,
verbose=1,
# callbacks=[ModelCheckpoint(
# project_paths["checkpoints"] + "/weights_epoch-{epoch:02d}.hdf5",
# save_weights_only=True,
# save_freq='epoch'),csv_logger],
validation_data=(x_test, y_test))
def get_dataset():
(X_train, y_train), (X_test, y_test) = cifar.load_data()
X_train = X_train.astype('float32')
X_train = (X_train - X_train.mean(axis=0)) / (X_train.std(axis=0))
X_test = X_test.astype('float32')
X_test = (X_test - X_test.mean(axis=0)) / (X_test.std(axis=0))
y_train = keras.utils.to_categorical(y_train)
y_test = keras.utils.to_categorical(y_test)
return X_train, y_train, X_test, y_test
def create_cifar100():
(x_train, y_train), (x_test, y_test) = cifar100.load_data()
x_train = x_train / 255.0
x_test = x_test / 255.0
x_train = x_train.reshape((x_train.shape[0], 32, 32, 3))
x_test = x_test.reshape((x_test.shape[0], 32, 32, 3))
y_train = tf.keras.utils.to_categorical(y_train, num_classes=100)
y_test = tf.keras.utils.to_categorical(y_test, num_classes=100)
return ((x_train, y_train), (x_test, y_test))
def __init__(self):
np.random.seed(31415)
(self.x_train, self.y_train), (self.x_test,
self.y_test) = cifar100.load_data()
self.index = np.arange(self.x_train.shape[0])
self.x_train, self.y_train = self.get_batch()
self.x_train, self.y_train, self.x_val, self.y_val = self.split_data(
self.x_train.shape[0])
self.y_train = keras.utils.to_categorical(self.y_train, num_classes)
self.y_val = keras.utils.to_categorical(self.y_val, num_classes)
self.y_test = keras.utils.to_categorical(self.y_test, num_classes)
def loadAndPrep100():
# x data in form of (num samples, num channels, width, height) = (50000 or 10000, 32, 32, 3)
# both in uint8
(xtrain, ytrain), (xtest, ytest) = cifar100.load_data()
# # use one-hot encoding for y
ytrain = np_utils.to_categorical(ytrain)
ytest = np_utils.to_categorical(ytest)
# this is for the resnet only (since vgg was abandoned)
# changes pixel values to be within a certain range
xtrain = preprocess_input(xtrain)
xtest = preprocess_input(xtest)
return xtrain, ytrain, xtest, ytest
def load_data():
# load data
(trainX, trainY), (testX, testY) = cifar100.load_data()
#one-hot encoding
trainY = to_categorical(trainY)
testY = to_categorical(testY)
# convert from integers to floats
train_norm = trainX.astype('float32')
test_norm = testX.astype('float32')
# normalize to range 0-1
train_norm = train_norm / 255.0
test_norm = test_norm / 255.0
# preprocess input
train_norm = preprocess_input(train_norm)
test_norm = preprocess_input(test_norm)
return (train_norm, trainY), (test_norm, testY)
def load_cifar(label, num):
if num == 10:
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
else:
(x_train, y_train), (x_test,
y_test) = cifar100.load_data(label_mode='fine')
train_mask = [y[0] == label for y in y_train]
test_mask = [y[0] == label for y in y_test]
x_data = np.concatenate([x_train[train_mask], x_test[test_mask]])
y_data = np.concatenate([y_train[train_mask], y_test[test_mask]])
x_data = (x_data.astype('float32') - 127.5) / 127.5
return (x_data, y_data)
def resize_cifar100(fine_labelled=True, size=(256, 256)):
label_mode = 'fine' if fine_labelled else 'coarse'
label = fine_label if fine_labelled else coarse_label
(x_train, y_train), (x_test,
y_test) = cifar100.load_data(label_mode=label_mode)
for i, (data, label_idx) in enumerate(zip(x_train, y_train)):
resized_image = cv2.resize(data, size)
cv2.imwrite(
"../dataset/cifar100/{}/train/{}.{}.jpg".format(
label_mode, label[label_idx[0]], i), resized_image)
for i, (data, label_idx) in enumerate(zip(x_test, y_test)):
resized_image = cv2.resize(data, size)
cv2.imwrite(
"../dataset/cifar100/{}/test/{}.{}.jpg".format(
label_mode, label[label_idx[0]], i), resized_image)
def load_data(self):
"""
Load data from CIFAR100 package
# Returns:
all_data : train data, train label, test data and test labels
"""
((self._train_data, self._train_labels),
(self._test_data, self._test_labels)) = cifar100.load_data()
self._train_labels = tf.keras.utils.to_categorical(self._train_labels)
self._test_labels = tf.keras.utils.to_categorical(self._test_labels)
self.shuffle()
return self._train_data, self._train_labels, self._test_data, self._test_labels
def generate_dataset(dataset_params):
if dataset_params["name"] == "cifar100":
dataset_root_dir = dataset_params["path"]
train_path = os.path.join(dataset_root_dir, "train")
test_path = os.path.join(dataset_root_dir, "test")
# download CIFAR100 files from the keras dataset repo
(x_train, y_train), (x_test,
y_test) = cifar100.load_data(label_mode='fine')
# creating train and test folder
save_files(train_path, x_train)
save_files(test_path, x_test)
tf.logging.info(" >> Cifar images saved to datasets directory " +
dataset_root_dir)
elif dataset_params["name"] == "cifar10":
class_details = []
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
category_counter = {}
num_per_category = round(dataset_params["dataset_size"] / 10)
c_counter = 0
f_utils.mkdir(dataset_params["path"])
for i, val in enumerate(list(y_train)):
val = val[0]
if (val in category_counter.keys()):
if (category_counter[val] < num_per_category):
class_details.append({str(c_counter): str(val)})
category_counter[val] = category_counter[val] + 1
img = Image.fromarray(x_train[i], 'RGB')
img.save(dataset_params["path"] + "/" + str(c_counter) +
'.jpg')
c_counter += 1
if c_counter >= dataset_params["dataset_size"]:
break
else:
category_counter[val] = 0
f_utils.save_json_file(
os.path.join(dataset_params["path"], "classes.json"),
class_details)
tf.logging.info(" >> Cifar10 images saved to datasets directory " +
dataset_params["path"])
def load_dataset(ds):
if ds == 'mnist':
from tensorflow.keras.datasets import mnist
return mnist.load_data(), 10
elif ds == 'fashion-mnist':
from tensorflow.keras.datasets import fashion_mnist
return fashion_mnist.load_data(), 10
elif ds == 'cifar10':
from tensorflow.keras.datasets import cifar10
return cifar10.load_data(), 10
elif ds == 'cifar100':
from tensorflow.keras.datasets import cifar100
return cifar100.load_data(), 100
else:
print('ERROR: Unknown dataset specified:', args.dataset)
sys.exit(1)
return
def cifar100(self, epochs=20):
""" Train on CIFAR-100
epochs : number of epochs for full training
"""
from tensorflow.keras.datasets import cifar100
import numpy as np
(x_train, y_train), (x_test, y_test) = cifar100.load_data()
x_train = (x_train / 255.0).astype(np.float32)
x_test = (x_test / 255.0).astype(np.float32)
print("Warmup the model for numerical stability")
self.warmup(x_train, y_train)
print("Full training")
self.compile()
self.model.fit(x_train, y_train, epochs=epochs, batch_size=32, validation_split=0.1, verbose=1)
self.model.evaluate(x_test, y_test)
def load_cifar100(self):
"""
Load the CIFAR-100 dataset
"""
logging.info("loading CIFAR-100 dataset...")
# Load the data
(self.train_x, self.train_y), (self.test_x,
self.test_y) = cifar100.load_data()
# Scale the data to the range [0, 1]
self.train_x = self.train_x.astype("float32") / 255.0
self.test_x = self.test_x.astype("float32") / 255.0
self.height = 32
self.width = 32
self.depth = 3
self.classes_cnt = 100
