Automated machine learning model deployment

Abstract

A code module usage specification and a resource usage specification of the model are identified using derived data of the machine learning model and the model training environment specification. And determining a code module installation specification according to the code module demand specification and the target execution environment specification. A code module specified by the code module installation specification is installed in the target execution environment. Using the data of the updated target execution environment, the updated target execution environment is validated to execute the model. And simulating execution of the model in the updated target execution environment. And in response to simulation success, deploying the model in the updated target execution environment.

Description

Background Art

[0001] The present invention generally relates to a method, system, and computer program product for software deployment. More specifically, the present invention relates to a method, system, and computer program product for automated machine learning model deployment.

[0002] A machine learning model is a model that learns to make predictions based on input data. Typically, a machine learning model initially learns by applying one or more learning techniques to training data. Once a model meets one or more acceptance criteria (e.g., the accuracy of the model output is above a threshold percentage), the model is considered sufficiently trained to be used on live (non-training) data for its intended purpose. However, model training can continue after the model is put into production. A machine learning model that operates on an incoming data stream is also called a machine learning pipeline or simply a pipeline.

[0003] Machine learning models are typically trained and evaluated in a model training environment. Human developers who are familiar with model development and training typically oversee model training and evaluation. Once the model is performing as expected, the model is deployed. Machine learning model deployment is the process of putting a trained machine learning model into a production environment where it will be used for its intended purpose, i.e., live (non-training) data. Machine learning model deployment typically requires data for the model itself, data for the training environment where the model was trained, and data for the production environment where the model is to be deployed. Summary of the invention

[0004] Illustrative embodiments provide a method, system, and computer program product. Embodiments include a method that uses the exported data of a machine learning model and a model training environment specification to identify the resource usage specification of the model and the code module usage specification of the model, the resource usage specification specifies a set of resources used to train the model in a model training environment specified by the model training environment specification, and the code module usage specification specifies a set of code modules used to train the model in the model training environment. The embodiment determines the code module installation specification according to the code module requirement specification and the target execution environment specification, the code module requirement specification specifies a set of code modules required to execute the model, and the code module installation specification specifies a set of code modules to be installed in the target execution environment, the target execution environment includes an environment for executing the model, and the target execution environment is specified by the target execution environment specification. The embodiment causes the code module specified by the code module installation specification to be installed in the target execution environment, and the installation results in an updated target execution environment. The embodiment uses the data of the updated target execution environment to verify the updated target execution environment to execute the model. The embodiment simulates the execution of the model in the updated target execution environment. The embodiment deploys the model in the updated target execution environment in response to the simulation success.

[0005] Embodiments include a computer usable program product including one or more computer readable storage devices and program instructions stored on at least one of the one or more storage devices.

[0006] Embodiments include a computer system comprising one or more processors, one or more computer-readable memories, and one or more computer-readable storage devices, and program instructions stored on at least one of the one or more storage devices for execution by at least one of the one or more processors via at least one of the one or more memories. BRIEF DESCRIPTION OF THE DRAWINGS

[0007] Certain novel features which are believed to be characteristic of the invention are set forth in the appended claims. However, the invention itself, as well as its preferred mode of use, further objects and advantages will be better understood by reference to the following detailed description of illustrative embodiments taken in conjunction with the accompanying drawings, in which:

[0008] Figure 1 An exemplary diagram showing a data processing environment in which the illustrative embodiments may be implemented;

[0009] Figure 2 A block diagram illustrating an example configuration for automated machine learning model deployment in accordance with an illustrative embodiment;

[0010] Figure 3An example of automated machine learning model deployment according to an illustrative embodiment is shown;

[0011] Figure 4 shows example results of automated machine learning model deployment according to an illustrative embodiment;

[0012] Figure 5 shows example results of automated machine learning model deployment according to an illustrative embodiment;

[0013] Fig. 6A A flowchart showing an example process for automating machine learning model deployment in accordance with an illustrative embodiment;

[0014] Figure 6B A continuing flow chart of an example process for automating machine learning model deployment in accordance with an illustrative embodiment is shown. DETAILED DESCRIPTION

[0015] The illustrative embodiments recognize that, while tools are currently available for automatically configuring and training machine learning models, there are currently no tools available for automatically deploying machine learning models. In addition, deployment is more complex than simply copying application files from one location to another and starting execution at the new location. Currently available automatic model development tools typically build custom models by combining existing components. Typically, these tools explore different model architectures before selecting the best performing model. Therefore, the model has different architectures and uses components or code modules from a different set of existing software libraries or software packages. For example, some common libraries in the Python computer language are sklearn, xgboost, tsfresh, and lifeline. (Python is a registered trademark of the Python Software Foundation in the United States and other countries.) The required software libraries must be installed in the environment where the model is to be executed, otherwise the model will not run properly. However, automated tools are generally unable to identify the required software libraries, and the dependencies between components may be difficult for human end users who deploy the model because they are not familiar with the details of each individual model to be deployed to track. In addition, other resources (such as processors and memory) must also be sufficient to enable the model and its software library to run at a specified speed and accuracy. For example, a model trained to monitor and adjust wind turbine operations based on changing environmental conditions but that reacts too slowly to an upcoming storm could result in the turbine being damaged by the storm. Some mission-critical applications require certification to prove that a model meets specific speed or response requirements in a specific execution environment. As a result, different models may have different, nonstandard deployment environment requirements that are difficult to assess by humans. Similarly, determining why a model that runs in an environment that is incorrectly configured for the model fails to deploy or run correctly can be difficult and time-consuming, especially for end users who are not familiar with the details of the model.

[0016] The illustrative embodiments recognize that one solution is to replicate the training environment of the model in the production environment, since the training environment is known to have sufficient resources and the correct software libraries. However, because model training is typically more resource-intensive than simply using the trained model, the training environment typically includes resources and software libraries that are not needed in the deployment environment. For example, a model may use 64 processors and 16GB of memory for training, but once training is complete, it may only require 4 processors and 4GB of memory. Allocating unused resources and installing unused libraries is inefficient. Allocating unused resources and installing unused libraries can also add unnecessary costs in environments where these services are charged separately.

[0017] The illustrative embodiments also recognize that model users have a variety of platforms on which models can be deployed, and these platforms have different characteristics. One platform allows users to customize the model execution environment, while another platform provides more than 40 default environment configurations that can be further customized. In addition, for speed, data security, or other reasons, some users want the model and the data processed by the model to run in the same environment, the same physical system, or the same data center. However, because different models have different deployment environment requirements, it is difficult for human end users who are not familiar with the details of the model to optimize the selected deployment environment for a specific model. The illustrative embodiments also recognize that although existing deployment tools generally test model accuracy, these tools do not test model speed or response time, nor do they verify and test the model to execute in the selected deployment environment.

[0018] Thus, the illustrative embodiments recognize that there is an unmet need for an automated tool that can determine the requirements of a model when executing in production (rather than training), select an appropriate deployment environment, validate and test the model to execute as specified in the deployment environment, and deploy the model, all in an automated, standardized manner.

[0019] The illustrative embodiments recognize that currently available tools or solutions do not meet these needs or provide adequate solutions to these needs. The illustrative embodiments used to describe the present invention generally address and solve the above-mentioned problems and other problems related to automated machine learning model deployment.

[0020] Embodiments may be implemented as software applications. Applications implementing embodiments may be configured as modifications to existing machine learning model management or execution systems, as separate applications that run in conjunction with existing machine learning model management or execution systems, as standalone applications, or some combination thereof.

[0021] Specifically, some illustrative embodiments provide a method that identifies resource usage and code module usage specifications of an exported model, determines a code module installation specification, causes the code module specified by the code module installation specification to be installed in a target execution environment, verifies an updated target execution environment to execute a trained model, simulates execution of the model in the updated target execution environment, and deploys the model in the updated target execution environment in response to a simulation success.

[0022] An embodiment receives export data of a trained machine learning model to be deployed and an environment specification of the environment in which the model is trained. The data of the trained machine learning model contains all model data required to execute the model in another execution environment. Several currently available automated model training tools (e.g., AutoAI, a currently available tool that automates the steps of building a predictive machine learning model) include a model export function that generates export data. An embodiment also receives an environment specification of the environment in which the model is trained. The embodiment specification specifies the characteristics of the model training environment, such as the number of processors, the amount of memory, and the software modules installed in the environment.

[0023] An embodiment uses the exported data of the trained machine learning model to be deployed and the environment specification of the environment in which the model is trained to identify a resource usage specification. The resource usage specification specifies a set of resources of the model training environment. Some non-limiting examples of resources of the model training environment are the number and speed of processors, the amount of memory, and the number, architecture, and speed of any graphics processors used to supplement the processors with specialized computing capabilities. For example, one resource usage specification might specify that the model training environment has 64 processors and 16GB of memory.

[0024] An embodiment uses the exported data of the trained machine learning model to be deployed and the environment specification of the environment in which the model is trained to identify a code module usage specification for the model. The code usage specification specifies a set of code modules or libraries present in the model training environment, and the version number of each code module (if applicable). For example, a code usage specification may specify that the training environment contains version 1.0 of the scikit-learn Python library.

[0025] Since not every code module present in the model training environment is required to execute the model, one embodiment analyzes the exported data to prune the code module usage specifications and remove one or more code modules that are not actually needed. Pruning results in the code module requirement specification specifying a set of code modules required to execute the model in the execution environment. In order to prune the code module usage specifications, one embodiment generates control flow data for the model and uses the control flow data to track the usage of specific code modules when executing the model in the training environment. Only the code modules actually used during model execution will be retained in the code module requirement specifications. In order to generate control flow data for an exported model implemented in Python language, one embodiment uses currently available Python tools (e.g., ast) to generate an abstract syntax tree, i.e., a record of the Python interpreter's interpretation of the Python program source code, including the control flow data of the program. There are currently also technologies for generating control flow data for exported models in other computer languages.

[0026] Embodiment uses model training environment specification to select target execution environment. Target execution environment is the environment where the model is deployed to execute on real-time (non-training) data. Target execution environment is specified by target execution environment specification. Target execution environment does not need to have the same resources, code modules, or code module versions as training execution environment. In an embodiment, the target execution environment has fewer processors, less memory, or different graphics processor architecture than the training execution environment. In an embodiment, the target execution environment lacks code modules present in the training execution environment, or has a code module with an older version than the training execution environment. In one embodiment, the user provides the target execution environment specification. For example, a wind turbine monitoring model may need to be executed in the same environment as the environment in which the wind turbine data to be processed by the collection model will be executed, and reconfiguring the data collection environment will require adding or replacing specific physical components. In another embodiment, the user provides preferences or constraints (for example, specifying the provider of the target execution environment, or specifying that the target execution environment is located in a specific country or data center), and the embodiment selects the target execution environment that meets the preferences or constraints. Another embodiment can select the target execution environment without user input. To select a target execution environment, an embodiment analyzes data of one or more available execution environments and ranks the environments based on one or more of the following: time to install additional components, additional memory required when existing packages cannot be removed, frequency of library version changes, and cost of providing required resources in the execution environment. An embodiment then selects the highest ranked available environment.

[0027] An embodiment determines a code module installation specification based on a target execution environment specification and a code module requirement specification. The code module installation specification specifies a set of code modules to be installed in the target execution environment. Specifically, an embodiment compares the data of the code modules currently installed in the target execution environment (specified by the target execution environment specification, or obtained separately from the target environment as specified by the target execution environment specification) with the data of the code modules that need to be installed in the target execution environment (specified by the code module requirement specification). An embodiment adds any code modules that have not yet been installed (or code modules that have been installed but have an earlier version) to the code module installation specification.

[0028] Embodiments enable installation of one or more code modules specified by code module installation specifications in a target execution environment. The target execution environment is updated by the installation. In one embodiment, code module installation is performed only after determining that installing the code module will not cause the target execution environment to exceed the resource limits specified by the target execution environment specifications. For example, installing a large code module in an environment that is already close to memory exhaustion may cause the environment to actually run out of memory, which is undesirable. If the embodiment determines that installing the code module will cause the target execution environment to exceed the resource limits, or if an error occurs during installation, the embodiment notifies the user, selects another target execution environment and repeats determining the code module installation specifications and installing in that environment, or takes another remedial action.

[0029] Embodiments also adjust resource usage specifications, code module installation specifications, or both to specify fewer resources or code modules than originally specified, or different versions of code modules. Typically, a deployed model requires fewer resources and code modules than the model to be trained, and adjusting the target environment requirements to more closely align with what the deployed model actually requires can more efficiently use computing resources and save money.

[0030] Embodiments use the updated target execution environment's data and resource usage specifications to validate the updated target execution environment's resources to execute the trained model. Embodiments also use the updated target execution environment's data and code module installation specifications to validate the updated target execution environment's code modules to execute the trained model. Validation checks whether the target execution environment has sufficient resources and whether the code modules are installed and have the correct versions to execute the trained model. Validation prior to model deployment can avoid some sources of model deployment failures, thereby avoiding the necessity to debug such failures, especially in non-standard execution environments.

[0031] An embodiment simulates the execution of a model in an updated target execution environment. The simulation checks whether the model executes correctly in the simulated version of the target execution environment. Simulating before model deployment can avoid some sources of model deployment failures, thereby avoiding the necessity to debug such failures, especially in non-standard execution environments. To perform the simulation, an embodiment uses currently available technology.

[0032] If the simulation fails due to an error, or does not meet the specified performance specifications, an embodiment readjusts the resource usage specifications, the code module installation specifications, or both to specify additional resources or code modules, or different versions of code modules, and repeats the verification and simulation using the readjusted specifications.

[0033] On the other hand, if the simulation is successful, the embodiment deploys the model in the updated target execution environment. After deployment, the model executes in the updated target execution environment and can process real-time data. To perform the deployment, the embodiment uses currently available technology.

[0034] An embodiment maintains a deployment record including the exported data of the trained machine learning model to be deployed, the environment specification of the environment in which the model was trained, the target execution environment, adjustments made to the target execution environment, and verification, simulation, and deployment results. This record can be used to adjust one or more methods described herein.

[0035] The automated machine learning model deployment method described herein is not available in the currently available methods in the field of machine learning model management technology. The method of the embodiment described herein, when implemented on a device or data processing system, includes significantly improving the functionality of the device or data processing system to identify resource usage and code module usage specifications for an exported model, determine code module installation specifications, cause the code module specified by the code module installation specifications to be installed in a target execution environment, verify the updated target execution environment to execute the trained model, simulate the execution of the model in the updated target execution environment, and deploy the model in the updated target execution environment in response to a successful simulation.

[0036] The illustrative embodiments are described for certain types of execution environments, resources, code modules, computer languages, specifications, models, verifications, adjustments, sensors, measurements, devices, data processing systems, environments, components, and applications as examples only. Any particular representation of these and other similar artifacts is not intended to limit the invention. Any suitable representation of these and other similar artifacts may be selected within the scope of the illustrative embodiments.

[0037] Furthermore, the illustrative embodiments may be implemented for any type of data, data source, or access to a data source over a data network. Any type of data storage device may provide data to embodiments of the present invention, either locally on a data processing system or over a data network, within the scope of the present invention. Where embodiments are described using a mobile device, any type of data storage device suitable for use with the mobile device may provide data to the embodiments, either locally on the mobile device or over a data network, within the scope of the illustrative embodiments.

[0038] The illustrative embodiments are described using only specific code, designs, architectures, protocols, layouts, schematics, and tools as examples, and are not limited to the illustrative embodiments. In addition, in some cases, the illustrative embodiments are described using only specific software, tools, and data processing environments as examples, so that the description is clear. The illustrative embodiments may be used in conjunction with other similar or similarly used structures, systems, applications, or architectures. For example, other similar mobile devices, structures, systems, applications, or architectures may be used in conjunction with such embodiments of the present invention within the scope of the present invention. The illustrative embodiments may be implemented in hardware, software, or a combination of both.

[0039] The examples in this disclosure are only for clarity of description and are not limited to the illustrative embodiments. Other data, operations, actions, tasks, activities and manipulations can be imagined from this disclosure, and these should be within the scope of the illustrative embodiments.

[0040] Any advantages listed herein are merely examples and are not intended to limit the illustrative embodiments. Specific illustrative embodiments may achieve additional or different advantages. Furthermore, specific illustrative embodiments may have some, all, or none of the above advantages.

[0041] It should be understood that although the present disclosure includes detailed descriptions about cloud computing, the implementation of the teachings described herein is not limited to cloud computing environments. Instead, embodiments of the present invention can be implemented in conjunction with any other type of computing environment now known or later developed.

[0042] Cloud computing is a service delivery model that aims to enable convenient, on-demand network access to a shared pool of configurable computing resources (e.g., networks, network bandwidth, servers, processing, memory, storage, applications, virtual machines, and services) that can be rapidly provisioned and released with minimal management effort or interaction with the service provider. This cloud model may include at least five characteristics, at least three service models, and at least four deployment models.

[0043] Features are as follows:

[0044] On-demand self-service: Cloud consumers can unilaterally and automatically provision computing capabilities, such as server time and network storage, as needed without requiring manual interaction with the service provider.

[0045] Wide Area Network Access: Capabilities are available over the network and accessed through standard mechanisms that facilitate use by heterogeneous thin or thick client platforms (e.g., mobile phones, laptops, and PDAs).

[0046] Resource pooling: A provider's computing resources are pooled to serve multiple consumers using a multi-tenant model, where different physical and virtual resources are dynamically allocated and reallocated based on demand. There is a sense of location independence, as consumers typically have no control or knowledge of the exact location of the resources provided, but can specify the location at a higher level of abstraction (e.g., country, state, or data center).

[0047] Rapid elasticity: In some cases, the ability to scale out quickly and in quickly can be provisioned quickly and elastically. To the consumer, the capacity available for provisioning often appears to be unlimited and can be purchased in any quantity at any time.

[0048] Metered Services: Cloud systems automatically control and optimize resource usage by leveraging metering capabilities at some level of abstraction appropriate to the type of service (e.g., storage, processing, bandwidth, and active user accounts). Resource usage can be monitored, controlled, reported, and invoiced, providing transparency to both providers and consumers of the utilized services.

[0049] The service model is as follows:

[0050] Software as a Service (SaaS): The capability provided to the consumer is to use the provider's applications running on the cloud infrastructure. The applications are accessible from a variety of client devices through a thin client interface such as a web browser (e.g., web-based email). The consumer does not manage or control the underlying cloud infrastructure including the network, servers, operating systems, storage, or even individual application capabilities, with the possible exception of limited user-specific application configuration settings.

[0051] Platform as a Service (PaaS): The capability provided to consumers is to deploy consumer-created or acquired applications onto cloud infrastructure, where the applications are created using programming languages ​​and tools supported by the provider. Consumers do not manage or control the underlying cloud infrastructure including networks, servers, operating systems, or storage, but have control over deployed applications and possible configuration of the application hosting environment.

[0052] Infrastructure as a Service (IaaS): The capabilities provided to consumers are processing, storage, networking, and other basic computing resources on which consumers can deploy and run arbitrary software, which may include operating systems and applications. Consumers do not manage or control the underlying cloud infrastructure, but have control over the operating system, storage, deployed applications, and possibly limited control over selected networking components (e.g., host firewalls).

[0053] The deployment model is as follows:

[0054] Private Cloud: The cloud infrastructure is operated only for the organization. It can be managed by the organization or a third party and can exist on-premises or off-premises.

[0055] Community cloud: The cloud infrastructure is shared by several organizations and supports a specific community with shared concerns (e.g., mission, security requirements, policies, and compliance considerations). It can be managed by the organization or a third party and can exist on-premises or off-premises.

[0056] Public cloud: Cloud infrastructure is available to the general public or large industrial groups and is owned by an organization that sells cloud services.

[0057] Hybrid cloud: A cloud infrastructure is a combination of two or more clouds (private, community or public) that remain a unique entity but are bound together by standardized or proprietary technologies that enable data and application portability (e.g., cloud bursting for load balancing between clouds).

[0058] The cloud computing environment is service-oriented, with a focus on statelessness, low coupling, modularity, and semantic interoperability. At the core of cloud computing is the infrastructure that includes a network of interconnected nodes. The cloud computing environment is service-oriented, with a focus on statelessness, low coupling, modularity, and semantic interoperability. At the core of cloud computing is the infrastructure that includes a network of interconnected nodes.

[0059] Various aspects of the present disclosure are described by narrative text, flow charts, block diagrams of computer systems, and / or block diagrams of machine logic contained in computer program product (CPP) embodiments. For any flow chart, depending on the technology involved, the operations may be performed in an order different from the order shown in a given flow chart. For example, also depending on the technology involved, two operations shown in consecutive flow chart blocks may be performed in reverse order, as a single integrated step, simultaneously, or in a manner that overlaps at least partially in time.

[0060] Computer program product embodiment is a term used in this disclosure to describe one or more sets of storage media (also referred to as "media") that are collectively contained in one or more sets of storage devices that collectively contain machine-readable code corresponding to instructions and / or data for performing the computer operations specified in a given CPP claim. A "storage device" is any tangible device that can retain and store instructions for use by a computer processor. A computer-readable storage medium may be, but is not limited to, an electronic storage medium, a magnetic storage medium, an optical storage medium, an electromagnetic storage medium, a semiconductor storage medium, a mechanical storage medium, or any suitable combination of the foregoing. Some known types of storage devices that include these media include: floppy disks, hard disks, random access memories (RAM), read-only memories (ROM), erasable programmable read-only memories (EPROM or flash memory), static random access memories (SRAM), compact disk read-only memories (CD-ROMs), digital versatile disks (DVDs), memory sticks, floppy disks, mechanical encoding devices (such as punch cards or pits / land formations on the major surface of a disc), or any suitable combination of the foregoing. Computer-readable storage media (as that term is used in this disclosure) should not be construed as storing in the form of transient signals themselves, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through waveguides, light pulses through fiber optic cables, electrical signals transmitted through wires, and / or other transmission media. Those skilled in the art will understand that data is typically moved at certain occasional points in time during normal operation of the storage device, such as during access, defragmentation, or garbage collection, but this does not make the storage device temporary because data is not temporary when stored.

[0061] With reference to the accompanying drawings, in particular with reference to Figure 1 , which is an exemplary diagram of a data processing environment in which an illustrative embodiment may be implemented. Figure 1 This is merely an example and is not intended to assert or imply any limitation in the environments in which different embodiments may be implemented. Specific embodiments may make many modifications to the depicted environment in light of the following description.

[0062] Figure 1A block diagram of a network of data processing systems in which illustrative embodiments may be implemented is depicted. Computing environment 100 includes an example of an environment for executing at least some of the computer codes involved in implementing the methods of the present invention, such as application 200. Application 200 implements the automated machine learning model deployment embodiment described herein. In addition to block 200, computing environment 100 also includes, for example, computer 101, wide area network (WAN) 102, end user device (EUD) 103, remote server 104, public cloud 105, and private cloud 106. In this embodiment, computer 101 includes processor group 110 (including processing circuit 120 and cache 121), communication structure 111, volatile memory 112, persistent storage device 113 (including operating system 122 and block 200, as described above), peripheral device group 114 (including user interface (UI), device group 123, storage device 124, and Internet of Things (IoT) sensor group 125), and network module 115. Remote server 104 includes remote database 130. Public cloud 105 includes gateway 140, cloud orchestration module 141, host physical machine group 142, virtual machine group 143, and container group 144. Unless explicitly stated otherwise, application 200 may be executed in any of computer 101, end-user device 103, remote server 104, or computers in public cloud 105 or private cloud 106. Application 200 may deploy a model in any of computer 101, end-user device 103, remote server 104, or computers in public cloud 105 or private cloud 106 or other environments.

[0063] Computer 101 may take the form of a desktop computer, laptop computer, tablet computer, smartphone, smart watch or other wearable computer, mainframe computer, quantum computer, or any other form of computer or mobile device now known or developed in the future that is capable of running programs, accessing a network, or querying a database (e.g., remote database 130). As is well known in the art of computer technology, and depending on the technology, the execution of the computer-implemented method may be distributed among multiple computers and / or among multiple locations. On the other hand, in this demonstration of computing environment 100, the detailed discussion focuses on a single computer, specifically computer 101, to keep the demonstration as simple as possible. Computer 101 may be located in the cloud, even though it is not shown in the illustration. Figure 1 On the other hand, unless explicitly stated, computer 101 need not be located in the cloud.

[0064] Processor group 110 includes one or more computer processors of any type known now or developed in the future. Processor group 110 may contain one or more processors and may be implemented using one or more heterogeneous processor systems. The processors in processor group 110 may be single-core or multi-core processors or graphics processors. Processing circuit 120 may be distributed over multiple packages, such as multiple coordinated integrated circuit chips. Processing circuit 120 may implement multiple processor threads and / or multiple processor cores. Cache 121 is a memory located in the processor chip package, typically used for data or code that should be quickly accessed by threads or cores running on processor group 110. Cache memory is typically organized into multiple levels based on relative proximity to the processing circuit. Alternatively, some or all of the caches of the processor group may be located "off chip". In certain computing environments, processor group 110 may be designed to process quantum bits and perform quantum computing.

[0065] An operating system 122 runs on the computer 101. The operating system 122 coordinates and provides control over various components within the computer 101. Instructions of the operating system 122 are located on a storage device (e.g., persistent storage 113) and can be loaded into at least one of one or more memories (e.g., volatile memory 112) for execution by the processor group 110.

[0066] Computer readable program instructions are typically loaded onto the computer 101 to cause the processor group 110 of the computer 101 to perform a series of operating steps to implement a computer-implemented method, such that the instructions executed will instantiate the method specified in the flowchart and / or narrative description of the computer-implemented method contained in this document (collectively referred to as the "inventive method"). These computer readable program instructions are stored in various types of computer readable storage media, such as cache 121 and other storage media discussed below. The processor group 110 accesses the program instructions and related data to control and direct the execution of the inventive method. In the computing environment 100, at least some instructions for executing the inventive method of the application 200 can be stored in a persistent storage device 113 and can be loaded into at least one of one or more memories (e.g., volatile memory 112) for execution by the processor group 110. The process of the illustrative embodiment can be performed by the processor group 110 using computer-implemented instructions, which can be located in a memory, such as volatile memory 112, persistent storage device 113, or in one or more peripheral devices in the peripheral device group 114. In addition, in one case, the application 200 can be downloaded from the remote server 104 via the WAN 102, where similar code is stored on a storage device. In another case, the application 200 can be downloaded to the remote server 104 via the WAN 102, where the downloaded code is stored on a storage device.

[0067] Communications fabric 111 is a signaling path that allows the various components of computer 101 to communicate with each other. Typically, the fabric is composed of switches and conductive paths, such as those that form a bus, a bridge, physical input / output ports, etc. Other types of signal communication paths may be used, such as fiber optic communication paths and / or wireless communication paths.

[0068] The volatile memory 112 is any type of volatile memory currently known or developed in the future. Examples include dynamic type random access memory (RAM) or static type RAM. Typically, volatile memory is characterized by random access, but this is not required unless explicitly stated. In the computer 101, the volatile memory 112 is located in a single package and is internal to the computer 101, but, as an alternative or in addition, the volatile memory can be distributed over multiple packages and / or located external to the computer 101.

[0069] Persistent storage 113 is any form of non-volatile storage for computers currently known or developed in the future. The non-volatility of such storage means that the stored data is maintained regardless of whether the computer 101 is powered on and / or power is directly supplied to the persistent storage 113. Persistent storage 113 may be a read-only memory (ROM), but typically at least a portion of the persistent storage allows data to be written, deleted, and rewritten. Some common forms of persistent storage include magnetic disks and solid-state storage devices. Operating system 122 may take a variety of forms, such as various known proprietary operating systems or open source portable operating system interface type operating systems that employ a kernel. The code contained in application 200 typically includes at least some of the computer code involved in executing the method of the present invention.

[0070] The peripheral device group 114 includes a peripheral device group of the computer 101. The data communication connection between the peripheral device and other components of the computer 101 can be implemented in various ways, such as a Bluetooth connection, a near field communication (NFC) connection, a connection established by a cable (such as a universal serial bus (USB) type cable), a plug-in type connection (such as a secure digital (SD) card), a connection established through a local area network, and even a connection established through a wide area network such as the Internet. In various embodiments, the user interface (UI) device group 123 may include components such as display screens, speakers, microphones, wearable devices (such as goggles and smart watches), keyboards, mice, printers, touch pads, game controllers, and tactile devices. The storage device 124 is an external storage device, such as an external hard drive, or a pluggable storage device, such as an SD card. The storage device 124 can be persistent and / or volatile. In some embodiments, the storage device 124 can take the form of a quantum computing storage device for storing data in the form of quantum bits. In embodiments where it is desirable for computer 101 to have a large amount of storage (e.g., computer 101 locally stores and manages a large database), this storage may be provided by a peripheral storage device designed to store large amounts of data, such as a storage area network (SAN) shared by multiple geographically distributed computers. Internet of Things (IoT) sensor group 125 consists of sensors that can be used for IoT applications. For example, one sensor may be a thermometer and another sensor may be a motion detector.

[0071] The network module 115 is a collection of computer software, hardware, and firmware that allows the computer 101 to communicate with other computers via the WAN 102. The network module 115 may include hardware, such as a modem or Wi-Fi signal transceiver, software for grouping and / or unpacking data for communication network transmission, and / or Web browser software for communicating data over the Internet. In some embodiments, the network control function and the network forwarding function of the network module 115 are executed on the same physical hardware device. In other embodiments (e.g., embodiments utilizing software defined networks (SDN)), the control function and the forwarding function of the network module 115 are executed on physically separate devices, so that the control function manages several different network hardware devices. Computer-readable program instructions for executing the method of the present invention can typically be downloaded to the computer 101 from an external computer or an external storage device via a network adapter card or a network interface included in the network module 115.

[0072] Wide area network (WAN) 102 is any WAN (e.g., the Internet) capable of communicating computer data over non-local distances by any technology for communicating computer data, currently known or developed in the future. In some embodiments, the WAN may be replaced and / or supplemented by a local area network (LAN) designed to communicate data between devices located in a local area, such as a Wi-Fi network. A WAN and / or LAN typically includes computer hardware, such as copper transmission cables, optical transmission fibers, wireless transmission, routers, firewalls, switches, gateway computers, and edge servers.

[0073] End-user device (EUD) 103 is any computer system used and controlled by an end-user (e.g., a customer of an enterprise operating computer 101), and may take any of the forms described above in relation to computer 101. EUD 103 typically receives helpful and useful data from the operation of computer 101. For example, assuming that computer 101 is designed to provide advice to an end-user, the advice would typically be communicated from network module 115 of computer 101 to EUD 103 via WAN 102. In this way, EUD 103 may display or otherwise present the advice to the end-user. In some embodiments, EUD 103 may be a client device, such as a thin client, a heavy client, a mainframe computer, a desktop computer, etc.

[0074] Remote server 104 is any computer system that provides at least some data and / or functionality to computer 101. Remote server 104 may be controlled and used by the same entity that operates computer 101. Remote server 104 represents a machine that collects and stores helpful and useful data for use by other computers, such as computer 101. For example, assuming that computer 101 is designed and programmed to provide recommendations based on historical data, the historical data may be provided to computer 101 from remote database 130 of remote server 104.

[0075] The public cloud 105 is any computer system available to multiple entities that provides on-demand availability of computer system resources and / or other computer capabilities, particularly data storage (cloud storage) and computing power, without direct active management by users. Cloud computing typically utilizes resource sharing to achieve consistency and economies of scale. The direct and active management of the computing resources of the public cloud 105 is performed by computer hardware and / or software of the cloud orchestration module 141. The computing resources provided by the public cloud 105 are typically implemented by a virtual computing environment that runs on various computers that constitute the host physical machine group 142, which is the physical computer world in and / or available to the public cloud 105. The virtual computing environment (VCE) is typically in the form of a virtual machine from the virtual machine group 143 and / or a container from the container group 144. It will be appreciated that these VCEs can be stored as images and can be transferred between various physical machine hosts, either as images or after the VCE is instantiated. Cloud orchestration module 141 manages the transfer and storage of images, deploys new instances of VCE, and manages active instances of VCE deployments. Gateway 140 is a collection of computer software, hardware, and firmware that allows public cloud 105 to communicate over WAN 102 .

[0076] The Virtualized Computing Environment (VCE) will now be explained further. A VCE can be stored as an "image". A new active instance of a VCE can be instantiated from an image. Two common types of VCEs are virtual machines and containers. Containers are VCEs that use operating system-level virtualization. This refers to an operating system feature where the kernel allows the existence of multiple isolated user space instances, called containers. From the perspective of the programs running in them, these isolated user space instances generally behave like real computers. Computer programs running on a normal operating system can utilize all of the resources of that computer, such as connected devices, files and folders, network shares, CPU power, and quantifiable hardware capabilities. However, programs running within a container can only use the contents of the container and the devices assigned to the container, a feature called containerization.

[0077] Private cloud 106 is similar to public cloud 105, except that the computing resources are only available to a single enterprise. Although private cloud 106 is depicted as communicating with WAN 102, in other embodiments, the private cloud may be completely disconnected from the Internet and only accessible through a local / private network. A hybrid cloud is a combination of multiple different types of clouds (e.g., private, community, or public cloud types), typically implemented by different vendors. Each of the multiple clouds remains an independent and discrete entity, but the larger hybrid cloud architecture is tied together through standardized or proprietary technologies to enable orchestration, management, and / or data / application portability between the multiple constituent clouds. In this embodiment, both public cloud 105 and private cloud 106 are part of a larger hybrid cloud.

[0078] refer to Figure 2 , which depicts a block diagram of an example configuration for automated machine learning model deployment according to an illustrative embodiment. Application 200 and Figure 1 The same as in application 200.

[0079] Application 200 receives the exported data of the trained machine learning model to be deployed and the environment specification of the environment in which the model is trained. The data of the trained machine learning model contains all the model data required to execute the model in another execution environment. Application 200 also receives the environment specification of the environment in which the model is trained. The embodiment specification specifies the characteristics of the model training environment, such as the number of processors, the amount of memory, and the software modules installed in the environment.

[0080] The model characteristic identification module 210 uses the exported data of the trained machine learning model to be deployed and the environment specification of the environment in which the model is trained to identify a resource usage specification. The resource usage specification specifies a set of resources of the model training environment. Some non-limiting examples of resources of the model training environment are the number and speed of processors, the amount of memory, and the number, architecture, and speed of any graphics processors used to supplement the processors with specialized computing capabilities. For example, one resource usage specification may specify that the model training environment has 64 processors and 16GB of memory.

[0081] Module 210 also uses the exported data of the trained machine learning model to be deployed and the environment specification of the environment in which the model is trained to identify the code module usage specification of the model. The code usage specification specifies a set of code modules or libraries that exist in the model training environment, and the version number of each code module (if applicable). For example, a code usage specification may specify that the training environment contains version 1.0 of the scikit-learn Python library.

[0082] Since not every code module present in the model training environment is required to execute the model, the code module pruning module 220 analyzes the exported data to prune the code module usage specifications and remove one or more code modules that are not actually needed. Pruning will produce a code module requirement specification that specifies a set of code modules required to execute the model in the execution environment. In order to prune the code module usage specifications, module 220 generates control flow data for the model and uses the control flow data to track the usage of specific code modules when the model is executed in the training environment. Only code modules that are actually used during model execution will be retained in the code module requirement specification. In order to generate control flow data for an exported model implemented in Python, an implementation of module 220 uses currently available Python tools (e.g., ast) to generate an abstract syntax tree, that is, a record of the Python interpreter's interpretation of the Python program source code, including the program's control flow data.

[0083] The target execution environment selection module 230 uses the model training environment specification to select the target execution environment. The target execution environment is the environment where the model is deployed to execute on real-time (non-training) data. The target execution environment is specified by the target execution environment specification. The target execution environment does not need to have the same resources, code modules, or versions of code modules as the training execution environment. In the implementation of module 230, the target execution environment has fewer processors, less memory, or different graphics processor architectures than the training execution environment. In the implementation of module 230, the target execution environment lacks code modules that exist in the training execution environment, or has a code module with an older version than the training execution environment. In one implementation of module 230, the user provides the target execution environment specification. For example, a wind turbine monitoring model may need to be executed in the same environment as the environment in which the wind turbine data to be processed by the collection model will be executed, and reconfiguring the data collection environment will require adding or replacing specific physical components. In another implementation of module 230, the user provides preferences or constraints (e.g., specifying the provider of the target execution environment, or specifying that the target execution environment is located in a specific country or data center), and the target execution environment that satisfies the preferences or constraints is selected. Another implementation of module 230 selects a target execution environment without user input. To select a target execution environment, module 230 analyzes data of one or more available execution environments and ranks the environments based on one or more of the following: time to install additional components, additional memory required when existing packages cannot be removed, frequency of library version changes, and cost of providing required resources in the execution environment. Module 230 then selects the highest ranked available environment.

[0084] Code module installation module 240 determines a code module installation specification based on the target execution environment specification and the code module requirement specification. The code module installation specification specifies a set of code modules to be installed in the target execution environment. Specifically, module 240 compares the data of the code modules currently installed in the target execution environment (specified by the target execution environment specification, or obtained separately from the target environment as specified by the target execution environment specification) with the data of the code modules that need to be installed in the target execution environment (specified by the code module requirement specification). Module 240 adds any code modules that have not yet been installed (or code modules that have been installed but have an earlier version) to the code module installation specification.

[0085] The code module installation module 240 also causes one or more code modules specified by the code module installation specification to be installed in the target execution environment. The target execution environment is updated by the installation. In an implementation of module 240, only after determining that the installation of the code module will not cause the target execution environment to exceed the resource limit specified by the target execution environment specification, the code module installation is performed. For example, installing a large code module in an environment that is close to memory exhaustion may cause the environment to really run out of memory, which is undesirable. If module 240 determines that the installation of the code module will cause the target execution environment to exceed the resource limit, or if an error occurs during installation, then module 240 notifies the user, selects another target execution environment and repeats determining the code module installation specification and installing in this environment, or takes another remedial action.

[0086] Application 200 also adjusts resource usage specifications, code module installation specifications, or both to specify fewer resources or code modules than originally specified, or different versions of code modules. Typically, a deployed model requires fewer resources and code modules than the model to be trained, and adjusting the target environment requirements to more closely align with what the deployed model actually requires can more efficiently use computing resources and save money.

[0087] Verification module 250 uses the updated target execution environment's data and resource usage specifications to verify the updated target execution environment's resources to execute the trained model. Module 250 also uses the updated target execution environment's data and code module installation specifications to verify the updated target execution environment's code modules to execute the trained model. Verification checks whether the target execution environment has sufficient resources and whether the code modules are installed and have the correct versions to execute the trained model. Verification before model deployment can avoid some sources of model deployment failures, thereby avoiding the necessity to debug such failures, especially in non-standard execution environments.

[0088] The simulation module 260 simulates the execution of the model in the updated target execution environment. The simulation checks whether the model executes correctly in the simulated version of the target execution environment. Simulating before model deployment can avoid some sources of model deployment failures, thereby avoiding the necessity of debugging such failures, especially in non-standard execution environments.

[0089] If the simulation fails due to an error, or does not meet the specified performance specifications, the application 200 readjusts the resource usage specifications, the code module installation specifications, or both to specify additional resources or code modules, or different versions of code modules, and repeats the verification and simulation using the readjusted specifications.

[0090] On the other hand, if the simulation is successful, the deployment module 270 deploys the model in the updated target execution environment. After deployment, the model is executed in the updated target execution environment and can process real-time data.

[0091] refer to Figure 3 , which shows an example of automated machine learning model deployment according to an illustrative embodiment. This example can be used Figure 1 The model feature identification module 210, the code module pruning module 220, the target execution environment selection module 230, the code module installation module 240, the verification module 250, the simulation module 260 and the deployment module 270 are connected to the Figure 2 The model feature identification module 210, code module pruning module 220, target execution environment selection module 230, code module installation module 240, verification module 250, simulation module 260 and deployment module 270 are the same.

[0092] As shown, the model feature identification module 210 uses the machine learning model data 310 (derived data of the trained machine learning model to be deployed) and the model training environment specification 312 (specifying the environment in which the model is trained) to identify the resource usage specification 320. The module 210 also uses the machine learning model data 310 and the model training environment specification 312 to identify the code module usage specification 330.

[0093] The code module pruning module 220 prunes the code module usage specification 330 to remove one or more code modules that are not actually needed. The pruning result is a code module requirement specification 340 that specifies a set of code modules required to execute the model in the execution environment.

[0094] Target execution environment selection module 230 uses model training environment specification 312 and execution environment data 314 to select target execution environment 350. Code module installation module 240 determines a code module installation specification based on target execution environment specification 350 and code module requirement specification 340. Code module installation module 240 also causes one or more code modules specified by the code module installation specification to be installed in the target execution environment, thereby generating an updated target execution environment 360.

[0095] Verification module 250 uses resource usage specification 330 and data of updated target execution environment 360 to verify whether the resources of the updated target execution environment can be used to execute the trained model. Module 250 also uses code module installation specification and data of updated target execution environment 360 to verify whether the code module of the updated target execution environment can be used to execute the trained model. The result is verification status 370.

[0096] If the validation state 370 succeeds, then the simulation module 260 simulates the execution of the model in the updated target execution environment. The result is a simulation state 380. If the simulation state 380 succeeds, then the deployment module 270 deploys the model in the updated target execution environment (390).

[0097] refer to Figure 4 , which depicts example results of automated machine learning model deployment according to an illustrative embodiment.

[0098] Specifically, example 400 depicts a table in which each row represents a scenario for deploying a machine learning pipeline or model using a different execution environment configuration. The leftmost column contains numbers corresponding to each different scenario, and the Algorithm column (second from the left) contains the algorithm used in the machine learning model. The pipeline can include components from multiple libraries, and the Installed Packages column (third from the left) indicates how many new libraries need to be installed in the target execution environment. In some cases, no new libraries are installed (e.g., Scenario 2), and in some cases (e.g., Scenario 7) exceptions are raised due to library installation errors. The New Deployment Time column (second from the right) reports the time it takes to prepare the target execution environment and make it available for use by the model. The rightmost column represents the time taken by currently available technologies, thereby showing the benefits of reducing deployment time using embodiments of the present invention.

[0099] refer to Figure 5 , which depicts example results of automated machine learning model deployment according to an illustrative embodiment.

[0100] Specifically, example 500 depicts a table where each row represents a scenario for deploying a machine learning pipeline or model using a different execution environment configuration. The leftmost column contains numbers corresponding to each different scenario, which are related to Figure 4 Because different machine learning models have different dependencies, the Package column names the model package, the Package Size column reports the package size of the deployed model, and the Install Size column reports the total memory used when the model is deployed.

[0101] refer to Fig. 6A , which depicts a flow chart of an example process for automating machine learning model deployment according to an illustrative embodiment. Process 600 may be performed at Figure 2 The application 200 is implemented in the embodiment.

[0102] In block 602, the application uses the exported data of the machine learning model and the model training environment specification to identify the resource usage specification of the model and the code module usage specification of the model. In block 604, the application prunes the code module usage specification by analyzing the exported data, and prunes the code module requirement specification. In block 606, the application uses the model training environment specification to select the target execution environment. In block 608, the application determines the code module installation specification according to the target execution environment specification and the code module requirement specification. In block 610, the application checks whether the code module specified by the installation code module installation specification will exceed the resource limit specified by the target execution environment specification. If yes (the "yes" path of block 610), then in block 612, the application selects another target execution environment and returns to block 608. Otherwise (the "no" path of block 610), in block 614, the application installs the code module specified by the code module installation specification in the target execution environment. Then the application continues to point A.

[0103] refer to Figure 6B , which shows a continued flow chart of an example process for automating machine learning model deployment according to an illustrative embodiment. Specifically, Figure 6B Shows Fig. 6A Continuation of process 600 in FIG. Fig. 6A The point A in is the same.

[0104] Starting from point A, in block 616, the application verifies the resources of the updated target execution environment and the code modules installed in the updated target execution environment to execute the trained model. In block 618, the application checks whether the verification is successful. If so (the "YES" path of block 618), then in block 620, the application simulates the execution of the model in the updated target execution environment. In block 622, the application checks whether the simulation is successful. If so (the "YES" path of block 622), then in block 624, the application deploys the model in the updated target execution environment. Then (also the "No" path of blocks 618 and 622), the application ends.

[0105] Thus, in the illustrative embodiments, computer-implemented methods, systems or apparatuses, and computer program products for automated machine learning model deployment and other related features, functions or operations are provided. When an embodiment or a portion thereof is described with respect to a certain type of device, the computer-implemented method, system or apparatus, computer program product, or a portion thereof, is adapted or configured for use with an appropriate and comparable representation of that type of device.

[0106] Where embodiments are described as being implemented in an application, within the scope of the illustrative embodiments, it may be considered that the application is delivered in a Software as a Service (SaaS) model. In the SaaS model, the functionality of the application implementing the embodiments is provided to users by executing the application in a cloud infrastructure. Users may access the application using a variety of client devices through a thin client interface, such as a web browser (e.g., web-based email) or other lightweight client applications. Users do not manage or control the underlying cloud infrastructure, including the network, servers, operating system, or storage of the cloud infrastructure. In some cases, users may not even manage or control the functionality of the SaaS application. In certain other cases, the SaaS implementation of the application may allow for limited exceptions to user-specific application configuration settings.

[0107] The present invention may be a system, method and / or computer program product at any possible level of technical detail integration. The computer program product may include a computer-readable storage medium (or media) having computer-readable program instructions thereon for causing a processor to perform aspects of the present invention.

[0108] The computer-readable program instructions described herein can be downloaded from a computer-readable storage medium to a corresponding computing / processing device, or downloaded to an external computer or external storage device via a network (e.g., the Internet, a local area network, a wide area network, and / or a wireless network). The network can include copper transmission cables, optical transmission fibers, wireless transmissions, routers, firewalls, switches, gateway computers, and / or edge servers. The network adapter card or network interface in each computing / processing device receives the computer-readable program instructions from the network and forwards the computer-readable program instructions to be stored in a computer-readable storage medium in the corresponding computing / processing device.

[0109] The computer-readable program instructions for performing the operation of the present invention may be assembly instructions, instruction set architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, firmware instructions, state setting data, configuration data of an integrated circuit, or source code or object code written in any combination of one or more programming languages, including object-oriented programming languages, such as Smalltalk, C++, etc., and procedural programming languages, such as "C" programming language or similar programming languages. The computer-readable program instructions may be executed entirely on the user's computer, partially on the user's computer, executed as an independent software package, partially on the user's computer, partially on a remote computer, or entirely on a remote computer or server. In the latter case, the remote computer may be connected to the user's computer via any type of network, including a local area network (LAN) or a wide area network (WAN), or may be connected to an external computer (e.g., via the Internet using an Internet service provider). In some embodiments, an electronic circuit (including, for example, a programmable logic circuit, a field programmable gate array (FPGA), or a programmable logic array (PLA)) may be personalized electronic circuits by utilizing the state information of the computer-readable program instructions, thereby executing the computer-readable program instructions to perform aspects of the present invention.

[0110] This article describes aspects of the present invention with reference to the flow chart and / or block diagram of the method, device (system) and computer program product according to an embodiment of the present invention. It should be understood that each block in the flow chart and / or block diagram and the combination of blocks in the flow chart and / or block diagram can be implemented by computer-readable program instructions.

[0111] These computer-readable program instructions may be provided to a processor of a computer or other programmable data processing device to produce a machine, such that the instructions executed by the processor of the computer or other programmable data processing device create means for implementing the functions / actions specified in the flowchart and / or block diagram blocks. These computer-readable program instructions may also be stored in a computer-readable storage medium, which may instruct a computer, a programmable data processing device, and / or other equipment to operate in a specific manner, such that the computer-readable storage medium storing the instructions includes an article of manufacture, which includes instructions for implementing various aspects of the functions / actions specified in the flowchart and / or block diagram blocks.

[0112] Computer-readable program instructions may also be loaded onto a computer, other programmable data processing device, or other apparatus, so that a series of operational steps are performed on the computer, other programmable apparatus, or other apparatus to produce a computer-implemented process, so that the instructions executed on the computer, other programmable apparatus, or other apparatus implement the functions / actions specified in the flowchart and / or block diagram blocks.

[0113] The flow chart and block diagram in the figure show the possible architecture, function and operation of the system, method and computer program product according to various embodiments of the present invention. In this regard, each block in the flow chart or block diagram can represent a part of a module, segment or instruction, which includes one or more executable instructions for realizing a specified logical function. In some alternative implementations, the function indicated in the block may not occur in the order indicated in the figure. For example, two blocks displayed continuously can actually be completed as a step, executed simultaneously, executed substantially simultaneously, executed in a manner of partial or full time overlap, or sometimes blocks can be executed in reverse order, depending on the functions involved. It should also be noted that each block in the block diagram and / or flow chart and the combination of blocks in the block diagram and / or flow chart can be implemented by a dedicated hardware system that performs a specified function or action or performs a combination of dedicated hardware and computer instructions.

Claims

1. A computer-implemented method comprising: Using the exported data of the machine learning model and the model training environment specification, identifying a resource usage specification of the model and a code module usage specification of the model, the resource usage specification specifying a set of resources used when training the model in the model training environment specified by the model training environment specification, and the code module usage specification specifying a set of code modules used when training the model in the model training environment; determining a code module installation specification based on a code module requirement specification and a target execution environment specification, the code module requirement specification specifying a set of code modules required to execute the model, the code module installation specification specifying a set of code modules to be installed in a target execution environment, the target execution environment including an environment for executing the model, the target execution environment specified by the target execution environment specification; causing the code module specified by the code module installation specification to be installed in the target execution environment, the installation producing an updated target execution environment; using the data of the updated target execution environment, validating the updated target execution environment for execution of the model; as well as simulating execution of the model in the updated target execution environment; as well as In response to the simulation being successful, the model is deployed in the updated target execution environment.

2. The computer-implemented method of claim 1 , wherein: The model is trained in a training execution environment.

3. The computer-implemented method of claim 2, wherein: The training execution environment includes at least one resource that is not included in the target execution environment.

4. The computer-implemented method of claim 2, wherein: The training execution environment includes at least one code module that is not included in the target execution environment.

5. The computer-implemented method of claim 1 , further comprising: The code module usage specification is pruned by analyzing the exported data, and the pruned code module requirement specification is generated.

6. The computer-implemented method of claim 1 , wherein: The installing is performed in response to determining that installing the code module specified by the code module installation specification will not exceed a resource limit specified by the target execution environment specification.

7. The computer-implemented method of claim 1 , wherein: Verifying the updated target execution environment using the updated target execution environment data for execution of the model includes: The resources of the updated target execution environment are validated using the resource usage specification of the model for execution of the model.

8. The computer-implemented method of claim 1 , wherein: Verifying the updated target execution environment using the updated target execution environment data for execution of the model includes: The code module installation specification is used to verify the code module installed in the updated target execution environment for execution of the model.

9. A computer program product, comprising one or more computer-readable storage media, and program instructions stored together on the one or more computer-readable storage media, wherein the program instructions are executable by a processor to cause the processor to perform operations including: Using the exported data of the machine learning model and the model training environment specification, identifying a resource usage specification of the model and a code module usage specification of the model, the resource usage specification specifying a set of resources used when training the model in the model training environment specified by the model training environment specification, and the code module usage specification specifying a set of code modules used when training the model in the model training environment; determining a code module installation specification based on a code module requirement specification and a target execution environment specification, the code module requirement specification specifying a set of code modules required to execute the model, the code module installation specification specifying a set of code modules to be installed in a target execution environment, the target execution environment including an environment for executing the model, the target execution environment specified by the target execution environment specification; causing the code module specified by the code module installation specification to be installed in the target execution environment, the installation producing an updated target execution environment; using the data of the updated target execution environment, validating the updated target execution environment for execution of the model; as well as simulating execution of the model in the updated target execution environment; as well as In response to the simulation being successful, the model is deployed in the updated target execution environment.

10. The computer program product according to claim 9, wherein: The stored program instructions are stored in a computer readable storage device in the data processing system and wherein the stored program instructions are transmitted from a remote data processing system over a network.

11. The computer program product of claim 9, wherein: The stored program instructions are stored in a computer readable storage device in a server data processing system, and wherein, in response to a request over a network, the stored program instructions are downloaded to a remote data processing system for use in a computer readable storage device associated with the remote data processing system, further comprising: program instructions for metering usage of program instructions associated with the request; and Program instructions for generating invoices based on metered usage.

12. The computer program product of claim 9, wherein: The model is trained in a training execution environment.

13. The computer program product of claim 12, wherein: The training execution environment includes at least one resource that is not included in the target execution environment.

14. The computer program product of claim 12, wherein: The training execution environment includes at least one code module that is not included in the target execution environment.

15. The computer program product of claim 9, further comprising: The code module usage specification is pruned by analyzing the exported data, and the pruned code module requirement specification is generated.

16. The computer program product of claim 9, wherein: The installing is performed in response to determining that installing the code module specified by the code module installation specification will not exceed a resource limit specified by the target execution environment specification.

17. The computer program product of claim 9, wherein: Verifying the updated target execution environment using the updated target execution environment data for execution of the model includes: The resources of the updated target execution environment are validated using the resource usage specification of the model for execution of the model.

18. The computer program product of claim 9, wherein: Verifying the updated target execution environment using the updated target execution environment data for execution of the model includes: The code module installation specification is used to verify the code module installed in the updated target execution environment for execution of the model.

19. A computer system comprising a processor and one or more computer-readable storage media, and program instructions stored together on the one or more computer-readable storage media, the program instructions being executable by the processor to cause the processor to perform operations comprising: Using the exported data of the machine learning model and the model training environment specification, identifying a resource usage specification of the model and a code module usage specification of the model, the resource usage specification specifying a set of resources used when training the model in the model training environment specified by the model training environment specification, and the code module usage specification specifying a set of code modules used when training the model in the model training environment; determining a code module installation specification based on a code module requirement specification and a target execution environment specification, the code module requirement specification specifying a set of code modules required to execute the model, the code module installation specification specifying a set of code modules to be installed in a target execution environment, the target execution environment including an environment for executing the model, the target execution environment specified by the target execution environment specification; causing the code module specified by the code module installation specification to be installed in the target execution environment, the installation producing an updated target execution environment; using the data of the updated target execution environment, validating the updated target execution environment for execution of the model; as well as simulating execution of the model in the updated target execution environment; as well as In response to the simulation being successful, the model is deployed in the updated target execution environment.

20. The computer system of claim 19, wherein: The model is trained in a training execution environment.

Images