sagemaker-core 1.0.62__py3-none-any.whl → 2.1.1__py3-none-any.whl

sagemaker/core/serializers/utils.py

@@ -0,0 +1,223 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+"""Placeholder docstring"""
+from __future__ import absolute_import
+
+import struct
+import sys
+import numpy as np
+
+
+def _write_feature_tensor(resolved_type, record, vector):
+    """Placeholder Docstring"""
+    raise NotImplementedError()
+    # if resolved_type == "Int32":
+    #     record.features["values"].int32_tensor.values.extend(vector)
+    # elif resolved_type == "Float64":
+    #     record.features["values"].float64_tensor.values.extend(vector)
+    # elif resolved_type == "Float32":
+    #     record.features["values"].float32_tensor.values.extend(vector)
+
+
+def _write_label_tensor(resolved_type, record, scalar):
+    """Placeholder Docstring"""
+    raise NotImplementedError()
+    # if resolved_type == "Int32":
+    #     record.label["values"].int32_tensor.values.extend([scalar])
+    # elif resolved_type == "Float64":
+    #     record.label["values"].float64_tensor.values.extend([scalar])
+    # elif resolved_type == "Float32":
+    #     record.label["values"].float32_tensor.values.extend([scalar])
+
+
+def _write_keys_tensor(resolved_type, record, vector):
+    """Placeholder Docstring"""
+    raise NotImplementedError()
+    # if resolved_type == "Int32":
+    #     record.features["values"].int32_tensor.keys.extend(vector)
+    # elif resolved_type == "Float64":
+    #     record.features["values"].float64_tensor.keys.extend(vector)
+    # elif resolved_type == "Float32":
+    #     record.features["values"].float32_tensor.keys.extend(vector)
+
+
+def _write_shape(resolved_type, record, scalar):
+    """Placeholder Docstring"""
+    raise NotImplementedError()
+    # if resolved_type == "Int32":
+    #     record.features["values"].int32_tensor.shape.extend([scalar])
+    # elif resolved_type == "Float64":
+    #     record.features["values"].float64_tensor.shape.extend([scalar])
+    # elif resolved_type == "Float32":
+    #     record.features["values"].float32_tensor.shape.extend([scalar])
+
+
+def write_numpy_to_dense_tensor(file, array, labels=None):
+    """Writes a numpy array to a dense tensor
+
+    Args:
+        file:
+        array:
+        labels:
+    """
+    raise NotImplementedError()
+    # # Validate shape of array and labels, resolve array and label types
+    # if not len(array.shape) == 2:
+    #     raise ValueError("Array must be a Matrix")
+    # if labels is not None:
+    #     if not len(labels.shape) == 1:
+    #         raise ValueError("Labels must be a Vector")
+    #     if labels.shape[0] not in array.shape:
+    #         raise ValueError(
+    #             "Label shape {} not compatible with array shape {}".format(
+    #                 labels.shape, array.shape
+    #             )
+    #         )
+    #     resolved_label_type = _resolve_type(labels.dtype)
+    # resolved_type = _resolve_type(array.dtype)
+    #
+    # # Write each vector in array into a Record in the file object
+    # record = Record()
+    # for index, vector in enumerate(array):
+    #     record.Clear()
+    #     _write_feature_tensor(resolved_type, record, vector)
+    #     if labels is not None:
+    #         _write_label_tensor(resolved_label_type, record, labels[index])
+    #     _write_recordio(file, record.SerializeToString())
+
+
+def write_spmatrix_to_sparse_tensor(file, array, labels=None):
+    """Writes a scipy sparse matrix to a sparse tensor
+
+    Args:
+        file:
+        array:
+        labels:
+    """
+    raise NotImplementedError()
+    # try:
+    #     import scipy
+    # except ImportError as e:
+    #     logging.warning(
+    #         "scipy failed to import. Sparse matrix functions will be impaired or broken."
+    #     )
+    #     # Any subsequent attempt to use scipy will raise the ImportError
+    #     scipy = DeferredError(e)
+    #
+    # if not scipy.sparse.issparse(array):
+    #     raise TypeError("Array must be sparse")
+    #
+    # # Validate shape of array and labels, resolve array and label types
+    # if not len(array.shape) == 2:
+    #     raise ValueError("Array must be a Matrix")
+    # if labels is not None:
+    #     if not len(labels.shape) == 1:
+    #         raise ValueError("Labels must be a Vector")
+    #     if labels.shape[0] not in array.shape:
+    #         raise ValueError(
+    #             "Label shape {} not compatible with array shape {}".format(
+    #                 labels.shape, array.shape
+    #             )
+    #         )
+    #     resolved_label_type = _resolve_type(labels.dtype)
+    # resolved_type = _resolve_type(array.dtype)
+    #
+    # csr_array = array.tocsr()
+    # n_rows, n_cols = csr_array.shape
+    #
+    # record = Record()
+    # for row_idx in range(n_rows):
+    #     record.Clear()
+    #     row = csr_array.getrow(row_idx)
+    #     # Write values
+    #     _write_feature_tensor(resolved_type, record, row.data)
+    #     # Write keys
+    #     _write_keys_tensor(resolved_type, record, row.indices.astype(np.uint64))
+    #
+    #     # Write labels
+    #     if labels is not None:
+    #         _write_label_tensor(resolved_label_type, record, labels[row_idx])
+    #
+    #     # Write shape
+    #     _write_shape(resolved_type, record, n_cols)
+    #
+    #     _write_recordio(file, record.SerializeToString())
+
+
+def read_records(file):
+    """Eagerly read a collection of amazon Record protobuf objects from file.
+
+    Args:
+        file:
+    """
+    raise NotImplementedError()
+    # records = []
+    # for record_data in read_recordio(file):
+    #     record = Record()
+    #     record.ParseFromString(record_data)
+    #     records.append(record)
+    # return records
+
+
+# MXNet requires recordio records have length in bytes that's a multiple of 4
+# This sets up padding bytes to append to the end of the record, for diferent
+# amounts of padding required.
+padding = {}
+for amount in range(4):
+    if sys.version_info >= (3,):
+        padding[amount] = bytes([0x00 for _ in range(amount)])
+    else:
+        padding[amount] = bytearray([0x00 for _ in range(amount)])
+
+_kmagic = 0xCED7230A
+
+
+def _write_recordio(f, data):
+    """Writes a single data point as a RecordIO record to the given file.
+
+    Args:
+        f:
+        data:
+    """
+    length = len(data)
+    f.write(struct.pack("I", _kmagic))
+    f.write(struct.pack("I", length))
+    pad = (((length + 3) >> 2) << 2) - length
+    f.write(data)
+    f.write(padding[pad])
+
+
+def read_recordio(f):
+    """Placeholder Docstring"""
+    while True:
+        try:
+            (read_kmagic,) = struct.unpack("I", f.read(4))
+        except struct.error:
+            return
+        assert read_kmagic == _kmagic
+        (len_record,) = struct.unpack("I", f.read(4))
+        pad = (((len_record + 3) >> 2) << 2) - len_record
+        yield f.read(len_record)
+        if pad:
+            f.read(pad)
+
+
+def _resolve_type(dtype):
+    """Placeholder Docstring"""
+    if dtype == np.dtype(int):
+        return "Int32"
+    if dtype == np.dtype(float):
+        return "Float64"
+    if dtype == np.dtype("float32"):
+        return "Float32"
+    raise ValueError("Unsupported dtype {} on array".format(dtype))

sagemaker/core/serverless_inference_config.py

@@ -0,0 +1,63 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+"""This module contains code related to the ServerlessInferenceConfig class.
+
+Codes are used for configuring serverless inference endpoint. Use it when deploying
+the model to the endpoints.
+"""
+from __future__ import print_function, absolute_import
+from typing import Optional
+
+
+class ServerlessInferenceConfig(object):
+    """Configuration object passed in when deploying models to Amazon SageMaker Endpoints.
+
+    This object specifies configuration related to serverless endpoint. Use this configuration
+    when trying to create serverless endpoint and make serverless inference
+    """
+
+    def __init__(
+        self,
+        memory_size_in_mb: int = 2048,
+        max_concurrency: int = 5,
+        provisioned_concurrency: Optional[int] = None,
+    ):
+        """Initialize a ServerlessInferenceConfig object for serverless inference configuration.
+
+        Args:
+            memory_size_in_mb (int): Optional. The memory size of your serverless endpoint.
+                Valid values are in 1 GB increments: 1024 MB, 2048 MB, 3072 MB, 4096 MB,
+                5120 MB, or 6144 MB. If no value is provided, Amazon SageMaker will choose
+                the default value for you. (Default: 2048)
+            max_concurrency (int): Optional. The maximum number of concurrent invocations
+                your serverless endpoint can process. If no value is provided, Amazon
+                SageMaker will choose the default value for you. (Default: 5)
+            provisioned_concurrency (int): Optional. The provisioned concurrency of your
+                serverless endpoint. If no value is provided, Amazon SageMaker will not
+                apply provisioned concucrrency to your Serverless endpoint. (Default: None)
+        """
+        self.memory_size_in_mb = memory_size_in_mb
+        self.max_concurrency = max_concurrency
+        self.provisioned_concurrency = provisioned_concurrency
+
+    def _to_request_dict(self):
+        """Generates a request dictionary using the parameters provided to the class."""
+        request_dict = {
+            "MemorySizeInMB": self.memory_size_in_mb,
+            "MaxConcurrency": self.max_concurrency,
+        }
+
+        if self.provisioned_concurrency is not None:
+            request_dict["ProvisionedConcurrency"] = self.provisioned_concurrency
+
+        return request_dict

sagemaker/core/session_settings.py

@@ -0,0 +1,55 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+"""Defines classes to parametrize a SageMaker ``Session``."""
+
+from __future__ import absolute_import
+
+
+class SessionSettings(object):
+    """Optional container class for settings to apply to a SageMaker session."""
+
+    def __init__(
+        self,
+        encrypt_repacked_artifacts=True,
+        local_download_dir=None,
+        include_jumpstart_tags=True,
+    ) -> None:
+        """Initialize the ``SessionSettings`` of a SageMaker ``Session``.
+
+        Args:
+            encrypt_repacked_artifacts (bool): Flag to indicate whether to encrypt the artifacts
+                at rest in S3 using the default AWS managed KMS key for S3 when a custom KMS key
+                is not provided (Default: True).
+            local_download_dir (str): Optional. A path specifying the local directory
+                for downloading artifacts. (Default: None).
+            include_jumpstart_tags (bool): Optional. By default, if a JumpStart model is identified,
+                it will receive special tags describing its properties.
+        """
+        self._encrypt_repacked_artifacts = encrypt_repacked_artifacts
+        self._local_download_dir = local_download_dir
+        self._include_jumpstart_tags = include_jumpstart_tags
+
+    @property
+    def encrypt_repacked_artifacts(self) -> bool:
+        """Return True if repacked artifacts at rest in S3 should be encrypted by default."""
+        return self._encrypt_repacked_artifacts
+
+    @property
+    def local_download_dir(self) -> str:
+        """Return path specifying the local directory for downloading artifacts."""
+        return self._local_download_dir
+
+    @property
+    def include_jumpstart_tags(self) -> bool:
+        """Return True if JumpStart tags should be attached to models with JumpStart artifacts."""
+        return self._include_jumpstart_tags

sagemaker/core/shapes/__init__.py

@@ -0,0 +1,3 @@
+from sagemaker.core.shapes.shapes import *
+
+from sagemaker.core.shapes.model_card_shapes import *

sagemaker/core/shapes/model_card_shapes.py

@@ -0,0 +1,159 @@
+from typing import List, Optional, Dict, Union, Literal, TYPE_CHECKING
+from pydantic import BaseModel, Field
+from enum import Enum
+
+from sagemaker.core import shapes
+from sagemaker.core.shapes import ModelDataSource
+
+if TYPE_CHECKING:
+    from sagemaker.core.shapes.shapes import BaseModel as CoreBaseModel
+
+
+class RiskRating(str, Enum):
+    HIGH = "High"
+    MEDIUM = "Medium"
+    LOW = "Low"
+    UNKNOWN = "Unknown"
+
+
+class Function(str, Enum):
+    MAXIMIZE = "Maximize"
+    MINIMIZE = "Minimize"
+
+
+class ContainersItem(BaseModel):
+    model_data_url: Optional[str] = Field(None, max_length=1024)
+    image: Optional[str] = Field(None, max_length=255)
+    nearest_model_name: Optional[str] = None
+    model_data_source: Optional[shapes.ModelDataSource] = None
+    is_checkpoint: Optional[bool] = None
+    base_model: Optional[shapes.BaseModel] = None
+
+
+class InferenceSpecification(BaseModel):
+    containers: List[ContainersItem]
+
+
+class ObjectiveFunction(BaseModel):
+    function: Optional[Function] = None
+    facet: Optional[str] = Field(None, max_length=63)
+    condition: Optional[str] = Field(None, max_length=63)
+
+
+class TrainingMetric(BaseModel):
+    name: str = Field(pattern=".{1,255}")
+    notes: Optional[str] = Field(None, max_length=1024)
+    value: float
+
+
+class TrainingEnvironment(BaseModel):
+    container_image: Optional[List[str]] = None
+
+
+class TrainingHyperParameter(BaseModel):
+    name: str = Field(pattern=".{1,255}")
+    value: Optional[str] = Field(None, pattern=".{0,255}")
+
+
+class TrainingJobDetails(BaseModel):
+    training_arn: Optional[str] = Field(None, max_length=1024)
+    training_datasets: Optional[List[str]] = None
+    training_environment: Optional[TrainingEnvironment] = None
+    training_metrics: Optional[List[TrainingMetric]] = None
+    user_provided_training_metrics: Optional[List[TrainingMetric]] = None
+    hyper_parameters: Optional[List[TrainingHyperParameter]] = None
+    user_provided_hyper_parameters: Optional[List[TrainingHyperParameter]] = None
+
+
+class TrainingDetails(BaseModel):
+    objective_function: Optional[ObjectiveFunction] = None
+    training_observations: Optional[str] = Field(None, max_length=1024)
+    training_job_details: Optional[TrainingJobDetails] = None
+
+
+class ModelOverview(BaseModel):
+    model_description: Optional[str] = Field(None, max_length=1024)
+    model_creator: Optional[str] = Field(None, max_length=1024)
+    model_artifact: Optional[List[str]] = None
+    algorithm_type: Optional[str] = Field(None, max_length=1024)
+    problem_type: Optional[str] = None
+    model_owner: Optional[str] = Field(None, max_length=1024)
+
+
+class AdditionalInformation(BaseModel):
+    ethical_considerations: Optional[str] = Field(None, max_length=2048)
+    caveats_and_recommendations: Optional[str] = Field(None, max_length=2048)
+    custom_details: Optional[Dict[str, str]] = None
+
+
+class SimpleMetric(BaseModel):
+    name: str = Field(pattern=".{1,255}")
+    notes: Optional[str] = Field(None, max_length=1024)
+    type: Literal["number", "string", "boolean"] = None
+    value: Union[float, str, bool]
+    x_axis_name: Optional[str] = None
+    y_axis_name: Optional[str] = None
+
+
+class BarChartMetric(BaseModel):
+    name: str = Field(pattern=".{1,255}")
+    notes: Optional[str] = Field(None, max_length=1024)
+    type: Literal["bar_chart"] = None
+    value: List
+    x_axis_name: Optional[List[str]] = None
+    y_axis_name: Optional[str] = None
+
+
+class LinearGraphMetric(BaseModel):
+    name: str = Field(pattern=".{1,255}")
+    notes: Optional[str] = Field(None, max_length=1024)
+    type: Literal["linear_graph"] = None
+    value: List
+    x_axis_name: Optional[str] = None
+    y_axis_name: Optional[str] = None
+
+
+class MatrixMetric(BaseModel):
+    name: str = Field(pattern=".{1,255}")
+    notes: Optional[str] = Field(None, max_length=1024)
+    type: Literal["matrix"] = None
+    value: List
+    x_axis_name: Optional[List[str]] = None
+    y_axis_name: Optional[List[str]] = None
+
+
+class MetricGroupsItem(BaseModel):
+    name: str = Field(pattern=".{1,63}")
+    metric_data: List[Union[SimpleMetric, LinearGraphMetric, BarChartMetric, MatrixMetric]]
+
+
+class EvaluationDetailsItem(BaseModel):
+    name: str = Field(pattern=".{1,63}")
+    evaluation_observation: Optional[str] = Field(None, max_length=2096)
+    evaluation_job_arn: Optional[str] = Field(None, max_length=256)
+    datasets: Optional[List[str]] = Field(None, max_length=10)
+    metadata: Optional[Dict[str, str]] = None
+    metric_groups: Optional[List[MetricGroupsItem]] = Field(default_factory=list)
+
+
+class IntendedUses(BaseModel):
+    purpose_of_model: Optional[str] = Field(None, max_length=2048)
+    intended_uses: Optional[str] = Field(None, max_length=2048)
+    factors_affecting_model_efficiency: Optional[str] = Field(None, max_length=2048)
+    risk_rating: Optional[RiskRating] = None
+    explanations_for_risk_rating: Optional[str] = Field(None, max_length=2048)
+
+
+class BusinessDetails(BaseModel):
+    business_problem: Optional[str] = Field(None, max_length=2048)
+    business_stakeholders: Optional[str] = Field(None, max_length=2048)
+    line_of_business: Optional[str] = Field(None, max_length=2048)
+
+
+class ModelCardContent(BaseModel):
+    model_overview: Optional[ModelOverview] = None
+    intended_uses: Optional[IntendedUses] = None
+    business_details: Optional[BusinessDetails] = None
+    training_details: Optional[TrainingDetails] = None
+    evaluation_details: Optional[List[EvaluationDetailsItem]] = Field(default_factory=list)
+    additional_information: Optional[AdditionalInformation] = None