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]))