Source code for featuretools.primitives.standard.cum_transform_feature

import numpy as np
from woodwork.column_schema import ColumnSchema
from woodwork.logical_types import IntegerNullable

from featuretools.primitives.base import TransformPrimitive


[docs]class CumSum(TransformPrimitive): """Calculates the cumulative sum. Description: Given a list of values, return the cumulative sum (or running total). There is no set window, so the sum at each point is calculated over all prior values. `NaN` values will return `NaN`, but in the window of a cumulative caluclation, they're ignored. Examples: >>> cum_sum = CumSum() >>> cum_sum([1, 2, 3, 4, None, 5]).tolist() [1.0, 3.0, 6.0, 10.0, nan, 15.0] """ name = "cum_sum" input_types = [ColumnSchema(semantic_tags={'numeric'})] return_type = ColumnSchema(semantic_tags={'numeric'}) uses_full_dataframe = True description_template = "the cumulative sum of {}" def get_function(self): def cum_sum(values): return values.cumsum() return cum_sum
[docs]class CumCount(TransformPrimitive): """Calculates the cumulative count. Description: Given a list of values, return the cumulative count (or running count). There is no set window, so the count at each point is calculated over all prior values. `NaN` values are counted. Examples: >>> cum_count = CumCount() >>> cum_count([1, 2, 3, 4, None, 5]).tolist() [1, 2, 3, 4, 5, 6] """ name = "cum_count" input_types = [[ColumnSchema(semantic_tags={'foreign_key'})], [ColumnSchema(semantic_tags={'category'})]] return_type = ColumnSchema(logical_type=IntegerNullable, semantic_tags={'numeric'}) uses_full_dataframe = True description_template = "the cumulative count of {}" def get_function(self): def cum_count(values): return np.arange(1, len(values) + 1) return cum_count
[docs]class CumMean(TransformPrimitive): """Calculates the cumulative mean. Description: Given a list of values, return the cumulative mean (or running mean). There is no set window, so the mean at each point is calculated over all prior values. `NaN` values will return `NaN`, but in the window of a cumulative caluclation, they're treated as 0. Examples: >>> cum_mean = CumMean() >>> cum_mean([1, 2, 3, 4, None, 5]).tolist() [1.0, 1.5, 2.0, 2.5, nan, 2.5] """ name = "cum_mean" input_types = [ColumnSchema(semantic_tags={'numeric'})] return_type = ColumnSchema(semantic_tags={'numeric'}) uses_full_dataframe = True description_template = "the cumulative mean of {}" def get_function(self): def cum_mean(values): return values.cumsum() / np.arange(1, len(values) + 1) return cum_mean
[docs]class CumMin(TransformPrimitive): """Calculates the cumulative minimum. Description: Given a list of values, return the cumulative min (or running min). There is no set window, so the min at each point is calculated over all prior values. `NaN` values will return `NaN`, but in the window of a cumulative caluclation, they're ignored. Examples: >>> cum_min = CumMin() >>> cum_min([1, 2, -3, 4, None, 5]).tolist() [1.0, 1.0, -3.0, -3.0, nan, -3.0] """ name = "cum_min" input_types = [ColumnSchema(semantic_tags={'numeric'})] return_type = ColumnSchema(semantic_tags={'numeric'}) uses_full_dataframe = True description_template = "the cumulative minimum of {}" def get_function(self): def cum_min(values): return values.cummin() return cum_min
[docs]class CumMax(TransformPrimitive): """Calculates the cumulative maximum. Description: Given a list of values, return the cumulative max (or running max). There is no set window, so the max at each point is calculated over all prior values. `NaN` values will return `NaN`, but in the window of a cumulative caluclation, they're ignored. Examples: >>> cum_max = CumMax() >>> cum_max([1, 2, 3, 4, None, 5]).tolist() [1.0, 2.0, 3.0, 4.0, nan, 5.0] """ name = "cum_max" input_types = [ColumnSchema(semantic_tags={'numeric'})] return_type = ColumnSchema(semantic_tags={'numeric'}) uses_full_dataframe = True description_template = "the cumulative maximum of {}" def get_function(self): def cum_max(values): return values.cummax() return cum_max