def __init__( self, max_features: int = 20001, pretraining: Optional[Union[str, hyperparameters.Choice]] = None, embedding_dim: Optional[Union[int, hyperparameters.Choice]] = None, dropout: Optional[Union[float, hyperparameters.Choice]] = None, **kwargs, ): super().__init__(**kwargs) self.max_features = max_features self.pretraining = utils.get_hyperparameter( pretraining, hyperparameters.Choice( "pretraining", ["random", "glove", "fasttext", "word2vec", "none"], default="none", ), str, ) self.embedding_dim = utils.get_hyperparameter( embedding_dim, hyperparameters.Choice( "embedding_dim", [32, 64, 128, 256, 512], default=128 ), int, ) self.dropout = utils.get_hyperparameter( dropout, hyperparameters.Choice("dropout", [0.0, 0.25, 0.5], default=0.25), float, )
def __init__( self, return_sequences: bool = False, bidirectional: Optional[Union[bool, hyperparameters.Boolean]] = None, num_layers: Optional[Union[int, hyperparameters.Choice]] = None, layer_type: Optional[Union[str, hyperparameters.Choice]] = None, **kwargs, ): super().__init__(**kwargs) self.return_sequences = return_sequences self.bidirectional = utils.get_hyperparameter( bidirectional, hyperparameters.Boolean("bidirectional", default=True), bool, ) self.num_layers = utils.get_hyperparameter( num_layers, hyperparameters.Choice("num_layers", [1, 2, 3], default=2), int, ) self.layer_type = utils.get_hyperparameter( layer_type, hyperparameters.Choice("layer_type", ["gru", "lstm"], default="lstm"), str, )
def __init__( self, num_layers: Optional[Union[int, hyperparameters.Choice]] = None, num_units: Optional[Union[int, hyperparameters.Choice]] = None, use_batchnorm: Optional[bool] = None, dropout: Optional[Union[float, hyperparameters.Choice]] = None, **kwargs, ): super().__init__(**kwargs) self.num_layers = utils.get_hyperparameter( num_layers, hyperparameters.Choice("num_layers", [1, 2, 3], default=2), int, ) self.num_units = utils.get_hyperparameter( num_units, hyperparameters.Choice( "num_units", [16, 32, 64, 128, 256, 512, 1024], default=32 ), int, ) self.use_batchnorm = use_batchnorm self.dropout = utils.get_hyperparameter( dropout, hyperparameters.Choice("dropout", [0.0, 0.25, 0.5], default=0.0), float, )
def test_Choice_types(): values1 = ["a", "b", 0] with pytest.raises(TypeError, match="can contain only one"): hp_module.Choice("a", values1) values2 = [{"a": 1}, {"a": 2}] with pytest.raises(TypeError, match="can contain only `int`"): hp_module.Choice("a", values2)
def test_choice_proto(): hp = hp_module.Choice("a", [2.3, 4.5, 6.3], ordered=True) proto = hp.to_proto() assert proto.name == "a" assert proto.ordered assert np.allclose([v.float_value for v in proto.values], [2.3, 4.5, 6.3]) # Proto stores the implicit default. assert np.isclose(proto.default.float_value, 2.3) new_hp = hp_module.Choice.from_proto(proto) assert new_hp.name == "a" assert np.allclose(new_hp.values, hp.values) assert new_hp.ordered assert np.isclose(new_hp._default, 2.3) # Test int values. int_choice = hp_module.Choice("b", [1, 2, 3], ordered=False, default=2) new_int_choice = hp_module.Choice.from_proto(int_choice.to_proto()) assert int_choice.get_config() == new_int_choice.get_config() # Test float values. float_choice = hp_module.Choice("b", [0.5, 2.5, 4.0], ordered=False, default=2.5) new_float_choice = hp_module.Choice.from_proto(float_choice.to_proto()) assert float_choice.get_config() == new_float_choice.get_config()
def test_get_hyperparameter_with_hp_return_same(): hp = utils.get_hyperparameter( hyperparameters.Choice("hp", [10, 30]), hyperparameters.Choice("hp", [10, 20]), int, ) assert isinstance(hp, hyperparameters.Choice)
def test_Choice(): choice = hp_module.Choice("choice", [1, 2, 3], default=2) choice = hp_module.Choice.from_config(choice.get_config()) assert choice.default == 2 assert choice.random_sample() in [1, 2, 3] assert choice.random_sample(123) == choice.random_sample(123) # No default choice = hp_module.Choice("choice", [1, 2, 3]) assert choice.default == 1 with pytest.raises(ValueError, match="default value should be"): hp_module.Choice("choice", [1, 2, 3], default=4)
def test_prob_one_choice(): hp = hp_module.Choice("a", [0, 1, 2]) # Check that boundaries are valid. value = hp_module.cumulative_prob_to_value(1, hp) assert value == 2 value = hp_module.cumulative_prob_to_value(0, hp) assert value == 0
def __init__( self, kernel_size: Optional[Union[int, hyperparameters.Choice]] = None, num_blocks: Optional[Union[int, hyperparameters.Choice]] = None, num_layers: Optional[Union[int, hyperparameters.Choice]] = None, filters: Optional[Union[int, hyperparameters.Choice]] = None, max_pooling: Optional[bool] = None, separable: Optional[bool] = None, dropout: Optional[Union[float, hyperparameters.Choice]] = None, **kwargs, ): super().__init__(**kwargs) self.kernel_size = utils.get_hyperparameter( kernel_size, hyperparameters.Choice("kernel_size", [3, 5, 7], default=3), int, ) self.num_blocks = utils.get_hyperparameter( num_blocks, hyperparameters.Choice("num_blocks", [1, 2, 3], default=2), int, ) self.num_layers = utils.get_hyperparameter( num_layers, hyperparameters.Choice("num_layers", [1, 2], default=2), int, ) self.filters = utils.get_hyperparameter( filters, hyperparameters.Choice( "filters", [16, 32, 64, 128, 256, 512], default=32 ), int, ) self.max_pooling = max_pooling self.separable = separable self.dropout = utils.get_hyperparameter( dropout, hyperparameters.Choice("dropout", [0.0, 0.25, 0.5], default=0.0), float, )
def __init__( self, max_sequence_length: Optional[Union[int, hyperparameters.Choice]] = None, **kwargs, ): super().__init__(**kwargs) self.max_sequence_length = utils.get_hyperparameter( max_sequence_length, hyperparameters.Choice( "max_sequence_length", [128, 256, 512], default=128 ), int, )
def __init__( self, translation_factor: Optional[ Union[float, Tuple[float, float], hyperparameters.Choice] ] = None, vertical_flip: Optional[bool] = None, horizontal_flip: Optional[bool] = None, rotation_factor: Optional[Union[float, hyperparameters.Choice]] = None, zoom_factor: Optional[ Union[float, Tuple[float, float], hyperparameters.Choice] ] = None, contrast_factor: Optional[ Union[float, Tuple[float, float], hyperparameters.Choice] ] = None, **kwargs ): super().__init__(**kwargs) self.translation_factor = utils.get_hyperparameter( translation_factor, hyperparameters.Choice("translation_factor", [0.0, 0.1]), Union[float, Tuple[float, float]], ) self.horizontal_flip = horizontal_flip self.vertical_flip = vertical_flip self.rotation_factor = utils.get_hyperparameter( rotation_factor, hyperparameters.Choice("rotation_factor", [0.0, 0.1]), float, ) self.zoom_factor = utils.get_hyperparameter( zoom_factor, hyperparameters.Choice("zoom_factor", [0.0, 0.1]), Union[float, Tuple[float, float]], ) self.contrast_factor = utils.get_hyperparameter( contrast_factor, hyperparameters.Choice("contrast_factor", [0.0, 0.1]), Union[float, Tuple[float, float]], )
def test_Choice_ordered_invalid(): with pytest.raises(ValueError, match="must be `False`"): hp_module.Choice("a", ["a", "b"], ordered=True)
def test_Choice_ordered(values, ordered_arg, ordered_val): choice = hp_module.Choice("choice", values, ordered=ordered_arg) assert choice.ordered == ordered_val choice_new = hp_module.Choice(**choice.get_config()) assert choice_new.ordered == ordered_val
def test_get_hyperparameter_with_int_return_int(): value = utils.get_hyperparameter(10, hyperparameters.Choice("hp", [10, 20]), int) assert isinstance(value, int) assert value == 10
def test_get_hyperparameter_with_none_return_hp(): hp = utils.get_hyperparameter(None, hyperparameters.Choice("hp", [10, 20]), int) assert isinstance(hp, hyperparameters.Choice)