Upgrade Woodwork to 0.6.0

core-requirements.txt

@@ -12,7 +12,7 @@ psutil>=5.6.6
 requirements-parser>=0.2.0
 shap>=0.36.0
 texttable>=1.6.2
-woodwork==0.5.1
+woodwork==0.6.0
 dask>=2.12.0
 featuretools>=0.26.1
 nlp-primitives>=1.1.0

docs/source/release_notes.rst

@@ -6,6 +6,7 @@ Release Notes
         * Integrated ``DefaultAlgorithm`` into ``AutoMLSearch`` :pr:`2634`
         * Removed SVM "linear" and "precomputed" kernel hyperparameter options, and improved default parameters :pr:`2651`
         * Updated ``ComponentGraph`` initalization to raise ``ValueError`` when user attempts to use ``.y`` for a component that does not produce a tuple output :pr:`2662`
+        * Updated to support Woodwork 0.6.0 :pr:`2690`
         * Updated pipeline ``graph()`` to distingush X and y edges :pr:`2654`
         * Added ``DropRowsTransformer`` component :pr:`2692`
         * Added ``DROP_ROWS`` to ``_make_component_list_from_actions`` and clean up metadata :pr:`2694`

docs/source/user_guide/model_understanding.ipynb

@@ -154,7 +154,8 @@
    "outputs": [],
    "source": [
     "X_fraud, y_fraud = evalml.demos.load_fraud(100, verbose=False)\n",
-    "X_fraud.ww.init(logical_types={\"provider\": \"Categorical\", 'region': \"Categorical\"})\n",
+    "X_fraud.ww.init(logical_types={\"provider\": \"Categorical\", 'region': \"Categorical\",\n",
+    "                               \"currency\": \"Categorical\", \"expiration_date\": \"Categorical\"})\n",
     "\n",
     "fraud_pipeline = BinaryClassificationPipeline([\"DateTime Featurization Component\",\"One Hot Encoder\", \"Random Forest Classifier\"])\n",
     "fraud_pipeline.fit(X_fraud, y_fraud)\n",

docs/source/user_guide/objectives.ipynb

@@ -69,7 +69,8 @@
     "from evalml.objectives import F1\n",
     "\n",
     "X, y = load_fraud(n_rows=100)\n",
-    "X.ww.init(logical_types={\"provider\": \"Categorical\", \"region\": \"Categorical\"})\n",
+    "X.ww.init(logical_types={\"provider\": \"Categorical\", \"region\": \"Categorical\",\n",
+    "                         \"currency\": \"Categorical\", \"expiration_date\": \"Categorical\"})\n",
     "objective = F1()\n",
     "pipeline = BinaryClassificationPipeline(component_graph=['Simple Imputer', 'DateTime Featurization Component', 'One Hot Encoder', 'Random Forest Classifier'])\n",
     "pipeline.fit(X, y)\n",

evalml/model_understanding/permutation_importance.py

@@ -293,6 +293,7 @@ def _shuffle_and_score_helper(
         col = X_permuted.iloc[shuffling_idx, col_idx]
         col.index = X_permuted.index
         X_permuted.iloc[:, col_idx] = col
+        X_permuted.ww.init(schema=X_features.ww.schema)
         if is_fast:
             feature_score = scorer(pipeline, X_permuted, X_features, y, objective)
         else:

evalml/pipelines/components/transformers/column_selectors.py

@@ -31,7 +31,7 @@ def _check_input_for_columns(self, X):
 
         missing_cols = set(cols) - set(column_names)
         if missing_cols:
-            raise ValueError("Columns of type {column_types} not found in input data.")
+            raise ValueError(f"Columns of type {missing_cols} not found in input data.")
 
     @abstractmethod
     def _modify_columns(self, cols, X, y=None):

evalml/pipelines/components/transformers/preprocessing/transform_primitive_components.py

@@ -72,20 +72,13 @@ def transform(self, X, y=None):
 
         es = self._make_entity_set(X_ww)
         features = ft.calculate_feature_matrix(features=self._features, entityset=es)
-
         features.set_index(X_ww.index, inplace=True)
 
         X_ww = X_ww.ww.drop(self._columns)
+        features.ww.init(logical_types={col_: "categorical" for col_ in features})
         for col in features:
             X_ww.ww[col] = features[col]
 
-        all_created_columns = self._get_feature_provenance().values()
-        to_categorical = {
-            col: "Categorical"
-            for feature_list in all_created_columns
-            for col in feature_list
-        }
-        X_ww.ww.set_types(to_categorical)
         return X_ww
 
     @staticmethod

evalml/tests/component_tests/test_column_selector_transformers.py

@@ -118,6 +118,7 @@ def test_column_transformer_transform(class_to_test, checking_functions):
 
     if class_to_test is SelectByType:
         transformer = class_to_test(column_types=["categorical", "Boolean", "Integer"])
+        X.ww.init(logical_types={"one": "categorical"})
     else:
         transformer = class_to_test(columns=list(X.columns))
     assert check4(X, transformer.transform(X))
@@ -175,6 +176,7 @@ def test_column_transformer_fit_transform(class_to_test, checking_functions):
         assert check2(X, class_to_test(columns=["one"]).fit_transform(X))
 
     if class_to_test is SelectByType:
+        X.ww.init(logical_types={"one": "categorical"})
         assert check3(
             X,
             class_to_test(
@@ -254,6 +256,7 @@ def test_typeortag_column_transformer_ww_logical_and_semantic_types():
             "four": [4.0, 2.3, 6.5, 2.6],
         }
     )
+    X.ww.init(logical_types={"one": "categorical"})
 
     transformer = SelectByType(column_types=[ww.logical_types.Age])
     with pytest.raises(ValueError, match="not found in input data"):

evalml/tests/component_tests/test_delayed_features_transformer.py

@@ -86,6 +86,8 @@ def test_delayed_feature_extractor_maxdelay3_gap1(
         answer["feature"] = X.feature.astype("int64")
     if not encode_y_as_str:
         answer["target_delay_0"] = y_answer.astype("int64")
+    else:
+        y = y.astype("category")
 
     assert_frame_equal(
         answer, DelayedFeatureTransformer(max_delay=3, gap=1).fit_transform(X=X, y=y)
@@ -130,6 +132,8 @@ def test_delayed_feature_extractor_maxdelay5_gap1(
             "target_delay_5": y_answer.shift(5),
         }
     )
+    if encode_y_as_str:
+        y = y.astype("category")
     if not encode_X_as_str:
         answer["feature"] = X.feature.astype("int64")
     assert_frame_equal(
@@ -173,6 +177,8 @@ def test_delayed_feature_extractor_maxdelay3_gap7(
             "target_delay_3": y_answer.shift(3),
         }
     )
+    if encode_y_as_str:
+        y = y.astype("category")
     if not encode_X_as_str:
         answer["feature"] = X.feature.astype("int64")
     assert_frame_equal(
@@ -193,15 +199,9 @@ def test_delayed_feature_extractor_maxdelay3_gap7(
     )
 
 
-@pytest.mark.parametrize("encode_X_as_str", [True, False])
-@pytest.mark.parametrize("encode_y_as_str", [True, False])
-def test_delayed_feature_extractor_numpy(
-    encode_X_as_str, encode_y_as_str, delayed_features_data
-):
+def test_delayed_feature_extractor_numpy(delayed_features_data):
     X, y = delayed_features_data
-    X, X_answer, y, y_answer = encode_X_y_as_strings(
-        X, y, encode_X_as_str, encode_y_as_str
-    )
+    X, X_answer, y, y_answer = encode_X_y_as_strings(X, y, False, False)
     X_np = X.values
     y_np = y.values
     answer = pd.DataFrame(
@@ -216,8 +216,7 @@ def test_delayed_feature_extractor_numpy(
             "target_delay_3": y_answer.shift(3),
         }
     )
-    if not encode_X_as_str:
-        answer[0] = X.feature.astype("int64")
+
     assert_frame_equal(
         answer, DelayedFeatureTransformer(max_delay=3, gap=7).fit_transform(X_np, y_np)
     )
@@ -264,6 +263,8 @@ def test_lagged_feature_extractor_delay_features_delay_target(
             "target_delay_3": y_answer.shift(3),
         }
     )
+    if encode_y_as_str:
+        y = y.astype("category")
     if not encode_X_as_str:
         all_delays["feature"] = X.feature.astype("int64")
     if not delay_features:
@@ -307,7 +308,8 @@ def test_lagged_feature_extractor_delay_target(
                 "target_delay_3": y_answer.shift(3),
             }
         )
-
+    if encode_y_as_str:
+        y = y.astype("category")
     transformer = DelayedFeatureTransformer(
         max_delay=3, gap=1, delay_features=delay_features, delay_target=delay_target
     )
@@ -372,6 +374,8 @@ def test_delay_feature_transformer_supports_custom_index(
 
     X = make_data_type(data_type, X)
     y = make_data_type(data_type, y)
+    if encode_y_as_str:
+        y = y.astype("category")
 
     assert_frame_equal(
         answer, DelayedFeatureTransformer(max_delay=3, gap=7).fit_transform(X, y)
@@ -407,6 +411,7 @@ def test_delay_feature_transformer_multiple_categorical_columns(delayed_features
             "target_delay_1": y_answer.shift(1),
         }
     )
+    y = y.astype("category")
     assert_frame_equal(
         answer, DelayedFeatureTransformer(max_delay=1, gap=11).fit_transform(X, y)
     )
@@ -469,9 +474,13 @@ def test_delay_feature_transformer_woodwork_custom_overrides_returned_by_compone
             dft.fit(X, y)
             transformed = dft.transform(X, y)
         assert isinstance(transformed, pd.DataFrame)
+
+        if logical_type == Boolean:
+            transformed.ww.init(logical_types={"0_delay_1": "categorical"})
         transformed_logical_types = {
             k: type(v) for k, v in transformed.ww.logical_types.items()
         }
+
         if logical_type in [Integer, Double, Categorical]:
             assert transformed_logical_types == {
                 0: logical_type,