diff --git a/examples/__only_for_dev__/to_test_node.py b/examples/__only_for_dev__/to_test_node.py index 323888d4..06431eb8 100644 --- a/examples/__only_for_dev__/to_test_node.py +++ b/examples/__only_for_dev__/to_test_node.py @@ -55,7 +55,7 @@ def test_regression( continuous_feature_transform=continuous_feature_transform, normalize_continuous_features=normalize_continuous_features, ) - model_config_params = dict(task="regression", depth=2, embed_categorical=embed_categorical) + model_config_params = {"task": "regression", "depth": 2, "embed_categorical": embed_categorical} model_config = NodeConfig(**model_config_params) # model_config_params = dict(task="regression") # model_config = NodeConfig(**model_config_params) @@ -98,7 +98,7 @@ def test_classification( continuous_feature_transform=continuous_feature_transform, normalize_continuous_features=normalize_continuous_features, ) - model_config_params = dict(task="classification", depth=2, embed_categorical=embed_categorical) + model_config_params = {"task": "classification", "depth": 2, "embed_categorical": embed_categorical} model_config = NodeConfig(**model_config_params) trainer_config = TrainerConfig(max_epochs=1, checkpoints=None, early_stopping=None) optimizer_config = OptimizerConfig() diff --git a/examples/__only_for_dev__/to_test_regression.py b/examples/__only_for_dev__/to_test_regression.py index 8282afc2..a0b93680 100644 --- a/examples/__only_for_dev__/to_test_regression.py +++ b/examples/__only_for_dev__/to_test_regression.py @@ -54,7 +54,7 @@ # batch_norm_continuous_input=True, # attention_pooling=True, # ) -model_config = CategoryEmbeddingModelConfig(task="regression", dropout=0.2, head_config=dict(layers="32-16")) +model_config = CategoryEmbeddingModelConfig(task="regression", dropout=0.2, head_config={"layers": "32-16"}) trainer_config = TrainerConfig( # checkpoints=None, diff --git a/pyproject.toml b/pyproject.toml index 82a53354..48c41206 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -22,6 +22,12 @@ select = [ # "D", # see: https://pypi.org/project/pydocstyle # "N", # see: https://pypi.org/project/pep8-naming ] +extend-select = [ + "C4", # see: https://pypi.org/project/flake8-comprehensions +# "SIM", # see: https://pypi.org/project/flake8-simplify +# "RET", # see: https://pypi.org/project/flake8-return +# "PT", # see: https://pypi.org/project/flake8-pytest-style +] ignore = [ "E731", # Do not assign a lambda expression, use a def ] diff --git a/src/pytorch_tabular/config/config.py b/src/pytorch_tabular/config/config.py index 628eb12b..8b5feb1b 100644 --- a/src/pytorch_tabular/config/config.py +++ b/src/pytorch_tabular/config/config.py @@ -231,7 +231,7 @@ class InferredConfig: def __post_init__(self): if self.embedding_dims is not None: assert all( - [(isinstance(t, Iterable) and len(t) == 2) for t in self.embedding_dims] + (isinstance(t, Iterable) and len(t) == 2) for t in self.embedding_dims ), "embedding_dims must be a list of tuples (cardinality, embedding_dim)" self.embedded_cat_dim = sum([t[1] for t in self.embedding_dims]) else: @@ -468,7 +468,7 @@ class TrainerConfig: metadata={"help": "The number of epochs to wait until there is no further improvements in loss/metric"}, ) early_stopping_kwargs: Optional[Dict[str, Any]] = field( - default_factory=lambda: dict(), + default_factory=lambda: {}, metadata={ "help": "Additional keyword arguments for the early stopping callback." " See the documentation for the PyTorch Lightning EarlyStopping callback for more details." @@ -505,7 +505,7 @@ class TrainerConfig: metadata={"help": "The number of best models to save"}, ) checkpoints_kwargs: Optional[Dict[str, Any]] = field( - default_factory=lambda: dict(), + default_factory=lambda: {}, metadata={ "help": "Additional keyword arguments for the checkpoints callback. See the documentation" " for the PyTorch Lightning ModelCheckpoint callback for more details." diff --git a/src/pytorch_tabular/feature_extractor.py b/src/pytorch_tabular/feature_extractor.py index d9d73558..dfef7732 100644 --- a/src/pytorch_tabular/feature_extractor.py +++ b/src/pytorch_tabular/feature_extractor.py @@ -67,7 +67,7 @@ def transform(self, X: pd.DataFrame, y=None) -> pd.DataFrame: continue batch[k] = v.to(self.tabular_model.model.device) if self.tabular_model.config.task == "ssl": - ret_value = dict(backbone_features=self.tabular_model.model.predict(batch, ret_model_output=True)) + ret_value = {"backbone_features": self.tabular_model.model.predict(batch, ret_model_output=True)} else: _, ret_value = self.tabular_model.model.predict(batch, ret_model_output=True) for k in self.extract_keys: diff --git a/src/pytorch_tabular/models/base_model.py b/src/pytorch_tabular/models/base_model.py index 4c98c4a0..b91cfe5d 100644 --- a/src/pytorch_tabular/models/base_model.py +++ b/src/pytorch_tabular/models/base_model.py @@ -486,7 +486,7 @@ def create_plotly_histogram(self, arr, name, bin_dict=None): # Overlay both histograms fig.update_layout( barmode="overlay", - legend=dict(orientation="h", yanchor="bottom", y=1.02, xanchor="right", x=1), + legend={"orientation": "h", "yanchor": "bottom", "y": 1.02, "xanchor": "right", "x": 1}, ) # Reduce opacity to see both histograms fig.update_traces(opacity=0.5) diff --git a/src/pytorch_tabular/models/common/layers.py b/src/pytorch_tabular/models/common/layers.py index 7e3ca622..34918ef1 100644 --- a/src/pytorch_tabular/models/common/layers.py +++ b/src/pytorch_tabular/models/common/layers.py @@ -150,7 +150,7 @@ def __init__( def forward(self, x): h = self.n_heads q, k, v = self.to_qkv(x).chunk(3, dim=-1) - q, k, v = map(lambda t: rearrange(t, "b n (h d) -> b h n d", h=h), (q, k, v)) + q, k, v = (rearrange(t, "b n (h d) -> b h n d", h=h) for t in (q, k, v)) sim = einsum("b h i d, b h j d -> b h i j", q, k) * self.scale attn = sim.softmax(dim=-1) diff --git a/src/pytorch_tabular/models/ft_transformer/config.py b/src/pytorch_tabular/models/ft_transformer/config.py index 321c27c4..e9e051f5 100644 --- a/src/pytorch_tabular/models/ft_transformer/config.py +++ b/src/pytorch_tabular/models/ft_transformer/config.py @@ -254,7 +254,7 @@ def __post_init__(self): " and `out_ff_initialization` as head_config is passed." ) else: - if any([p is not None for p in deprecated_args]): + if any(p is not None for p in deprecated_args): warnings.warn( "The `out_ff_layers`, `out_ff_activation`, `out_ff_dropoout`, and `out_ff_initialization`" " arguments are deprecated and will be removed next release." @@ -263,13 +263,13 @@ def __post_init__(self): ) # TODO: Remove this once we deprecate the old config # Fill the head_config using deprecated parameters - self.head_config = dict( - layers=ifnone(self.out_ff_layers, ""), - activation=ifnone(self.out_ff_activation, "ReLU"), - dropout=ifnone(self.out_ff_dropout, 0.0), - use_batch_norm=False, - initialization=ifnone(self.out_ff_initialization, "kaiming"), - ) + self.head_config = { + "layers": ifnone(self.out_ff_layers, ""), + "activation": ifnone(self.out_ff_activation, "ReLU"), + "dropout": ifnone(self.out_ff_dropout, 0.0), + "use_batch_norm": False, + "initialization": ifnone(self.out_ff_initialization, "kaiming"), + } return super().__post_init__() diff --git a/src/pytorch_tabular/models/mixture_density/mdn.py b/src/pytorch_tabular/models/mixture_density/mdn.py index e9849796..0cc4c7cb 100644 --- a/src/pytorch_tabular/models/mixture_density/mdn.py +++ b/src/pytorch_tabular/models/mixture_density/mdn.py @@ -86,8 +86,8 @@ def _build_network(self): def forward(self, x: Dict): if isinstance(self.backbone, TabTransformerBackbone): if self.hparams.categorical_dim > 0: - x_cat = self.embed_input(dict(categorical=x["categorical"])) - x = self.compute_backbone(dict(categorical=x_cat, continuous=x["continuous"])) + x_cat = self.embed_input({"categorical": x["categorical"]}) + x = self.compute_backbone({"categorical": x_cat, "continuous": x["continuous"]}) else: x = self.embedding_layer(x) x = self.compute_backbone(x) @@ -230,7 +230,7 @@ def validation_epoch_end(self, outputs) -> None: commit=False, ) if self.head.hparams.log_debug_plot: - fig = self.create_plotly_histogram(pi, "pi", bin_dict=dict(start=0.0, end=1.0, size=0.1)) + fig = self.create_plotly_histogram(pi, "pi", bin_dict={"start": 0.0, "end": 1.0, "size": 0.1}) wandb.log( { "valid_pi": fig, diff --git a/src/pytorch_tabular/models/tab_transformer/config.py b/src/pytorch_tabular/models/tab_transformer/config.py index 0e7767e5..4fd08122 100644 --- a/src/pytorch_tabular/models/tab_transformer/config.py +++ b/src/pytorch_tabular/models/tab_transformer/config.py @@ -243,7 +243,7 @@ def __post_init__(self): " and `out_ff_initialization` as head_config is passed." ) else: - if any([p is not None for p in deprecated_args]): + if any(p is not None for p in deprecated_args): warnings.warn( "The `out_ff_layers`, `out_ff_activation`, `out_ff_dropoout`, and `out_ff_initialization`" " arguments are deprecated and will be removed next release." @@ -252,13 +252,13 @@ def __post_init__(self): ) # TODO: Remove this once we deprecate the old config # Fill the head_config using deprecated parameters - self.head_config = dict( - layers=ifnone(self.out_ff_layers, ""), - activation=ifnone(self.out_ff_activation, "ReLU"), - dropout=ifnone(self.out_ff_dropout, 0.0), - use_batch_norm=False, - initialization=ifnone(self.out_ff_initialization, "kaiming"), - ) + self.head_config = { + "layers": ifnone(self.out_ff_layers, ""), + "activation": ifnone(self.out_ff_activation, "ReLU"), + "dropout": ifnone(self.out_ff_dropout, 0.0), + "use_batch_norm": False, + "initialization": ifnone(self.out_ff_initialization, "kaiming"), + } return super().__post_init__() diff --git a/src/pytorch_tabular/models/tab_transformer/tab_transformer.py b/src/pytorch_tabular/models/tab_transformer/tab_transformer.py index bacb898c..64480d6b 100644 --- a/src/pytorch_tabular/models/tab_transformer/tab_transformer.py +++ b/src/pytorch_tabular/models/tab_transformer/tab_transformer.py @@ -114,10 +114,10 @@ def _build_network(self): # Redefining forward because this model flow is slightly different def forward(self, x: Dict): if self.hparams.categorical_dim > 0: - x_cat = self.embed_input(dict(categorical=x["categorical"])) + x_cat = self.embed_input({"categorical": x["categorical"]}) else: x_cat = None - x = self.compute_backbone(dict(categorical=x_cat, continuous=x["continuous"])) + x = self.compute_backbone({"categorical": x_cat, "continuous": x["continuous"]}) return self.compute_head(x) # Redefining compute_backbone because this model flow is slightly different diff --git a/src/pytorch_tabular/models/tabnet/tabnet_model.py b/src/pytorch_tabular/models/tabnet/tabnet_model.py index 978b7bf0..4029e77c 100644 --- a/src/pytorch_tabular/models/tabnet/tabnet_model.py +++ b/src/pytorch_tabular/models/tabnet/tabnet_model.py @@ -26,7 +26,7 @@ def _build_network(self): n_a=self.hparams.n_a, n_steps=self.hparams.n_steps, gamma=self.hparams.gamma, - cat_idxs=[i for i in range(self.hparams.categorical_dim)], + cat_idxs=list(range(self.hparams.categorical_dim)), cat_dims=[cardinality for cardinality, _ in self.hparams.embedding_dims], cat_emb_dim=[embed_dim for _, embed_dim in self.hparams.embedding_dims], n_independent=self.hparams.n_independent, diff --git a/src/pytorch_tabular/ssl_models/common/heads.py b/src/pytorch_tabular/ssl_models/common/heads.py index 08888476..f4f432fc 100644 --- a/src/pytorch_tabular/ssl_models/common/heads.py +++ b/src/pytorch_tabular/ssl_models/common/heads.py @@ -24,7 +24,7 @@ def __init__(self, in_features, n_binary=0, n_categorical=0, n_numerical=0, card self.numerical_linear = nn.Linear(in_features, n_numerical) if n_numerical else None def forward(self, features): - outputs = dict() + outputs = {} if self.binary_linear: outputs["binary"] = self.binary_linear(features) diff --git a/src/pytorch_tabular/ssl_models/dae/config.py b/src/pytorch_tabular/ssl_models/dae/config.py index 76bca92d..263389a1 100644 --- a/src/pytorch_tabular/ssl_models/dae/config.py +++ b/src/pytorch_tabular/ssl_models/dae/config.py @@ -71,7 +71,7 @@ class DenoisingAutoEncoderConfig(SSLModelConfig): ) # Union not supported by omegaconf. Currently Union[float, Dict[str, float]] noise_probabilities: Dict[str, float] = field( - default_factory=lambda: dict(), + default_factory=lambda: {}, metadata={ "help": "Dict of individual probabilities to corrupt the input features with swap/zero noise." " Key should be the feature name and if any feature is missing," diff --git a/src/pytorch_tabular/ssl_models/dae/dae.py b/src/pytorch_tabular/ssl_models/dae/dae.py index a0d583d7..0f012cb2 100644 --- a/src/pytorch_tabular/ssl_models/dae/dae.py +++ b/src/pytorch_tabular/ssl_models/dae/dae.py @@ -158,7 +158,7 @@ def forward(self, x: Dict): reconstructed_in = self.reconstruction(z_hat) # mask reconstruction reconstructed_mask = self.mask_reconstruction(z_hat) - output_dict = dict(mask=self.output_tuple(mask, reconstructed_mask)) + output_dict = {"mask": self.output_tuple(mask, reconstructed_mask)} if "continuous" in reconstructed_in.keys(): output_dict["continuous"] = self.output_tuple( torch.cat( diff --git a/src/pytorch_tabular/tabular_datamodule.py b/src/pytorch_tabular/tabular_datamodule.py index 764faa72..9d639969 100644 --- a/src/pytorch_tabular/tabular_datamodule.py +++ b/src/pytorch_tabular/tabular_datamodule.py @@ -37,19 +37,19 @@ class TabularDatamodule(pl.LightningDataModule): CONTINUOUS_TRANSFORMS = { "quantile_uniform": { "callable": QuantileTransformer, - "params": dict(output_distribution="uniform", random_state=None), + "params": {"output_distribution": "uniform", "random_state": None}, }, "quantile_normal": { "callable": QuantileTransformer, - "params": dict(output_distribution="normal", random_state=None), + "params": {"output_distribution": "normal", "random_state": None}, }, "box-cox": { "callable": PowerTransformer, - "params": dict(method="box-cox", standardize=False), + "params": {"method": "box-cox", "standardize": False}, }, "yeo-johnson": { "callable": PowerTransformer, - "params": dict(method="yeo-johnson", standardize=False), + "params": {"method": "yeo-johnson", "standardize": False}, }, } @@ -224,7 +224,7 @@ def _label_encode_target(self, data: pd.DataFrame, stage: str) -> pd.DataFrame: def _target_transform(self, data: pd.DataFrame, stage: str) -> pd.DataFrame: if self.config.task == "regression": # target transform only for regression - if all([col in data.columns for col in self.config.target]): + if all(col in data.columns for col in self.config.target): if self.do_target_transform: if stage == "fit": target_transforms = [] @@ -607,7 +607,7 @@ def prepare_inference_dataloader(self, df: pd.DataFrame, batch_size: Optional[in categorical_cols=self.config.categorical_cols, continuous_cols=self.config.continuous_cols, embed_categorical=(not self.do_leave_one_out_encoder()), - target=self.target if all([col in df.columns for col in self.target]) else None, + target=self.target if all(col in df.columns for col in self.target) else None, ) return DataLoader( dataset, diff --git a/src/pytorch_tabular/tabular_model.py b/src/pytorch_tabular/tabular_model.py index 1c4a9c92..15648a23 100644 --- a/src/pytorch_tabular/tabular_model.py +++ b/src/pytorch_tabular/tabular_model.py @@ -155,8 +155,8 @@ def _run_validation(self): if self.config.target_range is not None: if ( (len(self.config.target_range) != len(self.config.target)) - or any([len(range_) != 2 for range_ in self.config.target_range]) - or any([range_[0] > range_[1] for range_ in self.config.target_range]) + or any(len(range_) != 2 for range_ in self.config.target_range) + or any(range_[0] > range_[1] for range_ in self.config.target_range) ): raise ValueError( "Targe Range, if defined, should be list tuples of length two(min,max)." @@ -1159,7 +1159,7 @@ def predict( " Please set it explicitly.", DeprecationWarning, ) - assert all([q <= 1 and q >= 0 for q in quantiles]), "Quantiles should be a decimal between 0 and 1" + assert all(q <= 1 and q >= 0 for q in quantiles), "Quantiles should be a decimal between 0 and 1" if device is not None: if isinstance(device, str): device = torch.device(device) @@ -1328,7 +1328,7 @@ def save_model_for_inference( self, path: Union[str, Path], kind: str = "pytorch", - onnx_export_params: Dict = dict(opset_version=12), + onnx_export_params: Dict = {"opset_version": 12}, ) -> bool: """Saves the model for inference. @@ -1362,7 +1362,7 @@ def save_model_for_inference( len(self.config.continuous_cols), requires_grad=True, ) - x = dict(continuous=cont, categorical=cat) + x = {"continuous": cont, "categorical": cat} torch.onnx.export(self.model, x, str(path), **onnx_export_params) return True else: diff --git a/src/pytorch_tabular/utils.py b/src/pytorch_tabular/utils.py index 7e0103c3..566b8a67 100644 --- a/src/pytorch_tabular/utils.py +++ b/src/pytorch_tabular/utils.py @@ -34,7 +34,7 @@ def get_logger(name): def _make_smooth_weights_for_balanced_classes(y_train, mu=1.0): - labels_dict = {label: count for label, count in zip(np.unique(y_train), np.bincount(y_train))} + labels_dict = dict(zip(np.unique(y_train), np.bincount(y_train))) total = np.sum(list(labels_dict.values())) keys = sorted(labels_dict.keys()) weight = [] diff --git a/tests/test_autoint.py b/tests/test_autoint.py index 5554af55..f9c6bb32 100644 --- a/tests/test_autoint.py +++ b/tests/test_autoint.py @@ -42,7 +42,7 @@ def test_regression( continuous_feature_transform=continuous_feature_transform, normalize_continuous_features=normalize_continuous_features, ) - model_config_params = dict(task="regression") + model_config_params = {"task": "regression"} if target_range: _target_range = [] for target in data_config.target: @@ -112,7 +112,7 @@ def test_classification( continuous_feature_transform=continuous_feature_transform, normalize_continuous_features=normalize_continuous_features, ) - model_config_params = dict(task="classification") + model_config_params = {"task": "classification"} model_config_params["deep_layers"] = deep_layers model_config_params["batch_norm_continuous_input"] = batch_norm_continuous_input model_config = AutoIntConfig(**model_config_params) diff --git a/tests/test_categorical_embedding.py b/tests/test_categorical_embedding.py index ac11ec29..c48467d5 100644 --- a/tests/test_categorical_embedding.py +++ b/tests/test_categorical_embedding.py @@ -73,7 +73,7 @@ def test_regression( continuous_feature_transform=continuous_feature_transform, normalize_continuous_features=normalize_continuous_features, ) - model_config_params = dict(task="regression") + model_config_params = {"task": "regression"} if target_range: _target_range = [] for target in data_config.target: @@ -86,7 +86,7 @@ def test_regression( model_config_params["target_range"] = _target_range if custom_head_config is not None: model_config_params["head"] = "LinearHead" - model_config_params["head_config"] = dict(layers=custom_head_config) + model_config_params["head_config"] = {"layers": custom_head_config} model_config = CategoryEmbeddingModelConfig(**model_config_params) trainer_config = TrainerConfig( max_epochs=3, @@ -152,7 +152,7 @@ def test_classification( continuous_feature_transform=continuous_feature_transform, normalize_continuous_features=normalize_continuous_features, ) - model_config_params = dict(task="classification") + model_config_params = {"task": "classification"} model_config = CategoryEmbeddingModelConfig(**model_config_params) trainer_config = TrainerConfig( max_epochs=3, @@ -192,7 +192,7 @@ def test_embedding_transformer(regression_data): ], categorical_cols=["HouseAgeBin"], ) - model_config_params = dict(task="regression") + model_config_params = {"task": "regression"} model_config = CategoryEmbeddingModelConfig(**model_config_params) trainer_config = TrainerConfig( max_epochs=1, @@ -215,4 +215,4 @@ def test_embedding_transformer(regression_data): train_transform = transformer.fit_transform(train) embed_cols = [col for col in train_transform.columns if "HouseAgeBin_embed_dim" in col] assert len(train["HouseAgeBin"].unique()) + 1 == len(transformer._mapping["HouseAgeBin"].keys()) - assert all([val.shape[0] == len(embed_cols) for val in transformer._mapping["HouseAgeBin"].values()]) + assert all(val.shape[0] == len(embed_cols) for val in transformer._mapping["HouseAgeBin"].values()) diff --git a/tests/test_common.py b/tests/test_common.py index f2637300..b1d7b0cc 100644 --- a/tests/test_common.py +++ b/tests/test_common.py @@ -16,20 +16,20 @@ MODEL_CONFIG_SAVE_TEST = [ - (CategoryEmbeddingModelConfig, dict(layers="10-20")), - (AutoIntConfig, dict(num_heads=1, num_attn_blocks=1)), - (NodeConfig, dict(num_trees=100, depth=2)), - (TabNetModelConfig, dict(n_a=2, n_d=2)), + (CategoryEmbeddingModelConfig, {"layers": "10-20"}), + (AutoIntConfig, {"num_heads": 1, "num_attn_blocks": 1}), + (NodeConfig, {"num_trees": 100, "depth": 2}), + (TabNetModelConfig, {"n_a": 2, "n_d": 2}), ] MODEL_CONFIG_SAVE_ONNX_TEST = [ - (CategoryEmbeddingModelConfig, dict(layers="10-20")), + (CategoryEmbeddingModelConfig, {"layers": "10-20"}), ( AutoIntConfig, - dict( - num_heads=1, - num_attn_blocks=1, - ), + { + "num_heads": 1, + "num_attn_blocks": 1, + }, ), ] MODEL_CONFIG_FEATURE_EXT_TEST = [ @@ -126,7 +126,7 @@ def test_feature_extractor( handle_missing_values=False if is_ssl else True, handle_unknown_categories=False if is_ssl else True, ) - model_config_params = dict() + model_config_params = {} if not is_ssl: model_config_params["task"] = "regression" else: @@ -170,7 +170,7 @@ def test_feature_extractor( ) dt = DeepFeatureExtractor(tabular_model) enc_df = dt.fit_transform(test) - assert any([col for col in enc_df.columns if "backbone" in col]) + assert any(col for col in enc_df.columns if "backbone" in col) @pytest.mark.parametrize("model_config_class", MODEL_CONFIG_SAVE_TEST) @@ -345,7 +345,7 @@ def test_model_reset( handle_missing_values=False if is_ssl else True, handle_unknown_categories=False if is_ssl else True, ) - model_config_params = dict() + model_config_params = {} if not is_ssl: model_config_params["task"] = "regression" else: diff --git a/tests/test_datamodule.py b/tests/test_datamodule.py index 9023caa0..c88c0fe5 100644 --- a/tests/test_datamodule.py +++ b/tests/test_datamodule.py @@ -63,7 +63,7 @@ def test_dataloader( normalize_continuous_features=normalize_continuous_features, validation_split=validation_split, ) - model_config_params = dict(task="regression", embedding_dims=embedding_dims) + model_config_params = {"task": "regression", "embedding_dims": embedding_dims} model_config = CategoryEmbeddingModelConfig(**model_config_params) trainer_config = TrainerConfig(max_epochs=1, checkpoints=None, early_stopping=None) optimizer_config = OptimizerConfig() @@ -117,7 +117,7 @@ def test_date_encoding(timeseries_data, freq): date_columns=[("date", freq)], encode_date_columns=True, ) - model_config_params = dict(task="regression") + model_config_params = {"task": "regression"} model_config = CategoryEmbeddingModelConfig(**model_config_params) trainer_config = TrainerConfig(max_epochs=1, checkpoints=None, early_stopping=None) optimizer_config = OptimizerConfig() diff --git a/tests/test_ft_transformer.py b/tests/test_ft_transformer.py index b8b33e43..1f41fa32 100644 --- a/tests/test_ft_transformer.py +++ b/tests/test_ft_transformer.py @@ -46,12 +46,12 @@ def test_regression( continuous_feature_transform=continuous_feature_transform, normalize_continuous_features=normalize_continuous_features, ) - model_config_params = dict( - task="regression", - input_embed_dim=8, - num_attn_blocks=1, - num_heads=2, - ) + model_config_params = { + "task": "regression", + "input_embed_dim": 8, + "num_attn_blocks": 1, + "num_heads": 2, + } if target_range: _target_range = [] for target in data_config.target: @@ -113,12 +113,12 @@ def test_classification( continuous_feature_transform=continuous_feature_transform, normalize_continuous_features=normalize_continuous_features, ) - model_config_params = dict( - task="classification", - input_embed_dim=8, - num_attn_blocks=1, - num_heads=2, - ) + model_config_params = { + "task": "classification", + "input_embed_dim": 8, + "num_attn_blocks": 1, + "num_heads": 2, + } model_config = FTTransformerConfig(**model_config_params) trainer_config = TrainerConfig( max_epochs=1, @@ -157,12 +157,12 @@ def test_embedding_transformer(regression_data): ], categorical_cols=["HouseAgeBin"], ) - model_config_params = dict( - task="regression", - input_embed_dim=8, - num_attn_blocks=1, - num_heads=2, - ) + model_config_params = { + "task": "regression", + "input_embed_dim": 8, + "num_attn_blocks": 1, + "num_heads": 2, + } model_config = FTTransformerConfig(**model_config_params) trainer_config = TrainerConfig( max_epochs=1, @@ -185,4 +185,4 @@ def test_embedding_transformer(regression_data): train_transform = transformer.fit_transform(train) embed_cols = [col for col in train_transform.columns if "HouseAgeBin_embed_dim" in col] assert len(train["HouseAgeBin"].unique()) + 1 == len(transformer._mapping["HouseAgeBin"].keys()) - assert all([val.shape[0] == len(embed_cols) for val in transformer._mapping["HouseAgeBin"].values()]) + assert all(val.shape[0] == len(embed_cols) for val in transformer._mapping["HouseAgeBin"].values()) diff --git a/tests/test_gate.py b/tests/test_gate.py index b550c507..b08165ff 100644 --- a/tests/test_gate.py +++ b/tests/test_gate.py @@ -47,12 +47,12 @@ def test_regression( continuous_feature_transform=continuous_feature_transform, normalize_continuous_features=normalize_continuous_features, ) - model_config_params = dict( - task="regression", - gflu_stages=1, - tree_depth=1, - num_trees=2, - ) + model_config_params = { + "task": "regression", + "gflu_stages": 1, + "tree_depth": 1, + "num_trees": 2, + } if target_range: _target_range = [] for target in data_config.target: @@ -114,12 +114,12 @@ def test_classification( continuous_feature_transform=continuous_feature_transform, normalize_continuous_features=normalize_continuous_features, ) - model_config_params = dict( - task="classification", - gflu_stages=1, - tree_depth=1, - num_trees=2, - ) + model_config_params = { + "task": "classification", + "gflu_stages": 1, + "tree_depth": 1, + "num_trees": 2, + } model_config = GatedAdditiveTreeEnsembleConfig(**model_config_params) trainer_config = TrainerConfig( max_epochs=1, diff --git a/tests/test_mdn.py b/tests/test_mdn.py index e8edce79..36a85860 100644 --- a/tests/test_mdn.py +++ b/tests/test_mdn.py @@ -48,11 +48,11 @@ def test_regression( continuous_feature_transform=continuous_feature_transform, normalize_continuous_features=normalize_continuous_features, ) - model_config_params = dict(task="regression") - mdn_config = dict(num_gaussian=num_gaussian) + model_config_params = {"task": "regression"} + mdn_config = {"num_gaussian": num_gaussian} model_config_params["head_config"] = mdn_config model_config_params["backbone_config_class"] = variant - model_config_params["backbone_config_params"] = dict(task="backbone") + model_config_params["backbone_config_params"] = {"task": "backbone"} model_config = MDNConfig(**model_config_params) trainer_config = TrainerConfig( @@ -109,11 +109,11 @@ def test_classification( continuous_feature_transform=continuous_feature_transform, normalize_continuous_features=normalize_continuous_features, ) - model_config_params = dict(task="classification") - mdn_config = dict(num_gaussian=num_gaussian) + model_config_params = {"task": "classification"} + mdn_config = {"num_gaussian": num_gaussian} model_config_params["head_config"] = mdn_config model_config_params["backbone_config_class"] = "CategoryEmbeddingMDNConfig" - model_config_params["backbone_config_params"] = dict(task="backbone") + model_config_params["backbone_config_params"] = {"task": "backbone"} model_config = MDNConfig(**model_config_params) trainer_config = TrainerConfig( diff --git a/tests/test_node.py b/tests/test_node.py index 2dfad078..fa04fae0 100644 --- a/tests/test_node.py +++ b/tests/test_node.py @@ -48,12 +48,12 @@ def test_regression( continuous_feature_transform=continuous_feature_transform, normalize_continuous_features=normalize_continuous_features, ) - model_config_params = dict( - task="regression", - depth=2, - num_trees=50, - embed_categorical=embed_categorical, - ) + model_config_params = { + "task": "regression", + "depth": 2, + "num_trees": 50, + "embed_categorical": embed_categorical, + } if target_range: _target_range = [] for target in data_config.target: @@ -117,12 +117,12 @@ def test_classification( continuous_feature_transform=continuous_feature_transform, normalize_continuous_features=normalize_continuous_features, ) - model_config_params = dict( - task="classification", - depth=2, - num_trees=50, - embed_categorical=embed_categorical, - ) + model_config_params = { + "task": "classification", + "depth": 2, + "num_trees": 50, + "embed_categorical": embed_categorical, + } model_config = NodeConfig(**model_config_params) trainer_config = TrainerConfig( max_epochs=1, @@ -161,7 +161,7 @@ def test_embedding_transformer(regression_data): ], categorical_cols=["HouseAgeBin"], ) - model_config_params = dict(task="regression", depth=2, num_trees=50, embed_categorical=True) + model_config_params = {"task": "regression", "depth": 2, "num_trees": 50, "embed_categorical": True} model_config = NodeConfig(**model_config_params) trainer_config = TrainerConfig( max_epochs=1, @@ -184,4 +184,4 @@ def test_embedding_transformer(regression_data): train_transform = transformer.fit_transform(train) embed_cols = [col for col in train_transform.columns if "HouseAgeBin_embed_dim" in col] assert len(train["HouseAgeBin"].unique()) + 1 == len(transformer._mapping["HouseAgeBin"].keys()) - assert all([val.shape[0] == len(embed_cols) for val in transformer._mapping["HouseAgeBin"].values()]) + assert all(val.shape[0] == len(embed_cols) for val in transformer._mapping["HouseAgeBin"].values()) diff --git a/tests/test_ssl.py b/tests/test_ssl.py index 20a83b16..1a732e5a 100644 --- a/tests/test_ssl.py +++ b/tests/test_ssl.py @@ -81,10 +81,10 @@ def test_regression( activation="LeakyReLU", # Activation between each layers ) - model_config_params = dict( - encoder_config=encoder_config, - decoder_config=decoder_config, - ) + model_config_params = { + "encoder_config": encoder_config, + "decoder_config": decoder_config, + } model_config = DenoisingAutoEncoderConfig(**model_config_params) trainer_config = TrainerConfig( max_epochs=1, @@ -188,10 +188,10 @@ def test_classification( layers="512-2048-4096", # Number of nodes in each layer activation="LeakyReLU", # Activation between each layers ) - model_config_params = dict( - encoder_config=encoder_config, - decoder_config=decoder_config, - ) + model_config_params = { + "encoder_config": encoder_config, + "decoder_config": decoder_config, + } model_config = DenoisingAutoEncoderConfig(**model_config_params) trainer_config = TrainerConfig( max_epochs=1, diff --git a/tests/test_tabnet.py b/tests/test_tabnet.py index fd8f6040..514f497c 100644 --- a/tests/test_tabnet.py +++ b/tests/test_tabnet.py @@ -45,7 +45,7 @@ def test_regression( continuous_feature_transform=continuous_feature_transform, normalize_continuous_features=normalize_continuous_features, ) - model_config_params = dict(task="regression") + model_config_params = {"task": "regression"} if target_range: _target_range = [] for target in data_config.target: @@ -105,7 +105,7 @@ def test_classification( continuous_feature_transform=continuous_feature_transform, normalize_continuous_features=normalize_continuous_features, ) - model_config_params = dict(task="classification") + model_config_params = {"task": "classification"} model_config = TabNetModelConfig(**model_config_params) trainer_config = TrainerConfig( max_epochs=1, diff --git a/tests/test_tabtransformer.py b/tests/test_tabtransformer.py index 17ea7b0b..a88cb470 100644 --- a/tests/test_tabtransformer.py +++ b/tests/test_tabtransformer.py @@ -46,12 +46,12 @@ def test_regression( continuous_feature_transform=continuous_feature_transform, normalize_continuous_features=normalize_continuous_features, ) - model_config_params = dict( - task="regression", - input_embed_dim=8, - num_attn_blocks=1, - num_heads=2, - ) + model_config_params = { + "task": "regression", + "input_embed_dim": 8, + "num_attn_blocks": 1, + "num_heads": 2, + } if target_range: _target_range = [] for target in data_config.target: @@ -113,12 +113,12 @@ def test_classification( continuous_feature_transform=continuous_feature_transform, normalize_continuous_features=normalize_continuous_features, ) - model_config_params = dict( - task="classification", - input_embed_dim=8, - num_attn_blocks=1, - num_heads=2, - ) + model_config_params = { + "task": "classification", + "input_embed_dim": 8, + "num_attn_blocks": 1, + "num_heads": 2, + } model_config = TabTransformerConfig(**model_config_params) trainer_config = TrainerConfig( max_epochs=1, @@ -157,12 +157,12 @@ def test_embedding_transformer(regression_data): ], categorical_cols=["HouseAgeBin"], ) - model_config_params = dict( - task="regression", - input_embed_dim=8, - num_attn_blocks=1, - num_heads=2, - ) + model_config_params = { + "task": "regression", + "input_embed_dim": 8, + "num_attn_blocks": 1, + "num_heads": 2, + } model_config = TabTransformerConfig(**model_config_params) trainer_config = TrainerConfig( max_epochs=1, @@ -185,4 +185,4 @@ def test_embedding_transformer(regression_data): train_transform = transformer.fit_transform(train) embed_cols = [col for col in train_transform.columns if "HouseAgeBin_embed_dim" in col] assert len(train["HouseAgeBin"].unique()) + 1 == len(transformer._mapping["HouseAgeBin"].keys()) - assert all([val.shape[0] == len(embed_cols) for val in transformer._mapping["HouseAgeBin"].values()]) + assert all(val.shape[0] == len(embed_cols) for val in transformer._mapping["HouseAgeBin"].values())