nvtabular.ops.HashBucket

class nvtabular.ops.HashBucket(num_buckets: Union[int, Dict[str, int]])[source]

Bases: merlin.dag.operator.Operator

This op maps categorical columns to a contiguous integer range by first hashing the column, then reducing modulo the number of buckets.

Example usage:

cat_names = ["feature_a", "feature_b"]

# this will hash both features a and b to 100 buckets
hash_features = cat_names >> ops.HashBucket({"feature_a": 100, "feature_b": 50})
processor = nvtabular.Workflow(hash_features)

The output of this op would be:

   feature_a  feature_b
       90         11
       70         40
       52          9

If you would like to do frequency capping or frequency hashing, you should use Categorify op instead. See Categorify op for example usage.

Parameters: num_buckets (int or dictionary:{column: num_hash_buckets}) – Column-wise modulo to apply after hash function. Note that this means that the corresponding value will be the categorical cardinality of the transformed categorical feature. If given as an int, that value will be used as the number of “hash buckets” for every feature. If a dictionary is passed, it will be used to specify explicit mappings from a column name to a number of buckets. In this case, only the columns specified in the keys of num_buckets will be transformed.

__init__(num_buckets: Union[int, Dict[str, int]])[source]

Methods

`__init__`(num_buckets)
`column_mapping`(col_selector)	Compute which output columns depend on which input columns
`compute_column_schema`(col_name, input_schema)
`compute_input_schema`(root_schema, …)	Given the schemas coming from upstream sources and a column selector for the input columns, returns a set of schemas for the input columns this operator will use
`compute_output_schema`(input_schema, col_selector)	Given a set of schemas and a column selector for the input columns, returns a set of schemas for the transformed columns this operator will produce
`compute_selector`(input_schema, selector[, …])	Provides a hook method for sub-classes to override to implement custom column selection logic.
`create_node`(selector)
`export`(path, input_schema, output_schema, …)	Export the class object as a config and all related files to the user defined path.
`get_embedding_sizes`(columns)
`load_artifacts`([artifact_path])	Load artifacts from disk required for operator function.
`output_column_names`(col_selector)	Given a set of columns names returns the names of the transformed columns this operator will produce
`save_artifacts`([artifact_path])	Save artifacts required to be reload operator state from disk
`transform`(col_selector, df)	Transform the dataframe by applying this operator to the set of input columns
`validate_schemas`(parents_schema, …[, …])	Provides a hook method that sub-classes can override to implement schema validation logic.

Attributes

`dependencies`	Defines an optional list of column dependencies for this operator.
`dynamic_dtypes`
`export_name`	Provides a clear common english identifier for this operator.
`is_subgraph`
`label`
`output_dtype`
`output_properties`
`output_tags`
`supported_formats`
`supports`	Returns what kind of data representation this operator supports

transform(col_selector: merlin.dag.selector.ColumnSelector, df: pandas.core.frame.DataFrame) → pandas.core.frame.DataFrame[source]

Transform the dataframe by applying this operator to the set of input columns

Parameters

col_selector (ColumnSelector) – The columns to apply this operator to
transformable (Transformable) – A pandas or cudf dataframe that this operator will work on

Returns

Returns a transformed dataframe or dictarray for this operator

Return type

Transformable

get_embedding_sizes(columns)[source]

property output_tags

property output_dtype