autogluon.cloud 0.3.0__tar.gz → 0.3.1__tar.gz

{autogluon.cloud-0.3.0/src/autogluon.cloud.egg-info → autogluon.cloud-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.cloud
-Version: 0.3.0
+Version: 0.3.1
 Summary: Train and deploy AutoGluon backed models on the cloud
 Home-page: https://github.com/autogluon/autogluon-cloud
 Author: AutoGluon Community

{autogluon.cloud-0.3.0 → autogluon.cloud-0.3.1}/setup.py

@@ -67,7 +67,8 @@ def default_setup_args(*, version):
         package_data={
             AUTOGLUON: [
                 "LICENSE",
-            ]
+            ],
+            'autogluon.cloud': ['default_cluster_configs/*.yaml'],
         },
         classifiers=[
             "Development Status :: 4 - Beta",
@@ -103,7 +104,7 @@ def default_setup_args(*, version):
     return setup_args
 
 
-version = "0.3.0"
+version = "0.3.1"
 version = update_version(version, use_file_if_exists=False, create_file=True)
 
 install_requires = [

autogluon.cloud-0.3.1/src/autogluon/cloud/scripts/ray_scripts/train.py

@@ -0,0 +1,124 @@
+import argparse
+import os
+import pickle
+import shutil
+import time
+from datetime import datetime, timezone
+from typing import Optional
+
+import boto3
+import ray
+
+from autogluon.common.utils.s3_utils import s3_path_to_bucket_prefix
+from autogluon.tabular import TabularDataset, TabularPredictor
+
+
+def wait_for_nodes_to_be_ready():
+    expected_num_nodes = int(os.environ.get("AG_NUM_NODES"))
+    ray.init("auto")
+    print("Waiting for worker nodes to be ready")
+    while len(ray.nodes()) < expected_num_nodes:
+        time.sleep(5)
+    ray.shutdown()
+    print("All nodes ready")
+
+
+def get_utc_timestamp_now():
+    return datetime.now(timezone.utc).strftime("%Y%m%d%H%M%S")
+
+
+def upload_log_file(job_id: str, model_output_path: str):
+    from ray.job_submission import JobSubmissionClient
+
+    client = JobSubmissionClient("http://127.0.0.1:8265")
+    logs = client.get_job_logs(job_id=job_id)
+    log_file = "training.log"
+    with open(log_file, "w") as f:
+        f.write(logs)
+    cloud_bucket, cloud_prefix = s3_path_to_bucket_prefix(model_output_path)
+    upload_file(file_name=log_file, bucket=cloud_bucket, prefix=cloud_prefix)
+
+
+def tear_down_cluster(cluster_config_file: str):
+    import subprocess
+
+    print("Will tear down the cluster in 10 secs")
+    time.sleep(10)
+    cmd = f"ray stop --force; ray down {cluster_config_file} -y"
+    subprocess.Popen(cmd, shell=True, preexec_fn=os.setpgrp)  # Avoid being terminated because ray runtime is down
+
+
+def upload_file(file_name: str, bucket: str, prefix: Optional[str] = None):
+    """
+    Upload a file to an S3 bucket
+
+    Parameters
+    ----------
+    file_name: str,
+        File to upload
+    bucket: str,
+        Bucket to upload to
+    prefix: Optional[str], default = None
+        S3 prefix. If not specified then will upload to the root of the bucket
+    """
+    object_name = os.path.basename(file_name)
+    if prefix is not None and len(prefix) == 0:
+        prefix = None
+    if prefix is not None:
+        object_name = prefix + "/" + object_name
+
+    # Upload the file
+    s3_client = boto3.client("s3")
+    s3_client.upload_file(file_name, bucket, object_name)
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--ag_args_path", type=str, required=True)
+    parser.add_argument("--train_data", type=str, required=True)
+    parser.add_argument("--tune_data", type=str, required=False)
+    parser.add_argument("--model_output_path", type=str, required=True)
+    parser.add_argument("--ray_job_id", type=str, required=True)
+    parser.add_argument("--leaderboard", action="store_true")
+    parser.add_argument("--cluster_config_file", type=str, required=False)
+    parser.set_defaults(leaderboard=False)
+    args = parser.parse_args()
+
+    try:
+        wait_for_nodes_to_be_ready()
+        train_data = TabularDataset(args.train_data)
+        tune_data = None
+        if args.tune_data is not None:
+            tune_data = TabularDataset(args.tune_data)
+        with open(args.ag_args_path, "rb") as f:
+            ag_args = pickle.load(f)
+        predictor_init_args = ag_args["predictor_init_args"]
+        predictor_fit_args = ag_args["predictor_fit_args"]
+        save_path = f"ag_distributed_training_{get_utc_timestamp_now()}"
+        predictor_init_args["path"] = save_path
+
+        print("Start training TabularPredictor")
+        predictor = TabularPredictor(**predictor_init_args).fit(
+            train_data=train_data, tuning_data=tune_data, **predictor_fit_args
+        )
+        print("Compressing the model artifacts")
+        model_artifact = shutil.make_archive("model", "zip", save_path)
+        model_output_path = os.path.dirname(args.model_output_path)
+        cloud_bucket, cloud_prefix = s3_path_to_bucket_prefix(model_output_path)
+        print(f"Uploading model artifact to {model_output_path}")
+        upload_file(file_name=model_artifact, bucket=cloud_bucket, prefix=cloud_prefix)
+
+        if args.leaderboard:
+            lb = predictor.leaderboard(silent=False)
+            leaderboard_file = "leaderboard.csv"
+            lb.to_csv(leaderboard_file)
+            upload_file(file_name=leaderboard_file, bucket=cloud_bucket, prefix=cloud_prefix)
+        print("Training finished")
+    except Exception as e:
+        raise e
+    finally:
+        upload_log_file(job_id=args.ray_job_id, model_output_path=os.path.dirname(args.model_output_path))
+
+        cluster_config_file = args.cluster_config_file
+        if cluster_config_file is not None:
+            tear_down_cluster(cluster_config_file)

autogluon.cloud-0.3.1/src/autogluon/cloud/scripts/sagemaker_scripts/multimodal_serve.py

@@ -0,0 +1,155 @@
+# flake8: noqa
+import base64
+import copy
+import os
+import pickle
+from io import BytesIO, StringIO
+
+import numpy as np
+import pandas as pd
+
+from autogluon.core.constants import BINARY, MULTICLASS
+from autogluon.core.utils import get_pred_from_proba_df
+from autogluon.multimodal import MultiModalPredictor
+
+
+def _cleanup_images():
+    files = os.listdir(".")
+    for file in files:
+        if file.endswith(".png"):
+            os.remove(file)
+
+
+def model_fn(model_dir):
+    """Loads model from previously saved artifact"""
+    model = MultiModalPredictor.load(model_dir)
+
+    # Check for _learner class which is available post 1.0.0 version of AutoGluon
+    if hasattr(model, "_learner") and hasattr(model._learner, "_label_column"):
+        label_column = model._learner._label_column
+        column_types = copy.copy(model._learner._column_types)
+    else:
+        # Fallback for older versions
+        label_column = model._label_column
+        column_types = copy.copy(model._column_types)
+    column_types.pop(label_column)
+    globals()["column_names"] = list(column_types.keys())
+
+    return model
+
+
+def transform_fn(model, request_body, input_content_type, output_content_type="application/json"):
+    image_bytearrays = None
+    inference_kwargs = {}
+    if input_content_type == "application/x-parquet":
+        buf = BytesIO(request_body)
+        data = pd.read_parquet(buf)
+
+    elif input_content_type == "text/csv":
+        buf = StringIO(request_body)
+        data = pd.read_csv(buf)
+
+    elif input_content_type == "application/json":
+        buf = StringIO(request_body)
+        data = pd.read_json(buf)
+
+    elif input_content_type == "application/jsonl":
+        buf = StringIO(request_body)
+        data = pd.read_json(buf, orient="records", lines=True)
+
+    elif input_content_type == "application/x-npy":
+        buf = BytesIO(request_body)
+        data = np.load(buf, allow_pickle=True)
+        image_bytearrays = []
+        for _bytes in data:
+            im_bytes = base64.b85decode(_bytes)
+            image_bytearrays.append(im_bytes)
+
+    elif input_content_type == "application/x-autogluon-parquet":
+        buf = bytes(request_body)
+        payload = pickle.loads(buf)
+        data = pd.read_parquet(BytesIO(payload["data"]))
+        inference_kwargs = payload["inference_kwargs"]
+        if inference_kwargs is None:
+            inference_kwargs = {}
+
+    elif input_content_type == "application/x-autogluon-npy":
+        buf = bytes(request_body)
+        payload = pickle.loads(buf)
+        data = np.load(BytesIO(payload["data"]), allow_pickle=True)
+        image_bytearrays = []
+        for _bytes in data:
+            im_bytes = base64.b85decode(_bytes)
+            image_bytearrays.append(im_bytes)
+        inference_kwargs = payload["inference_kwargs"]
+        if inference_kwargs is None:
+            inference_kwargs = {}
+
+    elif input_content_type == "application/x-image":
+        image_bytearrays = []
+        image_bytearrays.append(request_body)
+
+    else:
+        raise ValueError(f"{input_content_type} input content type not supported.")
+
+    if image_bytearrays is not None:
+        data = dict(image=image_bytearrays)  # multimodal image prediction takes in a dict containing image bytearrays
+    else:
+        # no header
+        test_columns = sorted(list(data.columns))
+        train_columns = sorted(column_names)
+        if test_columns != train_columns:
+            num_cols = len(data.columns)
+
+            if num_cols != len(column_names):
+                raise Exception(
+                    f"Invalid data format. Input data has {num_cols} while the model expects {len(column_names)}"
+                )
+
+            else:
+                new_row = pd.DataFrame(data.columns).transpose()
+                old_rows = pd.DataFrame(data.values)
+                data = pd.concat([new_row, old_rows]).reset_index(drop=True)
+                data.columns = column_names
+        # find image column
+        image_column = None
+        # Check for _learner class which is available post 1.0.0 version of AutoGluon
+        if hasattr(model, "_learner") and hasattr(model._learner, "_column_types"):
+            column_types = model._learner._column_types
+        else:
+            # Fallback for older versions
+            column_types = model._column_types
+        for column_name, column_type in column_types.items():
+            if column_type in ("image_path", "image", "image_bytearray"):
+                image_column = column_name
+                break
+        if image_column is not None:
+            print(f"Detected image column {image_column}")
+            data[image_column] = [base64.b85decode(_bytes) for _bytes in data[image_column]]
+
+    if model.problem_type == BINARY or model.problem_type == MULTICLASS:
+        pred_proba = model.predict_proba(data, as_pandas=True, **inference_kwargs)
+        pred = get_pred_from_proba_df(pred_proba, problem_type=model.problem_type)
+        pred_proba.columns = [str(c) + "_proba" for c in pred_proba.columns]
+        pred.name = model.label
+        prediction = pd.concat([pred, pred_proba], axis=1)
+    else:
+        prediction = model.predict(data, as_pandas=True, **inference_kwargs)
+    if isinstance(prediction, pd.Series):
+        prediction = prediction.to_frame()
+
+    if "application/x-parquet" in output_content_type:
+        output = prediction.to_parquet()
+        output_content_type = "application/x-parquet"
+    elif "application/json" in output_content_type:
+        output = prediction.to_json()
+        output_content_type = "application/json"
+    elif "text/csv" in output_content_type:
+        output = prediction.to_csv(index=None)
+        output_content_type = "text/csv"
+    else:
+        raise ValueError(f"{output_content_type} content type not supported")
+
+    _cleanup_images()
+
+    return output, output_content_type

autogluon.cloud-0.3.1/src/autogluon/cloud/scripts/sagemaker_scripts/tabular_serve.py

@@ -0,0 +1,121 @@
+# flake8: noqa
+import base64
+import hashlib
+import os
+import pickle
+from io import BytesIO, StringIO
+
+import pandas as pd
+from PIL import Image
+
+from autogluon.core.constants import QUANTILE, REGRESSION
+from autogluon.core.utils import get_pred_from_proba_df
+from autogluon.tabular import TabularPredictor
+
+image_dir = os.path.join("/tmp", "ag_images")
+
+
+def _save_image_and_update_dataframe_column(bytes):
+    os.makedirs(image_dir, exist_ok=True)
+    im_bytes = base64.b85decode(bytes)
+    # nosec B303 - not a cryptographic use
+    im_hash = hashlib.sha1(im_bytes).hexdigest()
+    im = Image.open(BytesIO(im_bytes))
+    im_name = f"tabular_image_{im_hash}.png"
+    im_path = os.path.join(image_dir, im_name)
+    im.save(im_path)
+    print(f"Image saved as {im_path}")
+
+    return im_path
+
+
+def model_fn(model_dir):
+    """loads model from previously saved artifact"""
+    model = TabularPredictor.load(model_dir)
+    model.persist_models()
+    globals()["column_names"] = model.original_features
+
+    return model
+
+
+def transform_fn(model, request_body, input_content_type, output_content_type="application/json"):
+    inference_kwargs = {}
+    if input_content_type == "application/x-parquet":
+        buf = BytesIO(request_body)
+        data = pd.read_parquet(buf)
+
+    elif input_content_type == "text/csv":
+        buf = StringIO(request_body)
+        data = pd.read_csv(buf)
+
+    elif input_content_type == "application/json":
+        buf = StringIO(request_body)
+        data = pd.read_json(buf)
+
+    elif input_content_type == "application/jsonl":
+        buf = StringIO(request_body)
+        data = pd.read_json(buf, orient="records", lines=True)
+
+    elif input_content_type == "application/x-autogluon":
+        buf = bytes(request_body)
+        payload = pickle.loads(buf)
+        data = pd.read_parquet(BytesIO(payload["data"]))
+        inference_kwargs = payload["inference_kwargs"]
+        if inference_kwargs is None:
+            inference_kwargs = {}
+
+    else:
+        raise ValueError(f"{input_content_type} input content type not supported.")
+
+    test_columns = sorted(list(data.columns))
+    train_columns = sorted(column_names)
+    if test_columns != train_columns:
+        num_cols = len(data.columns)
+
+        if num_cols != len(column_names):
+            raise Exception(
+                f"Invalid data format. Input data has {num_cols} while the model expects {len(column_names)}"
+            )
+
+        else:
+            new_row = pd.DataFrame(data.columns).transpose()
+            old_rows = pd.DataFrame(data.values)
+            data = pd.concat([new_row, old_rows]).reset_index(drop=True)
+            data.columns = column_names
+
+    # find image column
+    image_column = None
+    for column_name, special_types in model.feature_metadata.get_type_map_special().items():
+        if "image_path" in special_types:
+            image_column = column_name
+            break
+    # save image column bytes to disk and update the column with saved path
+    if image_column is not None:
+        print(f"Detected image column {image_column}")
+        data[image_column] = [_save_image_and_update_dataframe_column(bytes) for bytes in data[image_column]]
+
+    if model.problem_type not in [REGRESSION, QUANTILE]:
+        pred_proba = model.predict_proba(data, as_pandas=True, **inference_kwargs)
+        pred = get_pred_from_proba_df(pred_proba, problem_type=model.problem_type)
+        pred_proba.columns = [str(c) + "_proba" for c in pred_proba.columns]
+        pred.name = model.label
+        prediction = pd.concat([pred, pred_proba], axis=1)
+    else:
+        prediction = model.predict(data, as_pandas=True, **inference_kwargs)
+    if isinstance(prediction, pd.Series):
+        prediction = prediction.to_frame()
+
+    if "application/x-parquet" in output_content_type:
+        prediction.columns = prediction.columns.astype(str)
+        output = prediction.to_parquet()
+        output_content_type = "application/x-parquet"
+    elif "application/json" in output_content_type:
+        output = prediction.to_json()
+        output_content_type = "application/json"
+    elif "text/csv" in output_content_type:
+        output = prediction.to_csv(index=None)
+        output_content_type = "text/csv"
+    else:
+        raise ValueError(f"{output_content_type} content type not supported")
+
+    return output, output_content_type

autogluon.cloud-0.3.1/src/autogluon/cloud/scripts/sagemaker_scripts/timeseries_serve.py

@@ -0,0 +1,93 @@
+# flake8: noqa
+import os
+import pickle
+import shutil
+from io import BytesIO, StringIO
+
+import pandas as pd
+
+from autogluon.timeseries import TimeSeriesDataFrame, TimeSeriesPredictor
+
+
+def model_fn(model_dir):
+    """loads model from previously saved artifact"""
+    # TSPredictor will write to the model file during inference while the default model_dir is read only
+    # Copy the model file to a writable location as a temporary workaround
+    tmp_model_dir = os.path.join("/tmp", "model")
+    try:
+        shutil.copytree(model_dir, tmp_model_dir, dirs_exist_ok=False)
+    except:
+        # model already copied
+        pass
+    model = TimeSeriesPredictor.load(tmp_model_dir)
+    print("MODEL LOADED")
+    return model
+
+
+def prepare_timeseries_dataframe(df, predictor):
+    target = predictor.target
+    cols = df.columns.to_list()
+    id_column = cols[0]
+    timestamp_column = cols[1]
+    df[timestamp_column] = pd.to_datetime(df[timestamp_column])
+    static_features = None
+    if target != cols[-1]:
+        # target is not the last column, then there are static features being merged in
+        target_index = cols.index(target)
+        static_columns = cols[target_index + 1 :]
+        static_features = df[[id_column] + static_columns].groupby([id_column], sort=False).head(1)
+        static_features.set_index(id_column, inplace=True)
+        df.drop(columns=static_columns, inplace=True)
+    df = TimeSeriesDataFrame.from_data_frame(df, id_column=id_column, timestamp_column=timestamp_column)
+    if static_features is not None:
+        df.static_features = static_features
+    return df
+
+
+def transform_fn(model, request_body, input_content_type, output_content_type="application/json"):
+    inference_kwargs = {}
+    if input_content_type == "application/x-parquet":
+        buf = BytesIO(request_body)
+        data = pd.read_parquet(buf)
+
+    elif input_content_type == "text/csv":
+        buf = StringIO(request_body)
+        data = pd.read_csv(buf)
+
+    elif input_content_type == "application/json":
+        buf = StringIO(request_body)
+        data = pd.read_json(buf)
+
+    elif input_content_type == "application/jsonl":
+        buf = StringIO(request_body)
+        data = pd.read_json(buf, orient="records", lines=True)
+
+    elif input_content_type == "application/x-autogluon":
+        buf = bytes(request_body)
+        payload = pickle.loads(buf)
+        data = pd.read_parquet(BytesIO(payload["data"]))
+        inference_kwargs = payload["inference_kwargs"]
+        if inference_kwargs is None:
+            inference_kwargs = {}
+
+    else:
+        raise ValueError(f"{input_content_type} input content type not supported.")
+
+    data = prepare_timeseries_dataframe(data, model)
+    prediction = model.predict(data, **inference_kwargs)
+    prediction = pd.DataFrame(prediction)
+
+    if "application/x-parquet" in output_content_type:
+        prediction.columns = prediction.columns.astype(str)
+        output = prediction.to_parquet()
+        output_content_type = "application/x-parquet"
+    elif "application/json" in output_content_type:
+        output = prediction.to_json()
+        output_content_type = "application/json"
+    elif "text/csv" in output_content_type:
+        output = prediction.to_csv(index=None)
+        output_content_type = "text/csv"
+    else:
+        raise ValueError(f"{output_content_type} content type not supported")
+
+    return output, output_content_type

autogluon.cloud-0.3.1/src/autogluon/cloud/scripts/sagemaker_scripts/train.py

@@ -0,0 +1,173 @@
+# isort: skip_file
+# flake8: noqa
+# The import order of autogluon sub module here could cause seg fault. Ignore isort for now
+# https://github.com/autogluon/autogluon/issues/2042
+import argparse
+import os
+import pandas as pd
+import shutil
+from pprint import pprint
+
+import pickle
+
+from autogluon.common.loaders import load_pd
+from autogluon.tabular import TabularPredictor, TabularDataset
+
+
+def get_input_path(path):
+    file = os.listdir(path)[0]
+    if len(os.listdir(path)) > 1:
+        raise ValueError(f"WARN: more than one file is found in {channel} directory")
+    print(f"Using {file}")
+    filename = f"{path}/{file}"
+    return filename
+
+
+def get_env_if_present(name):
+    result = None
+    if name in os.environ:
+        result = os.environ[name]
+    return result
+
+
+def prepare_timeseries_dataframe(df, predictor_init_args):
+    target = predictor_init_args["target"]
+    cols = df.columns.to_list()
+    id_column = cols[0]
+    timestamp_column = cols[1]
+    df[timestamp_column] = pd.to_datetime(df[timestamp_column])
+    static_features = None
+    if target != cols[-1]:
+        # target is not the last column, then there are static features being merged in
+        target_index = cols.index(target)
+        static_columns = cols[target_index + 1 :]
+        static_features = df[[id_column] + static_columns].groupby([id_column], sort=False).head(1)
+        static_features.set_index(id_column, inplace=True)
+        df.drop(columns=static_columns, inplace=True)
+    df = TimeSeriesDataFrame.from_data_frame(df, id_column=id_column, timestamp_column=timestamp_column)
+    if static_features is not None:
+        print(static_features)
+        df.static_features = static_features
+    return df
+
+
+def prepare_data(data_file, predictor_type, predictor_init_args=None):
+    if predictor_type == "timeseries":
+        assert predictor_init_args is not None
+        data = load_pd.load(data_file)
+        data = prepare_timeseries_dataframe(data, predictor_init_args)
+    else:
+        data = TabularDataset(data_file)
+    return data
+
+
+if __name__ == "__main__":
+    # Disable Autotune
+    os.environ["MXNET_CUDNN_AUTOTUNE_DEFAULT"] = "0"
+
+    # ------------------------------------------------------------ Args parsing
+    print("Starting AG")
+    parser = argparse.ArgumentParser()
+
+    # Data, model, and output directories
+    parser.add_argument("--output-data-dir", type=str, default=get_env_if_present("SM_OUTPUT_DATA_DIR"))
+    parser.add_argument("--model-dir", type=str, default=get_env_if_present("SM_MODEL_DIR"))
+    parser.add_argument("--n_gpus", type=str, default=get_env_if_present("SM_NUM_GPUS"))
+    parser.add_argument("--train_dir", type=str, default=get_env_if_present("SM_CHANNEL_TRAIN"))
+    parser.add_argument("--tune_dir", type=str, required=False, default=get_env_if_present("SM_CHANNEL_TUNE"))
+    parser.add_argument(
+        "--train_images", type=str, required=False, default=get_env_if_present("SM_CHANNEL_TRAIN_IMAGES")
+    )
+    parser.add_argument(
+        "--tune_images", type=str, required=False, default=get_env_if_present("SM_CHANNEL_TUNE_IMAGES")
+    )
+    parser.add_argument("--ag_args", type=str, default=get_env_if_present("SM_CHANNEL_AG_ARGS"))
+    parser.add_argument("--serving_script", type=str, default=get_env_if_present("SM_CHANNEL_SERVING"))
+
+    args, _ = parser.parse_known_args()
+
+    print(f"Args: {args}")
+
+    # See SageMaker-specific environment variables: https://sagemaker.readthedocs.io/en/stable/overview.html#prepare-a-training-script
+    os.makedirs(args.output_data_dir, mode=0o777, exist_ok=True)
+
+    ag_args_file = get_input_path(args.ag_args)
+    with open(ag_args_file, "rb") as f:
+        ag_args = pickle.load(f)  # AutoGluon-specific args
+
+    if args.n_gpus:
+        ag_args["num_gpus"] = int(args.n_gpus)
+
+    print("Running training job with the config:")
+    pprint(ag_args)
+
+    # ---------------------------------------------------------------- Training
+    save_path = os.path.normpath(args.model_dir)
+    predictor_type = ag_args["predictor_type"]
+    predictor_init_args = ag_args["predictor_init_args"]
+    predictor_init_args["path"] = save_path
+    predictor_fit_args = ag_args["predictor_fit_args"]
+    valid_predictor_types = ["tabular", "multimodal", "timeseries"]
+    assert (
+        predictor_type in valid_predictor_types
+    ), f"predictor_type {predictor_type} not supported. Valid options are {valid_predictor_types}"
+    if predictor_type == "tabular":
+        predictor_cls = TabularPredictor
+    elif predictor_type == "multimodal":
+        from autogluon.multimodal import MultiModalPredictor
+
+        predictor_cls = MultiModalPredictor
+    elif predictor_type == "timeseries":
+        from autogluon.timeseries import TimeSeriesPredictor, TimeSeriesDataFrame
+
+        predictor_cls = TimeSeriesPredictor
+
+    train_file = get_input_path(args.train_dir)
+    training_data = prepare_data(train_file, predictor_type, predictor_init_args)
+
+    if predictor_type == "tabular" and "image_column" in ag_args:
+        feature_metadata = predictor_fit_args.get("feature_metadata", None)
+        assert (
+            feature_metadata is not None
+        ), f"Detected image_column: {ag_args['image_column']} while feature metadata is not included"
+        feature_metadata = feature_metadata.add_special_types({ag_args["image_column"]: ["image_path"]})
+        predictor_fit_args["feature_metadata"] = feature_metadata
+
+    tuning_data = None
+    if args.tune_dir:
+        tune_file = get_input_path(args.tune_dir)
+        tuning_data = prepare_data(tune_file, predictor_type)
+
+    if args.train_images:
+        train_image_compressed_file = get_input_path(args.train_images)
+        train_images_dir = "train_images"
+        shutil.unpack_archive(train_image_compressed_file, train_images_dir)
+        image_column = ag_args["image_column"]
+        training_data[image_column] = training_data[image_column].apply(
+            lambda path: os.path.join(train_images_dir, path)
+        )
+
+    if args.tune_images:
+        tune_image_compressed_file = get_input_path(args.tune_images)
+        tune_images_dir = "tune_images"
+        shutil.unpack_archive(tune_image_compressed_file, tune_images_dir)
+        image_column = ag_args["image_column"]
+        tuning_data[image_column] = tuning_data[image_column].apply(lambda path: os.path.join(tune_images_dir, path))
+
+    predictor = predictor_cls(**predictor_init_args).fit(training_data, tuning_data=tuning_data, **predictor_fit_args)
+
+    # When use automm backend, predictor needs to be saved with standalone flag to avoid need of internet access when loading
+    # This is required because of https://discuss.huggingface.co/t/error-403-when-downloading-model-for-sagemaker-batch-inference/12571/6
+    if predictor_type == "multimodal":
+        predictor.save(path=save_path, standalone=True)
+
+    if predictor_cls == TabularPredictor:
+        if ag_args.get("leaderboard", False):
+            lb = predictor.leaderboard(silent=False)
+            lb.to_csv(f"{args.output_data_dir}/leaderboard.csv")
+
+    print("Saving serving script")
+    serving_script_saving_path = os.path.join(save_path, "code")
+    os.mkdir(serving_script_saving_path)
+    serving_script_path = get_input_path(args.serving_script)
+    shutil.move(serving_script_path, os.path.join(serving_script_saving_path, os.path.basename(serving_script_path)))

{autogluon.cloud-0.3.0 → autogluon.cloud-0.3.1}/src/autogluon/cloud/version.py

@@ -1,2 +1,2 @@
 """This is the autogluon.cloud version file."""
-__version__ = '0.3.0'
+__version__ = '0.3.1'

{autogluon.cloud-0.3.0 → autogluon.cloud-0.3.1/src/autogluon.cloud.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: autogluon.cloud
-Version: 0.3.0
+Version: 0.3.1
 Summary: Train and deploy AutoGluon backed models on the cloud
 Home-page: https://github.com/autogluon/autogluon-cloud
 Author: AutoGluon Community

{autogluon.cloud-0.3.0 → autogluon.cloud-0.3.1}/src/autogluon.cloud.egg-info/SOURCES.txt

@@ -34,6 +34,7 @@ src/autogluon/cloud/cluster/ray_cluster_config_generator.py
 src/autogluon/cloud/cluster/ray_cluster_manager.py
 src/autogluon/cloud/data/__init__.py
 src/autogluon/cloud/data/format_converter.py
+src/autogluon/cloud/default_cluster_configs/__init__.py
 src/autogluon/cloud/endpoint/__init__.py
 src/autogluon/cloud/endpoint/endpoint.py
 src/autogluon/cloud/endpoint/sagemaker_endpoint.py
@@ -48,6 +49,13 @@ src/autogluon/cloud/predictor/tabular_cloud_predictor.py
 src/autogluon/cloud/predictor/timeseries_cloud_predictor.py
 src/autogluon/cloud/scripts/__init__.py
 src/autogluon/cloud/scripts/script_manager.py
+src/autogluon/cloud/scripts/ray_scripts/__init__.py
+src/autogluon/cloud/scripts/ray_scripts/train.py
+src/autogluon/cloud/scripts/sagemaker_scripts/__init__.py
+src/autogluon/cloud/scripts/sagemaker_scripts/multimodal_serve.py
+src/autogluon/cloud/scripts/sagemaker_scripts/tabular_serve.py
+src/autogluon/cloud/scripts/sagemaker_scripts/timeseries_serve.py
+src/autogluon/cloud/scripts/sagemaker_scripts/train.py
 src/autogluon/cloud/utils/__init__.py
 src/autogluon/cloud/utils/ag_sagemaker.py
 src/autogluon/cloud/utils/aws_utils.py

{autogluon.cloud-0.3.0 → autogluon.cloud-0.3.1}/src/autogluon.cloud.egg-info/requires.txt

@@ -13,8 +13,8 @@ ray[default]<2.7,>=2.6.3
 autogluon<1.0,>=0.7
 
 [tests]
-autogluon.common<1.1,>=0.7.0b
-tox
 pytest-cov
-moto
+autogluon.common<1.1,>=0.7.0b
 pytest
+moto
+tox