def main(args):
# Fix random seeds and threads
np.random.seed(args.seed)
tf.random.set_seed(args.seed)
tf.config.threading.set_inter_op_parallelism_threads(args.threads)
tf.config.threading.set_intra_op_parallelism_threads(args.threads)
# Create logdir name
args.logdir = os.path.join("logs", "{}-{}-{}".format(
os.path.basename(globals().get("__file__", "notebook")),
datetime.datetime.now().strftime("%Y-%m-%d_%H%M%S"),
",".join(("{}={}".format(re.sub("(.)[^_]*_?", r"\1", key), value) for key, value in sorted(vars(args).items())))
))
# Load data
cifar = CIFAR10()
# TODO: Create the model and train it
model = ...
# Generate test set annotations, but in args.logdir to allow parallel execution.
os.makedirs(args.logdir, exist_ok=True)
with open(os.path.join(args.logdir, "cifar_competition_test.txt"), "w", encoding="utf-8") as predictions_file:
for probs in model.predict(cifar.test.data["images"], batch_size=args.batch_size):
print(np.argmax(probs), file=predictions_file)
def main(_):
os.environ["CUDA_VISIBLE_DEVICES"] = FLAGS.gpu_index
# Evaluation optimizers and dropout
optimizer_options = [
'SGDNesterov', 'Adagrad', 'RMSProp', 'AdaDelta', 'Adam'
]
dropout_options = [False, True]
# Initialize model and log folders
if FLAGS.load_model is None:
cur_time = datetime.now().strftime("%Y%m%d-%H%M")
else:
cur_time = FLAGS.load_model
model_dir, log_dir = make_folders(is_train=FLAGS.is_train,
base=FLAGS.model,
cur_time=cur_time)
init_logger(log_dir=log_dir, is_train=FLAGS.is_train)
if FLAGS.model.lower() == 'logistic' or FLAGS.model.lower(
) == 'neural_network':
# Initialize MNIST dataset and print info
data = MNIST(log_dir=log_dir)
data.info(use_logging=True if FLAGS.is_train else False,
show_img=False) # print basic information
elif FLAGS.model.lower() == 'cnn':
# Initialize CIFAR10 dataset and print info
data = CIFAR10(log_dir=log_dir, is_train=FLAGS.is_train)
data.info(use_logging=True if FLAGS.is_train else False,
show_img=False,
smooth=True)
data.preprocessing(use_whiten=FLAGS.is_whiten
) # data preprocessing [whiten or subtract_mean]
else:
raise NotImplementedError
if FLAGS.is_train:
train(data, optimizer_options, dropout_options, model_dir, log_dir)
else:
test(data, optimizer_options, dropout_options, model_dir, log_dir)
def ingest_cifar10(root_dir, padded_size=32, overwrite=False):
'''
Save CIFAR-10 dataset as PNG files
'''
out_dir = os.path.join(root_dir, 'cifar10')
set_names = ('train', 'valid')
manifest_files = [
os.path.join(out_dir, setn + '-index.csv') for setn in set_names
]
if (all([os.path.exists(manifest) for manifest in manifest_files])
and not overwrite):
return manifest_files
datasets = CIFAR10(out_dir).load_data()
pad_size = (padded_size - 32) // 2 if padded_size > 32 else 0
pad_width = ((0, 0), (pad_size, pad_size), (pad_size, pad_size))
# Now write out image files and manifests
for setn, manifest, data in zip(set_names, manifest_files, datasets):
records = [('@FILE', 'STRING')]
img_path = os.path.join(out_dir, setn)
if not os.path.isdir(img_path):
os.makedirs(img_path)
for idx, (img, lbl) in enumerate(
tqdm(zip(data['image']['data'], data['label']['data']))):
im = np.pad(img.reshape((3, 32, 32)), pad_width, mode='mean')
im = Image.fromarray(
np.uint8(np.transpose(im, axes=[1, 2, 0]).copy()))
fname = os.path.join(img_path, '{}_{:05d}.png'.format(lbl, idx))
im.save(fname, format='PNG')
records.append((os.path.relpath(fname, out_dir), lbl))
np.savetxt(manifest, records, fmt='%s\t%s')
return manifest_files
transforms.ToTensor(),
transforms.Normalize(cifar10_mean_color, cifar10_std_color),
])
train_transform = transforms.Compose([
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(cifar10_mean_color, cifar10_std_color),
])
test_transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize(cifar10_mean_color, cifar10_std_color)
])
# Datasets
train_dataset = CIFAR10(args.cifar10_dir,
split='train',
download=True,
transform=transform)
val_dataset = CIFAR10(args.cifar10_dir,
split='val',
download=True,
transform=train_transform)
test_dataset = CIFAR10(args.cifar10_dir,
split='test',
download=True,
transform=transform)
####DATA augmentation
# DataLoaders
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=args.batch_size,
parser.add_argument('--ghostsize', type=int, default=100)
parser.add_argument('--lr', type=float, default=0.1)
parser.add_argument('--momentum', type=float, default=0.9)
parser.add_argument('--weightdecay', type=float, default=5e-4)
parser.add_argument('--aug', action='store_true', default=False)
parser.add_argument('--model', type=str, default='vgg')
parser.add_argument('--resume', type=str, default=None)
parser.add_argument('--datadir', type=str, default='/mnt/home/haoyi/jingfengwu/datasets/CIFAR10/numpy')
parser.add_argument('--logdir', type=str, default='logs/SGD')
args = parser.parse_args()
logger = LogSaver(args.logdir)
logger.save(str(args), 'args')
# data
dataset = CIFAR10(args.datadir)
logger.save(str(dataset), 'dataset')
test_list = dataset.getTestList(500, True)
# model
start_iter = 0
lr = args.lr
if args.model == 'resnet':
from resnet import ResNet18
model = ResNet18().cuda()
elif args.model == 'vgg':
from vgg import vgg11
model = vgg11().cuda()
else:
raise NotImplementedError()
criterion = torch.nn.CrossEntropyLoss().cuda()
def main(args):
# ----->>> Note that script was run on Google Collab as following;
# with tf.device('/device:GPU:0'):
# Fix random seeds and threads
np.random.seed(args.seed)
tf.random.set_seed(args.seed)
tf.config.threading.set_inter_op_parallelism_threads(args.threads)
tf.config.threading.set_intra_op_parallelism_threads(args.threads)
# Create logdir name
args.logdir = os.path.join(
"logs", "{}-{}-{}".format(
os.path.basename(globals().get("__file__", "notebook")),
datetime.datetime.now().strftime("%Y-%m-%d_%H%M%S"), ",".join(
("{}={}".format(re.sub("(.)[^_]*_?", r"\1", key), value)
for key, value in sorted(vars(args).items())))))
# Load data
cifar = CIFAR10()
# IMAGE AUGMENTATION SETUP
train_generator = tf.keras.preprocessing.image.ImageDataGenerator(
rotation_range=15,
width_shift_range=0.1,
height_shift_range=0.1,
horizontal_flip=True)
# RENAME DATASETS FOR CONVENIENCE
train_images = cifar.train.data["images"]
train_labels = cifar.train.data["labels"]
dev_images = cifar.dev.data["images"]
dev_labels = cifar.dev.data["labels"]
test_images = cifar.test.data["images"]
train_images = train_images.astype('float32')
dev_images = dev_images.astype('float32')
test_images = test_images.astype('float32')
# STANDARDIZE THE DATA
mean = np.mean(train_images, axis=(0, 1, 2, 3))
std = np.std(train_images, axis=(0, 1, 2, 3))
train_images = (train_images - mean) / (std + 1e-7)
dev_images = (dev_images - mean) / (std + 1e-7)
test_images = (test_images - mean) / (std + 1e-7)
# ------------------------------------------------------------------------------------------------------------------
# -------------------------------------------- ENSEMBLE MODEL ------------------------------------------------------
# ------------------------------------------------------------------------------------------------------------------
'''models = []
for model_x in range(args.models):
np.random.seed(args.seed + model_x)
tf.random.set_seed(args.seed + model_x)
# Create logdir name
args.logdir = os.path.join("logs", "{}-{}-{}".format(
os.path.basename(globals().get("__file__", "notebook")),
datetime.datetime.now().strftime("%Y-%m-%d_%H%M%S"),
",".join(
("{}={}".format(re.sub("(.)[^_]*_?", r"\1", key), value) for key, value in
sorted(vars(args).items())))
))
dropout_rate = 0.2
l2_rate = 1e-4
# CREATE A MODEL
model = tf.keras.Sequential()
model.add(tf.keras.layers.Conv2D(32, (3, 3), padding='same', activation='relu',
kernel_regularizer=tf.keras.regularizers.l2(l2_rate),
input_shape=(32, 32, 3)))
model.add(tf.keras.layers.Activation('relu'))
model.add(tf.keras.layers.BatchNormalization())
model.add(tf.keras.layers.Conv2D(32, (3, 3), padding='same', activation='relu',
kernel_regularizer=tf.keras.regularizers.l2(l2_rate)))
model.add(tf.keras.layers.Activation('relu'))
model.add(tf.keras.layers.BatchNormalization())
model.add(tf.keras.layers.MaxPool2D(pool_size=(2, 2)))
model.add(tf.keras.layers.Dropout(dropout_rate))
model.add(tf.keras.layers.Conv2D(64, (3, 3), padding='same', activation='relu',
kernel_regularizer=tf.keras.regularizers.l2(l2_rate)))
model.add(tf.keras.layers.Activation('relu'))
model.add(tf.keras.layers.BatchNormalization())
model.add(tf.keras.layers.Conv2D(64, (3, 3), padding='same', activation='relu',
kernel_regularizer=tf.keras.regularizers.l2(l2_rate)))
model.add(tf.keras.layers.Activation('relu'))
model.add(tf.keras.layers.BatchNormalization())
model.add(tf.keras.layers.MaxPool2D(pool_size=(2, 2)))
model.add(tf.keras.layers.Dropout(dropout_rate + 0.1))
model.add(tf.keras.layers.Conv2D(128, (3, 3), padding='same', activation='relu',
kernel_regularizer=tf.keras.regularizers.l2(l2_rate)))
model.add(tf.keras.layers.Activation('relu'))
model.add(tf.keras.layers.BatchNormalization())
model.add(tf.keras.layers.Conv2D(128, (3, 3), padding='same', activation='relu',
kernel_regularizer=tf.keras.regularizers.l2(l2_rate)))
model.add(tf.keras.layers.Activation('relu'))
model.add(tf.keras.layers.BatchNormalization())
model.add(tf.keras.layers.MaxPool2D(pool_size=(2, 2)))
model.add(tf.keras.layers.Dropout(dropout_rate + 0.2))
model.add(tf.keras.layers.Flatten())
model.add(tf.keras.layers.Dropout(dropout_rate + 0.3))
model.add(tf.keras.layers.Dense(10, activation='softmax'))
# APPEND CREATED MODEL INTO LIST
models.append(model)
# COMPILE MODEL INSIDE LIST
models[-1].compile(
optimizer=tf.keras.optimizers.RMSprop(lr=0.001, decay=1e-6),
loss=tf.keras.losses.SparseCategoricalCrossentropy(),
metrics=[tf.keras.metrics.SparseCategoricalAccuracy(name="accuracy")],
)
# SET TensorBoard
tb_callback = tf.keras.callbacks.TensorBoard(args.logdir, histogram_freq=1, update_freq=100,
profile_batch=0)
# FIT MODEL INSIDE LIST
models[-1].fit(
train_generator.flow(tf.reshape(train_images, [-1, 32, 32, 3]), train_labels, seed=args.seed,
batch_size=args.batch_size), shuffle=False,
epochs=args.epochs, steps_per_epoch=train_images.shape[0] // args.batch_size,
validation_data=(dev_images, dev_labels),
callbacks=[tb_callback], verbose=2
)
# SAVE MODEL
models[-1].save('cifar_' + str(model_x) + '.h5')'''
# ------------------------------------------------------------------------------------------------------------------
# ------------------------------------------- TEST SAVED MODELS ----------------------------------------------------
# ------------------------------------------------------------------------------------------------------------------
# LOAD SAVED MODELS INTO LIST
cifar_0 = tf.keras.models.load_model('cifar_0.h5')
cifar_1 = tf.keras.models.load_model('cifar_1.h5')
cifar_2 = tf.keras.models.load_model('cifar_2.h5')
pred_models = [cifar_0, cifar_1, cifar_2]
# ENSEMBLE THE PREDICTIONS
y_list = [
pred_models[m].predict(test_images, batch_size=64)
for m in range(args.models)
]
y_list = sum(y_list) / len(y_list)
# Generate test set annotations, but in args.logdir to allow parallel execution.
with open("cifar_competition_test.txt", "w",
encoding="utf-8") as predictions_file:
for probs in y_list:
print(np.argmax(probs), file=predictions_file)
args = parser.parse_args()
start_time = datetime.now()
logger = LogSaver(args.logdir)
logger.save(str(args), 'args')
logger.save(str(start_time), 'start time')
# device
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
logger.save(str(device), 'device')
# data
HOME = os.environ['HOME']
datadir = os.path.join(HOME, 'data/datasets/CIFAR10/numpy')
dataset = CIFAR10(datadir, device)
logger.save(str(dataset), 'dataset')
testloader = dataset.getTestList(500)
# model
start_epoch = 0
lr = args.lr
from resnet import ResNet18
model = ResNet18().to(device)
criterion = torch.nn.CrossEntropyLoss().to(device)
optimizer = torch.optim.SGD(model.parameters(),
lr=lr,
momentum=args.momentum,
weight_decay=args.weightdecay)
if args.resume:
checkpoint = torch.load(args.resume)
def main(args):
# Fix random seeds and threads
np.random.seed(args.seed)
tf.random.set_seed(args.seed)
tf.config.threading.set_inter_op_parallelism_threads(args.threads)
tf.config.threading.set_intra_op_parallelism_threads(args.threads)
if args.recodex:
tf.keras.utils.get_custom_objects(
)["glorot_uniform"] = tf.initializers.GlorotUniform(seed=args.seed)
tf.keras.utils.get_custom_objects(
)["orthogonal"] = tf.initializers.Orthogonal(seed=args.seed)
tf.keras.utils.get_custom_objects(
)["uniform"] = tf.initializers.RandomUniform(seed=args.seed)
# Create logdir name
args.logdir = os.path.join(
"logs", "{}-{}-{}".format(
os.path.basename(globals().get("__file__", "notebook")),
datetime.datetime.now().strftime("%Y-%m-%d_%H%M%S"), ",".join(
("{}={}".format(re.sub("(.)[^_]*_?", r"\1", key), value)
for key, value in sorted(vars(args).items())))))
# Load the data
cifar = CIFAR10(size={"dev": 1000})
# Create the model
inputs = tf.keras.layers.Input(shape=[CIFAR10.H, CIFAR10.W, CIFAR10.C])
hidden = tf.keras.layers.Conv2D(16, 3, 2, "same",
activation=tf.nn.relu)(inputs)
hidden = tf.keras.layers.Conv2D(16, 3, 1, "same",
activation=tf.nn.relu)(hidden)
hidden = tf.keras.layers.Conv2D(24, 3, 2, "same",
activation=tf.nn.relu)(hidden)
hidden = tf.keras.layers.Conv2D(24, 3, 1, "same",
activation=tf.nn.relu)(hidden)
hidden = tf.keras.layers.Conv2D(32, 3, 2, "same",
activation=tf.nn.relu)(hidden)
hidden = tf.keras.layers.Conv2D(32, 3, 1, "same",
activation=tf.nn.relu)(hidden)
hidden = tf.keras.layers.Flatten()(hidden)
hidden = tf.keras.layers.Dense(200, activation=tf.nn.relu)(hidden)
outputs = tf.keras.layers.Dense(CIFAR10.LABELS,
activation=tf.nn.softmax)(hidden)
# Train the model
model = tf.keras.Model(inputs=inputs, outputs=outputs)
model.compile(
optimizer=tf.optimizers.Adam(),
loss=tf.losses.SparseCategoricalCrossentropy(),
metrics=[tf.metrics.SparseCategoricalAccuracy(name="accuracy")],
)
tb_callback = tf.keras.callbacks.TensorBoard(args.logdir,
histogram_freq=1,
update_freq=100,
profile_batch=0)
# TODO: Create `train` and `dev` datasets by using
# `tf.data.Dataset.from_tensor_slices` on cifar.train and cifar.dev.
# The structure of a single example is inferred from the argument
# of `from_tensor_slices` -- in our case we want each example to
# be a pair of `(input_image, target_label)`, so we need to pass
# a pair `(data["images"], data["labels"])` to `from_tensor_slices`.
train = ...
dev = ...
# Simple data augmentation
generator = tf.random.Generator.from_seed(args.seed)
def train_augment(image, label):
if generator.uniform([]) >= 0.5:
image = tf.image.flip_left_right(image)
image = tf.image.resize_with_crop_or_pad(image, CIFAR10.H + 6,
CIFAR10.W + 6)
image = tf.image.resize(image, [
generator.uniform(
[], minval=CIFAR10.H, maxval=CIFAR10.H + 12, dtype=tf.int32),
generator.uniform(
[], minval=CIFAR10.W, maxval=CIFAR10.W + 12, dtype=tf.int32)
])
image = tf.image.crop_to_bounding_box(
image,
target_height=CIFAR10.H,
target_width=CIFAR10.W,
offset_height=generator.uniform([],
maxval=tf.shape(image)[0] -
CIFAR10.H + 1,
dtype=tf.int32),
offset_width=generator.uniform([],
maxval=tf.shape(image)[1] -
CIFAR10.W + 1,
dtype=tf.int32),
)
return image, label
# TODO: Now prepare the training pipeline.
# - first use `.take(5000)` method to utilize only the first 5000 examples
# - call `.shuffle(5000, seed=args.seed)` to shuffle the data using
# the given seed and a buffer of the size of the whole data
# - call `.map(train_augment)` to perform the dataset augmentation
# - finally call `.batch(args.batch_size)` to generate batches
# - optionally, you might want to add `.prefetch(tf.data.AUTOTUNE)` as
# the last call -- it allows the pipeline to run in parallel with
# the training process, dynamically adjusting the number of threads
# to fully saturate the training process
train = ...
# TODO: Prepare the `dev` pipeline
# - just use `.batch(args.batch_size)` to generate batches
dev = ...
# Train
logs = model.fit(train,
epochs=args.epochs,
validation_data=dev,
callbacks=[tb_callback])
# Return dev set accuracy
return logs.history["val_accuracy"][-1]
def main(args):
# Fix random seeds and threads
np.random.seed(args.seed)
tf.random.set_seed(args.seed)
tf.config.threading.set_inter_op_parallelism_threads(args.threads)
tf.config.threading.set_intra_op_parallelism_threads(args.threads)
if args.recodex:
tf.keras.utils.get_custom_objects()["glorot_uniform"] = tf.initializers.GlorotUniform(seed=args.seed)
tf.keras.utils.get_custom_objects()["orthogonal"] = tf.initializers.Orthogonal(seed=args.seed)
tf.keras.utils.get_custom_objects()["uniform"] = tf.initializers.RandomUniform(seed=args.seed)
# Create logdir name
args.logdir = os.path.join("logs", "{}-{}-{}".format(
os.path.basename(globals().get("__file__", "notebook")),
datetime.datetime.now().strftime("%Y-%m-%d_%H%M%S"),
",".join(("{}={}".format(re.sub("(.)[^_]*_?", r"\1", key), value) for key, value in sorted(vars(args).items())))
))
# Load the data
cifar = CIFAR10(size={"dev": 1000})
# Create the model
inputs = tf.keras.layers.Input(shape=[CIFAR10.H, CIFAR10.W, CIFAR10.C])
hidden = tf.keras.layers.Conv2D(16, 3, 2, "same", activation=tf.nn.relu)(inputs)
hidden = tf.keras.layers.Conv2D(16, 3, 1, "same", activation=tf.nn.relu)(hidden)
hidden = tf.keras.layers.Conv2D(24, 3, 2, "same", activation=tf.nn.relu)(hidden)
hidden = tf.keras.layers.Conv2D(24, 3, 1, "same", activation=tf.nn.relu)(hidden)
hidden = tf.keras.layers.Conv2D(32, 3, 2, "same", activation=tf.nn.relu)(hidden)
hidden = tf.keras.layers.Conv2D(32, 3, 1, "same", activation=tf.nn.relu)(hidden)
hidden = tf.keras.layers.Flatten()(hidden)
hidden = tf.keras.layers.Dense(200, activation=tf.nn.relu)(hidden)
outputs = tf.keras.layers.Dense(CIFAR10.LABELS, activation=tf.nn.softmax)(hidden)
# Train the model
model = tf.keras.Model(inputs=inputs, outputs=outputs)
model.compile(
optimizer=tf.optimizers.Adam(),
loss=tf.losses.SparseCategoricalCrossentropy(),
metrics=[tf.metrics.SparseCategoricalAccuracy(name="accuracy")],
)
tb_callback = tf.keras.callbacks.TensorBoard(args.logdir, histogram_freq=1, update_freq=100, profile_batch=0)
# TODO: Create data augmenting `tf.keras.preprocessing.image.ImageDataGenerator`.
# Specify:
# - rotation range of 20 degrees,
# - zoom range of 0.2 (20%),
# - width shift range and height shift range of 0.1 (10%),
# - allow horizontal flips
train_generator = ...
# TODO: Train using the generator. To augment data, use
# `train_generator.flow` and specify:
# - first 5000 of cifar.train.data["images"] as inputs
# - first 5000 of cifar.train.data["labels"] as target
# - batch_size of args.batch_size
# - args.seed as random seed
logs = model.fit(
...,
shuffle=False, epochs=args.epochs,
validation_data=(cifar.dev.data["images"], cifar.dev.data["labels"]),
callbacks=[tb_callback],
)
# Return dev set accuracy
return logs.history["val_accuracy"][-1]
def main(args: argparse.Namespace) -> Dict[str, float]:
# Fix random seeds and threads
tf.keras.utils.set_random_seed(args.seed)
tf.config.threading.set_inter_op_parallelism_threads(args.threads)
tf.config.threading.set_intra_op_parallelism_threads(args.threads)
# Create logdir name
args.logdir = os.path.join(
"logs", "{}-{}-{}".format(
os.path.basename(globals().get("__file__", "notebook")),
datetime.datetime.now().strftime("%Y-%m-%d_%H%M%S"), ",".join(
("{}={}".format(re.sub("(.)[^_]*_?", r"\1", k), v)
for k, v in sorted(vars(args).items())))))
# Load the data
cifar = CIFAR10(size={"train": 5000, "dev": 1000})
# Create the model
inputs = tf.keras.layers.Input(shape=[CIFAR10.H, CIFAR10.W, CIFAR10.C])
hidden = tf.keras.layers.Conv2D(16, 3, 2, "same",
activation=tf.nn.relu)(inputs)
hidden = tf.keras.layers.Conv2D(16, 3, 1, "same",
activation=tf.nn.relu)(hidden)
hidden = tf.keras.layers.Conv2D(24, 3, 2, "same",
activation=tf.nn.relu)(hidden)
hidden = tf.keras.layers.Conv2D(24, 3, 1, "same",
activation=tf.nn.relu)(hidden)
hidden = tf.keras.layers.Conv2D(32, 3, 2, "same",
activation=tf.nn.relu)(hidden)
hidden = tf.keras.layers.Conv2D(32, 3, 1, "same",
activation=tf.nn.relu)(hidden)
hidden = tf.keras.layers.Flatten()(hidden)
hidden = tf.keras.layers.Dense(200, activation=tf.nn.relu)(hidden)
outputs = tf.keras.layers.Dense(CIFAR10.LABELS,
activation=tf.nn.softmax)(hidden)
# Train the model
model = tf.keras.Model(inputs=inputs, outputs=outputs)
model.compile(
optimizer=tf.optimizers.Adam(),
loss=tf.losses.SparseCategoricalCrossentropy(),
metrics=[tf.metrics.SparseCategoricalAccuracy(name="accuracy")],
)
tb_callback = tf.keras.callbacks.TensorBoard(args.logdir)
# TODO: Create data augmenting `tf.keras.preprocessing.image.ImageDataGenerator`.
# Specify:
# - rotation range of 20 degrees,
# - zoom range of 0.2 (20%),
# - width shift range and height shift range of 0.1 (10%),
# - allow horizontal flips
train_generator = ...
# TODO: Train using the generator. To augment data, use
# `train_generator.flow` and specify:
# - `cifar.train.data["images"]` as inputs
# - `cifar.train.data["labels"]` as target
# - batch_size of `args.batch_size`
# - `args.seed` as the random seed
logs = model.fit(
...,
shuffle=False,
epochs=args.epochs,
validation_data=(cifar.dev.data["images"], cifar.dev.data["labels"]),
callbacks=[tb_callback],
)
# Return development metrics for ReCodEx to validate
return {
metric: values[-1]
for metric, values in logs.history.items() if metric.startswith("val_")
}
# Fix random seeds and number of threads
np.random.seed(42)
tf.random.set_seed(42)
if args.recodex:
tf.keras.utils.get_custom_objects(
)["glorot_uniform"] = lambda: tf.keras.initializers.glorot_uniform(seed
=42)
tf.config.threading.set_inter_op_parallelism_threads(args.threads)
tf.config.threading.set_intra_op_parallelism_threads(args.threads)
# Create logdir name
args.logdir = os.path.join(
"logs", "{}-{}-{}".format(
os.path.basename(__file__),
datetime.datetime.now().strftime("%Y-%m-%d_%H%M%S"), ",".join(
("{}={}".format(re.sub("(.)[^_]*_?", r"\1", key), value)
for key, value in sorted(vars(args).items())))))
# Load the data
mnist = CIFAR10()
# Create the network and train
network = Network(args)
network.train(mnist, args)
# Compute test set accuracy and print it
accuracy = network.test(mnist, args)
with open("mnist_cnn.out", "w") as out_file:
print("{:.2f}".format(100 * accuracy), file=out_file)
def __init__(self, args):
self.args = args
# Initial Data Transform
transform_img = [
transforms.ToTensor(),
]
# Normalisation Transform
if self.args.pretrained:
normalise = [
transforms.Normalize(self.args.imagenet_mean_color,
self.args.imagenet_std_color)
]
else:
normalise = [
transforms.Normalize(self.args.cifar10_mean_color,
self.args.cifar10_std_color)
]
# Model Specific Transform
if self.args.model == "alexnet":
resize = [transforms.Resize((224, 224))]
else:
resize = []
# Any Data Augmentation
data_augmentation = []
if self.args.data_aug:
if self.args.model == "resnet":
data_augmentation = [
transforms.RandomHorizontalFlip(),
transforms.RandomAffine(degrees=0.0,
translate=(0.1, 0.1),
resample=PIL.Image.NEAREST),
]
else:
data_augmentation = [
transforms.RandomCrop(self.args.random_crop_size,
padding=self.args.random_crop_pad),
transforms.RandomHorizontalFlip(),
]
# Combine all transformations
transform_img_train = data_augmentation + resize + transform_img + normalise
transform_img_test = resize + transform_img + normalise
self.transform_train = transforms.Compose(transform_img_train)
self.transform_test = transforms.Compose(transform_img_test)
# Datasets and DataLoaders
if self.args.eval is False:
if self.args.training_mode == "supervised":
# ########################## Fully Supervised ################################### #
self.full_supervised_train_dataset = CIFAR10(
self.args.cifar10_dir,
split="train",
download=True,
transform=self.transform_train,
)
if self.args.full_data:
self.train_dataset = self.full_supervised_train_dataset
else:
# ###################### Partially Supervised ############################### #
(
train_labeled_idxs,
train_unlabeled_idxs,
) = get_train_indices_for_ssl(
self.full_supervised_train_dataset,
self.args.train_data_size)
self.train_labeled_indices = train_labeled_idxs
self.supervised_train_dataset = CIFAR10(
self.args.cifar10_dir,
split="train",
train_split_supervised_indices=np.array(
self.train_labeled_indices),
download=True,
transform=self.transform_train,
)
self.train_dataset = self.supervised_train_dataset
self.train_loader = torch.utils.data.DataLoader(
self.train_dataset,
batch_size=self.args.batch_size,
shuffle=True)
elif self.args.training_mode == "semi-supervised" or "gmm":
# ########################### Semi Supervised ################################### #
self.full_supervised_train_dataset = CIFAR10(
self.args.cifar10_dir,
split="train",
download=True,
transform=self.transform_train,
)
train_labeled_idxs, train_unlabeled_idxs = get_train_indices_for_ssl(
self.full_supervised_train_dataset,
self.args.train_data_size)
self.train_labeled_indices = train_labeled_idxs
self.train_unlabeled_indices = train_unlabeled_idxs
self.supervised_train_dataset = CIFAR10(
self.args.cifar10_dir,
split="train",
train_split_supervised_indices=np.array(
self.train_labeled_indices),
download=True,
transform=self.transform_train,
)
self.unsupervised_train_dataset = CIFAR10(
self.args.cifar10_dir,
split="train",
train_split_supervised_indices=np.array(
self.train_unlabeled_indices),
download=True,
transform=self.transform_train,
)
self.supervised_train_loader = torch.utils.data.DataLoader(
self.supervised_train_dataset,
batch_size=self.args.batch_size,
shuffle=True,
)
self.unsupervised_train_loader = torch.utils.data.DataLoader(
self.unsupervised_train_dataset,
batch_size=self.args.ssl_label_generation_batch_size,
shuffle=True,
)
# ############################## Val Split ########################################## #
self.val_dataset = CIFAR10(
self.args.cifar10_dir,
split="val",
download=True,
transform=self.transform_test,
)
self.val_loader = torch.utils.data.DataLoader(
self.val_dataset,
batch_size=self.args.test_batch_size,
shuffle=True)
# ################################ Test Split ########################################### #
self.test_dataset = CIFAR10(
self.args.cifar10_dir,
split="test",
download=True,
transform=self.transform_test,
)
self.test_loader = torch.utils.data.DataLoader(
self.test_dataset,
batch_size=self.args.test_batch_size,
shuffle=True)
def ssl_init_epoch(self, predictions_indices=[], predictions_labels=[]):
self.train_labeled_indices.extend(predictions_indices)
self.supervised_train_dataset = CIFAR10(
self.args.cifar10_dir,
split="train",
train_split_supervised_indices=np.array(
self.train_labeled_indices),
download=True,
transform=self.transform_train,
)
if len(predictions_indices) != 0:
indices2array_indices = {
idx: i
for i, idx in enumerate(
self.supervised_train_dataset.train_indices)
}
array_indices = np.array([
indices2array_indices[index] for index in predictions_indices
])
self.supervised_train_dataset.train_labels[
array_indices] = predictions_labels
self.train_unlabeled_indices = [
idx for idx in self.train_unlabeled_indices
if idx not in predictions_indices
]
assert len(self.train_labeled_indices) + len(
self.train_unlabeled_indices) == len(
self.full_supervised_train_dataset.train_labels)
self.supervised_train_loader = torch.utils.data.DataLoader(
self.supervised_train_dataset,
batch_size=self.args.batch_size,
shuffle=True)
if len(self.train_unlabeled_indices) != 0:
self.unsupervised_train_dataset = CIFAR10(
self.args.cifar10_dir,
split="train",
train_split_supervised_indices=np.array(
self.train_unlabeled_indices),
download=True,
transform=self.transform_train,
)
self.unsupervised_train_loader = torch.utils.data.DataLoader(
self.unsupervised_train_dataset,
batch_size=self.args.ssl_label_generation_batch_size,
shuffle=True,
)
else:
self.stop_label_generation = True
self.train_loader = self.supervised_train_loader
print("Labeled Training data: %d/%d" % (
len(self.supervised_train_dataset.train_labels),
len(self.full_supervised_train_dataset.train_labels),
))
print("Unlabeled Training data: %d/%d" % (
len(self.supervised_train_dataset.train_labels),
len(self.full_supervised_train_dataset.train_labels),
))
from ngraph.frontends.neon import Affine, Preprocess, Convolution, Pool2D, Sequential
from ngraph.frontends.neon import UniformInit, Rectlin, Softmax, GradientDescentMomentum
from ngraph.frontends.neon import ax, loop_train, make_bound_computation, make_default_callbacks
from ngraph.frontends.neon import NgraphArgparser
from ngraph.frontends.neon import ArrayIterator
from cifar10 import CIFAR10
import ngraph.transformers as ngt
parser = NgraphArgparser(description='Train simple CNN on cifar10 dataset')
args = parser.parse_args()
np.random.seed(args.rng_seed)
# Create the dataloader
train_data, valid_data = CIFAR10(args.data_dir).load_data()
train_set = ArrayIterator(train_data,
args.batch_size,
total_iterations=args.num_iterations)
valid_set = ArrayIterator(valid_data, args.batch_size)
######################
# Model specification
def cifar_mean_subtract(x):
bgr_mean = ng.persistent_tensor(axes=x.axes[0],
initial_value=np.array([[104., 119.,
127.]]))
y = ng.expand_dims((x - bgr_mean) / 255., ax.D, 1)
return y
# classifier
weights = tf.Variable(tf.zeros([9216, n_classes]), name="output_weight")
bias = tf.Variable(tf.truncated_normal([n_classes]), name="output_bias")
model = tf.matmul(extractor, weights) + bias
outputs = tf.placeholder(tf.float32, [None, n_classes])
# ====================
# config dataset
# ====================
print('Prepare dataset')
if data_name == 'ucf101':
train_dataset = UCF101('rgb', 'trainlist01', batch_size = batch_size)
test_dataset = UCF101('rgb', 'testlist01b', batch_size = batch_size)
elif data_name == 'cifar10':
train_dataset = CIFAR10(split_name = 'train', batch_size = batch_size)
test_dataset = CIFAR10(split_name = 'val', batch_size = batch_size)
init = tf.initialize_all_variables()
trian_features = None
train_label = None
with tf.Session(config=config) as sess:
sess.run(init)
for i in tqdm(range(20), unit=" batch "):
this_batch = train_dataset.batch(i)
train_X, train_y = helper.reshape_batch(this_batch, (image_size, image_size), n_classes)
train_y = [np.argmax(element) for element in train_y]
features = sess.run(
[extractor],
feed_dict={
args = parser.parse_args()
# Fix random seeds
np.random.seed(42)
tf.random.set_seed(42)
tf.config.threading.set_inter_op_parallelism_threads(args.threads)
tf.config.threading.set_intra_op_parallelism_threads(args.threads)
# Create logdir name
args.logdir = os.path.join(
"logs", "{}-{}-{}".format(
os.path.basename(__file__),
datetime.datetime.now().strftime("%Y-%m-%d_%H%M%S"), ",".join(
("{}={}".format(re.sub("(.)[^_]*_?", r"\1", key), value)
for key, value in sorted(vars(args).items())))))
# Load data
cifar = CIFAR10()
# Create the network and train
network = Network(args)
network.train(cifar, args)
# Generate test set annotations, but in args.logdir to allow parallel execution.
with open(os.path.join(args.logdir, "cifar_competition_test.txt"),
"w",
encoding="utf-8") as out_file:
for probs in network.predict(cifar.test.data["images"],
batch_size=args.batch_size):
print(np.argmax(probs), file=out_file)
#%%
from cifar10 import CIFAR10
c = CIFAR10()
c.data_augmentation(10000)
#%%
from scipy import io as io
import numpy as np
c.y_train = np.argmax(c.y_train, axis=1).astype("int32")
c.y_test = np.argmax(c.y_test, axis=1).astype("int32")
io.savemat("train.mat", {"x": c.x_train, "y": c.y_train})
io.savemat("test.mat", {"x": c.x_test, "y": c.y_test})
