def __init__(self, restrictor_captioner, body_captioner, incorrect_distribution=None, pragmatical_redundancy_rate=None, pragmatical_tautology_rate=None, logical_redundancy_rate=None, logical_tautology_rate=None, logical_contradiction_rate=None):
super(ExistentialCaptioner, self).__init__(
internal_captioners=(restrictor_captioner, body_captioner),
pragmatical_redundancy_rate=pragmatical_redundancy_rate,
pragmatical_tautology_rate=pragmatical_tautology_rate,
logical_redundancy_rate=logical_redundancy_rate,
logical_tautology_rate=logical_tautology_rate,
logical_contradiction_rate=logical_contradiction_rate
)
self.restrictor_captioner = restrictor_captioner
self.body_captioner = body_captioner
self.incorrect_distribution = util.cumulative_distribution(util.value_or_default(incorrect_distribution, [1, 1]))
def __init__(self, quantifier_captioner, number_bounds=None, incorrect_distribution=None, pragmatical_redundancy_rate=None, pragmatical_tautology_rate=None, logical_redundancy_rate=None, logical_tautology_rate=None, logical_contradiction_rate=None):
super(NumberBoundCaptioner, self).__init__(
internal_captioners=(quantifier_captioner,),
pragmatical_redundancy_rate=pragmatical_redundancy_rate,
pragmatical_tautology_rate=pragmatical_tautology_rate,
logical_redundancy_rate=logical_redundancy_rate,
logical_tautology_rate=logical_tautology_rate,
logical_contradiction_rate=logical_contradiction_rate
)
self.quantifier_captioner = quantifier_captioner
self.number_bounds = number_bounds
self.incorrect_distribution = util.cumulative_distribution(util.value_or_default(incorrect_distribution, [3, 1, 1, 1]))
def __init__(self,
hypernym_rate=None,
existing_attribute_rate=None,
incorrect_distribution=None,
pragmatical_redundancy_rate=None,
pragmatical_tautology_rate=None,
logical_redundancy_rate=None,
logical_tautology_rate=None,
logical_contradiction_rate=None):
super(RegularTypeCaptioner, self).__init__(
internal_captioners=(),
pragmatical_redundancy_rate=pragmatical_redundancy_rate,
pragmatical_tautology_rate=pragmatical_tautology_rate,
logical_redundancy_rate=logical_redundancy_rate,
logical_tautology_rate=logical_tautology_rate,
logical_contradiction_rate=logical_contradiction_rate)
self.hypernym_rate = util.value_or_default(hypernym_rate, 0.5)
self.existing_attribute_rate = util.value_or_default(
existing_attribute_rate, 0.5)
self.incorrect_distribution = incorrect_distribution
def __init__(self, internal_captioners=None, trivial_acceptance_rate=None):
self.internal_captioners = list(
util.value_or_default(internal_captioners, ()))
self.trivial_acceptance_rate = trivial_acceptance_rate
if trivial_acceptance_rate is not None:
captioners = list(self.internal_captioners)
while captioners:
captioner = captioners.pop()
if captioner.trivial_acceptance_rate is None:
captioner.trivial_acceptance_rate = trivial_acceptance_rate
captioners.extend(captioner.internal_captioners)
self.realizer = None
self.correct = None
def __init__(self,
generators,
distribution=None,
train_distribution=None,
validation_distribution=None,
test_distribution=None):
assert len(generators) >= 1
assert all(generator.world_size == generators[0].world_size
for generator in generators)
assert not distribution or len(distribution) == len(generators)
assert bool(train_distribution) == bool(
validation_distribution) == bool(test_distribution)
assert not train_distribution or len(train_distribution) == len(
validation_distribution) == len(test_distribution) == len(
distribution)
super(GeneratorMixer, self).__init__(
world_size=generators[0].world_size,
world_color=generators[0].world_color,
shapes=generators[0].shapes,
colors=generators[0].colors,
textures=generators[0].textures,
rotation=generators[0].rotation,
size_range=generators[0].size_range,
distortion_range=generators[0].distortion_range,
shade_range=generators[0].shade_range,
collision_tolerance=generators[0].collision_tolerance,
boundary_tolerance=generators[0].boundary_tolerance)
self.generators = generators
distribution = util.value_or_default(distribution,
[1] * len(generators))
self.distribution = util.cumulative_distribution(distribution)
self.train_distribution = util.cumulative_distribution(
util.value_or_default(train_distribution, distribution))
self.validation_distribution = util.cumulative_distribution(
util.value_or_default(validation_distribution, distribution))
self.test_distribution = util.cumulative_distribution(
util.value_or_default(test_distribution, distribution))
def __init__(self,
captioners,
correct_distribution=None,
pragmatical_redundancy_rate=None,
pragmatical_tautology_rate=None,
logical_redundancy_rate=None,
logical_tautology_rate=None,
logical_contradiction_rate=None):
super(DisjunctionCaptioner, self).__init__(
internal_captioners=captioners,
pragmatical_redundancy_rate=pragmatical_redundancy_rate,
pragmatical_tautology_rate=pragmatical_tautology_rate,
logical_redundancy_rate=logical_redundancy_rate,
logical_tautology_rate=logical_tautology_rate,
logical_contradiction_rate=logical_contradiction_rate)
self.correct_distribution = util.cumulative_distribution(
util.value_or_default(correct_distribution, [1, 1, 1]))
def __init__(self,
scope_captioner,
attributes=None,
incorrect_distribution=None,
pragmatical_redundancy_rate=None,
pragmatical_tautology_rate=None,
logical_redundancy_rate=None,
logical_tautology_rate=None,
logical_contradiction_rate=None):
super(MaxAttributeCaptioner, self).__init__(
internal_captioners=(scope_captioner, ),
pragmatical_redundancy_rate=pragmatical_redundancy_rate,
pragmatical_tautology_rate=pragmatical_tautology_rate,
logical_redundancy_rate=logical_redundancy_rate,
logical_tautology_rate=logical_tautology_rate,
logical_contradiction_rate=logical_contradiction_rate)
self.scope_captioner = scope_captioner
self.attributes = attributes
self.incorrect_distribution = util.cumulative_distribution(
util.value_or_default(incorrect_distribution, [1, 1, 1]))
def __init__(self,
reference_captioner,
comparison_captioner,
relations=None,
incorrect_distribution=None,
pragmatical_redundancy_rate=None,
pragmatical_tautology_rate=None,
logical_redundancy_rate=None,
logical_tautology_rate=None,
logical_contradiction_rate=None):
super(RelationCaptioner, self).__init__(
internal_captioners=(reference_captioner, comparison_captioner),
pragmatical_redundancy_rate=pragmatical_redundancy_rate,
pragmatical_tautology_rate=pragmatical_tautology_rate,
logical_redundancy_rate=logical_redundancy_rate,
logical_tautology_rate=logical_tautology_rate,
logical_contradiction_rate=logical_contradiction_rate)
self.reference_captioner = reference_captioner
self.comparison_captioner = comparison_captioner
self.relations = relations
self.incorrect_distribution = util.cumulative_distribution(
util.value_or_default(incorrect_distribution, [1, 1, 1, 1]))
def __init__(self,
entity_counts,
train_entity_counts=None,
validation_entity_counts=None,
test_entity_counts=None,
validation_combinations=None,
test_combinations=None,
max_provoke_collision_rate=None,
**kwargs):
super(RandomAttributesGenerator,
self).__init__(entity_counts=entity_counts,
train_entity_counts=train_entity_counts,
validation_entity_counts=validation_entity_counts,
test_entity_counts=test_entity_counts,
validation_combinations=validation_combinations,
test_combinations=test_combinations,
**kwargs)
assert max_provoke_collision_rate is None or isinstance(
max_provoke_collision_rate,
float) and 0.0 <= max_provoke_collision_rate <= 1.0
self.max_provoke_collision_rate = util.value_or_default(
max_provoke_collision_rate, 0.5)
def __init__(self,
world_generator,
world_captioner,
caption_size,
words,
correct_ratio=None,
train_correct_ratio=None,
validation_correct_ratio=None,
test_correct_ratio=None,
caption_realizer=None,
language=None):
assert isinstance(caption_size, int) and caption_size > 0
assert isinstance(words, list) and len(words) > 0
super(CaptionAgreementDataset,
self).__init__(world_size=world_generator.world_size,
vectors=dict(caption=caption_size),
words=words,
language=language)
self.world_generator = world_generator
self.world_captioner = world_captioner
self.caption_size = caption_size
self.correct_ratio = util.value_or_default(correct_ratio, 0.5)
self.train_correct_ratio = util.value_or_default(
train_correct_ratio, self.correct_ratio)
self.validation_correct_ratio = util.value_or_default(
validation_correct_ratio, self.correct_ratio)
self.test_correct_ratio = util.value_or_default(
test_correct_ratio, self.correct_ratio)
if isinstance(caption_realizer, CaptionRealizer):
self.caption_realizer = caption_realizer
else:
assert caption_realizer is None or isinstance(
caption_realizer, str)
self.caption_realizer = CaptionRealizer.from_name(
name=util.value_or_default(caption_realizer, 'dmrs'),
language=util.value_or_default(language, 'english'))
self.world_captioner.set_realizer(self.caption_realizer)
def __init__(self,
world_size=64,
world_color='black',
shapes=('square', 'rectangle', 'triangle', 'pentagon',
'cross', 'circle', 'semicircle', 'ellipse'),
colors=('red', 'green', 'blue', 'yellow', 'magenta', 'cyan',
'gray'),
textures=('solid', ),
rotation=True,
size_range=(0.1, 0.25),
distortion_range=(2.0, 3.0),
shade_range=0.4,
collision_tolerance=0.25,
collision_shade_difference=0.5,
boundary_tolerance=0.25,
entity_counts=(1, ),
train_entity_counts=None,
validation_entity_counts=None,
validation_count_rate=0.5,
test_entity_counts=None,
test_count_rate=0.5,
validation_combinations=None,
validation_space_rate_range=(0.0, 1.0),
validation_combination_rate=0.5,
test_combinations=None,
test_space_rate_range=(0.0, 1.0),
test_combination_rate=0.5):
super(GenericGenerator, self).__init__(
world_size=world_size,
world_color=world_color,
shapes=shapes,
colors=colors,
textures=textures,
rotation=rotation,
size_range=size_range,
distortion_range=distortion_range,
shade_range=shade_range,
collision_tolerance=collision_tolerance,
collision_shade_difference=collision_shade_difference,
boundary_tolerance=boundary_tolerance)
assert util.all_and_any(
isinstance(n, int) and n >= 0 for n in entity_counts)
assert train_entity_counts is None or util.all_and_any(
isinstance(n, int) and n >= 0 for n in train_entity_counts)
assert validation_entity_counts is None or util.all_and_any(
isinstance(n, int) and n >= 0 for n in validation_entity_counts)
assert test_entity_counts is None or util.all_and_any(
isinstance(n, int) and n >= 0 for n in test_entity_counts)
self.entity_counts = entity_counts
self.train_entity_counts = util.value_or_default(
train_entity_counts, entity_counts)
self.validation_entity_counts = util.value_or_default(
validation_entity_counts, entity_counts)
self.validation_count_rate = validation_count_rate
self.test_entity_counts = util.value_or_default(
test_entity_counts, entity_counts)
self.test_count_rate = test_count_rate
assert (validation_combinations is None) == (test_combinations is None)
self.validation_combinations = validation_combinations
self.validation_space_rate_range = validation_space_rate_range
self.validation_combination_rate = validation_combination_rate
self.test_combinations = test_combinations
self.test_space_rate_range = test_space_rate_range
self.test_combination_rate = test_combination_rate
self.invalid_combinations = set()
self.invalid_validation_combinations = set()
if self.validation_combinations is not None:
assert len(self.validation_combinations) > 0
validation_shapes = set(
shape for shape, _, _ in self.validation_combinations)
validation_colors = set(
color for _, color, _ in self.validation_combinations)
validation_textures = set(
texture for _, _, texture in self.validation_combinations)
self.validation_space = [(shape, color, texture)
for shape in validation_shapes
for color in validation_colors
for texture in validation_textures]
self.invalid_combinations.update(self.validation_combinations)
if self.test_combinations is not None:
assert len(self.test_combinations) > 0
test_shapes = set(shape for shape, _, _ in self.test_combinations)
test_colors = set(color for _, color, _ in self.test_combinations)
test_textures = set(texture
for _, _, texture in self.test_combinations)
self.test_space = [(shape, color, texture) for shape in test_shapes
for color in test_colors
for texture in test_textures]
self.invalid_combinations.update(self.test_combinations)
self.invalid_validation_combinations.update(self.test_combinations)
def __init__(self, world_size=None, world_color=None, shapes=None, colors=None, textures=None, rotation=None, size_range=None, distortion_range=None, shade_range=None, collision_tolerance=None, boundary_tolerance=None):
self.world_size = util.value_or_default(world_size, 64)
self.shapes = list(util.value_or_default(shapes, all_shapes.keys()))
self.colors = list(util.value_or_default(colors, all_colors.keys()))
self.textures = list(util.value_or_default(textures, all_textures.keys()))
self.world_color = util.value_or_default(world_color, 'black')
if self.world_color in self.colors:
self.colors.remove(self.world_color)
self.rotation = util.value_or_default(rotation, True)
self.size_range = util.value_or_default(size_range, (0.1, 0.2))
self.distortion_range = util.value_or_default(distortion_range, (2.0, 3.0)) # greater than 1.0
self.shade_range = util.value_or_default(shade_range, 0.33)
self.collision_tolerance = util.value_or_default(collision_tolerance, 0.25)
self.boundary_tolerance = util.value_or_default(boundary_tolerance, 0.25)
def __init__(self, captioners, incorrect_distribution=None, trivial_acceptance_rate=None):
super(ConjunctionCaptioner, self).__init__(internal_captioners=captioners, trivial_acceptance_rate=trivial_acceptance_rate)
self.incorrect_distribution = util.cumulative_distribution(util.value_or_default(incorrect_distribution, [1, 1, 1]))
def __init__(self,
entity_counts,
world_size=None,
world_color=None,
shapes=None,
colors=None,
textures=None,
rotation=None,
size_range=None,
distortion_range=None,
shade_range=None,
collision_tolerance=None,
boundary_tolerance=None,
train_entity_counts=None,
validation_entity_counts=None,
test_entity_counts=None,
validation_combinations=None,
test_combinations=None,
shapes_range=None,
colors_range=None,
textures_range=None,
max_provoke_collision_rate=None):
super(GenericGenerator,
self).__init__(world_size, world_color, shapes, colors, textures,
rotation, size_range, distortion_range,
shade_range, collision_tolerance,
boundary_tolerance)
# assert world_color not random
assert entity_counts and all(
isinstance(n, int) and n >= 0 for n in entity_counts)
assert not train_entity_counts or all(
isinstance(n, int) and n >= 0 for n in train_entity_counts)
assert not validation_entity_counts or all(
isinstance(n, int) and n >= 0 for n in validation_entity_counts)
assert not test_entity_counts or all(
isinstance(n, int) and n >= 0 for n in test_entity_counts)
self.entity_counts = entity_counts
self.train_entity_counts = util.value_or_default(
train_entity_counts, entity_counts)
self.validation_entity_counts = util.value_or_default(
validation_entity_counts, entity_counts)
self.test_entity_counts = util.value_or_default(
test_entity_counts, entity_counts)
assert bool(validation_combinations) == bool(test_combinations)
self.validation_combinations = util.value_or_default(
validation_combinations, list())
self.test_combinations = util.value_or_default(test_combinations,
list())
if validation_combinations is None:
self.validation_shapes = list(self.shapes)
self.validation_colors = list(self.colors)
self.validation_textures = list(self.textures)
else:
self.validation_shapes = [
shape for shape, _, _ in self.validation_combinations
]
self.validation_colors = [
color for _, color, _ in self.validation_combinations
]
self.validation_textures = [
texture for _, _, texture in self.validation_combinations
]
if test_combinations is None:
self.test_shapes = list(self.shapes)
self.test_colors = list(self.colors)
self.test_textures = list(self.textures)
else:
self.test_shapes = [
shape for shape, _, _ in self.test_combinations
]
self.test_colors = [
color for _, color, _ in self.test_combinations
]
self.test_textures = [
texture for _, _, texture in self.test_combinations
]
assert shapes_range is None or (
1 <= shapes_range[0] <= shapes_range[1] <= len(self.shapes)
and shapes_range[1] <= len(self.validation_shapes)
and shapes_range[1] <= len(self.test_shapes))
assert colors_range is None or (
1 <= colors_range[0] <= colors_range[1] <= len(self.colors)
and colors_range[1] <= len(self.validation_colors)
and colors_range[1] <= len(self.test_colors))
assert textures_range is None or (
1 <= textures_range[0] <= textures_range[1] <= len(self.textures)
and textures_range[1] <= len(self.validation_textures)
and textures_range[1] <= len(self.test_textures))
self.shapes_range = shapes_range
self.colors_range = colors_range
self.textures_range = textures_range
assert max_provoke_collision_rate is None or (
isinstance(max_provoke_collision_rate, float)
and 0.0 <= max_provoke_collision_rate <= 1.0)
self.max_provoke_collision_rate = max_provoke_collision_rate if max_provoke_collision_rate is not None else 0.5
def __init__(self,
entity_counts,
world_size=None,
world_color=None,
shapes=None,
colors=None,
textures=None,
rotation=None,
size_range=None,
distortion_range=None,
shade_range=None,
collision_tolerance=None,
boundary_tolerance=None,
train_entity_counts=None,
validation_entity_counts=None,
test_entity_counts=None,
validation_combinations=None,
test_combinations=None):
super(GenericGenerator,
self).__init__(world_size=world_size,
world_color=world_color,
shapes=shapes,
colors=colors,
textures=textures,
rotation=rotation,
size_range=size_range,
distortion_range=distortion_range,
shade_range=shade_range,
collision_tolerance=collision_tolerance,
boundary_tolerance=boundary_tolerance)
assert util.all_and_any(
isinstance(n, int) and n >= 0 for n in entity_counts)
assert train_entity_counts is None or util.all_and_any(
isinstance(n, int) and n >= 0 for n in train_entity_counts)
assert validation_entity_counts is None or util.all_and_any(
isinstance(n, int) and n >= 0 for n in validation_entity_counts)
assert test_entity_counts is None or util.all_and_any(
isinstance(n, int) and n >= 0 for n in test_entity_counts)
self.entity_counts = entity_counts
self.train_entity_counts = util.value_or_default(
train_entity_counts, entity_counts)
self.validation_entity_counts = util.value_or_default(
validation_entity_counts, entity_counts)
self.test_entity_counts = util.value_or_default(
test_entity_counts, entity_counts)
assert (validation_combinations is None) == (test_combinations is None)
self.validation_combinations = util.value_or_default(
validation_combinations, list())
self.test_combinations = util.value_or_default(test_combinations,
list())
if validation_combinations is None:
self.validation_shapes = list(self.shapes)
self.validation_colors = list(self.colors)
self.validation_textures = list(self.textures)
else:
assert len(validation_combinations) > 0
self.validation_shapes = [
shape for shape, _, _ in self.validation_combinations
]
self.validation_colors = [
color for _, color, _ in self.validation_combinations
]
self.validation_textures = [
texture for _, _, texture in self.validation_combinations
]
if test_combinations is None:
self.test_shapes = list(self.shapes)
self.test_colors = list(self.colors)
self.test_textures = list(self.textures)
else:
assert len(test_combinations) > 0
self.test_shapes = [
shape for shape, _, _ in self.test_combinations
]
self.test_colors = [
color for _, color, _ in self.test_combinations
]
self.test_textures = [
texture for _, _, texture in self.test_combinations
]
