Autonomous Cloud Node Scoping Framework for Big Data Machine Learning Use Cases

Abstract

To provide a computing systems, a method, and non-transitory computer-readable media related to autonomous cloud-node scoping for big data machine learning use case.SOLUTION: A method includes the steps of: for each combination of a plurality of combinations of parameter values, setting 210 a combination of parameter values describing a use scenario; executing 215 a machine learning application according to the combination of the parameter values on a target cloud environment; measuring 220 computational cost for executing a machine learning application; and generating 225 recommendation for a configuration of a central processing unit, a graphics processing unit, and a memory of target cloud environment for executing the machine learning application based on the measured computational cost.SELECTED DRAWING: Figure 2

Description

[Background technology]

[0001] background The use of cloud containers is increasing in the business world. A cloud container is a logical package that encapsulates an application and its dependencies, allowing containerized applications to run on a variety of host environments, such as Linux®, Windows®, Mac®, operating systems, virtual machines, or bare-metal servers. One example of such a container is a Docker® container. Cloud container technology enables enterprises to easily deploy and access software as a service over the internet. Containerization provides separation of concerns, as enterprises can focus on their software application logic and dependencies without worrying about deployment and configuration details, while cloud vendors can focus on deployment and configuration without being burdened by the details of the software application. Cloud container implementation of applications also offers a high degree of customization and reduces enterprise operational and infrastructure costs (compared to the relatively high costs of operating their own data centers).

[0002] Implementing software applications using cloud container technology allows software to scale to meet an enterprise's computing needs. Cloud computing service vendors like Oracle® can charge for cloud container services based on specific use cases, number of users, storage space, and computational costs. Therefore, companies purchasing cloud container services only pay for the services they receive and can choose a package that fits their budget. Major cloud vendors, including Amazon®, Google®, Microsoft®, and Oracle®, offer cloud container services. [Overview of the project] [Problems that the invention aims to solve]

[0003] However, the implementation of machine learning software applications has not been easily scaled with cloud container technology due to the highly complex interrelationships between provisioned available memory, provisioned total GPU and CPU power, the total number of signals, and the sampling rate of sensor streams that govern throughput and latency. [Means for solving the problem]

[0004] overview In one embodiment, a computer-implemented method includes, for each of a plurality of combinations of parameter values, the steps of (i) setting a combination of parameter values ​​that describes a usage scenario, (ii) running a machine learning application on a target cloud environment according to the combination of parameter values, and (iii) measuring the computational cost for running the machine learning application, and generating recommendations regarding the configuration of the central processing unit, graphics processing unit and memory of the target cloud environment for running the machine learning application based on the measured computational cost.

[0005] In one embodiment, the method further includes the steps of simulating a set of signals from one or more sensors and providing the set of signals to the machine learning application as input to the machine learning application while the machine learning application is running.

[0006] In one embodiment, the combination of parameter values ​​for this method is a combination of the number of signals from one or more sensors, the number of observations streamed per unit time, and the number of training vectors given to a machine learning application.

[0007] In one embodiment, the machine learning application of this method creates a nonlinear relationship between the combination of parameter values ​​and the computational cost.

[0008] In one embodiment, the method further includes the steps of generating one or more graphic representations showing combinations of parameter values ​​associated with the computational cost for each combination, and generating instructions to display one or more graphic representations on a graphical user interface, enabling the selection of a configuration of a central processing unit, graphics processing unit and memory in a target cloud environment for running a machine learning application.

[0009] In one embodiment, the method further includes the step of automatically configuring cloud containers in a target cloud environment according to a recommended configuration.

[0010] In one embodiment, the combination of parameter values ​​in this method is set according to a Monte Carlo simulation, and the method further includes the step of providing the parameter values ​​to the machine learning application as input to the machine learning application while the machine learning application is running.

[0011] In one embodiment, the method further includes, for each set of available configurations of central processing units, graphics processing units, and memory in a target cloud environment, the steps of setting, executing, and measuring are repeated for each combination of multiple combinations of parameter values.

[0012] In one embodiment, in a non-temporary computer-readable medium storing computer-executable instructions, when an instruction is executed by at least the processor of a computer, the computer is instructed to perform, for each of a plurality of combinations of parameter values, the steps of: (i) setting a combination of parameter values ​​that describes a usage scenario; (ii) executing a machine learning application on a target cloud environment according to the combination of parameter values; and (iii) measuring the computational cost for executing the machine learning application, and generating recommendations regarding the configuration of the central processing unit, graphics processing unit and memory of the target cloud environment for executing the machine learning application based on the measured computational cost.

[0013] In one embodiment, a non-transient computer-readable medium further includes instructions that, when executed by at least a processor, cause a computer to perform the steps of simulating a set of signals from one or more sensors and providing the set of signals to a machine learning application as input to the machine learning application while the machine learning application is running.

[0014] In one embodiment, in a non-transient computer-readable medium, the combination of parameter values ​​is the number of signals from one or more sensors and the streaming per unit time. This is a combination of the number of observations being tracked and the number of training vectors provided to the machine learning application.

[0015] In one embodiment, a non-temporary computer-readable medium, when executed by at least a processor, further includes instructions that cause a computer to perform the steps of: generating one or more graphic representations showing combinations of parameter values ​​associated with the computational cost for each combination; generating instructions that cause one or more graphic representations to be displayed on a graphical user interface, enabling the selection of a configuration of a central processing unit, graphics processing unit and memory in a target cloud environment for running a machine learning application; and, in response to the selection, automatically configuring a cloud container in the target cloud environment according to the selected configuration.

[0016] In one embodiment, the computing system comprises a processor, memory operationally coupled to the processor, and a non-temporary computer-readable medium for storing computer executable instructions. When an instruction is executed by at least the processor accessing the memory, the computing system is instructed to perform, for each of a plurality of combinations of parameter values, the steps of: (i) setting a combination of parameter values ​​that describes a usage scenario; (ii) executing a machine learning application on a target cloud environment according to the combination of parameter values; and (iii) measuring the computational cost for executing the machine learning application, and generating recommendations regarding the configuration of the central processing unit, graphics processing unit and memory of the target cloud environment for executing the machine learning application based on the measured computational cost.

[0017] In one embodiment, the computer-readable medium further includes instructions to cause a computing system to execute a machine learning application in a container configured according to the container shape, according to a combination of the number of signals and the number of training vectors, for each container shape in a set of container shapes, for each increment of the number of signals in a range of the number of signals, for each increment of the sampling rate in a range of the sampling rate, and for each increment of the number of training vectors in a range of the number of training vectors.

[0018] In one embodiment, the computer-readable medium of the computing system further includes instructions that cause the computing system to perform the steps of: generating one or more graphic representations showing combinations of parameter values ​​associated with the computational cost for each combination; generating instructions that cause one or more graphic representations to be displayed on a graphical user interface, enabling the selection of a configuration of a central processing unit, graphics processing unit and memory in a target cloud environment for running a machine learning application; and, in response to the selection, automatically configuring a cloud container in the target cloud environment according to the selected configuration.

[0019] The accompanying drawings incorporated herein and forming part thereof illustrate various systems, methods, and other embodiments of the present disclosure. It will be understood that the boundaries of elements shown in the drawings (e.g., boxes, groups of boxes, or other shapes) represent one embodiment of the boundary. In some embodiments, one element may be implemented as multiple elements, or multiple elements may be implemented as a single element. In some embodiments, an element shown as an internal component of another element may be implemented as an external component, and vice versa. Furthermore, elements may not be to exact scale. [Brief explanation of the drawing]

[0020] [Figure 1]FIG. 0 is a diagram showing one embodiment of a cloud computing system associated with autonomous cloud node scoping for big data machine learning use cases. [Figure 2] FIG. 3 is a diagram showing one embodiment of a method associated with autonomous cloud node scoping for big data machine learning use cases. [Figure 3] FIG. 6 shows one embodiment of a method associated with autonomous cloud node scoping for big data machine learning use cases and shows details of one embodiment of a nested loop traversal of a combination of parameter values. [Figure 4] FIG. 9 is a diagram showing an example of a method for a specific use case associated with autonomous cloud node scoping for big data machine learning. [Figure 5A] FIG. 12 is a diagram showing an example of a three-dimensional (3D) graph generated to show the computational cost of a training process for a predictive machine learning technique called multivariate state estimation technique (MSET) as a function of the number of observations and the number of training vectors. [Figure 5B] FIG. 15 is a diagram showing an example of a three-dimensional (3D) graph generated to show the computational cost of a training process for a predictive machine learning technique called multivariate state estimation technique (MSET) as a function of the number of observations and the number of training vectors. [Figure 5C] FIG. 18 is a diagram showing an example of a three-dimensional (3D) graph generated to show the computational cost of a training process for a predictive machine learning technique called multivariate state estimation technique (MSET) as a function of the number of observations and the number of training vectors. [Figure 5D] FIG. 21 is a diagram showing an example of a three-dimensional (3D) graph generated to show the computational cost of a training process for a predictive machine learning technique called multivariate state estimation technique (MSET) as a function of the number of observations and the number of training vectors. [Figure 6A] FIG. 24 is a diagram showing an example of a three-dimensional (3D) graph generated to show the computational cost of streaming monitoring using MSET as a function of the number of observations and the number of training vectors. [Figure 6B]This figure shows an example of a 3D graph generated to illustrate the computational cost of streaming monitoring using MSET as a function of the number of observations and the number of training vectors. [Figure 6C] This figure shows an example of a 3D graph generated to illustrate the computational cost of streaming monitoring using MSET as a function of the number of observations and the number of training vectors. [Figure 6D] This figure shows an example of a 3D graph generated to illustrate the computational cost of streaming monitoring using MSET as a function of the number of observations and the number of training vectors. [Figure 7A] This figure shows an example of a 3D graph generated to illustrate the computational cost of the training process for MSET as a function of the number of observations and the number of signals. [Figure 7B] This figure shows an example of a 3D graph generated to illustrate the computational cost of the training process for MSET as a function of the number of observations and the number of signals. [Figure 7C] This figure shows an example of a 3D graph generated to illustrate the computational cost of the training process for MSET as a function of the number of observations and the number of signals. [Figure 7D] This figure shows an example of a 3D graph generated to illustrate the computational cost of the training process for MSET as a function of the number of observations and the number of signals. [Figure 8A] This figure shows an example of a three-dimensional (3D) graph generated to illustrate the computational cost of streaming monitoring using MSET as a function of the number of observations and the number of signals. [Figure 8B] This figure shows an example of a three-dimensional (3D) graph generated to illustrate the computational cost of streaming monitoring using MSET as a function of the number of observations and the number of signals. [Figure 8C] This figure shows an example of a three-dimensional (3D) graph generated to illustrate the computational cost of streaming monitoring using MSET as a function of the number of observations and the number of signals. [Figure 8D]This figure shows an example of a three-dimensional (3D) graph generated to illustrate the computational cost of streaming monitoring using MSET as a function of the number of observations and the number of signals. [Figure 9] This figure shows one embodiment of a method associated with autonomous cloud node scoping for big data machine learning use cases to evaluate multiple computational shapes. [Figure 10] This figure shows one embodiment of GUI1000 as an example for presenting container shape, cost, and 3D performance information curves, as well as container shape recommendations. [Figure 11] This figure shows an embodiment of a computing system configured using the disclosed system and / or method. [Modes for carrying out the invention]

[0021] Detailed explanation This specification describes a system and method that provides an autonomous cloud node scoping framework for big data machine learning use cases.

[0022] Machine learning (ML) techniques can be applied to generate predictive information for Internet of Things (IoT) applications. In several implementations, machine learning techniques are applied to datasets generated by high-density sensor IoT applications. High-density sensor applications have large amounts of sensor-generated information that require low-latency and high-throughput data processing. Often, predictive applications run on on-prem data center assets. Resources within the data center, such as central processing units (CPUs), graphics processing units (GPUs), memory, and input / output (I / O) handling, are reconfigured from time to time and grow along with use case requirements.

[0023] Cloud computing offers an alternative to on-premises computing. Companies implementing their predictive machine learning applications in a cloud container environment can save the enormous overhead costs associated with operating their own data centers. Furthermore, companies can access advanced predictive machine learning pattern recognition unique to the cloud environment to identify anomalies in streaming sensor signals. However, achieving low-latency and high-throughput specifications for large-scale streaming predictive applications using predictive ML algorithms (such as Oracle® MSET2) in a cloud computing environment requires that the cloud computing environment precisely match the performance specifications before the predictive application is deployed in the cloud. Sizing the computing environment involves identifying the correct number of CPUs and / or GPUs in the container configuration, the correct number of computing cores, the correct amount of storage, and / or the container "shape" relative to CPUs and GPUs. Ensuring that enterprises have good performance for real-time streaming predictive diagnostics through correct sizing of cloud containers for enterprise applications presents several technical challenges.

[0024] For companies that already have big data streaming analytics in their on-premises data centers, scaling to approximate the required CPU, GPU, memory, and / or storage footprint in Oracle Cloud Infrastructure (OCI) cloud containers was not feasible for several reasons.

[0025] Machine learning predictions are often "computation-bound," meaning the time required to complete a task is primarily determined by the speed of the central processor. However, companies performing streaming analytics are not only concerned with GPU / CPU performance keeping up with real-time (a fundamental requirement of streaming predictions), but are equally concerned with throughput and latency. In the case of streaming machine learning predictions, throughput and latency depend on the amount of provisioned available memory, the total provisioned GPU and CPU power, and the number of signals and observations per second in the sensor stream. It depends very complexly on the total number. Generally, the computational cost is quadratic with the number of signals. It scales linearly with the number of observations. Furthermore, enterprise expectations for the accuracy of machine learning predictions also influence the configuration requirements of cloud containers, and the number of training vectors directly impacts the container's memory requirements, in addition to adding computational cost overhead for training the machine learning model.

[0026] In the past, due to the complex relationships involved in machine learning predictions, discovering the optimal cloud configuration for a typical enterprise use case would require numerous trials and errors by the enterprise and the efforts of consultants. The trial-and-error nature of discovering the optimal cloud configuration prevents enterprises from initiating those small, autonomously growing cloud container capabilities through the elasticity determined by computational dynamics. To enable cloud container capabilities to grow autonomously in response to the computational dynamics in the actual use of predictive machine learning applications, the performance of machine learning technologies deployed in cloud containers must be evaluated.

[0027] To address these and other technical challenges, this application uses nested-loop Monte Carlo-based simulation to target cloud computing We provide an autonomous container scoping tool (or automated scoping tool) that autonomously scales customer machine learning use cases of any size across the range of cloud CPU-GPU "shapes" (CPU and / or GPU configurations within cloud containers such as OCI containers) available within TenaStack. In one embodiment, the autonomous container scoping tool stress-tests candidate cloud containers for machine learning applications as parameter functions of the total number of signals in observations, the number of observations, and the number of training vectors in a nested-loop multi-parameter approach. The autonomous container scoping tool generates expected cloud container performance in terms of throughput and latency as a function of the customer's expected number of signals and the sampling rate of those signals. This is a feature that has not existed until now.

[0028] The Autonomous Container Scoping Tool is a machine learning-friendly framework that enables automated scoping evaluation for any pluggable machine learning algorithm. In one embodiment, the automated scoping tool uses a pluggable framework that can support various forms of machine learning techniques, such as multivariate state estimation technique (MSET), neural networks, and support vector graphics. Any containerized machine learning technique, including applications such as thins, automated associative kernel regression, and customer-specific machine learning applications, can be easily plugged into the tool for evaluation, according to a defined scope of use cases. Thus, the autonomous container scoping tool can evaluate the performance of containerized machine learning applications under any specified type of use case. In one embodiment, the autonomous scoping tool can estimate the appropriate size and shape of a cloud container for a machine learning technique.

[0029] MSET, neural networks, support vector machines, and automated associative kernel regression machine learning techniques are all types of advanced nonlinear nonparametric (NLNP) pattern recognition. Computational computation for such NLNP pattern recognition is required. The storage and memory footprint scale in a complex non-linear manner depending on the number of sensors, the number of observations or samples per unit time (or sampling rate), the total number of samples used for training, and the subset of training data selected as the training vector.

[0030] Advantageously, in one embodiment, the automated scoping tool locates the platform of interest, i.e., the target cloud computer where the machine learning application is deployed. Perform scoping analysis on the computing platform. This can be important because computational cost overhead, as well as latency and throughput metrics, differ between various on-premises computing platforms such as enterprise legacy computing systems or Oracle Exadata® database machines, and the container forms available on cloud computing infrastructure such as Oracle Cloud Infrastructure (OCI).

[0031] In one embodiment, the automated scoping tool can be created entirely autonomously, without requiring corporate data scientists and / or consultants. This allows the entity to autonomously grow its cloud container capabilities through resilience as its processing demands increase. Furthermore, the automated scoping tool enables the entity to autonomously migrate machine learning applications from its on-premises data centers to cloud containers in a cloud computing environment.

[0032] In one embodiment, an automated scoping tool can be used to rapidly scoping cloud container sizes for new use cases requiring advanced predictive machine learning techniques. The automated scoping tool can indicate a range of suitable cloud container configurations, including one or more "shapes" that include CPU, GPU, and / or both CPU and GPU in various shared memory configurations. In one embodiment, the resulting configurations can be combined with a pricing schedule to provide enterprises with a range of cost estimates for the solution.

[0033] Aside from the automated scoping tools described herein, there are no other tools, techniques, or frameworks that can estimate the size of cloud containers for big data machine learning use cases (i.e., the number of CPUs, the number of GPUs, the amount of memory, and / or a proper description of the container's "shape").

[0034] -Example Environment- Figure 1 shows one embodiment of a cloud computing system 100 associated with autonomous cloud node scoping for a big data machine learning use case. The cloud computing system 100 includes a target cloud container stack 101 and an automated scoping tool 103, interconnected by one or more networks 105 (e.g., the Internet or a private network associated with the target cloud container stack 101). The cloud computing system 100 may be configured to provide one or more software applications as a service to client computers within an enterprise network 107 associated with a company, via the network 105.

[0035] In one embodiment, the target cloud container stack 101 may be an Oracle cloud infrastructure stack. In another embodiment, the target cloud container stack may be a GE Predix® stack, a Microsoft Azure® stack, an Amazon Web Services stack (including, for example, Amazon Elastic Container Service), or another scalable cloud computing stack capable of supporting container-based applications.

[0036] In one embodiment, the target cloud container stack 101 includes an infrastructure layer 109, an operating system layer 111, a container runtime engine 113, and a container layer 115. The infrastructure layer 109 is an infrastructure layer The system includes one or more servers 117 and one or more storage devices 119 interconnected by a Rakucha network 121. Each server 117 includes one or more central processing units (CPUs) 123 and / or graphics processing units (GPUs) 125, as well as memory 127. The storage devices may include solid-state memory drives, hard drive disks, network-attached storage (NAS) devices, or other storage devices.

[0037] In one embodiment, the operating system layer 111 is Linux®, Windows®, Mac®, Unix®, or any other operating system. These operating systems may be full-featured operating systems or minimal operating system configurations that include only the features necessary to support the use of the infrastructure layer 109 by the container runtime engine 113. In one embodiment, the operating system 111 is not included in the target cloud container stack 101, and the container runtime engine 113 is configured to interface directly with the infrastructure layer 109 in a bare-metal type configuration, such as that provided by Oracle Cloud Infrastructure Bare Metal Cloud.

[0038] The container runtime engine 113 automates the deployment, scaling, and management of containerized applications. In one embodiment, the container runtime engine 113 is Oracle Container Cloud Service®. In one embodiment, the container runtime engine 113 is the Kubernetes® engine. The container runtime engine 113 supports the operation of containers within the container tier 115. In one embodiment, containers 129 and 131 within the container tier are Docker® containers, i.e., containers built in the Docker image format. In one environment, container 129 for test application 133 is deployed in the container tier 115. The binaries and libraries 135 supporting test application 127 are included in container 123. In one embodiment, container 131 for production application 137 is deployed in the container tier 115. The binaries and libraries 139 supporting production application 137 are included in container 125.

[0039] A container deployed on container tier 115 (for example, a test application container 129 or a production application container 131) can specify the "shape" of its dedicated computing resources (represented by the number of CPUs 123, GPUs 125, and memory 127). This "shape" information may be stored in a container image file. In one embodiment, the "shape" information is communicated to the container runtime engine by setting runtime configuration flags in the "docker run" command (or equivalent commands and flags in other container formats).

[0040] In one embodiment, the automated scoping tool 103 includes a containerization module 141, a test execution module 143, a computation cost recording module 145, an interface module 147, and an evaluation module 149. In one embodiment, the automated scoping tool 103 is a dedicated computing device composed of modules 141 to 149. In one embodiment, the automated scoping tool is part of a target cloud container stack 101, for example, a component of a container runtime engine 113.

[0041] In one embodiment, the containerization module 141 automatically builds a Docker container. The containerization module 141 includes at least an application and application It accepts binaries and libraries that support the application, as well as container "shape" information, as input. From at least these inputs, the containerization module 141 creates a container image file (such as a Docker image) suitable for deployment to the container layer 115 of the target cloud container stack 101. In one embodiment, the containerization module 141 includes and / or interfaces with an automated containerization tool available from Docker, Inc. that scans the application and identifies the application code and associated binaries and / or libraries. The containerization module 141 then automatically generates a Docker image file, partly based on this code, binaries, and / or libraries. In one embodiment, the container image file is created, at least partly based on a template. The containerization module 141 can retrieve a template from a library of one or more templates.

[0042] In one embodiment, the test execution module 143 manipulates a sequence of benchmarking or stress test operations for a specific containerized application. For example, the test execution module 143 accepts as input at least (i) a range of the number of signals per observation and an increment over the range of the number of signals, (ii) a range of the number of observations and an increment over the range of the number of observations, (iii) a range of the number of training vectors and an increment over the range of the number of training vectors, (iv) a specific containerized application, and (v) test data. The test execution module causes the target cloud container stack 101 to run the specific containerized application for each permutation of the number of signals, the number of observations, and the number of training vectors, as they are incremented over their respective ranges. The number of training vectors is sometimes referred to as the size of the training dataset.

[0043] In one embodiment, the specific application being containerized is a test application 133. The containerization module 141 can have the test application 133 and its associated binaries and / or libraries 135 scanned, for example, from an on-premises server 151 associated with the enterprise, and sent from the enterprise network 107 to an automated scoping tool 103 via network 105. In one embodiment, the test application 133 is a high-density sensor IoT application for analyzing a large time-series database using machine learning predictions. The containerization module 141 creates a test application container 129 from the test application 133 and its associated binaries and / or libraries 135.

[0044] In response to an instruction that a test application container will be used for testing, the containerization module configures the test application container 129 to have a specific computation shape (with allocated CPU 123, allocated GPU 125, and allocated memory 127). In one embodiment, the computation shape is selected from a set or library of computation shapes suitable for implementation by the target cloud container stack 101. The appropriate computation shape may be based on characteristics of the target cloud container stack 101, such as the hardware and / or software configuration of the target cloud container stack 101. The set of appropriate shapes may differ between target cloud container stacks having different hardware or software configurations. A library of computation shapes associated with each possible target cloud container stack may be managed by an automated scoping tool 103, and the computation shapes associated with the target cloud container stack 101 may be retrieved from the library by the containerization module 141 when containerizing the test application 133.

[0045] In one embodiment, there are multiple computation shapes suitable for use with a target cloud container stack configuration. Each of the test application containers 129 may be a candidate for selection as a production application container 131. In one embodiment, in response to an instruction that the test application container is to be used for testing, the containerization module configures the test application container 129 to have a first unevaluated computation shape and increments it to the next unevaluated computation shape in the next iteration of the test. In this way, a test application container 129 is created for each computation shape suitable for the target cloud container stack 101, and the candidate container shapes are evaluated in sequence.

[0046] The container runtime engine 113 and the automated scoping tool 103 may each be configured with an application programming interface (API) for receiving and sending information and commands. For example, the API may be a Representation State Transfer (REST) ​​API. The containerization module 141 can send API commands to the container runtime engine 113 to instruct the container runtime engine 113 to deploy the test application container 129 to the container layer 115. The containerization module may also send the test application container 129 to the container runtime engine 113 for deployment.

[0047] In one embodiment, the test execution module 143 accesses the body of test data for use by the test application 133 while it is running on the target cloud container stack 101. The test data must include training vectors and observations. The training vectors are memory vectors for sensor observations that represent the normal operation of the system being monitored or supervised by the sensor. The test data must include a sufficient number of training vectors to enable the execution of each training permutation of the test. The observations are memory vectors for sensor observations that are unknown as to whether or not they represent the normal operation of the system being monitored by the sensor. The test data must include a sufficient number of observations to enable the execution of each observation permutation of the test. In one embodiment, the number of signals in the observations and training vectors is made to match the number of signals currently being tested. In one embodiment, the number of signals in the observations and training vectors is the maximum number of signals, and unused signals are ignored by the test.

[0048] In one embodiment, the test data body is historical data compiled by an on-premises server 151 from readings from, for example, one or more Internet of Things (IoT) (or other) sensors 153. The number of sensors 153 can be very large. In some implementations, machine learning techniques are applied to datasets generated by high-density sensor IoT applications. High-density sensor applications have a large amount of sensor-generated information that requires low-latency and high-throughput data processing. The test execution module 143 receives or retrieves the test data body from the on-premises server 151 via the network 105. The test execution module 143 causes the test data body to be provided to the test application 133 while being executed by the target cloud container stack 101.

[0049] In one embodiment, the test data body is synthesized data generated based on historical data compiled, for example, by an on-premises server 151. The automated scoping tool 103 may include a signal synthesis module (not shown).

[0050] In one embodiment, the computation cost recording module 145 tracks the computation cost of each permutation of the number of signals, the number of observations, and the number of training vectors in the test. In one embodiment, the computation cost is measured in milliseconds elapsed between the start and completion of the computation. In this configuration, computational cost is measured by the time it takes for the target cloud container stack 101 to run the test application 133 for the permutation. In one embodiment, the test application container 129 is configured to send the time it takes for the execution of the test application 133 to start and complete on the target cloud container stack 101 via the network 105 to the computational cost recording module 145. In one embodiment, for each permutation, the computational cost recording module 145 is configured to record performance in a data store associated with the automated scoping tool 103. Performance may be recorded as a data structure representing tuples indicating (i) the number of signals per observation for the permutation, (ii) the number of observations for the permutation, (iii) the number of training vectors for the permutation, and (iv) the difference between the time it started and the time it finished running the test application 133 for the permutation. Other computational cost metrics, such as the count of processor cycles or memory swap count required to complete the execution of the test application 133 for the permutation, may also be relevant and may be tracked, reported to the computational cost recording module, and recorded in the data store.

[0051] In one embodiment, the computation cost is decomposed into the computation cost of the training cycle and the computation cost of the monitoring cycle. The test application container 129 is configured to send to the computation cost recording module 145 (i) the start and completion times of the training cycle execution for the test application 133 on the target cloud container stack 101, and (ii) the start and completion times of the monitoring cycle execution for the test application 133 on the target cloud container stack 101. This performance may be recorded in a data store associated with the automated scoping tool 103. This record may be a data structure representing tuples indicating (i) the number of signals per observation for the permutation, (ii) the number of observations for the permutation, (iii) the number of training vectors for the permutation, (iv) the difference between the start and completion times of the training cycle execution for the test application 133 for the permutation, and (v) the difference between the start and completion times of the monitoring cycle execution for the test application 133.

[0052] In one embodiment, the interface module 147 is configured to generate and transmit commands to display a user interface to the automated scoping tool 103 on a client computing device. For example, the user interface may include a graphical user interface (GUI) that incorporates GUI elements for collecting information and commands from users or administrators of the automated scoping tool 103 and / or the cloud computing system 100. These GUI elements may include various graphical buttons, radio buttons, checkboxes, text boxes, menus such as drop-down menus, and other elements.

[0053] The interface module 147 may be configured to display visualizations of performance data recorded in a data store associated with the automated scoping tool 103. In one embodiment, the visualization is a graph showing the relationship between computational cost and one or more of the number of signals, observations, and training vectors across a set of test permutations. In one embodiment, the visualization may be specific to a test training cycle or a test monitoring cycle.

[0054] In one embodiment, the evaluation module 149 determines a recommended container "shape" (also called a "computer shape") for operating the production application 137 version of the application scanned from the on-premises server 151. The evaluation module 149 takes as input: (i) a minimum latency threshold or target latency for the rate of processing observations, (ii) a target number of signals to be included in each observation, (iii) a target number of observations per unit time or a target sampling rate, and (iv) a training vector. The evaluation module accepts target numbers. These can also be called performance constraints for the machine learning application and represent the operating conditions expected in the real world. The evaluation module 149 also accepts performance data recorded by the computation cost recording module as input (v). Based at least in part on these inputs, the evaluation module 149 can create a recommended container shape (described by the number of CPUs 123, the number of GPUs 125, and the allocated memory) for deployment on the target cloud container stack. This recommended shape can be presented to the GUI by the interface module for review and confirmation by the user of the automated scoping tool 103. The GUI can further display one or more visualizations of the performance data supporting the recommended shape. In one embodiment, the evaluation module 149 generates an instruction to form a production application container 131 with the recommended shape and sends it to the containerization module 141 to create the production application container 131. In one embodiment, the GUI includes a GUI element configured to accept input approving the creation of a production application container using the recommended shape.

[0055] In one embodiment, the evaluation module 149 further accepts the per-unit time cost of using the CPU and GPU as input. The recommended "shape" may further be based on the per-unit time cost of the CPU and GPU. For example, the recommended shape may be the shape that minimizes the overall cost to maintain the minimum rate of observation throughput.

[0056] In one embodiment, the evaluation module 149 ranks a set of possible container shapes according to criteria such as the monetary cost of manipulating the container shape. In one embodiment, the evaluation module may further rank container shapes that do not satisfy performance constraints from the set of possible container shapes in order to create a list of feasible container shapes.

[0057] In addition to the on-premises server 151 and IoT sensor 153, the enterprise network 107 may also include a wide variety of computing devices and / or network devices. Examples of such computing devices include server computers such as the on-premises server 151, desktop computers 155, laptop or notebook computers 157, personal computers such as tablet computers or personal digital assistants (PDAs), mobile phones, smartphones 159 or other mobile devices, machine control devices, IP phone devices, and other electronic devices incorporating one or more computing device components such as one or more electronic processors, microprocessors, central processing units (CPUs), or controllers. While the production application 137 is running on the target cloud container stack 101, one or more devices in the enterprise network 107 may provide information to the production application 137 or request and receive information from the production application 137. For example, the IoT sensor 153 may provide observations that are monitored or observed by the production application 137. Alternatively, for example, a client application running on a desktop computer 155, a laptop computer 157, and / or a smartphone 159 may request information about a system monitored or supervised by the production application 137.

[0058] -Example of method- This specification describes a computer-based method for autonomous cloud node scoping for big data machine learning use cases. In one embodiment, one or more computing devices (computers shown and described with reference to Figure 11) A computing device having an operationally connected processor (processor 1110, etc.), memory (memory 1115, etc.), and other components (e.g., 1105) may consist of logic (autonomous cloud node scoping logic 1130, etc.) that causes the computing device to perform steps of the method. For example, the processor performs the steps shown and described with reference to Figure 2 by accessing memory and reading from or writing to memory. These steps may include (i) retrieving any necessary information, (ii) computing, determining, generating, classifying, or creating any data, and (iii) storing any data that has been computed, determined, generated, classified, or created. In one embodiment, the method described herein may be performed by an automated scoping tool 103 or a target cloud container stack 101 (shown and described with reference to Figure 1).

[0059] In one embodiment, each subsequent step of the method is initiated in response to an analysis of a received signal or retrieved stored data, indicating that the previous step has been performed to at least the extent necessary for the subsequent step to begin. Generally, the retrieved received signal or stored data indicates the completion of the previous step.

[0060] Figure 2 shows one embodiment of Method 200 related to autonomous cloud node scoping for big data machine learning use cases. In one embodiment, a computer-implemented method is shown. This method includes, for each of several combinations of parameter values, the steps of (i) setting a combination of parameter values ​​that describes a use scenario, (ii) running a machine learning application on a target cloud environment according to the combination of parameter values, and (iii) measuring the computational cost to run the machine learning application. This method also includes the step of generating a recommended configuration of the central processing unit, graphics processing unit, and memory of the target cloud environment for running the machine learning application based on the measured computational cost. In one embodiment, Method 200 may be performed by an automated scoping tool 103 and / or a target cloud container stack 101.

[0061] Method 200 may be initiated based on various triggers, which may include receiving a signal over the network or analyzing stored data indicating that (i) a user (or administrator) of the cloud computing system 100 initiated Method 200, (ii) Method 200 is scheduled to start at a specified time, or (iii) an automated process is running to migrate a machine learning application from a first computer system to a target cloud environment. Method 200 is initiated in the START block 205 when it is determined that the received signal or retrieved stored data indicates that Method 200 should be initiated. Processing then proceeds to the process block 210.

[0062] In process block 210, the processor sets a combination of parameter values ​​that describe the usage scenario.

[0063] In one embodiment, the processor retrieves the following combination of parameter values ​​from memory or storage. The parameters may be the number of signals per observation, the number of observations, and the number of training vectors. The processor uses the retrieved combination of parameter values ​​to generate instructions for the test application 133 (a machine learning application containerized with a specific computational shape) to be executed. The processor sends the instructions to the test application 133, for example, as a REST command. The instructions may be sent to the test application via the container runtime engine 113. The steps of process block 210 are, for example, the test execution module 143 of the automated scoping tool 103. This can be done by [method].

[0064] Once the processor has finished setting the combination of parameter values ​​that describe the usage scenario in this way, the processing of process block 210 is completed and processing proceeds to process block 215.

[0065] In process block 215, the processor executes a machine learning application on the target cloud environment according to a combination of parameter values.

[0066] In one embodiment, the test application 133 includes a machine learning algorithm. The processor generates an instruction, such as a REST command, for the test application 133 that it should begin execution of. This step of generating the execution start instruction can be performed, for example, by the test execution module 143 of the automated scoping tool 103. Accordingly, the processor retrieves a set of test data defined by a combination of parameter values. The processor executes the test application 133, which includes the machine learning algorithm, on the set of test data. In one embodiment, the processor records in memory a first time when the processor begins execution of the test application 133 and a second time when the processor completes execution of the test application. In one embodiment, the processor records in memory a first time when the processor begins execution of the training cycle of the test application 133 and a second time when the processor completes execution of the training cycle of the test application. In one embodiment, the processor records in memory a first time when the processor begins execution of the monitoring cycle of the test application 133 and a second time when the processor completes execution of the monitoring cycle of the test application 133. In one embodiment, the processor records in memory the processor (CPU and / or GPU) cycles used during the execution of the test application 133, the training cycles of the test application 133, and / or the monitoring cycles of the test application 133. These steps—retrieving the set of test data, running the test application, and recording time or processor cycles—may be performed, for example, by the target cloud container stack 101.

[0067] Once the processor completes the execution of the machine learning application on the target cloud environment according to the combination of parameter values, the processing in process block 215 is completed, and the process proceeds to process block 220.

[0068] In process block 220, the processor measures the computational cost of running a machine learning application.

[0069] In one embodiment, a processor generates a request to a test application container 129 that asks for a first and second time record and / or an aggregate of processor cycles. This request may be, for example, a REST request directed to the test application container 129 via the container runtime engine 113. This request may also be generated and sent by, for example, a compute cost record module 145. Next, a processor running the application container (one or more processors in the target cloud container stack 101) returns the requested time and / or aggregate to the compute cost record module 145. Next, a processor running the compute cost record module 145 creates a compute cost record (data structure) containing the current combination of parameter values ​​and compute costs and stores it in memory or storage. The combination of parameter values ​​may include the number of signals, the number of observations, and the number of training vectors. The compute cost is the first time returned This may include the difference between the two time points and / or the sum of the returned processor cycles.

[0070] Once the processor has completed measuring the computational cost for running the machine learning application, the process is repeated from process block 210 for each of the remaining combinations of parameter values ​​until there are no more combinations of parameter values ​​left. The processor increments one of the parameter values ​​and moves on to the next combination of parameter values ​​in a nested loop traverse of possible combinations of parameter values ​​for the stored increment value. The increment value of a parameter can be retrieved from memory or storage. In this way, the combinations of parameter values ​​are set to describe each expected use case, the machine learning application is run for the parameter values ​​of each expected use case, and the performance of the machine learning application for each expected use case is measured. Thus, the process in process block 220 is completed, and the process proceeds to process block 225.

[0071] In process block 225, the processor generates recommendations for the configuration of the central processing unit, graphics processing unit, and memory in the target cloud environment for running the machine learning application, based on the measured computational cost.

[0072] In one embodiment, the processor retrieves a record of the computational cost for a target combination of the number of signals, observations, and training vectors. The processor determines whether the computational cost for the target combination exceeds the target latency for executing the machine learning application for that combination. The target latency and target combination are information provided by the user. If the target latency is exceeded, the computational shape (configuration of the central processing unit, graphics processing unit, and memory in the target cloud environment) assigned to the machine learning application in test application 133 is inappropriate and will result in a backup of unprocessed observations. Therefore, if the target latency is exceeded, the processor generates a recommendation for the computational shape of test application 133. If the target latency is not exceeded, the computational shape assigned to the machine learning application in test application 133 is appropriate and will process the observations provided to test application 133 in a timely manner. Therefore, if the target latency is not exceeded, the processor generates a recommendation favorable to the computational shape. The processor can further select the computational form of the test application (the configuration of the central processing unit, graphics processing unit, and memory in the target cloud environment) as the computational form of the container configuration for deploying the machine learning application to the target cloud container stack (creating a production application 137).

[0073] In one embodiment, if the computational costs of multiple test applications do not exceed the target latency, the processor may further evaluate which of the multiple test applications has the least expensive computational form (as further described herein).

[0074] Once the processor has finished generating recommendations regarding the configuration of the central processing unit, graphics processing unit, and memory for the target cloud environment to run the machine learning application based on the measured computational cost, the processing in process block 225 is complete, and processing proceeds to END block 230, where process 200 terminates.

[0075] In one embodiment, the combination of parameter values ​​is set according to a Monte Carlo simulation, and the parameter values ​​are provided to the machine learning application as input during the execution of the machine learning application. Thus, Figure 3 This document illustrates one embodiment of Method 300 relating to autonomous cloud node scoping for big data machine learning use cases, and details one embodiment of nested loop traversal of parameter value combinations. Method 300 may be initiated based on various triggers, which are, for example, receiving a signal over the network or analyzing stored data indicating that (i) a user (or administrator) of cloud computing system 100 has initiated Method 300, (ii) Method 300 is scheduled to be initiated at a specified time, or (iii) an automated process is running that migrates a machine learning application from a first computer system to a target cloud environment, or (iv) Method 300 is being executed for a particular computation shape as part of an evaluation of multiple computation shapes. Method 300 is initiated in START block 305 in response to analyzing the received signal or retrieved stored data and determining that this signal or stored data indicates that Method 300 should be initiated. Processing proceeds to process block 310.

[0076] In process block 310, the processor sets the number of signals (numSig) to the initial number of signals (S initialThe number of signals is initialized by setting it to be equal to ). In one embodiment, the processor takes the starting value of the range of the number of signals, such as the initial value of the range received as input by the test execution module 143, as the initial number of signals. The processor sets the number of signals to be equal to the taken value. Processing in process block 310 is completed, and processing proceeds to decision block 315.

[0077] In decision block 315, the processor determines that the number of signals (numSig) is equal to the final number of signals (S finai The processor determines whether the number of signals is less than the final number of signals. The processor takes the end value of the range of signal numbers, such as the last value of the range accepted as input by the test execution module 143, as the final number of signals. The processor compares the number of signals with the final number of signals. If it is true that the number of signals is less than the final number of signals, the processing in the decision block 315 is completed, and processing continues in the process block 320.

[0078] In process block 320, the processor sets the number of observations (numObs) to the initial number of observations (O initial The number of observations is initialized by setting it to be equal to ). In one embodiment, the processor takes the starting value of the range of observations, such as the initial value of the range received as input by the test execution module 143, as the initial number of observations. The processor sets the number of observations to be equal to the number taken. Processing in process block 320 is completed, and processing proceeds to decision block 325.

[0079] In decision block 325, the processor determines that the number of observations (numObs) is equal to the final number of observations (O finai The processor determines whether the number of observations is less than the final number of observations. In one embodiment, the processor takes the end value of the range of observations, such as the final value of the range received as input by the test execution module 143, as the final number of observations. The processor compares the number of observations with the final number of observations. If it is true that the number of observations is less than the final number of observations, the processing in the decision block 325 is completed, and processing continues in the process block 330.

[0080] In process block 330, the processor sets the number of training vectors (numVec) to the initial number of training vectors (V initial The number of training vectors is initialized by setting it to be equal to ). In one embodiment, the processor takes a starting value of the range of training vector numbers, such as an initial value of the range received as input by the test execution module 143, as the initial number of training vectors. The processor sets the number of training vectors to be equal to the taken value. Processing in process block 330 is completed, and processing proceeds to decision block 335.

[0081] In decision block 335, the processor determines that the number of training vectors (numVec) is equal to the final number of training vectors (V finai The processor determines whether the number of training vectors is less than the final number of training vectors. In one embodiment, the processor takes the final value of a range of training vector numbers, such as the final value of a range accepted as input by the test execution module 143, as the final number of training vectors. The processor compares the number of training vectors with the final number of training vectors. If it is true that the number of training vectors is less than the final number of training vectors, the processing in the decision block 335 is completed, and processing continues in the process block 340.

[0082] In process block 340, the processor executes a machine learning application that has been plugged into a container and deployed to the target cloud container stack, with respect to the number of signals (numSig), the number of observations (numObs), and the number of training vectors (numVec). In one embodiment, the processor generates instructions for the machine learning application, telling it to extract the number of observations and the number of training vectors from the body of test data. Each of the observations and training vectors is limited in length to the number of signals. The processor truncates any additional signal sequences from the drawn observations and training vectors. The processor records a first time when training of the machine learning application begins. The processor trains the machine learning application using the drawn training vectors. The processor records a second time when training of the machine learning application ends. The processor records a third time when monitoring (or supervision) by the machine learning application begins. The processor monitors (or supervision) the drawn observations. The processor records a fourth time when monitoring (or supervision) by the machine learning application ends. Processing in process block 340 is complete, and processing proceeds to process block 345.

[0083] In process block 345, the processor records the computational cost of training and monitoring (or supervision) by the executed machine learning application. In one embodiment, the processor (for example, while the computational cost recording module 145 of the automated scoping tool 103 is running) generates a request and sends it to a container deployed in the target cloud container stack. The request is for the container to return the first, second, third, and fourth times. The container retrieves the first, second, third, and fourth times from memory and generates a message containing these times. The container sends this message to the computational cost recording module 145. In response, the computational cost recording module 145 writes the first, second, third, and fourth times, or the difference between the second time and the first time, and the difference between the fourth time and the third time, along with the number of signals, the number of observations, and the number of training vectors, to a computational cost data structure in the data store. Processing in process block 345 is complete, and processing proceeds to process block 350.

[0084] In process block 350, the processor increments the number of training vectors by vector increment (V increment ) increment by ). In one embodiment, the processor takes a vector increment value, such as an increment over a range of the number of training vectors received by the test execution module 143, as the vector increment value. The processor assigns or sets the number of vectors to a new value which is the sum of the current value of the number of vectors and the vector increment value. Once the processor has incremented the number of vectors by the vector increment in this way, the processing of process block 350 is completed and processing returns to decision block 335.

[0085] The process between decision blocks 335 and 350 is repeated for each increment of the number of vectors, as long as it is true that the number of training vectors is less than the final number of training vectors. This forms the innermost loop of the set of nested loops. When it becomes false that the number is less than the final number of training vectors (i.e., the number of training vectors is greater than or equal to the final number of training vectors), the loop ends and the process proceeds to process block 355.

[0086] In process block 355, the processor increments the number of observations by the observation increment (O increment ). In one embodiment, the processor extracts an observation increment value, such as an increment over the range of the number of observations received by test execution module 143, as the observation increment value. The processor assigns or sets the number of observations to a new value that is the sum of the current value of the number of observations and the observation increment value. When the processor thus increments the number of observations by the observation increment, the processing of process block 355 is complete and the process returns to decision block 325.

[0087] The processing between decision blocks 325 and 355 is repeated for each increment of the number of observations while it is true that the number of observations is less than the final number of observations. This forms the central loop of a set of nested loops. When it becomes false that the number of observations is less than the final number of observations (i.e., the number of observations is greater than or equal to the final number of observations), the loop ends and the process proceeds to process block 360.

[0088] In process block 360, the processor increments the number of signals by the signal increment (S increment ). In one embodiment, the processor extracts a signal increment value, such as an increment over the range of the number of signals received by test execution module 143, as the signal increment value. The processor assigns or sets the number of signals to a new value that is the sum of the current value of the number of signals and the signal increment value. When the processor thus increments the number of signals by the signal increment, the processing of process block 360 is complete and the process returns to decision block 315.

[0089] The processing between decision block 315 and decision block 360 is repeated for each increment of the signal count, as long as it is true that the signal count is less than the final signal count. This forms the outer loop of the set of nested loops. When it becomes false that the signal count is less than the final signal count (i.e., the signal count is greater than or equal to the final signal count), the loop terminates and processing proceeds to process block 365.

[0090] In process block 365, the processor outputs the computational cost for all permutations of the number of signals, the number of observations, and the number of training vectors. In one embodiment, the processor (for example, running interface module 147) retrieves each computational cost data structure from the data store. The processor generates instructions to display one or more graphs that present bar plots and / or surface plots, as defined by one or more computational cost data structures. The processor then sends instructions to display one or more graphs. Next, processing in process block 365 is completed, and the process proceeds to termination block 370, where process 300 ends.

[0091] -Signal simulation- In one embodiment, Method 300 includes the steps of (i) simulating a set of signals from one or more sensors, and (ii) providing the set of signals to a machine learning application as input to the machine learning application during the execution of the machine learning application. For example, the processor performs the function of a signal synthesis module (as described with reference to Figure 1). The signal synthesis module analyzes historical data compiled by the on-premises server 151 and generates a body of test data that is statistically identical to the historical data, thereby simulating the signals. The signal synthesis module stores the body of test data in a data store associated with the automated scoping tool 103. The test execution module 143 is executed by the target cloud container stack 101. During the line, access the body of the synthesized test data for use by test application 133.

[0092] In one embodiment, the signal synthesis module analyzes historical data and generates a formula that can be used to generate test data that is statistically identical to the historical data. The signal synthesis module stores the formula in a data store associated with the automated scoping tool 103. The signal synthesis module generates synthesized test data as needed for use by the test application 133 running on the target cloud container stack 101. Using a formula to synthesize data as needed has advantages over using a body of historical or synthesized test data in terms of required storage and portability, where the test data body may be several terabytes of data, while a formula may be only a few kilobytes.

[0093] The synthesized test data has the same deterministic and stochastic structure as "actual" historical data, continuous correlations for univariate time series, cross-correlations for multivariate time series, and stochastic content for noise components (variability, skewness, kurtosis). In one embodiment, the synthesis of training vectors and data for observation is performed separately. The synthesis of training vectors for the test data body is based on historical sensor observations that represent the normal operation of the system monitored or supervised by the sensor. The synthesis of observations for the test data body is based on historical sensor observations that are unknown as to whether or not they represent the normal operation of the system monitored by the sensor.

[0094] -Parameter variables- In one embodiment, the combination of parameter values ​​in method 300 is a combination of (i) a value for the number of signals from one or more sensors, (ii) a value for the number of observations streamed per unit time, and (iii) a value for the number of training vectors given to a machine learning application.

[0095] In the diagram, the variable "numSig" represents the number of signals (or received discrete sensor outputs) for observation or training vectors. The variable "numObs" represents the number of observation vectors (memory vectors of length numSig) received from the sensors of the monitored system over a given time unit (numObs is sometimes called the sampling rate). In one embodiment, observations are drawn from simulated data during the scoping operation and from live data in the final deployment. The variable "numVec" represents the number of training vectors (memory vectors of length numSig) provided to the machine learning application to train the machine learning application (numVec is sometimes called the size of the training set). In one embodiment, the training vectors are selected to characterize the normal operation of the system monitored by the sensors.

[0096] -Nonlinear relationship with computational cost- In one embodiment, the machine learning application in Method 300 introduces a nonlinear relationship between the combination of parameter values ​​and the computational cost. As previously mentioned, the computational cost of streaming machine learning predictions does not scale linearly with respect to the number of signals and observations per unit time. Generally, the computational cost scales quadratically with respect to the number of signals and linearly with respect to the number of observations. Furthermore, the computational cost is also affected by the amount of provisioned available memory and the total provisioned GPU and CPU power. Thus, a containerized machine learning application has a nonlinear relationship between the combination of parameter values ​​and the computational cost.

[0097] Customer use cases include, for example, 10 sensors and one slow sampling rate. Use cases can vary greatly, from simple enterprise use cases for monitoring machines to multinational corporations using tens of thousands of high-sampling-rate sensors. The following examples illustrate the range of typical customer use case scenarios for machine learning predictions for cloud implementations.

[0098] Customer A has a use case involving only 20 signals that are sampled at a slow rate, only once per hour, and the data equivalent to a typical year is only a few MB.

[0099] Customer B has a fleet of Airbus 320s, each equipped with 75,000 sensors that sample once per second, and all aircraft generate 20 TB of data per month. Other corporate customers typically fall somewhere in a very broad use case spectrum between A and B.

[0100] In one embodiment, the automated scoping tool 103 (using a containerized module 141 in one embodiment) accepts a nonlinear nonparametric (NLNP) pattern recognition application as a pluggable machine learning application. In one embodiment, the NLNP pattern recognition application is at least one of the following: an MSET application, a multivariate state estimation technique 2 (MSET2) application, a neural network application, a support vector machine application, and an automated associative kernel regression application.

[0101] Figure 4 shows an example of Method 300 400 for a specific use case related to autonomous cloud node scoping for big data machine learning. In Example Method 400, the range of the number of signals is from 10 to 100, with an increment of 10, as shown by the initialization of the number of signals to 10 in process block 405, the determination in decision block 410 whether the number of signals is less than 100, and the addition of 10 to the number of signals in process block 415. The range of the number of observations (i.e., sampling rate or number of observations per unit time) is from 10,000 to 100,000, with an increment of 10,000, as shown by the initialization of the number of observations to 10,000 in process block 420, the determination in decision block 425 whether the number of observations is less than 100,000, and the addition of 10,000 to the number of observations in process block 430. The range of the number of training vectors (i.e., the size of the training dataset) is from 100 to 2,500 training vectors, with an increment of 100 training vectors, as shown by the initialization of the number of training vectors to 100 in process block 435, the determination in decision block 440 whether the number of training vectors is less than 2,500, and the addition of 100 to the number of training vectors in process block 445. In this example of method 400, the machine learning application is an MSET application, as shown by process block 450. The computational cost for running the MSET application for each permutation of the number of signals, the number of observations, and the number of training vectors is recorded in memory by the processor, as shown in process block 455. The computational cost for running the MSET application for each permutation of the number of signals, the number of observations, and the number of training vectors is output from memory by the processor, as shown in process block 460. For example, the output may be in the form of a graphical representation, as shown and explained with reference to Figures 5A to 8D.

[0102] In one embodiment, this example 400 is performed by an automated scoping tool 103. The automated scoping tool 103 (using a containerized module 141 in one embodiment) accepts input from an MSET machine learning application as a pluggable machine learning application. The automated scoping tool 103 is the MSET machine learning application The application is placed in a candidate cloud container. An automated scoping tool 103 (using a test execution module in one embodiment) runs the containerized MSET machine learning application for possible combinations of the number of signals, the number of observations of these signals, and the size of the training dataset. In one embodiment, the automated scoping tool 103 runs for all possible such combinations. In another embodiment, the combinations are selected at equal intervals across the width of each parameter, indicated by an increment associated with each parameter.

[0103] -Graphic representation of performance information- In one embodiment, Method 300 may further include (i) generating one or more graphic representations showing combinations of parameter values ​​associated with the computational cost for each combination, and (ii) generating instructions to display one or more graphic representations on a graphical user interface, enabling the selection of a configuration for a central processing unit, graphics processing unit, and memory in a target cloud environment for running a machine learning application.

[0104] In one example, an automated scoping tool is run on a candidate cloud container for MSET machine learning prediction techniques to determine how the computational cost varies with respect to the number of signals, observations, and training vectors when MSET is adopted as a cloud service, as in the case of Method 400 as an example. In one embodiment, the results are presented as a graphical representation of the information, such as bar plots and surface plots, showing the actual computational cost measurements and the observed trends in the scopeout of the MSET cloud implementation. In one embodiment, various presentations of the results are presented to assist the user of the automated scoping tool in selecting the shape of the container.

[0105] Figures 5A–5D show three-dimensional (3D) graphs as an example generated to illustrate the computational cost of the training process for the MSET machine learning technique as a function of the number of observations and the number of training vectors. The graphs illustrate the parametric empirical relationship between the computational cost, the number of memory vectors, and the number of observations for the training process for the MSET technique. The number of signals is specified in each individual Figure 5A, 5B, 5C, and 5D. Based on the observations in the graphs, it can be concluded that the computational cost of the training process for the MSET machine learning technique depends primarily on the number of memory vectors and the number of signals.

[0106] Figures 6A–6D show example three-dimensional (3D) graphs generated to illustrate the computational cost of streaming surveillance using MSET machine learning techniques as a function of the number of observations and the number of training vectors. The figures illustrate the parametric empirical relationship between the computational cost, the number of memory vectors, and the number of observations for streaming surveillance using MSET machine learning techniques. The number of signals is specified in each individual Figure 6A, Figure 6B, Figure 6C, and Figure 6D. It can be concluded that the computational cost of streaming surveillance depends primarily on the number of observations and the number of signals.

[0107] Figures 7A–7D show three-dimensional (3D) graphs as examples generated to illustrate the computational cost of the training process of the MSET machine learning technique as a function of the number of observations and the number of signals. Thus, Figures 7A–7D show an alternative layout of Figures 5A–5D for the computational cost versus the number of signals and observations in the training process for the MSET machine learning technique, with the number of memory vectors specified in each individual Figure 7A, 7B, 7C, and 7D.

[0108] Figures 8A to 8D show example three-dimensional (3D) graphs generated to illustrate the computational cost of streaming surveillance using MSET machine learning techniques as a function of the number of observations and signals. Therefore, Figures 8A to 8D show the computational cost of streaming surveillance using MSET machine learning techniques. Figures 6A to 6D show alternative layouts for computational cost versus the number of signals and observations in visual analysis, with the number of memory vectors specified in Figures 8A, 8B, 8C, and 8D, respectively.

[0109] Therefore, the 3D results presented by the system provide the system user with a wealth of information regarding the performance of a selected machine learning application in a target cloud environment, containerized in a selected computational shape (configuration of central processing unit, graphics processing unit, and memory). This allows the system user to quickly evaluate the performance of the machine learning application in the selected computational shape. For example, the 3D results visually show the user the "computational cost" (computational latency) of a machine learning application containerized in a given number of specific computational shapes for each of (i) sensors, (ii) observations (equivalent to the sampling rate of inputs to the machine learning application), and (iii) training vectors. In one embodiment, the system can present 3D results for each computational shape available in (and suitable for use in) a target cloud computing stack.

[0110] Furthermore, for each of these computational shapes, the system may also calculate and display the dollar cost associated with the shape to the user. In one embodiment, pricing is based on the amount of time each aspect of the computational shape is made available for use. In one embodiment, if the service is billed on an hourly basis, the price for a given computational shape may be given as SHAPE_Price / hr = (CPU_QTY * CPU_Price / hr) + (GPU_QTY * GPU_Price / hr) + (MEMORY_QTY * MEMORY_Price / hr). For example, a data center might charge $0.06 per hour for CPU usage, $0.25 per hour for GPU usage, and $0.02 per hour for the use of 1 gigabyte of RAM. Therefore, the data center charges $1.14 per hour to run the first example computation form with 8 CPUs, 2 GPUs, and 8 gigabytes of RAM, and $3.28 per hour to run the first example computation form with 16 CPUs, 6 GPUs, and 16 gigabytes of RAM.

[0111] At a minimum, presenting the user with 3D results and dollar costs related to a specific shape automatically provides them with the most information they would otherwise have to spend a very long time trying to grasp through trial and error.

[0112] -Evaluation of multiple computer-generated shapes- In one embodiment, the system evaluates the performance of a machine learning application for each of the sets of shapes that can be deployed on the target cloud computing stack. This set may include a selection of shapes provided by the data center, or all possible combinations of shapes, or any other set of shapes for deployment on the target cloud computing stack. The system user can then select an appropriate computational shape for containerizing the machine learning application, for example:

[0113] (1) If all available computational shapes satisfy the “computational cost” constraint ((i) maximum number of signals, (ii) maximum sampling rate, and (iii) maximum number of training vectors for the target latency machine learning application), the system may recommend that the user select the computational shape with the lowest monetary cost.

[0114] (2) If some of the available computational shapes do not satisfy the "computational cost" constraint, the system may recommend a computational shape with the lowest monetary cost that also satisfies the "computational cost" constraint.

[0115] Furthermore, the presented 3D results and cost information provide users with the information necessary to evaluate the reconfiguration of machine learning applications, for example, by reducing the number of sensors or observations (sampling rate), or by reducing the number of training vectors, thereby lowering overall predictive accuracy. Without the results provided by the system, guessing the trade-offs between reducing the number of signals, observations, or training vectors to satisfy the user's computational cost constraints involves uncertainty, guesswork, and weeks of trial and error. Using the 3D curves and cost calculation information provided by the system, users can quickly decide, for example, "let's discard 10 of the least useful sensors," or "let's lower the sampling rate by 8%," or "the predictive accuracy is excessive, so let's reduce the number of training vectors by 25%." This opportunity to tune model parameters to meet their unique predictive specifications was previously not available from cloud providers for machine learning use cases.

[0116] In one embodiment, the setting, executing, and measuring steps (steps 210, 215, and 220 described with reference to Figure 2), which are repeated for each of a plurality of combinations of parameter values, are further repeated for each of the available sets of computational shapes for the target cloud environment.

[0117] Figure 9 shows one embodiment of Method 900 related to autonomous cloud node scoping for a big data machine learning use case for evaluating multiple computational shapes. In one embodiment, Method 900 adds an additional outermost loop to Process 300 and repeats for each of the set of computational shapes. Method 900 may be started based on various triggers, which are, for example, receiving a signal over the network or analyzing stored data indicating that (i) a user (or administrator) of the cloud computing system 100 has started Method 900, (ii) Method 900 is scheduled to start at a specified time, or (iii) an automated process is running that migrates a machine learning application from a first computer system to a target cloud environment. Method 900 is started in START block 905 in response to analyzing the received signal or retrieved stored data and determining that this signal or stored data indicates that Method 900 should be started. Processing proceeds to Process block 910.

[0118] In process block 910, the processor retrieves the next available computation shape from the set of computation shapes available in the target cloud environment. In one embodiment, the processor parses the address of a library of computation shapes appropriate for implementation in the target cloud computing environment. The library may be stored as a data structure in storage or memory. The library may be a table enumerating the configurations of computation shapes. The processor selects the next computation shape in the library that has not yet been evaluated during the execution of method 900. The processor stores the retrieved configuration for the computation shape in memory. Processing in process block 910 is complete, and processing proceeds to process block 315.

[0119] In process block 915, the processor containerizes the machine learning application according to the extracted computational shape. In one embodiment, the processor analyzes the extracted configuration to identify a specific configuration of the computational shape, including at least a central processing unit and a graphics processing unit, as well as at least a certain amount of allocated memory. The processor then constructs a test application container for the machine learning application according to the computational shape. For example, the processor may execute or invoke a function of the containerization module 141 (shown and described with reference to Figure 1) to automatically construct the container. The processor provides at least the machine learning application and the extracted configuration as input to the containerization module 141. The processor then causes the containerization module 141 to automatically generate a containerized version of the machine learning application according to the extracted computational shape. Processing in process block 915 is completed, and processing proceeds to process block 920.

[0120] In process block 920, the processor starts process 300, which executes the process steps for the containerized machine learning application, as shown and explained above with reference to Figure 3. Process block 920 completes, and processing proceeds to decision block 925.

[0121] In decision block 925, the processor determines whether any given computation shape remains unevaluated in the set of computation shapes available in the target cloud environment. For example, the processor may parse the next entry in the library to determine whether the next entry describes a different shape, or whether the next entry is NULL, empty, or does not indicate any other shape. If the next entry describes a different shape (YES in decision block 925), the process returns to step 910, and method 900 is repeated for the next computation shape.

[0122] It should be noted that process block 365 (executed by process block 920) outputs computation cost information for each computation shape. In one embodiment, the computation cost information is output to memory in a data structure associated with a particular computation shape for subsequent evaluation of the performance of that computation shape in the execution of a machine learning application.

[0123] If the next entry in the set of calculated shapes does not indicate any other shapes (NO in decision block 925), the processing in decision block 925 is completed, the process proceeds to termination block 930, and method 900 ends.

[0124] Therefore, in one embodiment, for each container shape in the set of container shapes, for each increment of the number of signals within the range of the number of signals, for each increment of the sampling rate within the range of the sampling rate, and for each increment of the number of training vectors within the range of the number of training vectors, the processor executes a machine learning application in a container configured according to the container shape, according to the combination of the number of signals and the number of training vectors at the sampling rate.

[0125] In one embodiment, the system and method assume that the user automatically desires to use a computational shape container with the lowest monetary cost that satisfies the user's performance constraints (target latency, target number of sensors, target number of observations or target sampling rate, and target number of training vectors). Here, after evaluating the performance of a test application of multiple computational shapes, the processor automatically presents the lowest cost option that satisfies the performance constraints. For example, the system and method may present the user with an output indicating that "shape C with n CPUs and m GPUs satisfies the performance requirements at a minimum cost of $8.22 per hour." In this case, the processor ranks the feasible shapes that satisfy the customer's computational cost specifications (performance constraints), and then selects the shape with the lowest monetary cost from the list of feasible shapes. In one embodiment, these evaluation and ranking steps may be performed by the processor's implementation of evaluation module 149.

[0126] In one embodiment, the processor automatically configures cloud containers in the target cloud environment according to a recommended configuration. For example, this can be done by the processor's implementation of a containerization module 141 for machine learning applications, and by the amount of central processing unit, graphics processing unit, and allocated memory, as indicated by the recommended configuration or shape.

[0127] In one embodiment, other members of a list of feasible container shapes (some or all) are presented to the user for selection. In one embodiment, these process steps may be performed by the processor's implementation of interface module 147 and evaluation module 149. In one embodiment, the processor generates one or more graphical representations showing combinations of parameter values ​​related to the computational cost of each combination, and creates instructions to display one or more graphical representations on a graphical user interface, thereby enabling the selection of a central processing unit, graphics processing unit, and memory configuration for a target cloud environment for running a machine learning application. Figure 10 shows one embodiment of GUI 1000 as an example for presenting container shapes, costs, and 3D performance information curves, as well as container shape recommendations. GUI 1000 as an example has a series of rows 1005, 1010, 1015 describing each feasible container shape. Additional rows describing other container shapes may be made visible by scrolling down in the GUI. Each of rows 1005, 1010, and 1015 also displays a set of rows 1020, 1025, and 1030, each representing one or more graphical representations of the performance of a machine learning application in the specific container shape described by that row. For example, a graphical representation could be a 3D graph, as shown and explained with reference to Figures 5A through 8D.

[0128] Each row describes configuration information for that row (regarding the number of CPUs, GPUs, and allocated memory) and cost information (regarding the billed cost per unit time). In one embodiment, the rows are displayed in ascending order of criteria such as monetary cost, with the lowest cost feasible container shape placed in the top row. In one embodiment, example GUI 1000 may indicate a specific instruction 1035 that one particular container shape is recommended.

[0129] Each row is associated with a means for indicating the selection of a container shape associated with that row, such as a radio button, checkbox, or other button. For example, a user of GUI 1000 may choose not to select a recommended option by leaving radio button 1040 unselected, and then choose the next most expensive option by selecting radio button 1045 (e.g., by mouse click). The user can then finalize this selection by selecting the "Select Container Shape" button 1050 (e.g., by mouse click). Thus, in one embodiment, a user can input a configuration selection by selecting a radio button adjacent to the description of a desired container shape, and then selecting the "Select Container Shape" button 1050.

[0130] In one embodiment, upon receiving a selection, the processor may automatically configure cloud containers in the target cloud environment according to the selected configuration. For example, this may be done by the implementation of the containerization module 141 for machine learning applications, the number of central processing units and graphics processing units, and the allocated memory indicated by the selected configuration or shape.

[0131] GUI 1000 may also include a “Target Parameters and Re-evaluation Adjustment” button 1055. Selecting this button 1055 (e.g., by a mouse click) instructs GUI 1000 to display an adjustment menu that allows the user to adjust the target parameters. For example, the user may be able to enter updated values ​​for target latency, target number of signals and / or target number of observations, and target number of training vectors into text fields. Alternatively, the values ​​of these variables may be adjusted by graphical sliders, buttons, knobs, or other graphical user interface elements. The adjustment menu may also include a “Accept and Re-evaluate” button. Selecting the "Re-evaluate" button will cause the processor to re-evaluate the performance data for various container shapes, taking into account the new target parameters. In one embodiment, these process steps may be performed by the processor's implementation of interface module 147 and evaluation module 149.

[0132] Therefore, this system and method spans a range of customer sophistication, from customers who desire the maximum level of detail (unavailable from any other approach) to enable them to adjust the number of signals, observations, and training vectors to reach a satisfactory cost, to customers who simply want to be informed of which shape will meet all the required performance specifications of their predictive machine learning application at the lowest monetary cost.

[0133] -Cloud or enterprise-type implementation- In one embodiment, the automated scoping tool 103 and / or other systems shown and described herein are a computing / data processing system including a database application or a collection of distributed database applications. The applications and data processing systems may be configured to operate on, or implemented as, a cloud-based networking system, a Software as a Service (SaaS) architecture, a Platform as a Service (PaaS) architecture, an Infrastructure as a Service (laaS) architecture, or other types of networked computing solutions. In one embodiment, the cloud computing system 100 is a server-side system that provides at least the functions disclosed herein and is accessible to many users via computing devices / terminals that communicate with the cloud computing system 100 (acting as a server) over a computer network.

[0134] -Software Module Embodiment- Generally, software instructions are designed to be executed by a properly programmed processor. These software instructions may include, for example, computer executable code and source code that can be compiled into computer executable code. These software instructions may also include instructions written in an interpreted programming language, such as a scripting language.

[0135] In complex systems, such instructions are typically placed within program modules, each of which performs a specific task, process, function, or operation. The entire set of modules may be controlled or coordinated in their operation by an operating system (OS) or other form of organizational platform.

[0136] In one embodiment, one or more of the components, functions, methods, or processes described herein are configured as modules stored on a non-temporary computer-readable medium. The modules consist of stored software instructions that, when executed by at least a processor accessing memory or storage, cause a computing device to perform the corresponding function described herein.

[0137] - Embodiment of a Computing Device - Figure 11 shows an example of a computing device configured and / or programmed using one or more of the examples of systems and methods and / or equivalents described herein. This example of a computing device could be a computer 1105, including a processor 1110, memory 1115, and input / output ports 1120, which are operationally connected by a bus 1125. In one example, computer 1105 is shown in Figures 1 to 10. An autonomous cloud node scoping logic 1130 may be configured to facilitate autonomous cloud node scoping for big data machine learning use cases (e.g., determining the appropriate computational shape of a cloud container for a machine learning application), similar to the logic, systems, and methods shown and described. In other examples, the logic 1130 may be implemented in hardware, a non-transient computer-readable medium with stored instructions, firmware, and / or a combination thereof. Although the logic 1130 is shown as a hardware component mounted on bus 1125, it should be understood that in other embodiments, the logic 1130 may be implemented in processor 1110, stored in memory 1115, or stored on disk 1135.

[0138] In one embodiment, the logic 1130 or computer is a means (e.g., structure: hardware, non-temporary computer-readable medium, firmware) for performing the described actions. In some embodiments, the computing device may be a server operating in a cloud computing system, a server configured in a Software as a Service (SaaS) architecture, a smartphone, a laptop, a tablet computing device, etc.

[0139] The above means can be implemented, for example, as an ASIC programmed to automate process discovery and facilitation. Alternatively, the means can be implemented as a stored computer executable instruction, which is temporarily stored in memory 1115 and then presented to computer 1105 as data 1140 executed by processor 1110.

[0140] Logic 1130 can also provide means (e.g., hardware, non-temporary computer-readable media for storing executable instructions, firmware) for performing automated process discovery and facilitation.

[0141] To broadly describe an example of the configuration of computer 1105, the processor 1110 can be a variety of processors, including dual microprocessors and other multiprocessor architectures. Memory 1115 may include volatile memory and / or non-volatile memory. Non-volatile memory may include, for example, ROM, PROM, EPROM, EEPROM, etc. Volatile memory may include, for example, RAM, SRAM, DRAM, etc.

[0142] The storage disk 1135 may be operationally connected to the computer 1105, for example, via an input / output interface (e.g., a card, device) 1145 and an input / output port 1120 controlled by at least an input / output (I / O) controller 1147. The disk 1135 may be, for example, a magnetic disk drive, a solid-state disk drive, a floppy disk drive, a tape drive, a Zip drive, a flash memory card, a memory stick, etc. Furthermore, the disk 1135 may be a CD-ROM drive, a CD-R drive, a CD-RW drive, a DVD-ROM, etc. The memory 1115 may store, for example, a process 1150 and / or data 1140. The disk 1135 and / or the memory 1115 may store an operating system that controls and allocates the resources of the computer 1105.

[0143] Computer 1105 can interact with input / output (I / O) devices via an input / output (I / O) controller 1147, an input / output (I / O) interface 1145, and an input / output port 1120. Input / output devices may include, for example, a keyboard, microphone, pointing / selection device, camera, video card, display, disk 1135, and network device 1155. The input / output port 1120 may be, for example, a serial port. This may include parallel ports and USB ports.

[0144] Computer 1105 can operate within a network environment and may therefore be connected to network device 1155 via I / O interface 1145 and / or I / O port 1120. Computer 1105 may communicate with network 1160 through network device 1155. Computer 1105 may be logically connected to remote computer 1165 via network 1160. The networks that computer 1105 can communicate with include, but are not limited to, LANs, WANs, and other networks.

[0145] Computer 1105 can control one or more output devices through I / O port 1120, or can be controlled by one or more input devices. Output devices include one or more displays 1170, printers 1172 (such as inkjet, laser, or 3D printers), and audio output devices 1174 (such as speakers or headphones). Input devices include one or more text input devices 1180 (such as keyboards), cursor controllers 1182 (such as mice, touchpads, or touchscreens), audio input devices 1184 (such as microphones), and video input devices 1186 (such as video and still cameras).

[0146] -Definitions and other embodiments- In another embodiment, the methods described and / or their equivalents may be implemented in computer executable instructions. Thus, in one embodiment, a non-temporary computer-readable / storage medium comprises computer executable instructions containing algorithms / executable applications, which, when executed by a machine, cause that machine (and / or associated components) to perform the methods described above. Examples of machines include, but are not limited to, processors, computers, servers operating in cloud computing systems, servers configured in software-as-a-service (SaaS) architectures, and smartphones. In one embodiment, a computing device is implemented with one or more executable algorithms configured to perform any of the disclosed methods.

[0147] In one or more embodiments, the disclosed method or its equivalents are executed by either computer hardware configured to perform the method, or by a computer instruction executed in a module stored on a non-temporary computer-readable medium, wherein, in the case of a computer instruction, the instruction is configured as an executable algorithm that, when executed by at least one processor of a computing device, performs the method.

[0148] For the sake of brevity, the methodologies shown in the diagrams are presented and described as a series of algorithmic blocks, but it should be understood that the methodology is not limited by the order of the blocks. Some blocks may occur in a different order than those shown and described, and / or simultaneously with other blocks. In addition, fewer blocks than all shown may be used to implement an example of the methodology. Blocks may be combined or divided into multiple actions / components. Furthermore, additional and / or alternative methodologies may employ additional actions not shown in the blocks.

[0149] The following includes definitions of selected terms used herein. The definitions include various examples and / or forms of components that may be included in the scope of the terms and / or used for implementation. These examples are not intended to be limiting. The definitions include both singular and plural forms of the terms. obtain.

[0150] Descriptions such as "one embodiment," "a certain embodiment," "an example," or "a certain example" indicate that while the embodiments or examples described in this way may include certain features, structures, properties, elements, or limitations, not all embodiments or examples necessarily include those specific features, structures, properties, elements, or limitations. Furthermore, when the phrase "in one embodiment" is used repeatedly, it does not necessarily refer to the same embodiment, although it may refer to the same embodiment.

[0151] ASIC: Application-specific integrated circuit. CD: Compact Disc.

[0152] CD-R: A CD that can be written to. CD-RW: A rewritable CD.

[0153] DVD: Digital Multipurpose Disc and / or Digital Video Disc. LAN: Local Area Network.

[0154] RAM: Random Access Memory. DRAM: Dynamic RAM.

[0155] SRAM: Synchronous RAM. ROM: Read-only memory.

[0156] PROM: Programmable ROM. EPROM: Erasable PROM.

[0157] EEPROM: A PROM that can be electrically erased. USB: Universal Serial Bus.

[0158] WAN: Wide Area Network. As used herein, “data structure” refers to an organization of data within a computing system that is stored in memory, a storage device, or other computerized system. A data structure may be any one of the following: a data field, a data file, a data array, a data record, a database, a data table, a graph, a tree, a linked list, etc. A data structure may be formed from and contain a number of other data structures (for example, a database contains a number of data records). Other examples of data structures are possible according to other embodiments.

[0159] As used herein, “computer-readable medium” or “computer storage medium” means a non-temporary medium that stores instructions and / or data configured to perform one or more of the disclosed functions when executed. In some embodiments, data may function as instructions. Computer-readable mediums may, but are not limited to, non-volatile and volatile media. Non-volatile media may include, for example, optical disks and magnetic disks. Volatile media may include, for example, semiconductor memory and dynamic memory. Common forms of computer-readable media include floppy disks, flexible disks, hard disks, magnetic tapes, other magnetic media, application-specific integrated circuits (ASICs), programmable logic devices, compact disks (CDs), other optical media, random-access memory (RAM), read-only memory (ROM), memory chips or cards, memory sticks, solid-state storage. This may include, but is not limited to, SSDs, flash drives, and other media through which a computer, processor, or other electronic device can function. Each type of medium may contain stored instructions of an algorithm configured to perform one or more of the disclosed and / or claimed functions, when selected for implementation in one embodiment.

[0160] As used herein, “logic” refers to a component implemented by a computer or electrical hardware, a non-temporary medium having stored instructions for an executable application or program module, and / or a combination thereof, which performs one of the functions or actions disclosed herein and / or causes another logic, method, and / or system to perform a function or action disclosed herein. Equivalent logic may include firmware, an algorithm-programmed microprocessor, discrete logic (e.g., ASIC), at least one circuit, analog circuit, digital circuit, programmed logic device, memory device containing algorithmic instructions, and any of these may be configured to perform one or more of the disclosed functions. In one embodiment, logic may include one or more gates, combinations of gates, or other circuit components configured to perform one or more of the disclosed functions. Where multiple logics are described, it may be possible to consolidate these multiple logics into a single logic. Similarly, where a single logic is described, it may be possible to distribute that single logic into multiple logics. In one embodiment, one or more of these logics are corresponding structures associated with performing the disclosed and / or claimed functions. The choice of which type of logic to implement may depend on the desired system conditions or specifications. For example, if faster speed is a consideration, hardware may be chosen to implement the functionality. If lower cost is a consideration, stored instructions / executable applications may be chosen to implement the functionality.

[0161] An "operational connection," or a connection to which an entity is "operationally connected," is a connection that can transmit and / or receive signals, physical communications, and / or logical communications. An operational connection may include physical interfaces, electrical interfaces, and / or data interfaces. An operational connection may include various combinations of interfaces and / or connections sufficient to enable operational control. For example, by operationally connecting two entities, signals can be exchanged between them directly or through one or more intermediate entities (e.g., processors, operating systems, logic, non-transient computer-readable media). Logical and / or physical communication channels can be used to form an operational connection.

[0162] As used herein, "user" means one or more people, one or more computers or This includes, but is not limited to, other devices or combinations thereof.

[0163] While the embodiments disclosed are shown and described in considerable detail, they are not intended to limit or restrict the scope of the appended claims in any way. Naturally, it is impossible to describe all possible combinations of components or methodologies for the purpose of illustrating the various aspects of the subject matter. Therefore, this disclosure is not limited to the specific details or examples shown and described. Accordingly, this disclosure is intended to encompass modifications, alterations, and variations that fall within the scope of the appended claims.

[0164] The term "includes" or "including" is used in more detail. To the extent that it is used in a detailed description or claim, the term “comprising” is intended to be comprehensive, as is the interpretation of the term when it is used as a connecting word in a claim. The term “or” is intended to mean “A or B or both” to the extent that it is used in a detailed description or claim (e.g., A or B). If the applicant intends to indicate “A or B only, but not both,” the expression “A or B only, but not both” is used. Thus, the use of the term “or” in this specification is comprehensive and not exclusive.

Claims

1. A method implemented by a computer, wherein the method is For each of the multiple combinations of parameter values, (i) A step of setting a combination of parameter values ​​that describes the usage scenario, (ii) The step of running a machine learning application on a target cloud environment according to the combination of parameter values, and (iii) A step of measuring the computational cost for running the machine learning application, The steps include generating recommendations regarding the configuration of the central processing unit, graphics processing unit, and memory of the target cloud environment for next running the machine learning application based on the measured computational cost, The step of generating the aforementioned recommendation is: The steps include generating one or more graphic representations showing the combinations of parameter values ​​associated with the computation cost for each combination, A computer-implemented method further comprising the step of displaying one or more graphic representations on a graphical user interface, which enables the selection of a configuration of a central processing unit, a graphics processing unit, and memory in the target cloud environment for running the machine learning application.

2. A step to simulate a set of signals from one or more sensors, The method according to claim 1, further comprising the step of providing the machine learning application with the set of signals as input to the machine learning application while the machine learning application is running.

3. The combination of the aforementioned parameter values ​​is The number of signals from one or more sensors, The value of the number of observations streamed per unit time, The method according to claim 1, which is a combination of the number of training vectors given to the machine learning application and the value of the number of training vectors provided to the machine learning application.

4. The method according to claim 1, wherein the machine learning application generates a nonlinear relationship between the combination of parameter values ​​and the computation cost.

5. The method according to claim 1, wherein the recommendation relating to the configuration is generated as a recommended container shape, the container shape includes the number of central processing units and the number of graphics processing units and the amount of memory allocated in the target cloud environment for running the machine learning application.

6. The method according to claim 1, further comprising the step of automatically configuring a cloud container in the target cloud environment according to the recommended configuration.

7. The method according to claim 1, wherein the combination of parameter values ​​is set according to a Monte Carlo simulation, and the method further includes the step of providing the parameter values ​​to the machine learning application as input to the machine learning application during the execution of the machine learning application.

8. The method according to claim 1, further comprising the step of repeating the setting step, the execution step, and the measurement step for each combination of a plurality of combinations of parameter values ​​for each set of available configurations of the central processing unit, graphics processing unit and memory of the target cloud environment.

9. A program that causes at least one processor of a computer to execute the method according to any one of claims 1 to 8.

10. A computing system, Processor and A memory operationally coupled to the aforementioned processor, It comprises a non-temporary computer-readable medium for storing computer executable instructions, A computing system that, when the computer executable instruction is executed by at least one processor accessing memory, causes the computing system to perform the method according to any one of claims 1 to 8.

Images