Multiclass pipeline

evalml/models/auto_base.py

@@ -14,7 +14,7 @@
 
 
 class AutoBase:
-    def __init__(self, problem_types, tuner, cv, objective, max_pipelines, max_time,
+    def __init__(self, problem_type, tuner, cv, objective, max_pipelines, max_time,
                  model_types, default_objectives, detect_label_leakage, start_iteration_callback,
                  add_result_callback, random_state, verbose):
         if tuner is None:
@@ -30,7 +30,7 @@ def __init__(self, problem_types, tuner, cv, objective, max_pipelines, max_time,
         self.cv = cv
         self.verbose = verbose
 
-        self.possible_pipelines = get_pipelines(problem_types=problem_types, model_types=model_types)
+        self.possible_pipelines = get_pipelines(problem_type=problem_type, model_types=model_types)
 
         self.results = {}
         self.trained_pipelines = {}

evalml/models/auto_classifier.py

@@ -62,19 +62,19 @@ def __init__(self,
             cv = StratifiedKFold(n_splits=3, random_state=random_state)
 
         objective = get_objective(objective)
-        default_objectives = get_objectives('binary')
+        default_objectives = get_objectives(ProblemTypes.BINARY)
+        problem_type = ProblemTypes.BINARY
         if multiclass:
-            default_objectives = get_objectives('multiclass')
-
-        problem_types = [ProblemTypes.BINARY, ProblemTypes.MULTICLASS]
+            default_objectives = get_objectives(ProblemTypes.MULTICLASS)
+            problem_type = ProblemTypes.MULTICLASS
         super().__init__(
             tuner=tuner,
             objective=objective,
             cv=cv,
             max_pipelines=max_pipelines,
             max_time=max_time,
             model_types=model_types,
-            problem_types=problem_types,
+            problem_type=problem_type,
             default_objectives=default_objectives,
             detect_label_leakage=detect_label_leakage,
             start_iteration_callback=start_iteration_callback,

evalml/models/auto_regressor.py

@@ -56,12 +56,12 @@ def __init__(self,
             objective = "R2"
 
         objective = get_objective(objective)
-        default_objectives = get_objectives('regression')
+        default_objectives = get_objectives(ProblemTypes.REGRESSION)
 
         if cv is None:
             cv = KFold(n_splits=3, random_state=random_state)
 
-        problem_types = [ProblemTypes.REGRESSION]
+        problem_type = ProblemTypes.REGRESSION
 
         super().__init__(
             tuner=tuner,
@@ -70,7 +70,7 @@ def __init__(self,
             max_pipelines=max_pipelines,
             max_time=max_time,
             model_types=model_types,
-            problem_types=problem_types,
+            problem_type=problem_type,
             default_objectives=default_objectives,
             detect_label_leakage=detect_label_leakage,
             start_iteration_callback=start_iteration_callback,

evalml/objectives/fraud_cost.py

@@ -35,7 +35,6 @@ def __init__(self, retry_percentage=.5, interchange_fee=.02,
     def decision_function(self, y_predicted, extra_cols, threshold):
         """Determine if transaction is fraud given predicted probabilities,
             dataframe with transaction amount, and threshold"""
-
         transformed_probs = (y_predicted * extra_cols[self.amount_col])
         return transformed_probs > threshold
 

evalml/objectives/objective_base.py

@@ -14,13 +14,11 @@ class ObjectiveBase:
     def __init__(self, verbose=False):
         self.verbose = verbose
 
-    def supports_problem_types(self, problem_types):
-        problem_types = handle_problem_types(problem_types)
-        for problem_type in problem_types:
-            if problem_type in self.__class__.problem_types:
-                return True
-        else:
-            return False
+    def supports_problem_type(self, problem_type):
+        problem_type = handle_problem_types(problem_type)
+        if problem_type in self.__class__.problem_types:
+            return True
+        return False
 
     def fit(self, y_predicted, y_true, extra_cols=None):
         """Learn the objective function based on the predictions from a model.

evalml/objectives/standard_metrics.py

@@ -23,7 +23,7 @@ class F1Micro(ObjectiveBase):
     needs_fitting = False
     greater_is_better = True
     need_proba = False
-    name = "F1_Micro"
+    name = "F1 Micro"
     problem_types = [ProblemTypes.MULTICLASS]
 
     def score(self, y_predicted, y_true):
@@ -34,7 +34,7 @@ class F1Macro(ObjectiveBase):
     needs_fitting = False
     greater_is_better = True
     need_proba = False
-    name = "F1_Macro"
+    name = "F1 Macro"
     problem_types = [ProblemTypes.MULTICLASS]
 
     def score(self, y_predicted, y_true):
@@ -45,12 +45,9 @@ class F1Weighted(ObjectiveBase):
     needs_fitting = False
     greater_is_better = True
     need_proba = False
-    name = "F1_Weighted"
+    name = "F1 Weighted"
     problem_types = [ProblemTypes.MULTICLASS]
 
-    def __init__(self, average='binary'):
-        self.average = average
-
     def score(self, y_predicted, y_true):
         return metrics.f1_score(y_true, y_predicted, average='weighted')
 
@@ -70,12 +67,9 @@ class PrecisionMicro(ObjectiveBase):
     needs_fitting = False
     greater_is_better = True
     need_proba = False
-    name = "Precision_Micro"
+    name = "Precision Micro"
     problem_types = [ProblemTypes.MULTICLASS]
 
-    def __init__(self, average='binary'):
-        self.average = average
-
     def score(self, y_predicted, y_true):
         return metrics.precision_score(y_true, y_predicted, average='micro')
 
@@ -84,7 +78,7 @@ class PrecisionMacro(ObjectiveBase):
     needs_fitting = False
     greater_is_better = True
     need_proba = False
-    name = "Precision_Macro"
+    name = "Precision Macro"
     problem_types = [ProblemTypes.MULTICLASS]
 
     def score(self, y_predicted, y_true):
@@ -95,7 +89,7 @@ class PrecisionWeighted(ObjectiveBase):
     needs_fitting = False
     greater_is_better = True
     need_proba = False
-    name = "Precision_Weighted"
+    name = "Precision Weighted"
     problem_types = [ProblemTypes.MULTICLASS]
 
     def score(self, y_predicted, y_true):
@@ -117,7 +111,7 @@ class RecallMicro(ObjectiveBase):
     needs_fitting = False
     greater_is_better = True
     need_proba = False
-    name = "Recall_Micro"
+    name = "Recall Micro"
     problem_types = [ProblemTypes.MULTICLASS]
 
     def score(self, y_predicted, y_true):
@@ -128,7 +122,7 @@ class RecallMacro(ObjectiveBase):
     needs_fitting = False
     greater_is_better = True
     need_proba = False
-    name = "Recall_Macro"
+    name = "Recall Macro"
     problem_types = [ProblemTypes.MULTICLASS]
 
     def score(self, y_predicted, y_true):
@@ -161,7 +155,7 @@ class AUCMicro(ObjectiveBase):
     needs_fitting = False
     greater_is_better = True
     score_needs_proba = True
-    name = "AUC_Micro"
+    name = "AUC Micro"
     problem_types = [ProblemTypes.MULTICLASS]
 
     def score(self, y_predicted, y_true):
@@ -173,7 +167,7 @@ class AUCMacro(ObjectiveBase):
     needs_fitting = False
     greater_is_better = True
     score_needs_proba = True
-    name = "AUC_Macro"
+    name = "AUC Macro"
     problem_types = [ProblemTypes.MULTICLASS]
 
     def score(self, y_predicted, y_true):

evalml/objectives/utils.py

@@ -41,7 +41,7 @@ def get_objective(objective):
     return OPTIONS[objective]
 
 
-def get_objectives(problem_types):
+def get_objectives(problem_type):
     """Returns all objectives associated with the given problem types
 
     Args:
@@ -50,5 +50,5 @@ def get_objectives(problem_types):
     Returns:
         List of Objectives
     """
-    problem_types = handle_problem_types(problem_types)
-    return [obj for obj in OPTIONS if OPTIONS[obj].supports_problem_types(problem_types)]
+    problem_type = handle_problem_types(problem_type)
+    return [obj for obj in OPTIONS if OPTIONS[obj].supports_problem_type(problem_type)]

evalml/pipelines/classification/xgboost.py

@@ -57,9 +57,6 @@ def fit(self, X, y, objective_fit_size=.2):
 
             y (pd.Series): the target training labels of length [n_samples]
 
-            feature_types (list, optional): list of feature types. either numeric of categorical.
-                categorical features will automatically be encoded
-
         Returns:
 
             self

evalml/pipelines/utils.py

@@ -12,12 +12,12 @@
 ALL_PIPELINES = [RFClassificationPipeline, XGBoostPipeline, LogisticRegressionPipeline, RFRegressionPipeline]
 
 
-def get_pipelines(problem_types, model_types=None):
+def get_pipelines(problem_type, model_types=None):
     """Returns potential pipelines by model type
 
     Arguments:
 
-        problem_types(ProblemTypes/str or list[ProblemTypes/str]): the problem type/s the pipelines work for.
+        problem_types(ProblemTypes/str): the problem type the pipelines work for.
         model_types(list[str]): model types to match. if none, return all pipelines
 
     Returns
@@ -27,14 +27,11 @@ def get_pipelines(problem_types, model_types=None):
     """
 
     problem_pipelines = []
-    if not isinstance(problem_types, list):
-        problem_types = list(problem_types)
 
-    problem_types = handle_problem_types(problem_types)
+    problem_type = handle_problem_types(problem_type)
     for p in ALL_PIPELINES:
-        for problem_type in problem_types:
-            if problem_type in p.problem_types and p not in problem_pipelines:
-                problem_pipelines.append(p)
+        if problem_type in p.problem_types:
+            problem_pipelines.append(p)
 
     if model_types is None:
         return problem_pipelines

evalml/problem_types/utils.py

@@ -1,18 +1,22 @@
 from .problem_types import ProblemTypes
 
 
-def handle_problem_types(problem_types):
-    if isinstance(problem_types, ProblemTypes):
-        return problem_types
-    if isinstance(problem_types, str):
-        problem_types = [problem_types]
-    types = list()
-    for problem_type in problem_types:
-        if isinstance(problem_type, ProblemTypes):
-            types.append(problem_type)
-        elif isinstance(problem_type, str):
-            try:
-                types.append(ProblemTypes[problem_type.upper()])
-            except KeyError:
-                raise KeyError('Problem type \'{}\' does not exist'.format(problem_type))
-    return types
+def handle_problem_types(problem_type):
+    """Handles problem_type by either returning the ProblemTypes or converting to a str
+
+    Args:
+        problem_types (str/ProblemTypes) : problem type that needs to be handled
+
+    Returns:
+        ProblemType
+    """
+
+    if isinstance(problem_type, str):
+        try:
+            tpe = ProblemTypes[problem_type.upper()]
+        except KeyError:
+            raise KeyError('Problem type \'{}\' does not exist'.format(problem_type))
+        return tpe
+    if isinstance(problem_type, ProblemTypes):
+        return problem_type
+    raise ValueError('`handle_problem_types` was not passed a str or ProblemTypes object')

evalml/tests/test_autoclassifier.py

@@ -19,7 +19,7 @@ def test_init(X_y):
     clf = AutoClassifier(multiclass=False)
 
     # check loads all pipelines
-    assert get_pipelines(problem_types=[ProblemTypes.BINARY]) == clf.possible_pipelines
+    assert get_pipelines(problem_type=ProblemTypes.BINARY) == clf.possible_pipelines
 
     clf.fit(X, y)
 
@@ -65,7 +65,7 @@ def test_init_select_model_types():
     model_types = ["random_forest"]
     clf = AutoClassifier(model_types=model_types)
 
-    assert get_pipelines(problem_types=[ProblemTypes.BINARY], model_types=model_types) == clf.possible_pipelines
+    assert get_pipelines(problem_type=ProblemTypes.BINARY, model_types=model_types) == clf.possible_pipelines
     assert model_types == clf.possible_model_types
 
 

evalml/tests/test_autoregressor.py

@@ -18,7 +18,7 @@ def test_init(X_y):
     clf = AutoRegressor(objective="R2", max_pipelines=3)
 
     # check loads all pipelines
-    assert get_pipelines(problem_types=[ProblemTypes.REGRESSION]) == clf.possible_pipelines
+    assert get_pipelines(problem_type=ProblemTypes.REGRESSION) == clf.possible_pipelines
 
     clf.fit(X, y)
 

evalml/tests/test_pipelines.py

@@ -21,9 +21,9 @@ def test_list_model_types():
 
 
 def test_get_pipelines():
-    assert len(get_pipelines(problem_types=[ProblemTypes.BINARY])) == 3
-    assert len(get_pipelines(problem_types=[ProblemTypes.BINARY], model_types=["linear_model"])) == 1
-    assert len(get_pipelines(problem_types=[ProblemTypes.REGRESSION])) == 1
+    assert len(get_pipelines(problem_type=ProblemTypes.BINARY)) == 3
+    assert len(get_pipelines(problem_type=ProblemTypes.BINARY, model_types=["linear_model"])) == 1
+    assert len(get_pipelines(problem_type=ProblemTypes.REGRESSION)) == 1
 
 
 @pytest.fixture
@@ -40,8 +40,6 @@ def path_management():
 
 def test_serialization(X_y, trained_model, path_management):
     X, y = X_y
-    X = pd.DataFrame(X)
-    y = pd.Series(y)
     path = os.path.join(path_management, 'pipe.pkl')
     objective = Precision()
 
@@ -53,8 +51,7 @@ def test_serialization(X_y, trained_model, path_management):
 
 def test_reproducibility(X_y):
     X, y = X_y
-    X = pd.DataFrame(X)
-    y = pd.Series(y)
+    X = pd.DataFrame(X)  # TODO: FraudCost.decision_function breaks when given np.array(). Need to standardize input as pd or adjust function.
 
     objective = FraudCost(
         retry_percentage=.5,

evalml/tests/test_problem_types.py

@@ -4,27 +4,28 @@
 
 
 @pytest.fixture
-def correct_pts():
-    correct_pts = [[ProblemTypes.REGRESSION], [ProblemTypes.MULTICLASS], [ProblemTypes.BINARY], [ProblemTypes.MULTICLASS, ProblemTypes.BINARY]]
-    yield correct_pts
+def correct_problem_types():
+    correct_problem_types = [ProblemTypes.REGRESSION, ProblemTypes.MULTICLASS, ProblemTypes.BINARY]
+    yield correct_problem_types
 
 
-def test_handle_string(correct_pts):
-    pts = [['regression'], ['multiclass'], ['binary'], ['multiclass', 'binary']]
-    for pt in zip(pts, correct_pts):
-        assert handle_problem_types(pt[0]) == pt[1]
+def test_handle_string(correct_problem_types):
+    problem_types = ['regression', 'multiclass', 'binary']
+    for problem_type in zip(problem_types, correct_problem_types):
+        assert handle_problem_types(problem_type[0]) == problem_type[1]
 
-    pts = ['fake', 'regression']
+    problem_type = 'fake'
     error_msg = 'Problem type \'fake\' does not exist'
     with pytest.raises(KeyError, match=error_msg):
-        handle_problem_types(pts) == ProblemTypes.regression
+        handle_problem_types(problem_type) == ProblemTypes.REGRESSION
 
 
-def test_handle_problemtypes(correct_pts):
-    for pt in zip(correct_pts, correct_pts):
-        assert handle_problem_types(pt[0]) == pt[1]
+def test_handle_problem_types(correct_problem_types):
+    for problem_type in zip(correct_problem_types, correct_problem_types):
+        assert handle_problem_types(problem_type[0]) == problem_type[1]
 
-    pts = ['fake', 'regression']
-    error_msg = 'Problem type \'fake\' does not exist'
-    with pytest.raises(KeyError, match=error_msg):
-        handle_problem_types(pts) == ProblemTypes.regression
+
+def test_handle_incorrect_type():
+    error_msg = '`handle_problem_types` was not passed a str or ProblemTypes object'
+    with pytest.raises(ValueError, match=error_msg):
+        handle_problem_types(5)