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 ]