aws-cdk-neuronx-patterns 0.0.2 → 0.0.4

package/lib/private/await-compile-job/index.js

@@ -48,7 +48,7 @@ const isComplete = async (event) => {
             return {
                 IsComplete: true,
                 Data: {
-                    ArtifactS3Url: event.ResourceProperties.artifactS3Url,
+                    ArtifactS3Prefix: event.ResourceProperties.artifactS3Prefix,
                 },
             };
         case "FAILED":
@@ -59,4 +59,4 @@ const isComplete = async (event) => {
     };
 };
 exports.isComplete = isComplete;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/private/util.d.ts

@@ -0,0 +1,2 @@
+import { CompileOptions, Parameters } from "../model";
+export declare function calcTpDegree(parameters: Parameters, compileOptions: CompileOptions): number;

package/lib/private/util.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calcTpDegree = void 0;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const model_1 = require("../model");
+function calcTpDegree(parameters, compileOptions) {
+    // case of float16
+    const bytesPerParamete = 16 / 8;
+    // memory = bytes per parameter * number of parameters
+    let memory = aws_cdk_lib_1.Size.gibibytes(bytesPerParamete * parameters.toBilion());
+    switch (compileOptions.quantDtype) {
+        case model_1.QuantDtype.S8:
+            memory = aws_cdk_lib_1.Size.gibibytes(Math.floor(memory.toGibibytes() * 0.7));
+            break;
+    }
+    if (compileOptions.nPositions && compileOptions.nPositions < 4096) {
+        memory = aws_cdk_lib_1.Size.gibibytes(memory.toGibibytes() -
+            Math.floor((compileOptions.nPositions / 4096) * 0.1));
+    }
+    const neronxCoreMemory = aws_cdk_lib_1.Size.gibibytes(16);
+    const minimum = Math.ceil(memory.toGibibytes() / neronxCoreMemory.toGibibytes());
+    const tpDegrees = [1, 2, 4, 8, 24];
+    for (const tpDegree of tpDegrees) {
+        if (minimum <= tpDegree) {
+            return tpDegree;
+        }
+    }
+    throw new Error("This model is too large, I can not support this model current version.");
+}
+exports.calcTpDegree = calcTpDegree;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/transformers-neuronx-sagemaker-realtime-inference.d.ts

@@ -0,0 +1,113 @@
+import * as sagemaker from "@aws-cdk/aws-sagemaker-alpha";
+import { Duration, Size } from "aws-cdk-lib";
+import { Grant, IGrantable } from "aws-cdk-lib/aws-iam";
+import { IBucket } from "aws-cdk-lib/aws-s3";
+import { ISource } from "aws-cdk-lib/aws-s3-deployment";
+import { Construct } from "constructs";
+import { CompileOptions, OptLevel, Parameters, QuantDtype } from "./model";
+import { NeuronxCompile } from "./neuronx-compile";
+import { NeuronxInstanceType } from "./neuronx-instance-type";
+/**
+ * Precompiled model options.
+ */
+export interface CompiledModelOptions {
+    /**
+     * Neuronx compile options.
+     * @default - Each properties are set default.
+     */
+    readonly compileOptions?: CompileOptions;
+    /**
+     * Code used for inference
+     * @default - using the predefined code
+     */
+    readonly code?: ISource;
+    /**
+     * Model ID or saved path
+     * @default "./model"
+     */
+    readonly modelIdOrPath?: string;
+    /**
+     * The path where compiled artifacts (i.e. xxx.neff) are stored
+     * @default "./compiled"
+     */
+    readonly compiledArtifactPath?: string;
+}
+export interface BucketCompiledModelOptions extends CompiledModelOptions {
+    /**
+     * The number of parameters of model.
+     */
+    readonly parameters: Parameters;
+}
+export declare class TransformersNeuronxSageMakerInferenceModelData {
+    static fromBucket(bucket: IBucket, prefix: string, options: BucketCompiledModelOptions): TransformersNeuronxSageMakerInferenceModelData;
+    static fromNeuronxCompile(compile: NeuronxCompile, code?: ISource): TransformersNeuronxSageMakerInferenceModelData;
+    readonly bucket: IBucket;
+    readonly compiledArtifactS3Prefix: string;
+    readonly code: ISource;
+    readonly tpDegree: number;
+    readonly quantDtype?: QuantDtype;
+    readonly nPositions: number;
+    readonly optLevel: OptLevel;
+    readonly modelIdOrPath?: string;
+    readonly compiledArtifactPath?: string;
+    readonly parameters: Parameters;
+    private constructor();
+}
+export interface TransformersNeuronxSageMakerRealtimeInferenceEndpointProps {
+    /**
+     * Model data for SageMaker inference.
+     * The model data requires at least compiled artifacts.
+     */
+    readonly modelData: TransformersNeuronxSageMakerInferenceModelData;
+    /**
+     * An image of the container where the inference job is executed.
+     */
+    readonly image?: sagemaker.ContainerImage;
+    /**
+     * A map of environment variables to pass into the container.
+     * @default - Only the predefined environment variables required to use Neuronx have been set.
+     */
+    readonly environment?: {
+        [key: string]: string;
+    };
+    /**
+     * The instance type of compile worker instance.
+     * @default - It is determined automatically according to the number of model parameters and compilation options.
+     */
+    readonly instanceType?: NeuronxInstanceType;
+    /**
+     * The size, of the ML storage volume attached to individual inference instance associated with the production variant.
+     * Currently only Amazon EBS gp2 storage volumes are supported.
+     * @see https://aws.amazon.com/jp/releasenotes/host-instance-storage-volumes-table
+     * @default - 2.5 GB per billion parameter (Max 512 GB)
+     */
+    readonly volumeSize?: Size;
+    /**
+     * The timeout value, to download and extract the model that you want to host from Amazon S3
+     * to the individual inference instance associated with this production variant.
+     * @default - 60 seconds, when `volumeSize` larger than 30GB then 1GB x 15 seconds (max 60 minutes)
+     */
+    readonly modelDataDownloadTimeout?: Duration;
+    /**
+     * The timeout value, for your inference container to pass health check by SageMaker Hosting.
+     * @see https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-inference-code.html#your-algorithms-inference-algo-ping-requests
+     * @default - 60 seconds, when set the `modelDataDownloadTimeout` then use same value (max 60 minutes)
+     */
+    readonly containerStartupHealthCheckTimeout?: Duration;
+}
+export declare class TransformersNeuronxSageMakerRealtimeInferenceEndpoint extends Construct {
+    /**
+     * The ARN of the endpoint.
+     * @attribute
+     */
+    readonly endpointArn: string;
+    /**
+     * The name of the endpoint.
+     * @attribute
+     */
+    readonly endpointName: string;
+    private readonly endpoint;
+    constructor(scope: Construct, id: string, props: TransformersNeuronxSageMakerRealtimeInferenceEndpointProps);
+    grantInvoke(grantee: IGrantable): Grant;
+    private selectInstanceTypeByTpDegree;
+}

package/lib/transformers-neuronx-sagemaker-realtime-inference.js

@@ -0,0 +1,150 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransformersNeuronxSageMakerRealtimeInferenceEndpoint = exports.TransformersNeuronxSageMakerInferenceModelData = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const path_1 = require("path");
+const sagemaker = require("@aws-cdk/aws-sagemaker-alpha");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_s3_deployment_1 = require("aws-cdk-lib/aws-s3-deployment");
+const constructs_1 = require("constructs");
+const model_1 = require("./model");
+const neuronx_instance_type_1 = require("./neuronx-instance-type");
+const util_1 = require("./private/util");
+class TransformersNeuronxSageMakerInferenceModelData {
+    static fromBucket(bucket, prefix, options) {
+        const nPositions = options.compileOptions?.nPositions ?? 4096;
+        const quantDtype = options.compileOptions?.quantDtype;
+        const optLevel = options.compileOptions?.optLevel ?? model_1.OptLevel.BEST_BALANCE;
+        const tpDegree = options.compileOptions?.tpDegree ??
+            (0, util_1.calcTpDegree)(options.parameters, {
+                nPositions,
+                quantDtype,
+            });
+        return new TransformersNeuronxSageMakerInferenceModelData({
+            bucket,
+            compiledArtifactS3Prefix: prefix,
+            nPositions,
+            quantDtype,
+            optLevel,
+            tpDegree,
+            code: options.code,
+            modelIdOrPath: options.modelIdOrPath,
+            parameters: options.parameters,
+        });
+    }
+    static fromNeuronxCompile(compile, code) {
+        return new TransformersNeuronxSageMakerInferenceModelData({
+            ...compile,
+            bucket: compile.compiledArtifactS3Bucket,
+            compiledArtifactS3Prefix: compile.compiledArtifactS3Prefix,
+            code,
+        });
+    }
+    constructor(options) {
+        this.bucket = options.bucket;
+        this.compiledArtifactS3Prefix = options.compiledArtifactS3Prefix;
+        this.code =
+            options.code ??
+                aws_s3_deployment_1.Source.asset((0, path_1.join)(__dirname, "../scripts/inference/transformers-neuronx/code"));
+        this.tpDegree = options.tpDegree;
+        this.quantDtype = options.quantDtype;
+        this.nPositions = options.nPositions;
+        this.optLevel = options.optLevel;
+        this.modelIdOrPath = options.modelIdOrPath;
+        this.compiledArtifactPath = options.compiledArtifactPath;
+        this.parameters = options.parameters;
+    }
+}
+exports.TransformersNeuronxSageMakerInferenceModelData = TransformersNeuronxSageMakerInferenceModelData;
+_a = JSII_RTTI_SYMBOL_1;
+TransformersNeuronxSageMakerInferenceModelData[_a] = { fqn: "aws-cdk-neuronx-patterns.TransformersNeuronxSageMakerInferenceModelData", version: "0.0.4" };
+class TransformersNeuronxSageMakerRealtimeInferenceEndpoint extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const image = props.image ??
+            sagemaker.ContainerImage.fromAsset((0, path_1.join)(__dirname, "../scripts/inference/transformers-neuronx"));
+        const instanceType = props.instanceType ??
+            this.selectInstanceTypeByTpDegree(props.modelData.tpDegree);
+        const deploy = new aws_s3_deployment_1.BucketDeployment(this, "CodeDeployment", {
+            destinationBucket: props.modelData.bucket,
+            sources: [props.modelData.code],
+            destinationKeyPrefix: (0, path_1.join)(props.modelData.compiledArtifactS3Prefix, "code"),
+        });
+        const model = new sagemaker.Model(this, "Model", {
+            containers: [
+                {
+                    image,
+                    environment: {
+                        NEURON_RT_NUM_CORES: props.modelData.tpDegree.toString(),
+                        TS_DEFAULT_RESPONSE_TIMEOUT: (60 * 60).toString(),
+                        TS_DEFAULT_WORKERS_PER_MODEL: Math.floor(instanceType.acceleratorChips.neuronxCores /
+                            props.modelData.tpDegree).toString(),
+                        MODEL: props.modelData.modelIdOrPath ?? "./model",
+                        COMPILED_ARTIFACT: props.modelData.compiledArtifactPath ?? "./compiled",
+                        TP_DEGREE: props.modelData.tpDegree.toString(),
+                        N_POSITIONS: props.modelData.nPositions.toString(),
+                        OPT_LEVEL: props.modelData.optLevel.toString(),
+                        QUANT_DTYPE: props.modelData.quantDtype?.toString() ?? "",
+                        ...props.environment,
+                    },
+                },
+            ],
+        });
+        const cfnModel = model.node.findChild("Model");
+        cfnModel.addPropertyOverride("PrimaryContainer.ModelDataSource.S3DataSource.S3Uri", props.modelData.bucket.s3UrlForObject(props.modelData.compiledArtifactS3Prefix));
+        cfnModel.addPropertyOverride("PrimaryContainer.ModelDataSource.S3DataSource.S3DataType", "S3Prefix");
+        cfnModel.addPropertyOverride("PrimaryContainer.ModelDataSource.S3DataSource.CompressionType", "None");
+        props.modelData.bucket.grantRead(model);
+        model.node.addDependency(deploy);
+        const endpointConfig = new sagemaker.EndpointConfig(this, "EndpointConfig", {
+            instanceProductionVariants: [
+                {
+                    model,
+                    variantName: "PrimaryVariant",
+                    instanceType: sagemaker.InstanceType.of(instanceType.toString()),
+                },
+            ],
+        });
+        const cfnEndpointConfig = endpointConfig.node.findChild("EndpointConfig");
+        const volumeSize = aws_cdk_lib_1.Size.gibibytes(props.volumeSize?.toGibibytes() ??
+            (props.modelData.parameters.toBilion() * 2.5 > 512
+                ? 512
+                : props.modelData.parameters.toBilion() * 2.5));
+        cfnEndpointConfig.addPropertyOverride("ProductionVariants.0.VolumeSizeInGB", volumeSize.toGibibytes());
+        const modelDataDownloadTimeout = props.modelDataDownloadTimeout ??
+            inferenceModelDataDownloadTime(volumeSize);
+        cfnEndpointConfig.addPropertyOverride("ProductionVariants.0.ModelDataDownloadTimeoutInSeconds", modelDataDownloadTimeout.toSeconds());
+        cfnEndpointConfig.addPropertyOverride("ProductionVariants.0.ContainerStartupHealthCheckTimeoutInSeconds", (props.containerStartupHealthCheckTimeout ?? modelDataDownloadTimeout).toSeconds());
+        const endpoint = new sagemaker.Endpoint(this, "Endpoint", {
+            endpointConfig,
+        });
+        this.endpointArn = endpoint.endpointArn;
+        this.endpointName = endpoint.endpointName;
+        this.endpoint = endpoint;
+    }
+    grantInvoke(grantee) {
+        return this.endpoint.grantInvoke(grantee);
+    }
+    selectInstanceTypeByTpDegree(tpDegree) {
+        const instanceTypes = [
+            neuronx_instance_type_1.NeuronxInstanceType.INF2_8XLARGE,
+            neuronx_instance_type_1.NeuronxInstanceType.INF2_24XLARGE,
+            neuronx_instance_type_1.NeuronxInstanceType.INF2_48XLARGE,
+        ];
+        for (const instanceType of instanceTypes) {
+            if (tpDegree <= instanceType.acceleratorChips.neuronxCores) {
+                return instanceType;
+            }
+        }
+        throw new Error("This model is too large, I can not support this model current version.");
+    }
+}
+exports.TransformersNeuronxSageMakerRealtimeInferenceEndpoint = TransformersNeuronxSageMakerRealtimeInferenceEndpoint;
+_b = JSII_RTTI_SYMBOL_1;
+TransformersNeuronxSageMakerRealtimeInferenceEndpoint[_b] = { fqn: "aws-cdk-neuronx-patterns.TransformersNeuronxSageMakerRealtimeInferenceEndpoint", version: "0.0.4" };
+function inferenceModelDataDownloadTime(volumeSize) {
+    const seconds = volumeSize.toGibibytes() * 15;
+    return aws_cdk_lib_1.Duration.seconds(seconds < 3600 ? seconds : 3600);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transformers-neuronx-sagemaker-realtime-inference.js","sourceRoot":"","sources":["../src/transformers-neuronx-sagemaker-realtime-inference.ts"],"names":[],"mappings":"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","sourcesContent":["import { join } from \"path\";\nimport * as sagemaker from \"@aws-cdk/aws-sagemaker-alpha\";\nimport { Duration, Size } from \"aws-cdk-lib\";\nimport { Grant, IGrantable } from \"aws-cdk-lib/aws-iam\";\nimport { IBucket } from \"aws-cdk-lib/aws-s3\";\nimport {\n  BucketDeployment,\n  ISource,\n  Source,\n} from \"aws-cdk-lib/aws-s3-deployment\";\nimport { CfnEndpointConfig, CfnModel } from \"aws-cdk-lib/aws-sagemaker\";\nimport { Construct } from \"constructs\";\nimport { CompileOptions, OptLevel, Parameters, QuantDtype } from \"./model\";\nimport { NeuronxCompile } from \"./neuronx-compile\";\nimport { NeuronxInstanceType } from \"./neuronx-instance-type\";\nimport { calcTpDegree } from \"./private/util\";\n\n/**\n * Precompiled model options.\n */\nexport interface CompiledModelOptions {\n  /**\n   * Neuronx compile options.\n   * @default - Each properties are set default.\n   */\n  readonly compileOptions?: CompileOptions;\n  /**\n   * Code used for inference\n   * @default - using the predefined code\n   */\n  readonly code?: ISource;\n  /**\n   * Model ID or saved path\n   * @default \"./model\"\n   */\n  readonly modelIdOrPath?: string;\n  /**\n   * The path where compiled artifacts (i.e. xxx.neff) are stored\n   * @default \"./compiled\"\n   */\n  readonly compiledArtifactPath?: string;\n}\n\nexport interface BucketCompiledModelOptions extends CompiledModelOptions {\n  /**\n   * The number of parameters of model.\n   */\n  readonly parameters: Parameters;\n}\n\nexport class TransformersNeuronxSageMakerInferenceModelData {\n  static fromBucket(\n    bucket: IBucket,\n    prefix: string,\n    options: BucketCompiledModelOptions,\n  ) {\n    const nPositions = options.compileOptions?.nPositions ?? 4096;\n    const quantDtype = options.compileOptions?.quantDtype;\n    const optLevel = options.compileOptions?.optLevel ?? OptLevel.BEST_BALANCE;\n    const tpDegree =\n      options.compileOptions?.tpDegree ??\n      calcTpDegree(options.parameters, {\n        nPositions,\n        quantDtype,\n      });\n    return new TransformersNeuronxSageMakerInferenceModelData({\n      bucket,\n      compiledArtifactS3Prefix: prefix,\n      nPositions,\n      quantDtype,\n      optLevel,\n      tpDegree,\n      code: options.code,\n      modelIdOrPath: options.modelIdOrPath,\n      parameters: options.parameters,\n    });\n  }\n  static fromNeuronxCompile(compile: NeuronxCompile, code?: ISource) {\n    return new TransformersNeuronxSageMakerInferenceModelData({\n      ...compile,\n      bucket: compile.compiledArtifactS3Bucket,\n      compiledArtifactS3Prefix: compile.compiledArtifactS3Prefix,\n      code,\n    });\n  }\n  readonly bucket: IBucket;\n  readonly compiledArtifactS3Prefix: string;\n  readonly code: ISource;\n  readonly tpDegree: number;\n  readonly quantDtype?: QuantDtype;\n  readonly nPositions: number;\n  readonly optLevel: OptLevel;\n  readonly modelIdOrPath?: string;\n  readonly compiledArtifactPath?: string;\n  readonly parameters: Parameters;\n\n  private constructor(options: {\n    readonly bucket: IBucket;\n    readonly compiledArtifactS3Prefix: string;\n    readonly tpDegree: number;\n    readonly quantDtype?: QuantDtype;\n    readonly nPositions: number;\n    readonly optLevel: OptLevel;\n    readonly code?: ISource;\n    readonly modelIdOrPath?: string;\n    readonly compiledArtifactPath?: string;\n    readonly parameters: Parameters;\n  }) {\n    this.bucket = options.bucket;\n    this.compiledArtifactS3Prefix = options.compiledArtifactS3Prefix;\n    this.code =\n      options.code ??\n      Source.asset(\n        join(__dirname, \"../scripts/inference/transformers-neuronx/code\"),\n      );\n    this.tpDegree = options.tpDegree;\n    this.quantDtype = options.quantDtype;\n    this.nPositions = options.nPositions;\n    this.optLevel = options.optLevel;\n    this.modelIdOrPath = options.modelIdOrPath;\n    this.compiledArtifactPath = options.compiledArtifactPath;\n    this.parameters = options.parameters;\n  }\n}\n\nexport interface TransformersNeuronxSageMakerRealtimeInferenceEndpointProps {\n  /**\n   * Model data for SageMaker inference.\n   * The model data requires at least compiled artifacts.\n   */\n  readonly modelData: TransformersNeuronxSageMakerInferenceModelData;\n  /**\n   * An image of the container where the inference job is executed.\n   */\n  readonly image?: sagemaker.ContainerImage;\n  /**\n   * A map of environment variables to pass into the container.\n   * @default - Only the predefined environment variables required to use Neuronx have been set.\n   */\n  readonly environment?: { [key: string]: string };\n  /**\n   * The instance type of compile worker instance.\n   * @default - It is determined automatically according to the number of model parameters and compilation options.\n   */\n  readonly instanceType?: NeuronxInstanceType;\n  /**\n   * The size, of the ML storage volume attached to individual inference instance associated with the production variant.\n   * Currently only Amazon EBS gp2 storage volumes are supported.\n   * @see https://aws.amazon.com/jp/releasenotes/host-instance-storage-volumes-table\n   * @default - 2.5 GB per billion parameter (Max 512 GB)\n   */\n  readonly volumeSize?: Size;\n  /**\n   * The timeout value, to download and extract the model that you want to host from Amazon S3\n   * to the individual inference instance associated with this production variant.\n   * @default - 60 seconds, when `volumeSize` larger than 30GB then 1GB x 15 seconds (max 60 minutes)\n   */\n  readonly modelDataDownloadTimeout?: Duration;\n  /**\n   * The timeout value, for your inference container to pass health check by SageMaker Hosting.\n   * @see https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-inference-code.html#your-algorithms-inference-algo-ping-requests\n   * @default - 60 seconds, when set the `modelDataDownloadTimeout` then use same value (max 60 minutes)\n   */\n  readonly containerStartupHealthCheckTimeout?: Duration;\n}\n\nexport class TransformersNeuronxSageMakerRealtimeInferenceEndpoint extends Construct {\n  /**\n   * The ARN of the endpoint.\n   * @attribute\n   */\n  readonly endpointArn: string;\n  /**\n   * The name of the endpoint.\n   * @attribute\n   */\n  readonly endpointName: string;\n  private readonly endpoint: sagemaker.Endpoint;\n  constructor(\n    scope: Construct,\n    id: string,\n    props: TransformersNeuronxSageMakerRealtimeInferenceEndpointProps,\n  ) {\n    super(scope, id);\n    const image =\n      props.image ??\n      sagemaker.ContainerImage.fromAsset(\n        join(__dirname, \"../scripts/inference/transformers-neuronx\"),\n      );\n    const instanceType =\n      props.instanceType ??\n      this.selectInstanceTypeByTpDegree(props.modelData.tpDegree);\n    const deploy = new BucketDeployment(this, \"CodeDeployment\", {\n      destinationBucket: props.modelData.bucket,\n      sources: [props.modelData.code],\n      destinationKeyPrefix: join(\n        props.modelData.compiledArtifactS3Prefix,\n        \"code\",\n      ),\n    });\n    const model = new sagemaker.Model(this, \"Model\", {\n      containers: [\n        {\n          image,\n          environment: {\n            NEURON_RT_NUM_CORES: props.modelData.tpDegree.toString(),\n            TS_DEFAULT_RESPONSE_TIMEOUT: (60 * 60).toString(),\n            TS_DEFAULT_WORKERS_PER_MODEL: Math.floor(\n              instanceType.acceleratorChips.neuronxCores /\n                props.modelData.tpDegree,\n            ).toString(),\n            MODEL: props.modelData.modelIdOrPath ?? \"./model\",\n            COMPILED_ARTIFACT:\n              props.modelData.compiledArtifactPath ?? \"./compiled\",\n            TP_DEGREE: props.modelData.tpDegree.toString(),\n            N_POSITIONS: props.modelData.nPositions.toString(),\n            OPT_LEVEL: props.modelData.optLevel.toString(),\n            QUANT_DTYPE: props.modelData.quantDtype?.toString() ?? \"\",\n            ...props.environment,\n          },\n        },\n      ],\n    });\n    const cfnModel = model.node.findChild(\"Model\") as CfnModel;\n    cfnModel.addPropertyOverride(\n      \"PrimaryContainer.ModelDataSource.S3DataSource.S3Uri\",\n      props.modelData.bucket.s3UrlForObject(\n        props.modelData.compiledArtifactS3Prefix,\n      ),\n    );\n    cfnModel.addPropertyOverride(\n      \"PrimaryContainer.ModelDataSource.S3DataSource.S3DataType\",\n      \"S3Prefix\",\n    );\n    cfnModel.addPropertyOverride(\n      \"PrimaryContainer.ModelDataSource.S3DataSource.CompressionType\",\n      \"None\",\n    );\n    props.modelData.bucket.grantRead(model);\n    model.node.addDependency(deploy);\n    const endpointConfig = new sagemaker.EndpointConfig(\n      this,\n      \"EndpointConfig\",\n      {\n        instanceProductionVariants: [\n          {\n            model,\n            variantName: \"PrimaryVariant\",\n            instanceType: sagemaker.InstanceType.of(instanceType.toString()),\n          },\n        ],\n      },\n    );\n    const cfnEndpointConfig = endpointConfig.node.findChild(\n      \"EndpointConfig\",\n    ) as CfnEndpointConfig;\n    const volumeSize = Size.gibibytes(\n      props.volumeSize?.toGibibytes() ??\n        (props.modelData.parameters.toBilion() * 2.5 > 512\n          ? 512\n          : props.modelData.parameters.toBilion() * 2.5),\n    );\n    cfnEndpointConfig.addPropertyOverride(\n      \"ProductionVariants.0.VolumeSizeInGB\",\n      volumeSize.toGibibytes(),\n    );\n    const modelDataDownloadTimeout =\n      props.modelDataDownloadTimeout ??\n      inferenceModelDataDownloadTime(volumeSize);\n    cfnEndpointConfig.addPropertyOverride(\n      \"ProductionVariants.0.ModelDataDownloadTimeoutInSeconds\",\n      modelDataDownloadTimeout.toSeconds(),\n    );\n    cfnEndpointConfig.addPropertyOverride(\n      \"ProductionVariants.0.ContainerStartupHealthCheckTimeoutInSeconds\",\n      (\n        props.containerStartupHealthCheckTimeout ?? modelDataDownloadTimeout\n      ).toSeconds(),\n    );\n    const endpoint = new sagemaker.Endpoint(this, \"Endpoint\", {\n      endpointConfig,\n    });\n    this.endpointArn = endpoint.endpointArn;\n    this.endpointName = endpoint.endpointName;\n    this.endpoint = endpoint;\n  }\n  grantInvoke(grantee: IGrantable): Grant {\n    return this.endpoint.grantInvoke(grantee);\n  }\n\n  private selectInstanceTypeByTpDegree(tpDegree: number) {\n    const instanceTypes = [\n      NeuronxInstanceType.INF2_8XLARGE,\n      NeuronxInstanceType.INF2_24XLARGE,\n      NeuronxInstanceType.INF2_48XLARGE,\n    ];\n    for (const instanceType of instanceTypes) {\n      if (tpDegree <= instanceType.acceleratorChips.neuronxCores) {\n        return instanceType;\n      }\n    }\n    throw new Error(\n      \"This model is too large, I can not support this model current version.\",\n    );\n  }\n}\n\nfunction inferenceModelDataDownloadTime(volumeSize: Size) {\n  const seconds = volumeSize.toGibibytes() * 15;\n  return Duration.seconds(seconds < 3600 ? seconds : 3600);\n}\n"]}

package/package.json

@@ -38,8 +38,8 @@
   "devDependencies": {
     "@aws-cdk/integ-runner": "2.149.0-alpha.0",
     "@aws-cdk/integ-tests-alpha": "2.149.0-alpha.0",
-    "@aws-sdk/client-batch": "^3.616.0",
-    "@types/aws-lambda": "^8.10.141",
+    "@aws-sdk/client-batch": "^3.620.0",
+    "@types/aws-lambda": "^8.10.142",
     "@types/jest": "^29.5.12",
     "@types/node": "^18",
     "@typescript-eslint/eslint-plugin": "^7",
@@ -60,16 +60,20 @@
     "jsii-pacmak": "^1.101.0",
     "jsii-rosetta": "~5.4.0",
     "prettier": "^3.3.3",
-    "projen": "^0.84.6",
+    "projen": "^0.84.10",
     "standard-version": "^9",
     "ts-jest": "^29.2.3",
     "ts-node": "^10.9.2",
-    "typescript": "^5.5.3"
+    "typescript": "^5.5.4"
   },
   "peerDependencies": {
+    "@aws-cdk/aws-sagemaker-alpha": "2.149.0-alpha.0",
     "aws-cdk-lib": "^2.149.0",
     "constructs": "^10.0.5"
   },
+  "dependencies": {
+    "@aws-cdk/aws-sagemaker-alpha": "2.149.0-alpha.0"
+  },
   "keywords": [
     "cdk",
     "neuronx"
@@ -87,7 +91,7 @@
       ]
     }
   },
-  "version": "0.0.2",
+  "version": "0.0.4",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [

package/scripts/compile/Dockerfile

@@ -0,0 +1,10 @@
+FROM public.ecr.aws/neuron/pytorch-inference-neuronx:2.1.2-neuronx-py310-sdk2.19.1-ubuntu20.04
+
+# https://repost.aws/it/questions/QU2l9P6ZEhSkSL0lFQonOHfQ/a-lambda-failed-to-start-with-the-error-cannot-import-name-is-s3express-bucket-from-botocore-utils
+RUN pip install -U boto3==1.34.151 botocore==1.34.151
+COPY compile.py /usr/local/bin/compile.py
+COPY entrypoint.sh /usr/local/bin/entrypoint.sh
+RUN chmod +x /usr/local/bin/compile.py \
+ && chmod +x /usr/local/bin/entrypoint.sh
+
+ENTRYPOINT [ "bash", "-m", "entrypoint.sh"]

package/scripts/compile/entrypoint.sh

@@ -0,0 +1,9 @@
+curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | bash &&
+apt-get install git-lfs &&
+git lfs install &&
+git clone https://huggingface.co/${MODEL_ID} model &&
+rm -rf model/.git &&
+python /usr/local/bin/compile.py &&
+aws s3 sync --no-progress ./model ${ARTIFACT_S3_URL}/model &&
+aws s3 sync --no-progress ./compiled ${ARTIFACT_S3_URL}/compiled &&
+echo 'compile completed'

package/scripts/inference/transformers-neuronx/Dockerfile

@@ -0,0 +1 @@
+FROM public.ecr.aws/neuron/pytorch-inference-neuronx:2.1.2-neuronx-py310-sdk2.19.1-ubuntu20.04

package/scripts/inference/transformers-neuronx/code/inference.py

@@ -0,0 +1,63 @@
+import json
+import os
+from typing import Tuple
+import torch
+from transformers import AutoTokenizer, PreTrainedTokenizer, PreTrainedTokenizerFast
+from transformers_neuronx import NeuronAutoModelForCausalLM
+from transformers_neuronx.config import NeuronConfig, QuantizationConfig
+
+model_path = os.environ['MODEL']
+compiled_artifact_path = os.environ['COMPILED_ARTIFACT']
+batch_size = 1
+tp_degree = int(os.environ['TP_DEGREE'])
+amp = "bf16"
+quant_dtype = os.getenv('QUANT_DTYPE')
+n_positions = int(os.environ['N_POSITIONS'])
+opt_level = int(os.getenv('OPT_LEVEL', "2"))
+sequence_length = int(os.getenv('SEQUENCE_LENGTH', n_positions))
+top_k = int(os.getenv('TOP_K', 50))
+
+def model_fn(model_dir, context=None):
+    tokenizer = AutoTokenizer.from_pretrained(model_path)
+    neuron_config = NeuronConfig(
+        quant=QuantizationConfig(quant_dtype=quant_dtype, dequant_dtype='bf16') if quant_dtype is not None and quant_dtype != '' else None,
+    )
+    os.environ['NEURON_CC_FLAGS'] = f"--enable-saturate-infinity --enable-mixed-precision-accumulation --optlevel {opt_level}"
+    model = NeuronAutoModelForCausalLM.from_pretrained(
+        model_path,  # Should reference the split checkpoint produced by "save_pretrained_split"
+        batch_size=batch_size,           # Batch size must be determined prior to inference time.
+        tp_degree=tp_degree,            # Controls the number of NeuronCores to execute on. Change to 32 for trn1.32xlarge
+        amp=amp,              # This automatically casts the weights to the specified dtype.
+        n_positions=n_positions,
+        neuron_config=neuron_config,
+    )
+    model.load(compiled_artifact_path)
+    model.to_neuron()
+    print('Load complete!')
+    return model, tokenizer
+
+
+def input_fn(data, content_type, context=None):
+    if content_type != 'application/json':
+        raise TypeError('content_type is only allowed application/json')
+    return json.loads(data)
+
+
+def predict_fn(data: dict, model_and_tokenizer: Tuple[NeuronAutoModelForCausalLM, PreTrainedTokenizer | PreTrainedTokenizerFast], context=None):
+    model, tokenizer = model_and_tokenizer
+    with torch.inference_mode():
+        raw_prompt = tokenizer.apply_chat_template(conversation=data["messages"], tokenize=False, add_generation_prompt=True)
+        if 'role' in data and data["role"] != '':
+            raw_prompt = raw_prompt.replace("assistant", data["role"])
+        input_ids = tokenizer.encode(raw_prompt, add_special_tokens=False, return_tensors="pt")
+        generated_sequences = model.sample(input_ids, sequence_length=sequence_length, top_k=top_k)
+        generated_sequences = [tokenizer.decode(seq) for seq in generated_sequences]
+        prompt = [tokenizer.decode(seq) for seq in input_ids][0]
+        response = generated_sequences[0].replace(prompt, "").replace(tokenizer.eos_token, "")
+        return response.strip()
+
+
+def output_fn(data, content_type, context=None):
+    if content_type != 'application/json':
+        raise TypeError('content_type is only allowed application/json')
+    return json.dumps({'generated_text' : data})

package/scripts/inference/transformers-neuronx/code/requirements.txt

@@ -0,0 +1 @@
+Jinja2==3.1.3