def create_reader(map_file, mean_file, train):
"""
Define the reader for both training and evaluation action.
"""
if not os.path.exists(map_file) or not os.path.exists(mean_file):
raise RuntimeError("This example require prepared dataset. \
Please run cifar_prepare.py example.")
transforms = []
if train:
transforms += [xforms.crop(crop_type='randomside', side_ratio=0.8)]
transforms += [
xforms.scale(width=image_width,
height=image_height,
channels=num_channels,
interpolations='linear'),
xforms.mean(mean_file)
]
return C.io.MinibatchSource(
C.io.ImageDeserializer(
map_file,
C.io.StreamDefs(features=C.io.StreamDef(field='image',
transforms=transforms),
labels=C.io.StreamDef(field='label',
shape=num_classes))))
def create_reader(map_file, mean_file, train):
# transformation pipeline for the features has jitter/crop only when training
trs = []
# if train:
# transforms += [
# ImageDeserializer.crop(crop_type='Random', ratio=0.8, jitter_type='uniRatio') # train uses jitter
# ]
trs += [
transforms.scale(width=image_width,
height=image_height,
channels=num_channels,
interpolations='linear'),
transforms.mean(mean_file)
]
# deserializer
return MinibatchSource(
ImageDeserializer(
map_file,
StreamDefs(
features=StreamDef(
field='image', transforms=trs
), # first column in map file is referred to as 'image'
labels=StreamDef(field='label',
shape=num_classes) # and second as 'label'
)))
def create_reader(map_file, mean_file, is_training):
if not os.path.exists(map_file) or not os.path.exists(mean_file):
raise RuntimeError(
"File '%s' or '%s' does not exist. Please run install_cifar10.py from DataSets/CIFAR-10 to fetch them"
% (map_file, mean_file))
# transformation pipeline for the features has jitter/crop only when training
transforms = []
if is_training:
transforms += [
xforms.crop(crop_type='RandomSide',
side_ratio=0.8,
jitter_type='uniRatio') # train uses jitter
]
transforms += [
xforms.scale(width=image_width,
height=image_height,
channels=num_channels,
interpolations='linear'),
xforms.mean(mean_file)
]
# deserializer
return cntk.io.MinibatchSource(
cntk.io.ImageDeserializer(
map_file,
cntk.io.StreamDefs(
features=cntk.io.StreamDef(
field='image', transforms=transforms
), # first column in map file is referred to as 'image'
labels=cntk.io.StreamDef(
field='label',
shape=num_classes))), # and second as 'label'
randomize=is_training)
def create_image_mb_source(map_file, mean_file, train, total_number_of_samples):
if not os.path.exists(map_file) or not os.path.exists(mean_file):
raise RuntimeError("File '%s' or '%s' does not exist." % (map_file, mean_file))
# transformation pipeline for the features has jitter/crop only when training
transforms = []
if train:
transforms += [
xforms.crop(crop_type='randomarea', area_ratio=(0.08, 1.0), aspect_ratio=(0.75, 1.3333), jitter_type='uniratio'), # train uses jitter
xforms.color(brightness_radius=0.4, contrast_radius=0.4, saturation_radius=0.4)
]
else:
transforms += [
C.io.transforms.crop(crop_type='center', side_ratio=0.875) # test has no jitter
]
transforms += [
xforms.scale(width=image_width, height=image_height, channels=num_channels, interpolations='cubic'),
xforms.mean(mean_file)
]
# deserializer
return C.io.MinibatchSource(
C.io.ImageDeserializer(map_file, C.io.StreamDefs(
features=C.io.StreamDef(field='image', transforms=transforms), # 1st col in mapfile referred to as 'image'
labels=C.io.StreamDef(field='label', shape=num_classes))), # and second as 'label'
randomize=train,
max_samples=total_number_of_samples,
multithreaded_deserializer=True)
def create_reader(map_file, mean_file, is_training):
print("Reading map file:", map_file)
print("Reading mean file:", mean_file)
if not os.path.exists(map_file) or not os.path.exists(mean_file):
raise RuntimeError(
"This tutorials depends 201A tutorials, please run 201A first.")
# transformation pipeline for the features has jitter/crop only when training
transforms = []
# train uses data augmentation (translation only)
if is_training:
transforms += [xforms.crop(crop_type='randomside', side_ratio=0.8)]
transforms += [
xforms.scale(width=image_width,
height=image_height,
channels=num_channels,
interpolations='linear'),
xforms.mean(mean_file)
]
# deserializer
return C.io.MinibatchSource(
C.io.ImageDeserializer(
map_file,
C.io.StreamDefs(
features=C.io.StreamDef(
field='image', transforms=transforms
), # first column in map file is referred to as 'image'
labels=C.io.StreamDef(
field='label', shape=num_classes) # and second as 'label'
)))
def create_reader(map_file, mean_file, is_training):
if not os.path.exists(map_file) or not os.path.exists(mean_file):
raise RuntimeError(
"File '%s' or '%s' does not exist. Please run install_cifar10.py from DataSets/CIFAR-10 to fetch them"
% (map_file, mean_file))
# crop transform 40 * 0.8 = 32
transforms = []
if is_training:
transforms += [
xforms.crop(crop_type='RandomSide',
side_ratio=0.8,
jitter_type='uniRatio') # train uses jitter
]
transforms += [
xforms.scale(width=image_width,
height=image_height,
channels=num_channels,
interpolations='linear'),
xforms.mean(mean_file)
]
# deserializer
return C.io.MinibatchSource(C.io.ImageDeserializer(
map_file,
C.io.StreamDefs(features=C.io.StreamDef(field='image',
transforms=transforms),
labels=C.io.StreamDef(field='label',
shape=num_classes))),
randomize=is_training)
def create_image_mb_source(map_file, mean_file, is_training, total_number_of_samples):
if not os.path.exists(map_file) or not os.path.exists(mean_file):
raise RuntimeError("File '%s' or '%s' does not exist." %
(map_file, mean_file))
# transformation pipeline for the features has jitter/crop only when training
transforms = []
if is_training:
transforms += [
xforms.crop(crop_type='randomside', side_ratio=0.875, jitter_type='uniratio') # train uses jitter
]
else:
transforms += [
xforms.crop(crop_type='center', side_ratio=0.875) # test has no jitter
]
transforms += [
xforms.scale(width=image_width, height=image_height, channels=num_channels, interpolations='linear'),
xforms.mean(mean_file)
]
# deserializer
return MinibatchSource(
ImageDeserializer(map_file, StreamDefs(
features = StreamDef(field='image', transforms=transforms), # first column in map file is referred to as 'image'
labels = StreamDef(field='label', shape=num_classes))),
randomize = is_training,
epoch_size=total_number_of_samples,
multithreaded_deserializer = True)
def create_image_mb_source(map_file, mean_file, is_training, total_number_of_samples):
if not os.path.exists(map_file) or not os.path.exists(mean_file):
raise RuntimeError("File '%s' or '%s' does not exist." %
(map_file, mean_file))
# transformation pipeline for the features has jitter/crop only when training
transforms = []
if is_training:
transforms += [
xforms.crop(crop_type='randomside', side_ratio=0.8, jitter_type='uniratio') # train uses jitter
]
else:
transforms += [
xforms.crop(crop_type='center', crop_size=IMAGE_WIDTH)
]
transforms += [
xforms.scale(width=IMAGE_WIDTH, height=IMAGE_HEIGHT, channels=NUM_CHANNELS, interpolations='linear'),
xforms.mean(mean_file)
]
# deserializer
return MinibatchSource(
ImageDeserializer(map_file, StreamDefs(
features=StreamDef(field='image', transforms=transforms), # first column in map file is referred to as 'image'
labels=StreamDef(field='label', shape=NUM_CLASSES))), # and second as 'label'
randomize=is_training,
max_samples=total_number_of_samples,
multithreaded_deserializer = True)
def create_image_mb_source(map_file, mean_file, train, total_number_of_samples):
if not os.path.exists(map_file) or not os.path.exists(mean_file):
raise RuntimeError("File '%s' or '%s' does not exist. Please run install_cifar10.py from DataSets/CIFAR-10 to fetch them" %
(map_file, mean_file))
# transformation pipeline for the features has jitter/crop only when training
transforms = []
if train:
transforms += [
xforms.crop(crop_type='randomside', side_ratio=0.8, jitter_type='uniratio') # train uses jitter
]
transforms += [
xforms.scale(width=image_width, height=image_height, channels=num_channels, interpolations='linear'),
xforms.mean(mean_file)
]
# deserializer
return cntk.io.MinibatchSource(
cntk.io.ImageDeserializer(map_file, cntk.io.StreamDefs(
features = cntk.io.StreamDef(field='image', transforms=transforms), # first column in map file is referred to as 'image'
labels = cntk.io.StreamDef(field='label', shape=num_classes))), # and second as 'label'
randomize=train,
epoch_size=total_number_of_samples,
multithreaded_deserializer = True)
def create_reader(map_file,
mean_file,
train,
image_height=64,
image_width=64,
num_channels=3,
num_classes=32):
# transformation pipeline for the features has jitter/crop only when training
# https://docs.microsoft.com/en-us/python/api/cntk.io.transforms?view=cntk-py-2.2
trs = []
if train:
trs += [
transforms.crop(crop_type='randomside',
side_ratio=0,
jitter_type='none') # Horizontal flip enabled
]
trs += [
transforms.scale(width=image_width,
height=image_height,
channels=num_channels,
interpolations='linear'),
transforms.mean(mean_file)
]
# deserializer
image_source = ImageDeserializer(
map_file,
StreamDefs(
features=StreamDef(
field='image', transforms=trs
), # first column in map file is referred to as 'image'
labels=StreamDef(field='label',
shape=num_classes) # and second as 'label'
))
return MinibatchSource(image_source)
def create_image_mb_source(map_file, mean_file, train,
total_number_of_samples):
if not os.path.exists(map_file) or not os.path.exists(mean_file):
raise RuntimeError(
"File '%s' or '%s' does not exist. Please run install_cifar10.py from DataSets/CIFAR-10 to fetch them"
% (map_file, mean_file))
# transformation pipeline for the features has jitter/crop only when training
transforms = []
# if train:
# transforms += [
# xforms.crop(crop_type='randomside', side_ratio=(0.8, 1.0), jitter_type='uniratio') # train uses jitter
# ]
transforms += [
xforms.scale(width=image_width,
height=image_height,
channels=num_channels,
interpolations='linear'),
xforms.mean(mean_file)
]
# deserializer
return MinibatchSource(
ImageDeserializer(
map_file,
StreamDefs(
features=StreamDef(
field='image', transforms=transforms
), # first column in map file is referred to as 'image'
labels=StreamDef(field='label',
shape=num_classes))), # and second as 'label'
randomize=train,
max_samples=total_number_of_samples,
multithreaded_deserializer=True)
def create_image_mb_source(map_file, mean_file, train, total_number_of_samples):
if not os.path.exists(map_file) or not os.path.exists(mean_file):
raise RuntimeError("File '%s' or '%s' does not exist." % (map_file, mean_file))
# transformation pipeline for the features has jitter/crop only when training
transforms = []
if train:
transforms += [
xforms.crop(crop_type='randomarea', area_ratio=(0.08, 1.0), aspect_ratio=(0.75, 1.3333), jitter_type='uniratio'), # train uses jitter
xforms.color(brightness_radius=0.4, contrast_radius=0.4, saturation_radius=0.4)
]
else:
transforms += [
C.io.transforms.crop(crop_type='center', side_ratio=0.875) # test has no jitter
]
transforms += [
xforms.scale(width=image_width, height=image_height, channels=num_channels, interpolations='cubic'),
xforms.mean(mean_file)
]
# deserializer
return C.io.MinibatchSource(
C.io.ImageDeserializer(map_file, C.io.StreamDefs(
features=C.io.StreamDef(field='image', transforms=transforms), # 1st col in mapfile referred to as 'image'
labels=C.io.StreamDef(field='label', shape=num_classes))), # and second as 'label'
randomize=train,
max_samples=total_number_of_samples,
multithreaded_deserializer=True)
def test_image():
map_file = "input.txt"
mean_file = "mean.txt"
feature_name = "f"
image_width = 100
image_height = 200
num_channels = 3
label_name = "l"
num_classes = 7
transforms = [
xforms.crop(crop_type='randomside', side_ratio=0.5,
jitter_type='uniratio'),
xforms.scale(width=image_width, height=image_height,
channels=num_channels, interpolations='linear'),
xforms.mean(mean_file)]
defs = StreamDefs(f=StreamDef(field='image', transforms=transforms),
l=StreamDef(field='label', shape=num_classes))
image = ImageDeserializer(map_file, defs)
config = to_dictionary(MinibatchSourceConfig([image], randomize=False))
assert len(config['deserializers']) == 1
d = config['deserializers'][0]
assert d['type'] == 'ImageDeserializer'
assert d['file'] == map_file
assert set(d['input'].keys()) == {label_name, feature_name}
l = d['input'][label_name]
assert l['labelDim'] == num_classes
f = d['input'][feature_name]
assert set(f.keys()) == {'transforms'}
t0, t1, t2, _ = f['transforms']
assert t0['type'] == 'Crop'
assert t1['type'] == 'Scale'
assert t2['type'] == 'Mean'
assert t0['cropType'] == 'randomside'
assert t0['sideRatio'] == 0.5
assert t0['aspectRatio'] == 1.0
assert t0['jitterType'] == 'uniratio'
assert t1['width'] == image_width
assert t1['height'] == image_height
assert t1['channels'] == num_channels
assert t1['interpolations'] == 'linear'
assert t2['meanFile'] == mean_file
config = to_dictionary(MinibatchSourceConfig([image, image]))
assert len(config['deserializers']) == 2
config = to_dictionary(MinibatchSourceConfig([image, image, image]))
assert len(config['deserializers']) == 3
# TODO depends on ImageReader.dll
'''
def create_image_mb_source(map_file, mean_file, train,
total_number_of_samples):
""" Creates minibatch source
"""
if not os.path.exists(map_file) or not os.path.exists(mean_file):
raise RuntimeError("File '%s' or '%s' does not exist. " %
(map_file, mean_file))
# transformation pipeline for the features has jitter/crop only when training
transforms = []
if train:
imgfolder = os.path.join(os.path.split(map_file)[0], 'train')
transforms += [
xforms.crop(crop_type='randomside',
side_ratio=0.8,
jitter_type='uniratio') # train uses jitter
]
else:
imgfolder = os.path.join(os.path.split(map_file)[0], 'test')
transforms += [
xforms.scale(width=_IMAGE_WIDTH,
height=_IMAGE_HEIGHT,
channels=_NUM_CHANNELS,
interpolations='linear'),
xforms.mean(mean_file)
]
map_file = process_map_file(map_file, imgfolder)
# deserializer
return MinibatchSource(
ImageDeserializer(
map_file,
StreamDefs(
features=StreamDef(field='image', transforms=transforms),
# first column in map file is referred to as 'image'
labels=StreamDef(
field='label',
shape=_NUM_CLASSES))), # and second as 'label'
randomize=train,
max_samples=total_number_of_samples,
multithreaded_deserializer=True)
def create_reader(map_file, mean_file, is_training):
if not os.path.exists(map_file) or not os.path.exists(mean_file):
raise RuntimeError("File '%s' or '%s' does not exist. Please run install_cifar10.py from DataSets/CIFAR-10 to fetch them" %
(map_file, mean_file))
# transformation pipeline for the features has jitter/crop only when training
transforms = []
if is_training:
transforms += [
xforms.crop(crop_type='randomside', side_ratio=0.8, jitter_type='uniratio') # train uses jitter
]
transforms += [
xforms.scale(width=image_width, height=image_height, channels=num_channels, interpolations='linear'),
xforms.mean(mean_file)
]
# deserializer
return MinibatchSource(ImageDeserializer(map_file, StreamDefs(
features=StreamDef(field='image', transforms=transforms), # first column in map file is referred to as 'image'
labels=StreamDef(field='label', shape=num_classes))), # and second as 'label'
randomize=is_training, max_sweeps = INFINITELY_REPEAT if is_training else 1)
def create_reader(map_file, mean_file, train, pixel_dimensions, classes,
total_number_of_samples):
print(
f"Reading map file: {map_file} with number of samples {total_number_of_samples}"
)
transforms = [
xforms.scale(width=pixel_dimensions['width'],
height=pixel_dimensions['height'],
channels=pixel_dimensions['depth'],
interpolations='linear'),
xforms.mean(mean_file)
]
source = MinibatchSource(deserializers=ImageDeserializer(
map_file,
StreamDefs(features=StreamDef(field='image', transforms=transforms),
labels=StreamDef(field='label', shape=len(classes)))),
randomize=train,
max_samples=total_number_of_samples)
return source
def create_img_reader(Dataset_result,train,train_args):
for file in Dataset_result:
if file.find('map.txt') != -1:
map_file = file
if file.find('mean.xml') != -1:
mean_file = file
if not os.path.exists(map_file) or not os.path.exists(mean_file):
return print (r'map.txt or mean.xml file is not found')
transforms = []
if train:
transforms +=[
xforms.crop(crop_type='randomside',side_ratio=0.8,jitter_type='uniratio')
]
transforms += [
xforms.scale(width=train_args.resize,height=train_args.resize,channels=train_args.channels,interpolations='linear'),
xforms.mean(mean_file)
]
return cntk.io.MinibatchSource(cntk.io.ImageDeserializer(map_file, cntk.io.StreamDefs(
features = cntk.io.StreamDef(field='image', transforms=transforms),
labels = cntk.io.StreamDef(field='label', shape=train_args.out_dim))),
randomize=train)
def create_reader(map_file, mean_file, train, dimensions, classes,
total_number_of_samples):
print("Reading map file: {} with number of samples {}".format(
map_file, total_number_of_samples))
# transformation pipeline for the features has jitter/crop only when training
transforms = []
transforms += [
xforms.scale(width=dimensions['width'],
height=dimensions['height'],
channels=dimensions['depth'],
interpolations='linear'),
xforms.mean(mean_file)
]
source = MinibatchSource(ImageDeserializer(
map_file,
StreamDefs(features=StreamDef(field='image', transforms=transforms),
labels=StreamDef(field='label', shape=len(classes)))),
randomize=train,
max_samples=total_number_of_samples)
return source
def train(self,
path_to_folder: str,
model_definition,
epochs: int = 10,
output_model_path: str = "driver_model.onnx"):
path_to_folder = path_to_folder.rstrip('/')
map_file_train = path_to_folder + "/train_map.txt"
map_file_test = path_to_folder + "/test_map.txt"
mean_file = path_to_folder + "/meanfile.xml"
classes_set = set()
num_train = 0
num_test = 0
num_channels = 3
try:
with open(map_file_train) as f:
csv_reader = csv.reader(f, delimiter='\t')
for row in csv_reader:
cmd = row[1]
classes_set.add(cmd)
num_train = num_train + 1
except Exception as e:
raise Exception(
"No train_map.txt file found in path " + path_to_folder +
". Did you create a dataset using create_balanced_dataset()?")
num_classes = len(classes_set)
with open(map_file_test) as f:
for num_test, l in enumerate(f):
pass
transforms = [
xforms.scale(width=self.__image_width,
height=self.__image_height,
channels=num_channels,
interpolations='linear'),
xforms.mean(mean_file),
]
# ImageDeserializer loads images in the BGR format, not RGB
reader_train = MinibatchSource(
ImageDeserializer(
map_file_train,
StreamDefs(features=StreamDef(field='image',
transforms=transforms),
labels=StreamDef(field='label',
shape=num_classes))))
reader_test = MinibatchSource(
ImageDeserializer(
map_file_test,
StreamDefs(features=StreamDef(field='image',
transforms=transforms),
labels=StreamDef(field='label',
shape=num_classes))))
input_var = input_variable(
(num_channels, self.__image_height, self.__image_width))
label_var = input_variable((num_classes))
# Normalize the input
feature_scale = 1.0 / 256.0
input_var_norm = element_times(feature_scale, input_var)
model = model_definition(input_var)
ce = cross_entropy_with_softmax(model, label_var)
pe = classification_error(model, label_var)
epoch_size = num_train
minibatch_size = 64
lr_per_minibatch = learning_parameter_schedule([0.01] * 10 +
[0.003] * 10 + [0.001],
epoch_size=epoch_size)
momentums = momentum_schedule(0.9, minibatch_size=minibatch_size)
l2_reg_weight = 0.001
learner = momentum_sgd(model.parameters,
lr=lr_per_minibatch,
momentum=momentums,
l2_regularization_weight=l2_reg_weight)
progress_printer = ProgressPrinter(tag='Training', num_epochs=epochs)
trainer = cntk.train.Trainer(model, (ce, pe), [learner],
[progress_printer])
input_map = {
input_var: reader_train.streams.features,
label_var: reader_train.streams.labels
}
batch_index = 0
plot_data = {'batchindex': [], 'loss': [], 'error': []}
for epoch in range(epochs):
sample_count = 0
while sample_count < epoch_size:
data = reader_train.next_minibatch(min(
minibatch_size, epoch_size - sample_count),
input_map=input_map)
trainer.train_minibatch(data)
sample_count += data[label_var].num_samples
plot_data['batchindex'].append(batch_index)
plot_data['loss'].append(
trainer.previous_minibatch_loss_average)
plot_data['error'].append(
trainer.previous_minibatch_evaluation_average)
batch_index += 1
trainer.summarize_training_progress()
epoch_size = num_test
minibatch_size = 16
metric_numer = 0
metric_denom = 0
sample_count = 0
minibatch_index = 0
while sample_count < epoch_size:
current_minibatch = min(minibatch_size, epoch_size - sample_count)
data = reader_test.next_minibatch(current_minibatch,
input_map=input_map)
metric_numer += trainer.test_minibatch(data) * current_minibatch
metric_denom += current_minibatch
sample_count += data[label_var].num_samples
minibatch_index += 1
print("")
print("Final Results: Minibatch[1-{}]: errs = {:0.1f}% * {}".format(
minibatch_index + 1, (metric_numer * 100.0) / metric_denom,
metric_denom))
print("")
model.save(output_model_path, format=ModelFormat.ONNX)
def test_image(tmpdir):
map_file = "input.txt"
mean_file = "mean.txt"
feature_name = "f"
image_width = 100
image_height = 200
num_channels = 3
label_name = "l"
num_classes = 7
transforms = [
xforms.crop(crop_type='randomside', side_ratio=0.5,
jitter_type='uniratio'),
xforms.scale(width=image_width, height=image_height,
channels=num_channels, interpolations='linear'),
xforms.mean(mean_file)]
defs = StreamDefs(f=StreamDef(field='image', transforms=transforms),
l=StreamDef(field='label', shape=num_classes))
image = ImageDeserializer(map_file, defs)
config = to_dictionary(MinibatchSourceConfig([image], randomize=False))
# Multithreading should be on by default for the ImageDeserializer.
assert config['multiThreadedDeserialization'] is True
assert len(config['deserializers']) == 1
d = config['deserializers'][0]
assert d['type'] == 'ImageDeserializer'
assert d['file'] == map_file
assert set(d['input'].keys()) == {label_name, feature_name}
l = d['input'][label_name]
assert l['labelDim'] == num_classes
f = d['input'][feature_name]
assert set(f.keys()) == {'transforms'}
t0, t1, t2, _ = f['transforms']
assert t0['type'] == 'Crop'
assert t1['type'] == 'Scale'
assert t2['type'] == 'Mean'
assert t0['cropType'] == 'randomside'
assert t0['cropSize'] == '0:0'
assert t0['sideRatio'] == '0.5:0.5'
assert t0['aspectRatio'] == '1:1'
assert t0['areaRatio'] == '0:0'
assert t0['jitterType'] == 'uniratio'
assert t1['width'] == image_width
assert t1['height'] == image_height
assert t1['channels'] == num_channels
assert t1['interpolations'] == 'linear'
assert t2['meanFile'] == mean_file
config = to_dictionary(MinibatchSourceConfig([image, image]))
assert len(config['deserializers']) == 2
ctf = create_ctf_deserializer(tmpdir)
config = to_dictionary(MinibatchSourceConfig([image, ctf, image]))
# Multithreading should still be enabled.
assert config['multiThreadedDeserialization'] is True
assert len(config['deserializers']) == 3
# TODO depends on ImageReader.dll
'''
def test_image():
map_file = "input.txt"
mean_file = "mean.txt"
epoch_size = 150
feature_name = "f"
image_width = 100
image_height = 200
num_channels = 3
label_name = "l"
num_classes = 7
transforms = [
xforms.crop(crop_type='randomside',
side_ratio=0.5,
jitter_type='uniratio'),
xforms.scale(width=image_width,
height=image_height,
channels=num_channels,
interpolations='linear'),
xforms.mean(mean_file)
]
image = ImageDeserializer(
map_file,
StreamDefs(f=StreamDef(field='image', transforms=transforms),
l=StreamDef(field='label', shape=num_classes)))
rc = _ReaderConfig(image, randomize=False, epoch_size=epoch_size)
assert rc['epochSize'].value == epoch_size
assert rc['randomize'] == False
assert rc['sampleBasedRandomizationWindow'] == False
assert len(rc['deserializers']) == 1
d = rc['deserializers'][0]
assert d['type'] == 'ImageDeserializer'
assert d['file'] == map_file
assert set(d['input'].keys()) == {label_name, feature_name}
l = d['input'][label_name]
assert l['labelDim'] == num_classes
f = d['input'][feature_name]
assert set(f.keys()) == {'transforms'}
t0, t1, t2 = f['transforms']
assert t0['type'] == 'Crop'
assert t1['type'] == 'Scale'
assert t2['type'] == 'Mean'
assert t0['cropType'] == 'randomside'
assert t0['sideRatio'] == 0.5
assert t0['aspectRatio'] == 1.0
assert t0['jitterType'] == 'uniratio'
assert t1['width'] == image_width
assert t1['height'] == image_height
assert t1['channels'] == num_channels
assert t1['interpolations'] == 'linear'
assert t2['meanFile'] == mean_file
rc = _ReaderConfig(image,
randomize=False,
randomization_window=100,
sample_based_randomization_window=True,
epoch_size=epoch_size)
assert rc['epochSize'].value == epoch_size
assert rc['randomize'] == False
assert rc['sampleBasedRandomizationWindow'] == True
assert len(rc['deserializers']) == 1
d = rc['deserializers'][0]
assert d['type'] == 'ImageDeserializer'
assert d['file'] == map_file
assert set(d['input'].keys()) == {label_name, feature_name}
l = d['input'][label_name]
assert l['labelDim'] == num_classes
rc = _ReaderConfig(image,
randomize=True,
randomization_window=100,
sample_based_randomization_window=True,
epoch_size=epoch_size)
assert rc['epochSize'].value == epoch_size
assert rc['randomize'] == True
assert rc['sampleBasedRandomizationWindow'] == True
assert len(rc['deserializers']) == 1
d = rc['deserializers'][0]
assert d['type'] == 'ImageDeserializer'
assert d['file'] == map_file
assert set(d['input'].keys()) == {label_name, feature_name}
l = d['input'][label_name]
assert l['labelDim'] == num_classes
# TODO depends on ImageReader.dll
'''
def test_image():
map_file = "input.txt"
mean_file = "mean.txt"
epoch_size = 150
feature_name = "f"
image_width = 100
image_height = 200
num_channels = 3
label_name = "l"
num_classes = 7
transforms = [xforms.crop(crop_type='randomside', side_ratio=0.5, jitter_type='uniratio'),
xforms.scale(width=image_width, height=image_height, channels=num_channels, interpolations='linear'),
xforms.mean(mean_file)]
image = ImageDeserializer(map_file, StreamDefs(f = StreamDef(field='image', transforms=transforms), l = StreamDef(field='label', shape=num_classes)))
rc = _ReaderConfig(image, randomize=False, epoch_size=epoch_size)
assert rc['epochSize'].value == epoch_size
assert rc['randomize'] == False
assert rc['sampleBasedRandomizationWindow'] == False
assert len(rc['deserializers']) == 1
d = rc['deserializers'][0]
assert d['type'] == 'ImageDeserializer'
assert d['file'] == map_file
assert set(d['input'].keys()) == {label_name, feature_name}
l = d['input'][label_name]
assert l['labelDim'] == num_classes
f = d['input'][feature_name]
assert set(f.keys()) == { 'transforms' }
t0, t1, t2 = f['transforms']
assert t0['type'] == 'Crop'
assert t1['type'] == 'Scale'
assert t2['type'] == 'Mean'
assert t0['cropType'] == 'randomside'
assert t0['sideRatio'] == 0.5
assert t0['aspectRatio'] == 1.0
assert t0['jitterType'] == 'uniratio'
assert t1['width'] == image_width
assert t1['height'] == image_height
assert t1['channels'] == num_channels
assert t1['interpolations'] == 'linear'
assert t2['meanFile'] == mean_file
rc = _ReaderConfig(image, randomize=False, randomization_window = 100,
sample_based_randomization_window = True, epoch_size=epoch_size)
assert rc['epochSize'].value == epoch_size
assert rc['randomize'] == False
assert rc['sampleBasedRandomizationWindow'] == True
assert len(rc['deserializers']) == 1
d = rc['deserializers'][0]
assert d['type'] == 'ImageDeserializer'
assert d['file'] == map_file
assert set(d['input'].keys()) == {label_name, feature_name}
l = d['input'][label_name]
assert l['labelDim'] == num_classes
rc = _ReaderConfig(image, randomize=True, randomization_window = 100,
sample_based_randomization_window = True, epoch_size=epoch_size)
assert rc['epochSize'].value == epoch_size
assert rc['randomize'] == True
assert rc['sampleBasedRandomizationWindow'] == True
assert len(rc['deserializers']) == 1
d = rc['deserializers'][0]
assert d['type'] == 'ImageDeserializer'
assert d['file'] == map_file
assert set(d['input'].keys()) == {label_name, feature_name}
l = d['input'][label_name]
assert l['labelDim'] == num_classes
# TODO depends on ImageReader.dll
'''
