FLAML 2.3.3__tar.gz → 2.3.4__tar.gz

{flaml-2.3.3 → flaml-2.3.4}/FLAML.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: FLAML
-Version: 2.3.3
+Version: 2.3.4
 Summary: A fast library for automated machine learning and tuning
 Home-page: https://github.com/microsoft/FLAML
 Author: Microsoft Corporation

{flaml-2.3.3 → flaml-2.3.4}/FLAML.egg-info/SOURCES.txt

@@ -113,5 +113,4 @@ flaml/tune/spark/utils.py
 test/test_autovw.py
 test/test_conda_distribution.py
 test/test_gpu.py
-test/test_model.py
 test/test_version.py

{flaml-2.3.3 → flaml-2.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: FLAML
-Version: 2.3.3
+Version: 2.3.4
 Summary: A fast library for automated machine learning and tuning
 Home-page: https://github.com/microsoft/FLAML
 Author: Microsoft Corporation

{flaml-2.3.3 → flaml-2.3.4}/flaml/automl/model.py

@@ -9,6 +9,7 @@ import os
 import shutil
 import signal
 import sys
+import threading
 import time
 import warnings
 from contextlib import contextmanager
@@ -89,21 +90,25 @@ def limit_resource(memory_limit, time_limit):
             except ValueError:
                 # According to https://bugs.python.org/issue40518, it's a mac-specific error.
                 pass
-    main_thread = False
-    if time_limit is not None:
+    alarm_set = False
+    if time_limit is not None and threading.current_thread() is threading.main_thread():
         try:
             signal.signal(signal.SIGALRM, TimeoutHandler)
             signal.alarm(int(time_limit) or 1)
-            main_thread = True
+            alarm_set = True
         except ValueError:
             pass
+
     try:
         yield
     finally:
-        if main_thread:
+        if alarm_set:
             signal.alarm(0)
         if memory_limit > 0:
-            resource.setrlimit(resource.RLIMIT_AS, (soft, hard))
+            try:
+                resource.setrlimit(resource.RLIMIT_AS, (soft, hard))
+            except ValueError:
+                pass
 
 
 class BaseEstimator:
@@ -130,7 +135,7 @@ class BaseEstimator:
         self._task = task if isinstance(task, Task) else task_factory(task, None, None)
         self.params = self.config2params(config)
         self.estimator_class = self._model = None
-        if "_estimator_type" in config:
+        if "_estimator_type" in self.params:
             self._estimator_type = self.params.pop("_estimator_type")
         else:
             self._estimator_type = "classifier" if self._task.is_classification() else "regressor"
@@ -1691,7 +1696,7 @@ class XGBoostEstimator(SKLearnEstimator):
         # use_label_encoder is deprecated in 1.7.
         if xgboost_version < "1.7.0":
             params["use_label_encoder"] = params.get("use_label_encoder", False)
-        if "n_jobs" in config:
+        if "n_jobs" in params:
             params["nthread"] = params.pop("n_jobs")
         return params
 
@@ -1891,7 +1896,7 @@ class RandomForestEstimator(SKLearnEstimator, LGBMEstimator):
         params = super().config2params(config)
         if "max_leaves" in params:
             params["max_leaf_nodes"] = params.get("max_leaf_nodes", params.pop("max_leaves"))
-        if not self._task.is_classification() and "criterion" in config:
+        if not self._task.is_classification() and "criterion" in params:
             params.pop("criterion")
         if "random_state" not in params:
             params["random_state"] = 12032022
@@ -2344,7 +2349,7 @@ class SGDEstimator(SKLearnEstimator):
         params["loss"] = params.get("loss", None)
         if params["loss"] is None and self._task.is_classification():
             params["loss"] = "log_loss" if SKLEARN_VERSION >= "1.1" else "log"
-        if not self._task.is_classification():
+        if not self._task.is_classification() and "n_jobs" in params:
             params.pop("n_jobs")
 
         if params.get("penalty") != "elasticnet":

{flaml-2.3.3 → flaml-2.3.4}/flaml/automl/task/generic_task.py

@@ -769,10 +769,10 @@ class GenericTask(Task):
             if not is_spark_dataframe:
                 y_train, y_val = y_train_split[train_index], y_train_split[val_index]
                 if weight is not None:
-                    fit_kwargs["sample_weight"], weight_val = (
-                        weight[train_index],
-                        weight[val_index],
+                    fit_kwargs["sample_weight"] = (
+                        weight[train_index] if isinstance(weight, np.ndarray) else weight.iloc[train_index]
                     )
+                    weight_val = weight[val_index] if isinstance(weight, np.ndarray) else weight.iloc[val_index]
                 if groups is not None:
                     fit_kwargs["groups"] = (
                         groups[train_index] if isinstance(groups, np.ndarray) else groups.iloc[train_index]

{flaml-2.3.3 → flaml-2.3.4}/flaml/tune/tune.py

@@ -197,9 +197,16 @@ def report(_metric=None, **kwargs):
     global _training_iteration
     if _use_ray:
         try:
-            from ray import tune
+            from ray import __version__ as ray_version
+
+            if ray_version.startswith("1."):
+                from ray import tune
+
+                return tune.report(_metric, **kwargs)
+            else:  # ray>=2
+                from ray.air import session
 
-            return tune.report(_metric, **kwargs)
+                return session.report(metrics={"metric": _metric, **kwargs})
         except ImportError:
             # calling tune.report() outside tune.run()
             return

flaml-2.3.4/flaml/version.py

@@ -0,0 +1 @@
+__version__ = "2.3.4"

{flaml-2.3.3 → flaml-2.3.4}/test/test_gpu.py

@@ -59,6 +59,17 @@ def _test_hf_data():
     except requests.exceptions.ConnectionError:
         return
 
+    # Tests will only run if there is a GPU available
+    try:
+        import ray
+
+        pg = ray.util.placement_group([{"CPU": 1, "GPU": 1}])
+
+        if not pg.wait(timeout_seconds=10):  # Wait 10 seconds for resources
+            raise RuntimeError("No available node types can fulfill resource request!")
+    except RuntimeError:
+        return
+
     custom_sent_keys = ["sentence1", "sentence2"]
     label_key = "label"
 

flaml-2.3.3/flaml/version.py

@@ -1 +0,0 @@
-__version__ = "2.3.3"

flaml-2.3.3/test/test_model.py

@@ -1,146 +0,0 @@
-from datetime import datetime
-
-import numpy as np
-from pandas import DataFrame
-from sklearn.datasets import make_classification
-
-from flaml.automl.contrib.histgb import HistGradientBoostingEstimator
-from flaml.automl.model import (
-    BaseEstimator,
-    CatBoostEstimator,
-    KNeighborsEstimator,
-    LGBMEstimator,
-    LRL2Classifier,
-    RandomForestEstimator,
-    XGBoostEstimator,
-)
-from flaml.automl.time_series import ARIMA, LGBM_TS, Prophet, TimeSeriesDataset
-
-
-def test_lrl2():
-    BaseEstimator.search_space(1, "")
-    X, y = make_classification(100000, 1000)
-    print("start")
-    lr = LRL2Classifier()
-    lr.predict(X)
-    lr.fit(X, y, budget=1e-5)
-
-
-def test_prep():
-    X = np.array(
-        list(
-            zip(
-                [
-                    3.0,
-                    16.0,
-                    10.0,
-                    12.0,
-                    3.0,
-                    14.0,
-                    11.0,
-                    12.0,
-                    5.0,
-                    14.0,
-                    20.0,
-                    16.0,
-                    15.0,
-                    11.0,
-                ],
-                [
-                    "a",
-                    "b",
-                    "a",
-                    "c",
-                    "c",
-                    "b",
-                    "b",
-                    "b",
-                    "b",
-                    "a",
-                    "b",
-                    1.0,
-                    1.0,
-                    "a",
-                ],
-            )
-        ),
-        dtype=object,
-    )
-    y = np.array([0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1])
-    lr = LRL2Classifier()
-    lr.fit(X, y)
-    lr.predict(X)
-    print(lr.feature_names_in_)
-    print(lr.feature_importances_)
-    lgbm = LGBMEstimator(n_estimators=4)
-    lgbm.fit(X, y)
-    print(lgbm.feature_names_in_)
-    print(lgbm.feature_importances_)
-    cat = CatBoostEstimator(n_estimators=4)
-    cat.fit(X, y)
-    print(cat.feature_names_in_)
-    print(cat.feature_importances_)
-    knn = KNeighborsEstimator(task="regression")
-    knn.fit(X, y)
-    print(knn.feature_names_in_)
-    print(knn.feature_importances_)
-    xgb = XGBoostEstimator(n_estimators=4, max_leaves=4)
-    xgb.fit(X, y)
-    xgb.predict(X)
-    print(xgb.feature_names_in_)
-    print(xgb.feature_importances_)
-    rf = RandomForestEstimator(task="regression", n_estimators=4, criterion="gini")
-    rf.fit(X, y)
-    print(rf.feature_names_in_)
-    print(rf.feature_importances_)
-    hgb = HistGradientBoostingEstimator(task="regression", n_estimators=4, max_leaves=4)
-    hgb.fit(X, y)
-    hgb.predict(X)
-    print(hgb.feature_names_in_)
-    print(hgb.feature_importances_)
-
-    prophet = Prophet()
-    try:
-        prophet.predict(4)
-    except ValueError:
-        # predict() with steps is only supported for arima/sarimax.
-        pass
-    prophet.predict(X)
-
-    # What's the point of callin ARIMA without parameters, or calling predict before fit?
-    arima = ARIMA(p=1, q=1, d=0)
-    arima.predict(X)
-    arima._model = False
-    try:
-        arima.predict(X)
-    except ValueError:
-        # X_test needs to be either a pandas Dataframe with dates as the first column or an int number of periods for predict().
-        pass
-    lgbm = LGBM_TS(lags=1)
-    X = DataFrame(
-        {
-            "A": [
-                datetime(1900, 3, 1),
-                datetime(1900, 3, 2),
-                datetime(1900, 3, 3),
-                datetime(1900, 3, 4),
-                datetime(1900, 3, 4),
-                datetime(1900, 3, 4),
-                datetime(1900, 3, 5),
-                datetime(1900, 3, 6),
-            ],
-        }
-    )
-    y = np.array([0, 1, 0, 1, 1, 1, 0, 0])
-    lgbm.predict(X[:2])
-    df = X.copy()
-    df["y"] = y
-    tsds = TimeSeriesDataset(df, time_col="A", target_names="y")
-    lgbm.fit(tsds, period=2)
-    lgbm.predict(X[:2])
-    print(lgbm.feature_names_in_)
-    print(lgbm.feature_importances_)
-
-
-if __name__ == "__main__":
-    test_prep()