aws-cdk-neuronx-patterns 0.0.0

package/lib/neuronx-compile.d.ts

@@ -0,0 +1,166 @@
+import { Size } from "aws-cdk-lib";
+import * as ec2 from "aws-cdk-lib/aws-ec2";
+import { ContainerImage } from "aws-cdk-lib/aws-ecs";
+import { IBucket } from "aws-cdk-lib/aws-s3";
+import { Construct } from "constructs";
+import { NeuronxInstanceType } from "./neuronx-instance-type";
+/**
+ * Compile runtime.
+ */
+export interface CompileRuntime {
+    /**
+     * An image of the container where the compile job is executed.
+     */
+    readonly image: ContainerImage;
+    /**
+     * Neuronx version included in container image.
+     */
+    readonly neuronxVersion: string;
+}
+/**
+ * Quant data type.
+ */
+export declare enum QuantDtype {
+    /**
+     * int8 weight storage.
+     */
+    S8 = "s8"
+}
+/**
+ * Optimization level.
+ */
+export declare enum OptLevel {
+    /**
+     * enables the core performance optimizations in the compiler, while also minimizing compile time.
+     */
+    MINIMIZING_COMPILE_TIME = 1,
+    /**
+     * provides the best balance between model performance and compile time.
+     */
+    BEST_BALANCE = 2,
+    /**
+     * may provide additional model execution performance but may incur longer compile times and higher host memory usage during model compilation.
+     */
+    MODEL_EXECUTION_PERFORMANCE = 3
+}
+/**
+ * Compile options.
+ */
+export interface CompileOptions {
+    /**
+     * @default - calc from parameters and quantDtype
+     */
+    readonly tpDegree?: number;
+    /**
+     * @default - No quant
+     */
+    readonly quantDtype?: QuantDtype;
+    /**
+     * @default 4092
+     */
+    readonly nPositions?: number;
+    /**
+     * @default OptLevel.BEST_BALANCE
+     */
+    readonly optLevel?: OptLevel;
+}
+/**
+ * Represents the amount of parameters.
+ */
+export declare class Parameters {
+    private readonly billion;
+    /**
+     * Create a Parameters representing an amount bilion.
+     * @param parameters number of parameters bilionX
+     * @returns parameters
+     */
+    static billion(parameters: number): Parameters;
+    private constructor();
+    /**
+     * Return this number of parameters as bilion.
+     * @returns This number of parameters as bilion.
+     */
+    toBilion(): number;
+}
+/**
+ * Compile target model basic infromation
+ */
+export interface ModelOptions {
+    readonly parameters: Parameters;
+}
+/**
+ * Compile target model.
+ */
+export declare class Model {
+    readonly modelId: string;
+    readonly options: ModelOptions;
+    /**
+     * model informations at HuggingFace
+     * @param modelId model id on the HuggingFace
+     * @param options model basic infromation
+     * @returns model instance
+     */
+    static fromHuggingFace(modelId: string, options: ModelOptions): Model;
+    private constructor();
+}
+/**
+ * Props of NeuronxCompile.
+ */
+export interface NeuronxCompileProps {
+    /**
+     * VPC in which this will launch compile worker instance.
+     */
+    readonly vpc: ec2.IVpc;
+    /**
+     * The instance type of compile worker instance.
+     */
+    readonly instanceType?: NeuronxInstanceType;
+    /**
+     * The bucket to upload compiled artifacts.
+     */
+    readonly bucket: IBucket;
+    /**
+     * The model to be compiled.
+     */
+    readonly model: Model;
+    /**
+     * The root volume of worker instance.
+     * @default - N bilion parameters * 5GiB EBS
+     */
+    readonly volumeSize?: Size;
+    /**
+     * Compile runtime.
+     * @default { neuronxSdkVersion: "2.19.0", image: ContainerImage.fromRegistry("public.ecr.aws/neuron/pytorch-training-neuronx:2.1.2-neuronx-py310-sdk2.19.0-ubuntu20.04")}
+     */
+    readonly runtime?: CompileRuntime;
+    /**
+     * Neuronx compile options.
+     * @default - Each properties are set default.
+     */
+    readonly compileOptions?: CompileOptions;
+    /**
+     * Whether or not to use spot instances. Spot instances are less expensive EC2 instances that can be reclaimed by EC2 at any time; your job will be given two minutes of notice before reclamation.
+     *
+     * @default false
+     */
+    readonly spot?: boolean;
+    /**
+     * The VPC Subnets this Compute Environment will launch instances in.
+     *
+     * @default - new subnets will be created
+     */
+    readonly vpcSubnets?: ec2.SubnetSelection;
+}
+/**
+ * Neuronx compile construct. Compile the model to work with Inferentia2 and Trainium1 and upload it to an S3 bucket.
+ */
+export declare class NeuronxCompile extends Construct {
+    /**
+     * S3 URL that compiled artifact uploaded.
+     */
+    readonly compiledArtifactS3Url: string;
+    constructor(scope: Construct, id: string, props: NeuronxCompileProps);
+    private connectAcceleratorChips;
+    private calcTpDegree;
+    private selectInstanceTypeByTpDegree;
+}

package/lib/neuronx-compile.js

@@ -0,0 +1,285 @@
+"use strict";
+var _a, _b, _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NeuronxCompile = exports.Model = exports.Parameters = exports.OptLevel = exports.QuantDtype = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const batch = require("aws-cdk-lib/aws-batch");
+const ec2 = require("aws-cdk-lib/aws-ec2");
+const aws_ecs_1 = require("aws-cdk-lib/aws-ecs");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const custom_resources_1 = require("aws-cdk-lib/custom-resources");
+const constructs_1 = require("constructs");
+const neuronx_instance_type_1 = require("./neuronx-instance-type");
+const neuron_optimized_machine_image_1 = require("./private/neuron-optimized-machine-image");
+/**
+ * Quant data type.
+ */
+var QuantDtype;
+(function (QuantDtype) {
+    /**
+     * int8 weight storage.
+     */
+    QuantDtype["S8"] = "s8";
+})(QuantDtype || (exports.QuantDtype = QuantDtype = {}));
+/**
+ * Optimization level.
+ */
+var OptLevel;
+(function (OptLevel) {
+    /**
+     * enables the core performance optimizations in the compiler, while also minimizing compile time.
+     */
+    OptLevel[OptLevel["MINIMIZING_COMPILE_TIME"] = 1] = "MINIMIZING_COMPILE_TIME";
+    /**
+     * provides the best balance between model performance and compile time.
+     */
+    OptLevel[OptLevel["BEST_BALANCE"] = 2] = "BEST_BALANCE";
+    /**
+     * may provide additional model execution performance but may incur longer compile times and higher host memory usage during model compilation.
+     */
+    OptLevel[OptLevel["MODEL_EXECUTION_PERFORMANCE"] = 3] = "MODEL_EXECUTION_PERFORMANCE";
+})(OptLevel || (exports.OptLevel = OptLevel = {}));
+/**
+ * Represents the amount of parameters.
+ */
+class Parameters {
+    /**
+     * Create a Parameters representing an amount bilion.
+     * @param parameters number of parameters bilionX
+     * @returns parameters
+     */
+    static billion(parameters) {
+        return new Parameters(parameters);
+    }
+    constructor(billion) {
+        this.billion = billion;
+    }
+    /**
+     * Return this number of parameters as bilion.
+     * @returns This number of parameters as bilion.
+     */
+    toBilion() {
+        return this.billion;
+    }
+}
+exports.Parameters = Parameters;
+_a = JSII_RTTI_SYMBOL_1;
+Parameters[_a] = { fqn: "aws-cdk-neuronx-patterns.Parameters", version: "0.0.0" };
+/**
+ * Compile target model.
+ */
+class Model {
+    /**
+     * model informations at HuggingFace
+     * @param modelId model id on the HuggingFace
+     * @param options model basic infromation
+     * @returns model instance
+     */
+    static fromHuggingFace(modelId, options) {
+        return new Model(modelId, options);
+    }
+    constructor(modelId, options) {
+        this.modelId = modelId;
+        this.options = options;
+    }
+}
+exports.Model = Model;
+_b = JSII_RTTI_SYMBOL_1;
+Model[_b] = { fqn: "aws-cdk-neuronx-patterns.Model", version: "0.0.0" };
+/**
+ * Neuronx compile construct. Compile the model to work with Inferentia2 and Trainium1 and upload it to an S3 bucket.
+ */
+class NeuronxCompile extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const nPositions = props.compileOptions?.nPositions ?? 4092;
+        const quantDtype = props.compileOptions?.quantDtype;
+        const optLevel = props.compileOptions?.optLevel ?? OptLevel.BEST_BALANCE;
+        const tpDegree = props.compileOptions?.tpDegree ??
+            this.calcTpDegree(props.model.options.parameters, {
+                nPositions,
+                quantDtype,
+            });
+        const instanceType = props.instanceType ?? this.selectInstanceTypeByTpDegree(tpDegree);
+        const launchTemplate = new ec2.LaunchTemplate(this, "LaunchTemplate", {
+            blockDevices: [
+                {
+                    deviceName: "/dev/xvda",
+                    volume: ec2.BlockDeviceVolume.ebs(props.volumeSize?.toGibibytes() ??
+                        props.model.options.parameters.toBilion() * 5),
+                },
+            ],
+        });
+        const computeEnvironment = new batch.ManagedEc2EcsComputeEnvironment(this, "ComputeEnvironment", {
+            vpc: props.vpc,
+            vpcSubnets: props.vpcSubnets,
+            instanceTypes: [instanceType.instanceType],
+            useOptimalInstanceClasses: false,
+            images: [
+                {
+                    image: new neuron_optimized_machine_image_1.NeuronOptimizedMachineImage(this, "MachinImage"),
+                    // @ts-ignore
+                    imageType: "ECS_AL2023",
+                },
+            ],
+            launchTemplate,
+            spot: props.spot,
+        });
+        computeEnvironment.node.defaultChild.addPropertyOverride("ComputeResources.LaunchTemplate.Version", launchTemplate.latestVersionNumber);
+        aws_cdk_lib_1.Tags.of(computeEnvironment).add("Name", "neuronx-compile-worker");
+        const jobQueue = new batch.JobQueue(this, "JobQueue", {
+            computeEnvironments: [
+                {
+                    computeEnvironment,
+                    order: 1,
+                },
+            ],
+            jobStateTimeLimitActions: [
+                {
+                    state: batch.JobStateTimeLimitActionsState.RUNNABLE,
+                    reason: batch.JobStateTimeLimitActionsReason.JOB_RESOURCE_REQUIREMENT,
+                    maxTime: aws_cdk_lib_1.Duration.minutes(10),
+                    action: batch.JobStateTimeLimitActionsAction.CANCEL,
+                },
+            ],
+        });
+        const runtime = props.runtime ?? {
+            image: aws_ecs_1.ContainerImage.fromRegistry("public.ecr.aws/neuron/pytorch-training-neuronx:2.1.2-neuronx-py310-sdk2.19.0-ubuntu20.04"),
+            neuronxVersion: "2.19.0",
+            neuronxTransformersVersion: "0.11.351",
+        };
+        let compiledArtifactPathPrefix = `${props.model.modelId}/neuronx-${runtime.neuronxVersion}/tp${tpDegree}-np${nPositions}-opt${optLevel}`;
+        if (quantDtype) {
+            compiledArtifactPathPrefix = `${compiledArtifactPathPrefix}-quant${quantDtype}`;
+        }
+        props.bucket.grantReadWrite(computeEnvironment.instanceRole, `${compiledArtifactPathPrefix}/*`);
+        const compileScript = (0, fs_1.readFileSync)((0, path_1.join)(__dirname, "private/compile.py")).toString();
+        const jobDefinition = new batch.EcsJobDefinition(this, "JobDefinition", {
+            container: new batch.EcsEc2ContainerDefinition(this, "ContainerDefinition", {
+                image: runtime.image,
+                // The fllowing command was executed on inf2.8xlarge
+                // sh-5.2$ free -b
+                // 			total					used			free					shared	buff/cache	available
+                // Mem:	132265766912	866320384	130341785600	667648	1057660928	130529148928
+                // https://docs.aws.amazon.com/batch/latest/userguide/memory-management.html
+                memory: aws_cdk_lib_1.Size.mebibytes(Math.ceil(instanceType.memory.toMebibytes() * 0.95)),
+                cpu: instanceType.vCpu,
+                command: [
+                    `cat <<EOF > compile.py\n${compileScript}\nEOF\n`,
+                    [
+                        runtime.neuronxTransformersVersion
+                            ? "pip install -U --extra-index-url https://pip.repos.neuron.amazonaws.com transformers-neuronx==$NEURONX_TRANSFORMERS_VERSION"
+                            : undefined,
+                        "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/${props.model.modelId} model`,
+                        "rm -rf model/.git",
+                        "python ./compile.py",
+                        `aws s3 sync --no-progress ./model ${props.bucket.s3UrlForObject(`${compiledArtifactPathPrefix}/model`)}`,
+                        `aws s3 sync --no-progress ./compiled ${props.bucket.s3UrlForObject(`${compiledArtifactPathPrefix}/compiled`)}`,
+                    ]
+                        .filter((v) => !!v)
+                        .join(" && "),
+                ],
+                environment: {
+                    MODEL_ID: props.model.modelId,
+                    TP_DEGREE: tpDegree.toString(),
+                    N_POSITIONS: nPositions.toString(),
+                    OPT_LEVEL: optLevel.toString(),
+                    QUANT_DTYPE: quantDtype?.toString() ?? "",
+                    ARTIFACT_S3_URL: props.bucket.s3UrlForObject(compiledArtifactPathPrefix),
+                    NEURONX_TRANSFORMERS_VERSION: runtime.neuronxTransformersVersion ?? "",
+                },
+            }),
+        });
+        this.connectAcceleratorChips(jobDefinition, instanceType);
+        const jobSubmitFunction = new aws_lambda_1.SingletonFunction(this, "JobSubmitFunction", {
+            code: aws_lambda_1.Code.fromAsset((0, path_1.join)(__dirname, "private/await-compile-job")),
+            handler: "index.onEvent",
+            runtime: aws_lambda_1.Runtime.NODEJS_20_X,
+            uuid: "1361f469-5c92-4c46-9e11-5d1dbf925bac",
+        });
+        jobDefinition.grantSubmitJob(jobSubmitFunction, jobQueue);
+        const jobMonitoringFunction = new aws_lambda_1.SingletonFunction(this, "JobMonitoringFunction", {
+            code: aws_lambda_1.Code.fromAsset((0, path_1.join)(__dirname, "private/await-compile-job")),
+            handler: "index.isComplete",
+            runtime: aws_lambda_1.Runtime.NODEJS_20_X,
+            uuid: "df16dba8-5f77-480c-a6ad-cfdf74c3de62",
+        });
+        aws_iam_1.Grant.addToPrincipal({
+            resourceArns: ["*"],
+            grantee: jobMonitoringFunction,
+            actions: ["batch:DescribeJobs"],
+        });
+        const provider = new custom_resources_1.Provider(this, "CompileJobProvider", {
+            onEventHandler: jobSubmitFunction,
+            isCompleteHandler: jobMonitoringFunction,
+            queryInterval: aws_cdk_lib_1.Duration.minutes(1),
+            totalTimeout: aws_cdk_lib_1.Duration.hours(1),
+        });
+        const compileJob = new aws_cdk_lib_1.CustomResource(this, "CompileJob", {
+            serviceToken: provider.serviceToken,
+            resourceType: "Custom::CompileJob",
+            properties: {
+                jobDefinitionArn: jobDefinition.jobDefinitionArn,
+                jobQueueArn: jobQueue.jobQueueArn,
+                artifactS3Url: props.bucket.s3UrlForObject(compiledArtifactPathPrefix),
+            },
+        });
+        this.compiledArtifactS3Url = compileJob.getAttString("ArtifactS3Url");
+    }
+    connectAcceleratorChips(jobDefinition, instanceType) {
+        const devices = Array.from({
+            length: instanceType.acceleratorChips.chips,
+        }).map((_, index) => ({
+            HostPath: `/dev/neuron${index}`,
+            ContainerPath: `/dev/neuron${index}`,
+            Permissions: ["read", "write"],
+        }));
+        const cfnJobDefinition = jobDefinition.node
+            .defaultChild;
+        cfnJobDefinition.addPropertyOverride("ContainerProperties.LinuxParameters.Devices", devices);
+    }
+    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 QuantDtype.S8:
+                memory = aws_cdk_lib_1.Size.gibibytes(memory.toGibibytes() / 2);
+                break;
+        }
+        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.");
+    }
+    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.NeuronxCompile = NeuronxCompile;
+_c = JSII_RTTI_SYMBOL_1;
+NeuronxCompile[_c] = { fqn: "aws-cdk-neuronx-patterns.NeuronxCompile", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"neuronx-compile.js","sourceRoot":"","sources":["../src/neuronx-compile.ts"],"names":[],"mappings":"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","sourcesContent":["import { readFileSync } from \"fs\";\nimport { join } from \"path\";\nimport { CustomResource, Duration, Size, Tags } from \"aws-cdk-lib\";\nimport * as batch from \"aws-cdk-lib/aws-batch\";\nimport * as ec2 from \"aws-cdk-lib/aws-ec2\";\nimport { ContainerImage } from \"aws-cdk-lib/aws-ecs\";\nimport { Grant } from \"aws-cdk-lib/aws-iam\";\nimport { Code, Runtime, SingletonFunction } from \"aws-cdk-lib/aws-lambda\";\nimport { IBucket } from \"aws-cdk-lib/aws-s3\";\nimport { Provider } from \"aws-cdk-lib/custom-resources\";\nimport { Construct } from \"constructs\";\nimport { NeuronxInstanceType } from \"./neuronx-instance-type\";\nimport { NeuronOptimizedMachineImage } from \"./private/neuron-optimized-machine-image\";\n\n/**\n * Compile runtime.\n */\nexport interface CompileRuntime {\n  /**\n   * An image of the container where the compile job is executed.\n   */\n  readonly image: ContainerImage;\n  /**\n   * Neuronx version included in container image.\n   */\n  readonly neuronxVersion: string;\n}\n\n/**\n * Quant data type.\n */\nexport enum QuantDtype {\n  /**\n   * int8 weight storage.\n   */\n  S8 = \"s8\",\n}\n\n/**\n * Optimization level.\n */\nexport enum OptLevel {\n  /**\n   * enables the core performance optimizations in the compiler, while also minimizing compile time.\n   */\n  MINIMIZING_COMPILE_TIME = 1,\n  /**\n   * provides the best balance between model performance and compile time.\n   */\n  BEST_BALANCE = 2,\n  /**\n   * may provide additional model execution performance but may incur longer compile times and higher host memory usage during model compilation.\n   */\n  MODEL_EXECUTION_PERFORMANCE = 3,\n}\n\n/**\n * Compile options.\n */\nexport interface CompileOptions {\n  /**\n   * @default - calc from parameters and quantDtype\n   */\n  readonly tpDegree?: number;\n  /**\n   * @default - No quant\n   */\n  readonly quantDtype?: QuantDtype;\n  /**\n   * @default 4092\n   */\n  readonly nPositions?: number;\n  /**\n   * @default OptLevel.BEST_BALANCE\n   */\n  readonly optLevel?: OptLevel;\n}\n\n/**\n * Represents the amount of parameters.\n */\nexport class Parameters {\n  /**\n   * Create a Parameters representing an amount bilion.\n   * @param parameters number of parameters bilionX\n   * @returns parameters\n   */\n  static billion(parameters: number) {\n    return new Parameters(parameters);\n  }\n  private constructor(private readonly billion: number) {}\n  /**\n   * Return this number of parameters as bilion.\n   * @returns This number of parameters as bilion.\n   */\n  toBilion() {\n    return this.billion;\n  }\n}\n\n/**\n * Compile target model basic infromation\n */\nexport interface ModelOptions {\n  readonly parameters: Parameters;\n}\n/**\n * Compile target model.\n */\nexport class Model {\n  /**\n   * model informations at HuggingFace\n   * @param modelId model id on the HuggingFace\n   * @param options model basic infromation\n   * @returns model instance\n   */\n  static fromHuggingFace(modelId: string, options: ModelOptions) {\n    return new Model(modelId, options);\n  }\n  private constructor(\n    readonly modelId: string,\n    readonly options: ModelOptions,\n  ) {}\n}\n/**\n * Props of NeuronxCompile.\n */\nexport interface NeuronxCompileProps {\n  /**\n   * VPC in which this will launch compile worker instance.\n   */\n  readonly vpc: ec2.IVpc;\n  /**\n   * The instance type of compile worker instance.\n   */\n  readonly instanceType?: NeuronxInstanceType;\n  /**\n   * The bucket to upload compiled artifacts.\n   */\n  readonly bucket: IBucket;\n  /**\n   * The model to be compiled.\n   */\n  readonly model: Model;\n  /**\n   * The root volume of worker instance.\n   * @default - N bilion parameters * 5GiB EBS\n   */\n  readonly volumeSize?: Size;\n  /**\n   * Compile runtime.\n   * @default { neuronxSdkVersion: \"2.19.0\", image: ContainerImage.fromRegistry(\"public.ecr.aws/neuron/pytorch-training-neuronx:2.1.2-neuronx-py310-sdk2.19.0-ubuntu20.04\")}\n   */\n  readonly runtime?: CompileRuntime;\n  /**\n   * Neuronx compile options.\n   * @default - Each properties are set default.\n   */\n  readonly compileOptions?: CompileOptions;\n  /**\n   * Whether or not to use spot instances. Spot instances are less expensive EC2 instances that can be reclaimed by EC2 at any time; your job will be given two minutes of notice before reclamation.\n   *\n   * @default false\n   */\n  readonly spot?: boolean;\n  /**\n   * The VPC Subnets this Compute Environment will launch instances in.\n   *\n   * @default - new subnets will be created\n   */\n  readonly vpcSubnets?: ec2.SubnetSelection;\n}\n\n/**\n * Neuronx compile construct. Compile the model to work with Inferentia2 and Trainium1 and upload it to an S3 bucket.\n */\nexport class NeuronxCompile extends Construct {\n  /**\n   * S3 URL that compiled artifact uploaded.\n   */\n  readonly compiledArtifactS3Url: string;\n  constructor(scope: Construct, id: string, props: NeuronxCompileProps) {\n    super(scope, id);\n\n    const nPositions = props.compileOptions?.nPositions ?? 4092;\n    const quantDtype = props.compileOptions?.quantDtype;\n    const optLevel = props.compileOptions?.optLevel ?? OptLevel.BEST_BALANCE;\n    const tpDegree =\n      props.compileOptions?.tpDegree ??\n      this.calcTpDegree(props.model.options.parameters, {\n        nPositions,\n        quantDtype,\n      });\n    const instanceType =\n      props.instanceType ?? this.selectInstanceTypeByTpDegree(tpDegree);\n    const launchTemplate = new ec2.LaunchTemplate(this, \"LaunchTemplate\", {\n      blockDevices: [\n        {\n          deviceName: \"/dev/xvda\",\n          volume: ec2.BlockDeviceVolume.ebs(\n            props.volumeSize?.toGibibytes() ??\n              props.model.options.parameters.toBilion() * 5,\n          ),\n        },\n      ],\n    });\n    const computeEnvironment = new batch.ManagedEc2EcsComputeEnvironment(\n      this,\n      \"ComputeEnvironment\",\n      {\n        vpc: props.vpc,\n        vpcSubnets: props.vpcSubnets,\n        instanceTypes: [instanceType.instanceType],\n        useOptimalInstanceClasses: false,\n        images: [\n          {\n            image: new NeuronOptimizedMachineImage(this, \"MachinImage\"),\n            // @ts-ignore\n            imageType: \"ECS_AL2023\",\n          },\n        ],\n        launchTemplate,\n        spot: props.spot,\n      },\n    );\n    (\n      computeEnvironment.node.defaultChild as batch.CfnComputeEnvironment\n    ).addPropertyOverride(\n      \"ComputeResources.LaunchTemplate.Version\",\n      launchTemplate.latestVersionNumber,\n    );\n\n    Tags.of(computeEnvironment).add(\"Name\", \"neuronx-compile-worker\");\n    const jobQueue = new batch.JobQueue(this, \"JobQueue\", {\n      computeEnvironments: [\n        {\n          computeEnvironment,\n          order: 1,\n        },\n      ],\n      jobStateTimeLimitActions: [\n        {\n          state: batch.JobStateTimeLimitActionsState.RUNNABLE,\n          reason: batch.JobStateTimeLimitActionsReason.JOB_RESOURCE_REQUIREMENT,\n          maxTime: Duration.minutes(10),\n          action: batch.JobStateTimeLimitActionsAction.CANCEL,\n        },\n      ],\n    });\n\n    const runtime: CompileRuntime & { neuronxTransformersVersion?: string } =\n      props.runtime ?? {\n        image: ContainerImage.fromRegistry(\n          \"public.ecr.aws/neuron/pytorch-training-neuronx:2.1.2-neuronx-py310-sdk2.19.0-ubuntu20.04\",\n        ),\n        neuronxVersion: \"2.19.0\",\n        neuronxTransformersVersion: \"0.11.351\" as const,\n      };\n    let compiledArtifactPathPrefix = `${props.model.modelId}/neuronx-${runtime.neuronxVersion}/tp${tpDegree}-np${nPositions}-opt${optLevel}`;\n    if (quantDtype!!) {\n      compiledArtifactPathPrefix = `${compiledArtifactPathPrefix}-quant${quantDtype}`;\n    }\n    props.bucket.grantReadWrite(\n      computeEnvironment.instanceRole!,\n      `${compiledArtifactPathPrefix}/*`,\n    );\n\n    const compileScript = readFileSync(\n      join(__dirname, \"private/compile.py\"),\n    ).toString();\n    const jobDefinition = new batch.EcsJobDefinition(this, \"JobDefinition\", {\n      container: new batch.EcsEc2ContainerDefinition(\n        this,\n        \"ContainerDefinition\",\n        {\n          image: runtime.image,\n          // The fllowing command was executed on inf2.8xlarge\n          // sh-5.2$ free -b\n          // \t\t\ttotal\t\t\t\t\tused\t\t\tfree\t\t\t\t\tshared\tbuff/cache\tavailable\n          // Mem:\t132265766912\t866320384\t130341785600\t667648\t1057660928\t130529148928\n          // https://docs.aws.amazon.com/batch/latest/userguide/memory-management.html\n          memory: Size.mebibytes(\n            Math.ceil(instanceType.memory.toMebibytes() * 0.95),\n          ),\n          cpu: instanceType.vCpu,\n          command: [\n            `cat <<EOF > compile.py\\n${compileScript}\\nEOF\\n`,\n            [\n              runtime.neuronxTransformersVersion\n                ? \"pip install -U --extra-index-url https://pip.repos.neuron.amazonaws.com transformers-neuronx==$NEURONX_TRANSFORMERS_VERSION\"\n                : undefined,\n              \"curl -s https://packagecloud.io/install/repositories/github/git-lfs/script.deb.sh | bash\",\n              \"apt-get install git-lfs\",\n              \"git lfs install\",\n              `git clone https://huggingface.co/${props.model.modelId} model`,\n              \"rm -rf model/.git\",\n              \"python ./compile.py\",\n              `aws s3 sync --no-progress ./model ${props.bucket.s3UrlForObject(`${compiledArtifactPathPrefix}/model`)}`,\n              `aws s3 sync --no-progress ./compiled ${props.bucket.s3UrlForObject(`${compiledArtifactPathPrefix}/compiled`)}`,\n            ]\n              .filter((v) => !!v)\n              .join(\" && \"),\n          ],\n          environment: {\n            MODEL_ID: props.model.modelId,\n            TP_DEGREE: tpDegree.toString(),\n            N_POSITIONS: nPositions.toString(),\n            OPT_LEVEL: optLevel.toString(),\n            QUANT_DTYPE: quantDtype?.toString() ?? \"\",\n            ARTIFACT_S3_URL: props.bucket.s3UrlForObject(\n              compiledArtifactPathPrefix,\n            ),\n            NEURONX_TRANSFORMERS_VERSION:\n              runtime.neuronxTransformersVersion ?? \"\",\n          },\n        },\n      ),\n    });\n    this.connectAcceleratorChips(jobDefinition, instanceType);\n\n    const jobSubmitFunction = new SingletonFunction(this, \"JobSubmitFunction\", {\n      code: Code.fromAsset(join(__dirname, \"private/await-compile-job\")),\n      handler: \"index.onEvent\",\n      runtime: Runtime.NODEJS_20_X,\n      uuid: \"1361f469-5c92-4c46-9e11-5d1dbf925bac\",\n    });\n    jobDefinition.grantSubmitJob(jobSubmitFunction, jobQueue);\n    const jobMonitoringFunction = new SingletonFunction(\n      this,\n      \"JobMonitoringFunction\",\n      {\n        code: Code.fromAsset(join(__dirname, \"private/await-compile-job\")),\n        handler: \"index.isComplete\",\n        runtime: Runtime.NODEJS_20_X,\n        uuid: \"df16dba8-5f77-480c-a6ad-cfdf74c3de62\",\n      },\n    );\n    Grant.addToPrincipal({\n      resourceArns: [\"*\"],\n      grantee: jobMonitoringFunction,\n      actions: [\"batch:DescribeJobs\"],\n    });\n    const provider = new Provider(this, \"CompileJobProvider\", {\n      onEventHandler: jobSubmitFunction,\n      isCompleteHandler: jobMonitoringFunction,\n      queryInterval: Duration.minutes(1),\n      totalTimeout: Duration.hours(1),\n    });\n    const compileJob = new CustomResource(this, \"CompileJob\", {\n      serviceToken: provider.serviceToken,\n      resourceType: \"Custom::CompileJob\",\n      properties: {\n        jobDefinitionArn: jobDefinition.jobDefinitionArn,\n        jobQueueArn: jobQueue.jobQueueArn,\n        artifactS3Url: props.bucket.s3UrlForObject(compiledArtifactPathPrefix),\n      },\n    });\n    this.compiledArtifactS3Url = compileJob.getAttString(\"ArtifactS3Url\");\n  }\n\n  private connectAcceleratorChips(\n    jobDefinition: batch.EcsJobDefinition,\n    instanceType: NeuronxInstanceType,\n  ) {\n    type PascalCase<T extends object> = {\n      [P in keyof T as P extends string ? Capitalize<P> : never]: T[P];\n    };\n    const devices = Array.from({\n      length: instanceType.acceleratorChips.chips,\n    }).map(\n      (_, index) =>\n        ({\n          HostPath: `/dev/neuron${index}`,\n          ContainerPath: `/dev/neuron${index}`,\n          Permissions: [\"read\", \"write\"],\n        }) satisfies PascalCase<batch.CfnJobDefinition.DeviceProperty>,\n    );\n    const cfnJobDefinition = jobDefinition.node\n      .defaultChild as batch.CfnJobDefinition;\n    cfnJobDefinition.addPropertyOverride(\n      \"ContainerProperties.LinuxParameters.Devices\",\n      devices,\n    );\n  }\n\n  private calcTpDegree(parameters: Parameters, compileOptions: CompileOptions) {\n    // case of float16\n    const bytesPerParamete = 16 / 8;\n    // memory = bytes per parameter * number of parameters\n    let memory = Size.gibibytes(bytesPerParamete * parameters.toBilion());\n    switch (compileOptions.quantDtype) {\n      case QuantDtype.S8:\n        memory = Size.gibibytes(memory.toGibibytes() / 2);\n        break;\n    }\n    const neronxCoreMemory = Size.gibibytes(16);\n    const minimum = Math.ceil(\n      memory.toGibibytes() / neronxCoreMemory.toGibibytes(),\n    );\n\n    const tpDegrees = [1, 2, 4, 8, 24];\n    for (const tpDegree of tpDegrees) {\n      if (minimum <= tpDegree) {\n        return tpDegree;\n      }\n    }\n    throw new Error(\n      \"This model is too large, I can not support this model current version.\",\n    );\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"]}

package/lib/neuronx-instance-type.d.ts

@@ -0,0 +1,44 @@
+import { Size } from "aws-cdk-lib";
+import * as ec2 from "aws-cdk-lib/aws-ec2";
+/**
+ *
+ */
+export interface IAcceleratorChips {
+    readonly chips: number;
+    readonly neuronxCores: number;
+    readonly acceleratorMemory: Size;
+}
+export declare class Inferentia2Chips implements IAcceleratorChips {
+    readonly chips: number;
+    readonly neuronxCores: number;
+    readonly acceleratorMemory: Size;
+    constructor(chips: number);
+}
+export declare class NeuronxInstanceType {
+    readonly instanceType: ec2.InstanceType;
+    readonly vCpu: number;
+    readonly memory: Size;
+    readonly acceleratorChips: IAcceleratorChips;
+    /**
+     * ml.inf2.xlarge
+     */
+    static readonly INF2_XLARGE: NeuronxInstanceType;
+    /**
+     * ml.inf2.8xlarge
+     */
+    static readonly INF2_8XLARGE: NeuronxInstanceType;
+    /**
+     * ml.inf2.24xlarge
+     */
+    static readonly INF2_24XLARGE: NeuronxInstanceType;
+    /**
+     * ml.inf2.48xlarge
+     */
+    static readonly INF2_48XLARGE: NeuronxInstanceType;
+    private constructor();
+    /**
+     * Return the instance type as a string
+     * @returns The instance type as a string
+     */
+    toString(): string;
+}

package/lib/neuronx-instance-type.js

@@ -0,0 +1,52 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NeuronxInstanceType = exports.Inferentia2Chips = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const ec2 = require("aws-cdk-lib/aws-ec2");
+class Inferentia2Chips {
+    constructor(chips) {
+        this.chips = chips;
+        this.neuronxCores = chips * 2;
+        this.acceleratorMemory = aws_cdk_lib_1.Size.gibibytes(16 * this.neuronxCores);
+    }
+}
+exports.Inferentia2Chips = Inferentia2Chips;
+_a = JSII_RTTI_SYMBOL_1;
+Inferentia2Chips[_a] = { fqn: "aws-cdk-neuronx-patterns.Inferentia2Chips", version: "0.0.0" };
+class NeuronxInstanceType {
+    constructor(instanceType, vCpu, memory, acceleratorChips) {
+        this.instanceType = instanceType;
+        this.vCpu = vCpu;
+        this.memory = memory;
+        this.acceleratorChips = acceleratorChips;
+    }
+    /**
+     * Return the instance type as a string
+     * @returns The instance type as a string
+     */
+    toString() {
+        return `ml.${this.instanceType.toString()}`;
+    }
+}
+exports.NeuronxInstanceType = NeuronxInstanceType;
+_b = JSII_RTTI_SYMBOL_1;
+NeuronxInstanceType[_b] = { fqn: "aws-cdk-neuronx-patterns.NeuronxInstanceType", version: "0.0.0" };
+/**
+ * ml.inf2.xlarge
+ */
+NeuronxInstanceType.INF2_XLARGE = new NeuronxInstanceType(ec2.InstanceType.of(ec2.InstanceClass.INF2, ec2.InstanceSize.XLARGE), 4, aws_cdk_lib_1.Size.gibibytes(16), new Inferentia2Chips(1));
+/**
+ * ml.inf2.8xlarge
+ */
+NeuronxInstanceType.INF2_8XLARGE = new NeuronxInstanceType(ec2.InstanceType.of(ec2.InstanceClass.INF2, ec2.InstanceSize.XLARGE8), 32, aws_cdk_lib_1.Size.gibibytes(128), new Inferentia2Chips(1));
+/**
+ * ml.inf2.24xlarge
+ */
+NeuronxInstanceType.INF2_24XLARGE = new NeuronxInstanceType(ec2.InstanceType.of(ec2.InstanceClass.INF2, ec2.InstanceSize.XLARGE24), 96, aws_cdk_lib_1.Size.gibibytes(384), new Inferentia2Chips(6));
+/**
+ * ml.inf2.48xlarge
+ */
+NeuronxInstanceType.INF2_48XLARGE = new NeuronxInstanceType(ec2.InstanceType.of(ec2.InstanceClass.INF2, ec2.InstanceSize.XLARGE48), 192, aws_cdk_lib_1.Size.gibibytes(768), new Inferentia2Chips(12));
+//# sourceMappingURL=data:application/json;base64,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

package/lib/private/await-compile-job/index.d.ts

@@ -0,0 +1,4 @@
+import { type CdkCustomResourceHandler, type CdkCustomResourceIsCompleteHandler } from "aws-lambda";
+export declare const onEvent: CdkCustomResourceHandler;
+export declare const onCreate: CdkCustomResourceHandler;
+export declare const isComplete: CdkCustomResourceIsCompleteHandler;