Featuretools

1.31.0 · active · verified Thu Apr 16

Featuretools is an open-source Python library for automated feature engineering. It excels at transforming temporal and relational datasets into feature matrices suitable for machine learning. The library, currently at version 1.31.0, is actively maintained by Alteryx and follows a frequent release cadence, often introducing new features and improvements.

Common errors

```
AttributeError: 'Series' object has no attribute 'ww'
```
cause Attempting to access Woodwork attributes (e.g., `logical_type` or `semantic_tags`) on a pandas Series directly, or using old syntax from pre-1.0.0 versions after migrating to Featuretools 1.0+.

fix Ensure you are accessing Woodwork properties via the DataFrame or a Woodwork-aware object, often by first selecting the column from the `Woodwork DataFrame` and then accessing its `.ww` accessor. Example: `entityset['dataframe_name'].ww['column_name'].logical_type`.
```
AttributeError: Can't get 'time' column from cutoff_time. The column must be labeled either as the target entity's time index variable name or as 'time'.
```
cause In `featuretools.dfs` or `featuretools.calculate_feature_matrix`, the 'time' column in a `cutoff_time` DataFrame is not correctly named or identified.

fix Ensure the time column in your `cutoff_time` DataFrame is explicitly named either 'time' or matches the time index variable name of your target DataFrame in the EntitySet. This was a breaking change in v0.16.0.
```
ImportError: cannot import name 'flatten_list' from 'featuretools.utils'
```
cause The utility function `flatten_list` was moved within the Featuretools internal structure.

fix This issue was a bug in certain minor versions. As of v1.31.0, the fix involved moving this function internally. Users experiencing this on older `1.x` versions should update to the latest patch release (e.g., `1.31.0`) to resolve it.
```
UserWarning: Index is not unique on dataframe
```
cause When creating an EntitySet or adding a DataFrame, the specified index column contains duplicate values.

fix Ensure that the column designated as the index for a DataFrame within the EntitySet contains only unique values. Duplicate index values can lead to unexpected behavior in feature calculation. Review your data and pre-process to ensure index uniqueness.

Warnings

breaking As of Featuretools v1.31.0, EntitySets can no longer be created directly from Dask or PySpark DataFrames. This functionality has been removed. Users must convert their Dask/PySpark DataFrames to pandas DataFrames first.
Fix: Convert Dask or PySpark DataFrames to pandas DataFrames before creating an EntitySet. For Dask, use `.compute()` to get a pandas DataFrame.
breaking The `featuretools` command-line interface (CLI) has been completely removed in version 1.31.0.
Fix: All CLI functionalities must now be performed programmatically within Python scripts.
breaking Featuretools v1.0.0 introduced significant breaking changes by replacing its legacy custom typing system with Woodwork. The `Entity` and `Variable` classes were removed, and `EntitySet` creation and primitive definitions changed. Columns now use Woodwork `LogicalType` and `semantic_tags` for type information.
Fix: Refer to the 'Transitioning to Featuretools Version 1.0' guide for detailed migration steps. Key changes include using `Woodwork DataFrames` and accessing column metadata via the `.ww` accessor on DataFrames within an EntitySet.
gotcha Dask is now an optional dependency. If you use `calculate_feature_matrix` with `n_jobs` set to anything other than 1 (to enable parallel processing), you must explicitly install Dask.
Fix: Install Dask with `pip install "featuretools[dask]"` or `pip install dask[dataframe]` before running parallel computations.

Install

pip install featuretools PyPI
conda install -c conda-forge featuretools Conda-forge

Imports

featuretools
```
import featuretools as ft
```
EntitySet
wrong:
```
from featuretools.entityset import EntitySet
```
correct:
```
from featuretools import EntitySet
```
The EntitySet class is a top-level import since version 1.0.0.

Quickstart

This quickstart demonstrates how to load a multi-table dataset into an EntitySet, define a target dataframe, and then use Deep Feature Synthesis (DFS) to automatically generate a rich set of features. It utilizes built-in aggregation and transform primitives to create new meaningful features for a machine learning task.

import featuretools as ft
import pandas as pd

# Load mock customer data into an EntitySet
es = ft.demo.load_mock_customer(return_entityset=True)

# Define target dataframe for feature engineering
target_dataframe_name = "customers"

# Run Deep Feature Synthesis (DFS)
feature_matrix, feature_defs = ft.dfs(
    entityset=es,
    target_dataframe_name=target_dataframe_name,
    agg_primitives=["count", "sum", "mean"],
    trans_primitives=["day", "month", "weekday"]
)

print(feature_matrix.head())

view raw JSON →