def set_realizer(self, realizer):
if not super(AttributesRelationCaptioner, self).set_realizer(realizer):
return False
assert 'attribute' in realizer.relations and 'type' in realizer.relations
if self.shapes is None:
self.shapes = list(realizer.attributes.get('shape', ()))
self.attributes = list(('shape', value) for value in realizer.attributes.get('shape', ()))
else:
self.shapes = list(value for value in realizer.attributes.get('shape', ()) if value in self.shapes)
self.attributes = list(('shape', value) for value in realizer.attributes.get('shape', ()) if value in self.shapes)
if self.colors is None:
self.colors = list(realizer.attributes.get('color', ()))
self.attributes.extend(('color', value) for value in realizer.attributes.get('color', ()))
else:
self.colors = list(value for value in realizer.attributes.get('color', ()) if value in self.colors)
self.attributes.extend(('color', value) for value in realizer.attributes.get('color', ()) if value in self.colors)
if self.textures is None:
self.textures = list(realizer.attributes.get('texture', ()))
self.attributes.extend(('texture', value) for value in realizer.attributes.get('texture', ()))
else:
self.textures = list(value for value in realizer.attributes.get('texture', ()) if value in self.textures)
self.attributes.extend(('texture', value) for value in realizer.attributes.get('texture', ()) if value in self.textures)
assert self.shapes or self.colors or self.textures
if self.incorrect_distribution is None:
max_length = max(len(self.shapes), len(self.colors), len(self.textures))
self.incorrect_distribution = util.cumulative_distribution([len(self.shapes), len(self.shapes), len(self.colors), len(self.colors), len(self.textures), len(self.textures), max_length, max_length])
else:
self.incorrect_distribution = util.cumulative_distribution(self.incorrect_distribution)
return True
def __init__(self,
captioners,
distribution=None,
train_distribution=None,
validation_distribution=None,
test_distribution=None,
pragmatical_redundancy_rate=None,
pragmatical_tautology_rate=None,
logical_redundancy_rate=None,
logical_tautology_rate=None,
logical_contradiction_rate=None):
assert len(captioners) >= 1
assert not distribution or len(distribution) == len(captioners)
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(CaptionerMixer, 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)
distribution = util.value_or_default(distribution,
[1] * len(captioners))
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,
distribution=None,
train_distribution=None,
validation_distribution=None,
test_distribution=None,
trivial_acceptance_rate=None):
assert len(captioners) >= 1
assert not distribution or len(distribution) == len(captioners)
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(CaptionerMixer,
self).__init__(internal_captioners=captioners,
trivial_acceptance_rate=trivial_acceptance_rate)
distribution = util.value_or_default(distribution,
[1] * len(captioners))
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, shapes=None, colors=None, textures=None, attribute_distribution=None, existing_attribute_ratio=None, incorrect_distribution=None, trivial_acceptance_rate=None):
super(AttributesRelationCaptioner, self).__init__(trivial_acceptance_rate=trivial_acceptance_rate)
self.shapes = shapes
self.colors = colors
self.textures = textures
self.attribute_distribution = util.cumulative_distribution(util.value_or_default(attribute_distribution, [1, 1, 1]))
self.existing_attribute_ratio = util.value_or_default(existing_attribute_ratio, 0.5)
self.incorrect_distribution = util.cumulative_distribution(util.value_or_default(incorrect_distribution, [1, 1, 1, 1]))
assert self.existing_attribute_ratio < 1.0 or self.attribute_distribution[0] > 0.0
def __init__(self,
datasets,
consistent_batches=False,
distribution=None,
train_distribution=None,
validation_distribution=None,
test_distribution=None):
assert len(datasets) >= 1
for n, dataset in enumerate(datasets):
if not isinstance(dataset, Dataset):
datasets[n] = Dataset.dataset(config=dataset)
assert all(dataset.type == datasets[0].type for dataset in datasets)
assert all(dataset.language == datasets[0].language
for dataset in datasets)
assert all(dataset.values == datasets[0].values
for dataset in datasets)
assert all(dataset.world_size == datasets[0].world_size
for dataset in datasets)
assert all(
sorted(dataset.vectors) == sorted(datasets[0].vectors)
for dataset in datasets)
assert all((dataset.words is None) == (datasets[0].words is None)
for dataset in datasets)
# combine vectors and words information
vectors = {
value_name:
max(dataset.vectors[value_name] for dataset in datasets)
for value_name in datasets[0].vectors
}
words = sorted(
set(word for dataset in datasets for word in dataset.words))
words = {words[n]: n for n in range(len(words))}
language = datasets[0].language
super(DatasetMixer, self).__init__(None,
vectors=vectors,
words=words,
language=language)
for dataset in datasets:
dataset.vectors = self.vectors
dataset.words = self.words
self.datasets = datasets
self.consistent_batches = consistent_batches
assert not distribution or len(distribution) == len(datasets)
distribution = util.value_or_default(distribution, [1] * len(datasets))
self.distribution = util.cumulative_distribution(distribution)
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(
self.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, 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
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,
restrictor_captioner,
comparison_captioner,
body_captioner,
quantifiers=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(ComparativeQuantifierCaptioner, self).__init__(
internal_captioners=(restrictor_captioner, comparison_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.comparison_captioner = comparison_captioner
self.body_captioner = body_captioner
self.quantifiers = quantifiers
self.incorrect_distribution = util.cumulative_distribution(
util.value_or_default(incorrect_distribution, [1, 1, 1, 3]))
def __init__(self,
restrictor_captioner,
body_captioner,
pragmatical_redundancy_rate=1.0,
pragmatical_tautology_rate=0.0,
logical_redundancy_rate=0.0,
logical_tautology_rate=0.0,
logical_contradiction_rate=0.0,
quantifiers=None,
incorrect_distribution=(3, 3, 3, 1, 1, 1),
zero_quantification_rate=0.1,
all_quantification_rate=0.3):
super(QuantifierCaptioner, 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.quantifiers = quantifiers
self.incorrect_distribution = util.cumulative_distribution(
incorrect_distribution)
self.zero_quantification_rate = zero_quantification_rate
self.all_quantification_rate = all_quantification_rate
def __init__(self,
restrictor_captioner,
comparison_captioner,
body_captioner,
pragmatical_redundancy_rate=1.0,
pragmatical_tautology_rate=0.0,
logical_redundancy_rate=1.0,
logical_tautology_rate=0.0,
logical_contradiction_rate=0.0,
comparative_quantifiers=None,
incorrect_distribution=(1, 1, 1, 3)):
super(ComparativeQuantifierCaptioner, self).__init__(
internal_captioners=(restrictor_captioner, comparison_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.comparison_captioner = comparison_captioner
self.body_captioner = body_captioner
self.comparative_quantifiers = comparative_quantifiers
self.incorrect_distribution = util.cumulative_distribution(
incorrect_distribution)
def __init__(
self,
reference_captioner,
comparison_captioner,
pragmatical_redundancy_rate=1.0,
pragmatical_tautology_rate=0.0,
logical_redundancy_rate=1.0,
logical_tautology_rate=0.0,
logical_contradiction_rate=0.0,
relations=None,
incorrect_distribution=(1, 1, 1, 1)
):
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(incorrect_distribution)
def __init__(
self,
scope_captioner,
comparison_captioner,
pragmatical_redundancy_rate=1.0,
pragmatical_tautology_rate=0.0,
logical_redundancy_rate=0.0,
logical_tautology_rate=0.0,
logical_contradiction_rate=0.0,
selectors=None,
incorrect_distribution=(1, 1)
):
super(SelectorCaptioner, self).__init__(
internal_captioners=(scope_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.scope_captioner = scope_captioner
self.comparison_captioner = comparison_captioner
self.selectors = selectors
self.incorrect_distribution = util.cumulative_distribution(incorrect_distribution)
def __init__(self,
shapes,
colors,
textures,
realizer=None,
quantifier_tolerance=None,
incorrect_modes=None,
hypernym_ratio=None):
# ideally requires relations 'left', 'right', 'above', 'below'
# requires quantifier ('absolute', 'geq', 1)
# requires caption 'none'
super(SpatialCaptioner,
self).__init__(realizer=realizer,
quantifier_tolerance=quantifier_tolerance)
self.shapes = shapes
self.colors = colors
self.textures = textures
self.incorrect_modes = cumulative_distribution(incorrect_modes
or [2, 1, 1, 1, 1])
self.hypernym_ratio = hypernym_ratio if hypernym_ratio is not None else 0.5
self.spatial_relations = [
reltype[0]
for reltype in self.realizer.get_relations(reltypes=('left',
'right',
'above',
'below'))
]
def set_realizer(self, realizer):
if not super(RegularTypeCaptioner, self).set_realizer(realizer):
return False
self.shapes = list(realizer.attributes.get('shape', ()))
self.colors = list(realizer.attributes.get('color', ()))
self.textures = list(realizer.attributes.get('texture', ()))
assert self.shapes or self.colors or self.textures
if self.incorrect_distribution is None:
# incorrect mode distribution uniform across attributes
max_length = max(len(self.shapes), len(self.colors), len(self.textures)) - 1
self.incorrect_distribution = util.cumulative_distribution([len(self.shapes) - 1, len(self.colors) - 1, len(self.textures) - 1, max_length])
else:
self.incorrect_distribution = util.cumulative_distribution(self.incorrect_distribution)
return True
def __init__(self,
captioners,
correct_distribution=None,
trivial_acceptance_rate=None):
super(DisjunctionCaptioner,
self).__init__(internal_captioners=captioners,
trivial_acceptance_rate=trivial_acceptance_rate)
self.correct_distribution = util.cumulative_distribution(
util.value_or_default(correct_distribution, [1, 1, 1]))
def __init__(self, captioners, incorrect_distribution=None, pragmatical_redundancy_rate=None, pragmatical_tautology_rate=None, logical_redundancy_rate=None, logical_tautology_rate=None, logical_contradiction_rate=None):
super(ConjunctionCaptioner, 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.incorrect_distribution = util.cumulative_distribution(util.value_or_default(incorrect_distribution, [1, 1, 1]))
def __init__(self, shapes, colors, textures, realizer=None, quantifier_tolerance=None, modes=None, quantifiers=None):
# ideally requires modifiers of all values for modtype 'shape', 'color', 'texture'
super(QuantificationCaptioner, self).__init__(realizer=realizer, quantifier_tolerance=quantifier_tolerance)
self.modes = cumulative_distribution(modes or [1, 1, 1, 1, 1])
# self.incorrect_modes = cumulative_distribution(
# incorrect_mode_distribution or [1, 1, 1, 1, 1, 1])
if quantifiers:
self.quantifiers = self.realizer.get_quantifiers(names=quantifiers)
else:
self.quantifiers = self.realizer.get_quantifiers()
self.shape_modifiers = [value for _, value in self.realizer.get_modifiers(modtypes=('shape',))]
self.color_modifiers = [value for _, value in self.realizer.get_modifiers(modtypes=('color',))]
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, 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,
restrictor_captioner=None,
body_captioner=None,
incorrect_distribution=None,
trivial_acceptance_rate=None):
self.restrictor_captioner = util.value_or_default(
restrictor_captioner, AttributesTypeCaptioner())
self.body_captioner = util.value_or_default(body_captioner,
AttributesTypeCaptioner())
super(ExistentialCaptioner,
self).__init__(internal_captioners=(self.restrictor_captioner,
self.body_captioner),
trivial_acceptance_rate=trivial_acceptance_rate)
self.incorrect_distribution = util.cumulative_distribution(
util.value_or_default(incorrect_distribution, [1, 1]))
def __init__(self,
reference_captioner=None,
relations=None,
incorrect_distribution=None,
trivial_acceptance_rate=None):
assert relations is None or all(
reltype in ComparisonRelationCaptioner.comparison_reltypes
for reltype in relations)
self.reference_captioner = util.value_or_default(
reference_captioner, AttributesTypeCaptioner())
super(ComparisonRelationCaptioner,
self).__init__(internal_captioners=(self.reference_captioner, ),
trivial_acceptance_rate=trivial_acceptance_rate)
self.relations = relations
self.incorrect_distribution = util.cumulative_distribution(
util.value_or_default(incorrect_distribution, [1, 1, 1]))
def __init__(self,
relation_captioner,
pragmatical_redundancy_rate=1.0,
pragmatical_tautology_rate=0.0,
logical_redundancy_rate=1.0,
logical_tautology_rate=0.0,
logical_contradiction_rate=0.0,
incorrect_distribution=(1, 1)):
super(NegationRelationCaptioner, self).__init__(
internal_captioners=(relation_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.relation_captioner = relation_captioner
self.incorrect_distribution = util.cumulative_distribution(
incorrect_distribution)
def __init__(self,
captioner,
pragmatical_redundancy_rate=1.0,
pragmatical_tautology_rate=0.0,
logical_redundancy_rate=0.0,
logical_tautology_rate=0.0,
logical_contradiction_rate=0.0,
correct_distribution=(1, 1, 1)):
super(ImplicationCaptioner, self).__init__(
internal_captioners=(captioner, deepcopy(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.captioner1, self.captioner2 = self.internal_captioners
self.correct_distribution = util.cumulative_distribution(
correct_distribution)
def __init__(self,
shapes,
colors,
textures,
realizer=None,
quantifier_tolerance=None,
incorrect_modes=None,
hypernym_ratio=None):
# requires relation 'existence'
# requires quantifier ('absolute', 'geq', 1)
# requires caption 'none'
super(ExistentialCaptioner,
self).__init__(realizer=realizer,
quantifier_tolerance=quantifier_tolerance)
self.shapes = shapes
self.colors = colors
self.textures = textures
self.incorrect_modes = cumulative_distribution(incorrect_modes
or [1, 1, 1, 1, 1, 1])
self.hypernym_ratio = hypernym_ratio if hypernym_ratio is not None else 0.5
def __init__(self,
restrictor_captioner,
body_captioner,
pragmatical_redundancy_rate=1.0,
pragmatical_tautology_rate=0.0,
logical_redundancy_rate=1.0,
logical_tautology_rate=0.0,
logical_contradiction_rate=0.0,
incorrect_distribution=(1, 1)):
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(
incorrect_distribution)
def __init__(self,
pragmatical_redundancy_rate=1.0,
pragmatical_tautology_rate=0.0,
logical_redundancy_rate=1.0,
logical_tautology_rate=0.0,
logical_contradiction_rate=0.0,
hypernym_rate=0.5,
existing_attribute_rate=0.5,
incorrect_distribution=(1, 1, 1, 1)):
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 = hypernym_rate
self.existing_attribute_rate = existing_attribute_rate
self.incorrect_distribution = util.cumulative_distribution(
incorrect_distribution)
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]))
