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

Abstract

Systems, methods, and other embodiments associated with autonomous cloud node scoping for big data machine learning use cases are described. In some example embodiments, an automated scoping tool, method, and system are presented that, for each of a plurality of combinations of parameter values, (i) sets a combination of parameter values ​​that describes a usage scenario, (ii) executes a machine learning application on a target cloud environment according to the combination of parameter values, and (iii) measures a computational cost of executing the machine learning application. Recommendations are generated regarding configurations of central processing unit(s), graphics processing unit(s), and memory of a target cloud environment for executing the machine learning application based on the measured computational costs.

Description

Technical Field

[0001] The present disclosure relates to cloud computing, and in particular to an autonomous cloud node scoping framework for big data machine learning use cases. Background Art

[0002] Cloud containers have seen increasing usage in the business world. A cloud container is a logical wrapper that encapsulates an application and its dependencies, allowing the containerized application to run on a variety of host environments such as Linux, Windows, Mac, operating systems, virtual machines, or bare metal servers. An example of such a container is Containers. Cloud container technology enables commercial enterprises to easily deploy and access software as a service over the Internet. Containerization provides separation of concerns, as commercial enterprises can focus on their software application logic and dependencies without worrying about deployment and configuration details, while cloud providers can focus on deployment and configuration without worrying about software application details. Using cloud containers to implement applications also provides a high degree of customization and reduces the operational and infrastructure costs of commercial enterprises (relative to the relatively high costs of operating their own data centers).

[0003] Implementing software applications using cloud container technology also enables the software to scale according to the computing needs of commercial enterprises. Cloud computing service providers such as Oracle may charge for cloud container services based on specific use cases, number of users, storage space, and computing costs. Therefore, commercial enterprises that purchase cloud container services will only pay for the purchased services and will select packages that fit the budget of the commercial enterprise. Major cloud providers (including Amazon, Google, Microsoft, and Oracle) provide cloud container services.

[0004] However, the implementation of machine learning software applications cannot be easily scaled using cloud container technology due to the highly complex interrelationship between the available memory provisioned, the total GPU and CPU power provisioned, the total number of signals, and the sampling rates of sensor streams that govern throughput and latency. Summary of the invention

[0005] In one embodiment, a computer-implemented method includes: for each of multiple combinations of parameter values, (i) setting the 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 of executing the machine learning application; and generating a recommendation regarding the configuration of (one or more) central processing units, (one or more) graphics processing units, and memory of the target cloud environment for executing the machine learning application based on the measured computational cost.

[0006] In one embodiment, the method further includes: 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 during execution of the machine learning application.

[0007] In one embodiment, the method, wherein the combination of parameter values ​​is a combination of: a value for the number of signals from one or more sensors; a value for the number of observations streamed per unit time; and a value for the number of training vectors to be provided to a machine learning application.

[0008] In one embodiment, the method, wherein the machine learning application results in a non-linear relationship between combinations of parameter values ​​and computational cost.

[0009] In one embodiment, the method also includes: generating one or more graphical representations showing combinations of parameter values ​​associated with a computational cost for each combination; and creating instructions to display the one or more graphical representations on a graphical user interface to enable selection of a configuration of (one or more) central processing units, (one or more) graphics processing units, and memory of a target cloud environment for executing the machine learning application.

[0010] In one embodiment, the method further includes automatically configuring the cloud container in the target cloud environment according to the recommended configuration.

[0011] In one embodiment, the method, wherein the combination of parameter values ​​is set according to a Monte Carlo simulation, the method further comprises providing the parameter values ​​to the machine learning application as input to the machine learning application during execution of the machine learning application.

[0012] In one embodiment, the method further comprises repeating the steps of setting, executing, and measuring for each of a set of available configurations of (one or more) central processing units, (one or more) graphics processing units, and memory of the target cloud environment, the steps being repeated for each of multiple combinations of parameter values.

[0013] In one embodiment, a non-transitory computer-readable medium storing computer-executable instructions, when the computer-executable instructions are executed by at least a processor of a computer, causes the computer to: for each of a plurality of combinations of parameter values, (i) set a combination of parameter values ​​that describes a usage scenario, (ii) execute a machine learning application on a target cloud environment according to the combination of parameter values, and (iii) measure a computational cost of executing the machine learning application; and generate a recommendation regarding a configuration of (one or more) central processing units, (one or more) graphics processing units, and a memory of the target cloud environment for executing the machine learning application based on the measured computational cost.

[0014] In one embodiment, the non-transitory computer-readable medium also includes instructions that, when executed by at least a processor, cause the computer to: simulate a set of signals from one or more sensors; and provide the set of signals to the machine learning application as input to the machine learning application during execution of the machine learning application.

[0015] In one embodiment, the non-transitory computer readable medium, wherein the combination of parameter values ​​is a combination of: a value for a number of signals from one or more sensors; a value for a number of observations streamed per unit time; and a value for a number of training vectors to be provided to a machine learning application.

[0016] In one embodiment, the non-transitory computer-readable medium also includes instructions that, when executed by at least the processor, cause the computer to: generate one or more graphical representations showing combinations of parameter values ​​associated with a computational cost for each combination; create instructions to display the one or more graphical representations on a graphical user interface to allow selection of a configuration of (one or more) central processing units, (one or more) graphics processing units, and memory of a target cloud environment for executing a machine learning application; and in response to receiving a selection, automatically configure a cloud container in the target cloud environment according to the selected configuration.

[0017] In one embodiment, a computing system includes: a processor; a memory operably coupled to the processor; and a non-transitory computer-readable medium storing computer-executable instructions, which, when the computer-executable instructions are executed by at least the processor accessing the memory, cause the computing system to: for each of a plurality of combinations of parameter values, (i) set a combination of parameter values ​​that describes a usage scenario, (ii) execute a machine learning application on a target cloud environment according to the combination of parameter values, and (iii) measure a computational cost of executing the machine learning application; and generate a recommendation regarding a configuration of (one or more) central processing units, (one or more) graphics processing units, and a memory of the target cloud environment for executing the machine learning application based on the measured computational cost.

[0018] In one embodiment, the computing system, wherein the computer-readable medium further comprises instructions that cause the computing system to: for each container shape in a set of container shapes, for each increment of the number of signals across a range of signal numbers, for each increment of the sampling rate across a range of sampling rates, and for each increment of the number of training vectors across a range of the number of training vectors, perform a machine learning application based on a combination of the number of signals at the sampling rate and the number of training vectors in the container configured according to the container shape.

[0019] In one embodiment, the computing system, wherein the computer-readable medium further comprises instructions that cause the computing system to: generate one or more graphical representations showing combinations of parameter values ​​associated with a computational cost for each combination; create instructions to display the one or more graphical representations on a graphical user interface to allow selection of a configuration of (one or more) central processing units, (one or more) graphics processing units, and memory of a target cloud environment for executing a machine learning application; and in response to receiving a selection, automatically configure a cloud container in the target cloud environment according to the selected configuration. BRIEF DESCRIPTION OF THE DRAWINGS

[0020] The accompanying drawings that are incorporated into and form a part of the specification illustrate various systems, methods and other embodiments of the present disclosure. It should be understood that the element boundaries (e.g., frames, groups of frames or other shapes) shown in the figures represent an embodiment of boundaries. In some embodiments, an element can be implemented as multiple elements, or multiple elements can be implemented as one element. In some embodiments, an element shown as an internal component of another element can be implemented as an external component, and vice versa. In addition, the elements may not be drawn to scale.

[0021] Figure 1 An embodiment of a cloud computing system associated with autonomous cloud node scoping for a big data machine learning use case is illustrated.

[0022] Figure 2 One embodiment of a method associated with autonomous cloud node scoping for a big data machine learning use case is illustrated.

[0023] Figure 3 One embodiment of a method associated with autonomous cloud node scoping for a big data machine learning use case is illustrated, and details of one embodiment of a nested loop traversal of parameter value combinations are shown.

[0024] Figure 4 One example of an approach for a specific use case associated with autonomous cloud node scoping for big data machine learning is shown.

[0025] Figure 5A-5D An example three-dimensional (3D) plot generated to illustrate the computational cost of a training process for a predictive machine learning technique known as a multivariate state estimation technique (MSET) as a function of the number of observations and the number of training vectors is shown.

[0026] Figure 6A-6D An example three-dimensional (3D) plot 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 is shown.

[0027] Figure 7A-7DAn example three-dimensional (3D) plot generated to illustrate the computational cost of the training process of MSET as a function of the number of observations and the number of signals is shown.

[0028] Figure 8A-8D An example three-dimensional (3D) plot generated to illustrate the computational cost of streaming monitoring using MSET as a function of the number of observations and the number of signals is shown.

[0029] Fig. 9 One embodiment of a method for evaluating multiple compute shapes associated with autonomous cloud node scoping for a big data machine learning use case is illustrated.

[0030] Fig.10 One embodiment of an example GUI 1000 for presenting container shape, costing and 3D performance information curves, and container shape recommendations is shown.

[0031] Fig.11 An embodiment of a computing system configured with the disclosed example systems and / or methods is illustrated. DETAILED DESCRIPTION

[0032] This article describes systems and methods that provide an autonomous cloud node scoping framework for big data machine learning use cases.

[0033] Machine learning (ML) techniques can be applied to generate predictive information for Internet of Things (IoT) applications. In some implementations, machine learning techniques are applied to data sets generated by sensor-intensive IoT applications. Sensor-intensive applications have a large amount of sensor-generated information that requires low-latency and high-throughput data processing. Typically, predictive applications are run by local ("on-prem") data center assets. Resources in a data center such as central processing units (CPUs), graphics processing units (GPUs), memory, and input / output (I / O) processing will be reconfigured from time to time to grow with use case demands.

[0034] Cloud computing provides an alternative to local computing. Businesses implementing their predictive machine learning applications in a cloud container environment will save the huge overhead costs associated with running their own data centers. In addition, business enterprises can also gain access to advanced predictive machine learning pattern recognition native to the cloud environment to identify anomalies in streaming sensor signals. However, using predictive ML algorithms (such as MSET2) Achieving low latency and high throughput metrics for large-scale streaming prediction applications requires correctly matching the cloud computing environment to the performance metrics before the prediction application is deployed in the cloud environment. The size of the computing environment involves identifying the right number of CPUs and / or GPUs, the right number of computing cores, the right amount of storage, and / or container configurations in terms of GPU to CPU "shapes". Correctly sizing cloud containers for commercial enterprise applications to ensure good real-time streaming prediction performance for the commercial enterprise presents many technical challenges.

[0035] For commercial enterprises that already have big data streaming analytics in their on-premises data centers, it is not possible to scale to approximate the CPU, GPU, memory, and / or storage footprint required in Oracle Cloud Infrastructure (OCI) cloud containers for a number of reasons.

[0036] Machine learning predictions are typically “compute-bound,” meaning that the time it takes to complete a task is primarily determined by the speed of the central processing unit. However, commercial enterprises implementing streaming analytics are not only concerned with GPU / CPU performance keeping up with real time (a fundamental metric for streaming predictions), but are equally concerned with throughput and latency. For streaming machine learning predictions, throughput and latency depend in very complex ways on the amount of available memory provisioned, the total GPU and CPU power provisioned, and the total number of signals and observations per second in the sensor stream. Typically, the computational cost scales quadratically with the number of signals and linearly with the number of observations. In addition, commercial enterprises’ expectations for machine learning prediction accuracy also affect the configuration requirements of cloud containers—in addition to increasing the computational cost overhead of machine learning model training, the number of training vectors also directly affects the container’s memory requirements.

[0037] In the past, due to these complex relationships predicted by machine learning, business enterprises needed to conduct multiple trial and error runs, as well as consultant efforts, to discover the best cloud configuration for the business enterprise's typical use cases. The trial and error nature of discovering the best cloud configuration prevented business enterprises from starting small and autonomously growing their cloud container capacity through elasticity as compute dynamics impacted them. In order to achieve autonomous growth of cloud container capacity in response to the compute dynamics in real-life usage of predicted machine learning applications, the performance of machine learning technologies deployed in cloud containers must be evaluated.

[0038] To address these and other technical challenges, the present application provides an autonomous container scoping tool (or automatic scoping tool) that uses nested loop Monte Carlo based simulations to automatically scale customer machine learning use cases of any size across the range of cloud CPU-GPU "shapes" (CPU and / or GPU configurations in cloud containers, such as OCI containers) available in the target cloud container stack. In one embodiment, the autonomous container scoping tool stresses candidate cloud containers for machine learning applications as a parameterized function of the total number of signals, the number of observations, and the number of training vectors in the observations in a nested loop multi-parameter approach. The autonomous container scoping tool generates the expected cloud container performance in terms of throughput and latency as a function of the number of signals expected by the customer and the sampling rate of those signals, an unprecedented capability.

[0039] The Autonomous Container Scoping Tool is a machine learning-friendly framework that allows automatic scoping evaluation to be performed for any pluggable machine learning algorithm. In one embodiment, the automatic scoping tool employs a pluggable framework that can accommodate various forms of machine learning techniques. Depending on the defined scope of the use case, any containerized machine learning technology, such as applications including multivariate state estimation techniques (MSET), neural networks, support vector machines, auto-correlation kernel regression, and customer-specific machine learning applications, can be simply plugged into the tool for evaluation. Therefore, 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 automatic scoping tool can estimate cloud containers of appropriate size and shape for machine learning technologies.

[0040] Each of the MSET, neural network, support vector machine, and auto-correlation kernel regression machine learning techniques is a type of advanced nonlinear nonparametric (NLNP) pattern recognition. The computational cost and memory footprint of such NLNP pattern recognition scales in a complex nonlinear manner with 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 training vectors.

[0041] Advantageously, in one embodiment, the automated scoping tool performs the scoping analysis on the platform of interest - the target cloud computing platform on which the machine learning application will be deployed. This can be important because computational cost overheads as well as latency and throughput metrics vary widely across a variety of local computing platforms, such as traditional computing systems of commercial enterprises or Oracle The shape of the containers available in database machines and cloud computing infrastructures, such as Oracle Cloud Infrastructure (OCI), will vary.

[0042] In one embodiment, the automatic scoping tool can be completely autonomous and does not require data scientists and / or consultants from the business enterprise. This enables the business entity to autonomously grow its cloud container capacity through elasticity as its processing needs increase. In addition, the automatic scoping tool enables the business entity to autonomously migrate machine learning applications from its local data center to a cloud container in a cloud computing environment.

[0043] In one embodiment, an automatic scoping tool can be used to quickly size cloud containers for new use cases involving advanced predictive machine learning techniques. The automatic scoping tool can indicate a range of appropriate cloud container configurations, including CPUs, GPUs, and / or one or more "shapes" including both CPUs and GPUs in various shared memory configurations. In one embodiment, the resulting configurations can be combined with pricing tables to then provide a range of cost estimates for the solution to the business enterprise.

[0044] Aside from the automated scoping tool described in this article, there are no tools, techniques, or frameworks that can estimate cloud container sizes (i.e., number of CPUs, number of GPUs, amount of memory, and / or describe the appropriate “shape” of the container) for big data machine learning use cases.

[0045] — Sample Environment —

[0046] Figure 1 One embodiment of a cloud computing system 100 associated with autonomous cloud node scoping for a big data machine learning use case is illustrated. The cloud computing system 100 includes a target cloud container stack 101 and an automatic scoping tool 103 interconnected by one or more networks 105, such as the Internet or a private network associated with the target cloud container stack 101. The cloud computing system 100 can be configured to provide one or more software applications as a service to client computers in an enterprise network 107 associated with a business enterprise through the network 105.

[0047] 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 Stack, Microsoft stack, Amazon Web Services stack (including, for example, Amazon Elastic Container Service), or other scalable cloud computing stack capable of supporting container-based applications.

[0048] 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 includes one or more servers 117 and one or more storage devices 119 interconnected by an infrastructure network 121. Each server 117 includes one or more central processing units (CPUs) 123 and / or graphics processing units (GPUs) 125, and a memory 127. The storage device may include a solid-state memory drive, a hard disk drive, a network attached storage (NAS) device, or other storage device.

[0049] In one embodiment, the operating system layer 111 is any of Linux, Windows, Mac, Unix, or other operating systems. These operating systems can be fully featured operating systems, or minimal operating system configurations that include only the features necessary to support the container runtime engine 113's use of the infrastructure layer 109. 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 provided by Oracle Cloud Infrastructure Bare Metal Cloud).

[0050] 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 In one embodiment, the container runtime engine 113 is The container runtime engine 113 supports the operation of containers in the container layer 115. In one embodiment, the containers 129, 131 in the container layer are Containers, i.e., containers built in the Docker image format. In one environment, a container 129 for a test application 133 is deployed to the container layer 115. Binary files and libraries 135 that support the test application 133 are included in the container 123. In one embodiment, a container 131 for a production application 137 is deployed to the container layer 115. Binary files and libraries 139 that support the production application 137 are included in the container 125.

[0051] A container deployed to the container layer 115 (e.g., a test application container 129 or a production application container 131) can specify the "shape" of computing resources (expressed in terms of the amount of CPU 123, GPU 125, and memory 127) to be dedicated to the container. This "shape" information can be stored in the container image file. In one embodiment, the "shape" information is communicated to the container runtime engine by setting a runtime configuration flag of the "docker run" command (or equivalent commands and flags for other container formats).

[0052] In one embodiment, the automatic scoping tool 103 includes a containerization module 141, a test execution module 143, a computational cost recording module 145, an interface module 147, and an evaluation module 149. In one embodiment, the automatic scoping tool 103 is a dedicated computing device configured with the modules 141-149. In one embodiment, the automatic scoping tool is part of the target cloud container stack 101, such as a component of the container runtime engine 113.

[0053] In one embodiment, the containerization module 141 automatically builds a docker container. The containerization module 141 accepts at least an application, binaries and libraries supporting the application, and the "shape" information of the container as input. At least from 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 an automatic containerization tool available from Docker and / or docks with an automatic containerization tool that can scan the application and identify the application code and related binaries and / or libraries. The containerization module 141 then automatically generates a Docker image file based in part on these codes, binaries and / or libraries. In one embodiment, the container image file is created at least in part based on a template. The containerization module 141 can retrieve a template from a library of one or more templates.

[0054] In one embodiment, the test execution module 143 operates a series of benchmark or stress testing operations for a specific containerized application. For example, the test execution module 143 accepts at least the following as input: (i) a range of the number of signals per observation and an increment on the range of the number of signals, (ii) a range of the number of observations and an increment on the range of the number of observations, (iii) a range of the number of training vectors and an increment on the range of the number of training vectors, (iv) a specific containerized application, and (v) test data. The test execution module will cause the target cloud container stack 101 to execute a specific containerized application for each permutation of the number of signals, the number of observations, and the number of training vectors as each of them increases over their respective ranges. The number of training vectors may also be referred to as the size of the training data set.

[0055] In one embodiment, the particular containerized application is a test application 133. The containerization module 141 can cause the test application 133 and its associated binaries and / or libraries 135 to be scanned, for example, from a local server 151 associated with a business enterprise and sent from the enterprise network 107 to the automatic scoping tool 103 via the network 105. In one embodiment, the test application 133 is a dense sensor IoT application for analyzing a large-scale 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.

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

[0057] In one embodiment, there are multiple compute shapes suitable for use with the target cloud container stack configuration. Each test application container 129 can be a candidate for selection as a production application container 131. In one embodiment, in response to an indication 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 compute shape, and an increment to the next unevaluated compute shape at the next test iteration. In this way, a test application container 129 is created for each compute shape suitable for the target cloud container stack 101, and each candidate container shape is evaluated in turn.

[0058] The container runtime engine 113 and the automatic scoping tool 103 can each be configured with an application programming interface (API) to receive and send information and commands. For example, the API can be a representational state transfer (REST) ​​API. The containerization module 141 can send an API command to the container runtime engine 113, which instructs the container runtime engine 113 to deploy the test application container 129 into the container layer 115. The containerization module can also send the test application container 129 to the container runtime engine 113 for deployment.

[0059] In one embodiment, the test execution module 143 accesses the test data body for use by the test application 133 during execution by the target cloud container stack 101. The test data should include training vectors and observations. The training vectors are memory vectors of sensor observations for normal operation of a system monitored or monitored by a sensor. The test data should include a sufficient number of training vectors to allow execution of each training permutation of the test. Observations are memory vectors of sensor observations that are unknown as to whether they represent normal operation of the system monitored by the sensor. The test data should include a sufficient number of observations to allow execution of each observation permutation of the test. In one embodiment, the number of signals in the observations and training vectors matches 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.

[0060] In one embodiment, the test data body is historical data compiled by, for example, a local server 151 from readings from one or more Internet of Things (IoT) (or other) sensors 153. The number of sensors 153 may be very high. In some implementations, machine learning techniques are applied to data sets generated by intensive sensor IoT applications. Intensive sensor applications have a large amount of sensor-generated information that requires low latency and high throughput data processing. The test execution module 143 accepts or retrieves the test data body from the local server 151 over the network 105. The test execution module 143 causes the test data body to be provided to the test application 133 during execution by the target cloud container stack 101.

[0061] In one embodiment, the body of test data is synthetic data generated based on historical data compiled by, for example, the local server 151. The automatic scoping tool 103 may include a signal synthesis module (not shown).

[0062] In one embodiment, the computational cost recording module 145 tracks the computational 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 computational cost is measured in milliseconds elapsed between starting and completing the computation. In one embodiment, the computational cost is measured by the time it takes the target cloud container stack 101 to execute the test application 133 for the permutation. In one embodiment, the test application container 129 is configured to send the respective times at which the execution of the test application 133 starts and finishes on the target cloud container stack 101 to the computational cost recording module 145 via the network 105. In one embodiment, for each permutation, the computational cost recording module 145 is configured to record the performance in a data repository associated with the automatic scoping tool 103. The performance can be recorded as a data structure representing a tuple indicating (i) the number of signals per observation for the permutation, (ii) the number of observations for the permutation, (ii) the number of training vectors for the permutation, and (iv) the difference between the time when the execution of the test application 133 for the permutation starts and finishes. Other computational cost metrics may also be appropriate, such as a processor cycle count or a memory swap count required to complete execution of the test application 133 for the arrangement, and may similarly be tracked and reported to the computational cost recording module and recorded in the data repository.

[0063] In one embodiment, the computational cost is decomposed into the computational cost of the training cycle and the computational cost of the monitoring cycle. The test application container 129 is configured to send to the computational cost recording module 145 (i) the corresponding time when the execution of the training cycle of the test application 133 starts and completes on the target cloud container stack 101, and (ii) the corresponding time when the execution of the monitoring cycle of the test application 133 starts and completes on the target cloud container stack 101. This performance can be recorded in a data repository associated with the automatic scoping tool 103. The record can be a data structure representing a tuple that indicates i) the number of signals per observation for the permutation, (ii) the number of observations for the permutation, (ii) the number of training vectors for the permutation, (iv) the difference between the time when the execution of the training cycle of the test application 133 for the permutation starts and completes, and (iv) the difference between the time when the execution of the monitoring cycle of the test application 133 for the permutation starts and completes.

[0064] In one embodiment, the interface module 147 is configured to generate and send instructions that cause a user interface for the automatic scoping tool 103 to be displayed on the 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 the automatic scoping tool 103 and / or a user or administrator of the cloud computing system 100. These GUI elements include various graphical buttons, radio buttons, check boxes, text boxes, menus such as drop-down menus, and other elements.

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

[0066] In one embodiment, the evaluation module 149 determines a recommended container "shape" (also referred to as a "compute shape") for operating the production application 137 version of the application scanned from the local server 151. The evaluation module 149 accepts as input: (i) a minimum latency threshold for the rate at which observations are processed, or a target latency, (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 target number of training vectors. These can be referred to as performance constraints for machine learning applications and represent real-world expected operating conditions. The evaluation module 149 also accepts as input (v) performance data recorded by the compute cost recording module. Based at least in part on these inputs, the evaluation module 149 can create a recommended container shape (described in terms of the amount of CPU 123, the amount of GPU 125, and the allocated memory) to be deployed on the target cloud container stack. This recommended shape can be presented in a GUI by the interface module for review and confirmation by a user of the automatic scoping tool 103. The GUI can also display one or more visualizations of the performance data to support the recommended shape. In one embodiment, the evaluation module 149 generates instructions to form a production application container 131 having a recommended shape and sends it to the containerization module 141 to generate the production application container 131. In one embodiment, the GUI includes an input configured to accept approval to create the production application container using the recommended shape.

[0067] In one embodiment, the evaluation module 149 also accepts as input the price per unit time for the use of each of the CPU and GPU. The recommended "shape" can also be based on the price per unit time of the CPU and GPU. For example, the recommended shape may be the shape that minimizes the overall cost of maintaining a minimum throughput rate for observations.

[0068] In one embodiment, the evaluation module 149 ranks a set of possible container shapes according to criteria such as the monetary cost of operating the container shapes. In one embodiment, the evaluation module excludes those container shapes that do not meet the performance constraints from the set of possible container shapes to create a list of feasible container shapes that can be further ranked.

[0069] In addition to the local server 151 and the IoT sensor 153, the enterprise network 107 may also include a variety of computing devices and / or networked devices. Examples of such computing devices include server computers, such as the local server 151, personal computers such as desktop computers 155, laptop or notebook computers 157, tablet computers or personal digital assistants (PDAs), cellular phones, smart phones 159, or other mobile devices, machine control devices, IP telephony 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). During the execution of the production application 137 by the target cloud container stack 101, one or more of the devices of 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 monitored or monitored by the production application 137. Alternatively, for example, a client application executing on a desktop computer 155, a laptop computer 157, and / or a smart phone 159 may request information about a system monitored or monitored by the production application 137.

[0070] — Sample Method —

[0071] A computer-implemented method for autonomous cloud node scoping for big data machine learning use cases is described herein. In one embodiment, one or more computing devices (such as reference 1100) having an operably connected processor (such as processor 1110) and memory (such as memory 1115) and other components Fig.11 The computer 1105 shown and described may be configured with logic (such as autonomous cloud node scoping logic 1130) that causes the computing device to perform the steps of the method. For example, the processor accesses and reads or writes to the memory to perform the reference Figure 2 The steps shown and described herein may include (i) retrieving any necessary information, (ii) calculating, determining, generating, classifying, or otherwise creating any data, and (iii) storing any data calculated, determined, generated, classifying, or otherwise created. In one embodiment, the method described herein may be performed by (eg, referring to Figure 1 ) automatic scoping tool 103 or target cloud container stack 101 as shown and described.

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

[0073] Figure 2 An embodiment of a method 200 associated with autonomous cloud node scoping for a big data machine learning use case is illustrated. In one embodiment, a computer-implemented method is presented. The method includes, for each of a plurality of combinations of parameter values, (i) a step of setting a combination of parameter values ​​that describes a usage scenario, (ii) a step of executing a machine learning application on a target cloud environment according to the combination of parameter values, and (iii) a step of measuring a computational cost of executing the machine learning application. The method also includes generating a recommended configuration of (one or more) central processing units, (one or more) graphics processing units, and memory of a target cloud environment for executing the machine learning application based on the measured computational cost. In one embodiment, the method 200 can be performed by an automatic scoping tool 103 and / or a target cloud container stack 101.

[0074] Method 200 can be initiated based on various triggers, such as receiving a signal over a network or parsing stored data, which indicates that (i) a user (or administrator) of cloud computing system 100 has initiated method 200, (ii) method 200 is scheduled to be initiated at a defined time, or (iii) an automated process for migrating a machine learning application from a first computer system to a target cloud environment is being executed. Method 200 is initiated at start block 205 in response to parsing a received signal or retrieved stored data and determining that the signal or stored data indicates that method 200 should be initiated. Processing continues to process block 210.

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

[0076] In one embodiment, the processor retrieves the next combination of parameter values ​​from the memory or storage device. The parameters can be the number of signals per observation, the number of observations, and the number of training vectors. The processor generates instructions to the test application 133 (a machine learning application containerized with a specific computation shape) that it should execute using the combination of retrieved parameter values. The processor sends the instructions to the test application 133, for example as a REST command. The instructions can be sent to the test application via the container runtime engine 113. The steps of process box 210 can be performed, for example, by the test execution module 143 of the automatic scoping tool 103.

[0077] Once the processor has thus completed setting the combination of parameter values ​​that describes the usage scenario, processing at process block 210 is complete and processing continues to process block 215 .

[0078] At process block 215 , the processor executes the machine learning application on the target cloud environment based on the combination of parameter values.

[0079] In one embodiment, the test application 133 includes a machine learning algorithm. The processor generates an instruction to the test application 133 that the test application 133 should start executing, such as a REST command. This step of generating instructions to start execution can be performed, for example, by the test execution module 143 of the automatic scoping tool 103. In response, the processor retrieves a set of test data defined by a combination of parameter values. The processor executes the test application 133 on the set of test data, including the machine learning algorithm. In one embodiment, the processor records in memory the first time that the processor starts executing the test application 133, and records in memory the second time that the processor completes executing the test application. In one embodiment, the processor records in memory the first time that the processor starts executing a training cycle of the test application 133, and records in memory the second time that the processor completes executing the training cycle of the test application. In one embodiment, the processor records in memory the first time that the processor starts executing a monitoring cycle of the test application 133, and records in memory the second time that the processor completes executing the monitoring cycle of the test application 133. In one embodiment, the processor counts the memory processor (CPU and / or GPU) cycles used during the execution of the test application 133, the training cycle of the test application 133, and / or the monitoring cycle of the test application 133. For example, the steps of retrieving a test data set, executing a test application, and recording time or processor cycles may be performed by the target cloud container stack 101 .

[0080] Once the processor has thus completed executing the machine learning application according to the combination of parameter values ​​on the target cloud environment, processing at process block 215 is complete and processing continues to process block 220 .

[0081] At process block 220 , the processor measures the computational cost of executing the machine learning application.

[0082] In one embodiment, the processor generates a request to the test application container 129 to return a record of the first and second times and / or a count of processor cycles. This request can be, for example, a REST request directed to the test application container 129 by the container runtime engine 113. This request can also be, for example, generated and sent by the computational cost recording module 145. The processor executing the application container (one or more processors of the target cloud container stack 101) then returns the requested time and / or count to the computational cost recording module 145. The processor executing the computational cost recording module 145 then composes a computational cost record (data structure) including the current combination of parameter values ​​and the computational cost and stores it in a memory or storage device. The combination of parameter values ​​may include the number of signals, the number of observations, and the number of training vectors. The computational cost may include the difference (one or more) between the returned first and second times, and / or the count of the returned processor cycles.

[0083] Once the processor has thus completed measuring the computational cost of executing the machine learning application, processing is repeated from process block 210 for each of the remaining multiple combinations of parameter values ​​until no other combinations of parameter values ​​remain. The processor increments one of the parameter values ​​to move to the next combination of parameter values ​​in a nested loop traversal of the parameter value combinations that may be used for the stored incremental values. The incremental values ​​of the parameters may be retrieved from a memory or storage device. In this way, a combination of parameter values ​​is set to describe each expected use case, the machine learning application is executed for the parameter values ​​for each expected use case, and the performance of the machine learning application is measured for each expected use case. Processing at process block 220 is then complete, and processing continues to process block 225.

[0084] At process block 225, the processor generates recommendations regarding configuration of central processing unit(s), graphics processing unit(s), and memory of a target cloud environment for executing the machine learning application based on the measured computational costs.

[0085] In one embodiment, the processor retrieves a record of the computational cost of a target combination of signals, observations, and the number of training vectors. The processor determines whether the computational cost at the target combination exceeds the target latency for the performance of the machine learning application at the target combination. The target latency and target combination are user-provided information. If the target latency is exceeded, the computational shape (configuration of (one or more) central processing units, (one or more) graphics processing units, and memory of the target cloud environment) assigned to the machine learning application in the test application 133 is insufficient and will result in a backup of unprocessed observations. Therefore, if the target latency is exceeded, the processor will generate a recommendation against the computational shape of the test application 133. If the target latency is not exceeded, the computational shape assigned to the machine learning application in the test application 133 is sufficient and the observations provided to the test application 133 will be processed in a timely manner. Therefore, if the target latency is not exceeded, the processor will generate a recommendation in favor of the computational shape. The processor may also select the compute shape of the test application (the configuration of central processing unit(s), graphics processing unit(s), and memory of the target cloud environment) as the compute shape of the container configuration for deploying the machine learning application to the target cloud container stack (creating the production application 137).

[0086] In one embodiment, where the computational costs of the multiple test applications do not exceed the target latency, the processor may also evaluate which of the multiple test applications has the cheapest computational shape (as further discussed herein).

[0087] Once the processor has thus completed generating recommendations regarding the configuration of central processing unit(s), graphics processing unit(s), and memory of a target cloud environment for executing a machine learning application based on the measured computational costs, processing at process box 225 is complete and processing continues to end box 230, where process 200 ends.

[0088] In one embodiment, the combination of parameter values ​​is set according to a Monte Carlo simulation, and during execution of the machine learning application, the parameter values ​​of the machine learning application serve as input to the machine learning application. Figure 3One embodiment of a method 300 associated with autonomous cloud node scoping for a big data machine learning use case is illustrated, and details of one embodiment of a nested loop traversal of parameter value combinations are shown. The method 300 can be initiated based on various triggers, such as receiving a signal over a network or parsing stored data, the signal or data indicating that (i) a user (or administrator) of the cloud computing system 100 has initiated the method 300, (ii) the method 300 is scheduled to be initiated at a defined time, (iii) an automated process for migrating a machine learning application from a first computer system to a target cloud environment is being executed; or (iv) the method 300 is being executed for a particular compute shape as part of an evaluation of multiple compute shapes. The method 300 is initiated at a start block 305 in response to parsing a received signal or retrieved stored data and determining that the signal or stored data indicates that the method 300 should be initiated. Processing continues to process block 310.

[0089] At process block 310, the processor generates an initial number of signals by setting the number of signals equal to the initial number of signals (S initial ) to initialize the number of signals (numSig). In one embodiment, the processor retrieves a starting value for a range of the number of signals (such as the initial value of the range accepted as input by the test execution module 143) as the initial number of signals. The processor sets the number of signals equal to the retrieved value. Processing at process block 310 is complete and processing continues at decision block 315.

[0090] At decision block 315, the processor determines whether the number of signals (numSig) is less than the final number of signals (S final ). The processor retrieves the end value of the signal quantity range (such as the final value of the range accepted as input by the test execution module 143) as the final quantity of signals. The processor compares the signal quantity to the final quantity of signals. If it is true that the signal quantity is less than the final quantity of signals, then processing at decision block 315 is complete and processing continues at process block 320.

[0091] At process block 320, the processor generates an observation by setting the number of observations equal to the initial number of observations ( initial ) to initialize the number of observations (numObs). In one embodiment, the processor retrieves a starting value for a range of the number of observations (such as the initial value of the range accepted as input by the test execution module 143) as the initial number of observations. The processor sets the number of observations equal to the retrieved value. Processing at process block 320 is complete and processing continues at decision block 325.

[0092] At decision block 325, the processor determines whether the number of observations (numObs) is less than the final number of observations (numObs). finalIn one embodiment, the processor retrieves the end value of the range of observation number (such as the final value of the range accepted as input by the test execution module 143) as the final number of observations. The processor compares the number of observations to the final number of observations. If it is true that the number of observations is less than the final number of observations, then processing at decision block 325 is complete and processing continues at process block 330.

[0093] At process block 330, the processor generates an initial number of training vectors by setting the number of training vectors equal to the initial number of training vectors (V initial ) to initialize the number of training vectors (numVec). In one embodiment, the processor retrieves a starting value for a range of the number of training vectors (such as the initial value of the range accepted as input by the test execution module 143) as the initial number of training vectors. The processor sets the number of training vectors equal to the retrieved value. Processing at process block 330 is complete and processing continues at decision block 335.

[0094] At decision block 335, the processor determines whether the number of training vectors (numVec) is less than the final number of training vectors (V final In one embodiment, the processor retrieves the end value of the range of the number of training vectors (such as the final value of the 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 to 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, then processing at decision block 335 is complete and processing continues at process block 340.

[0095] At process block 340, the processor executes a machine learning application for the number of signals (numSig), the number of observations (numObs), and the number of training vectors (numVec), which is inserted into the container and deployed to the target cloud container stack. In one embodiment, the processor generates instructions to the machine learning application that tell it to extract the number of observations and the number of training vectors from the test data body. Each of the observations and the training vectors is limited to the length of the number of signals. The processor truncates additional signal columns from the extracted 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 extracted 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 monitoring) of the machine learning application begins. The processor monitors (or monitors) the extracted observations. The processor records a fourth time when monitoring (or monitoring) of the machine learning application ends. Processing at process block 340 is complete and processing continues at process block 345.

[0096] At process box 345, the processor records the computational cost for training and monitoring (or monitoring) performed by the executed machine learning application. In one embodiment, the processor (e.g., in the execution of the computational cost recording module 145 of the automatic scoping tool 103) generates and sends a request to the container deployed to 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 the memory and generates a message including the time. The container sends the 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 fourth time and the third time, and the number of signals, the number of observations, and the number of training vectors in the computational cost data structure to the data repository. The processing at process box 345 is completed and the processing continues at process box 350.

[0097] At process block 350, the processor increases the number of training vectors by a vector increment (V increment In one embodiment, the processor retrieves a vector increment value (such as an increment over the range of training vector quantities accepted by the test execution module 143) as the vector increment value. The processor assigns or sets the vector quantity to a new value—the sum of the current value of the vector quantity and the vector increment value. Once the processor has thus increased the vector quantity by the vector increment, processing at process block 350 is complete and processing returns to decision block 335.

[0098] While the number of training vectors is less than the final number of training vectors is still true, the processing between decision blocks 335 and 350 is repeated for each increment of the number of vectors. This forms the innermost loop of a set of nested loops. Once the number of training vectors is less than the final number of training vectors becomes false (i.e., the number of training vectors is greater than or equal to the final number of training vectors), the loop terminates and processing continues at process block 355.

[0099] At process block 355, the processor increases the number of observations by the observation increment (O increment In one embodiment, the processor retrieves an observation increment value (such as an increment over the range of observation numbers accepted by the test execution module 143) as the observation increment value. The processor assigns or sets the observation number to a new value—the sum of the current value of the observation number and the observation increment value. Once the processor has thus increased the observation number by the observation increment, processing at process block 355 is complete and processing returns to decision block 325.

[0100] While the number of observations is less than the final number of observations is still true, the processing between decision blocks 325 and 355 is repeated for each increment of the number of observations. This forms the middle loop of a set of nested loops. Once the number of observations is less than the final number of observations becomes false (i.e., the number of observations is greater than or equal to the final number of observations), the loop terminates and processing continues at process block 360.

[0101] At process block 360, the processor increases the signal quantity by a signal increment (S increment In one embodiment, the processor retrieves a signal increment value (such as an increment over the range of signal quantities accepted by the test execution module 143) as the signal increment value. The processor assigns or sets the signal quantity to a new value—the sum of the current value of the signal quantity and the signal increment value. Once the processor has thus incremented the signal quantity by the signal increment, processing at process block 360 is complete and processing returns to decision block 315.

[0102] While the signal quantity is less than the final quantity of signals is still true, the processing between decision blocks 315 and 360 is repeated for each increment of the signal quantity. This forms an outer loop of a set of nested loops. Once the signal quantity is less than the final quantity of signals becomes false (i.e., the signal quantity is greater than or equal to the final quantity of signals), the loop terminates and processing continues at process block 365.

[0103] At process block 365, the processor outputs the computational cost of all permutations of the number of signals, the number of observations, and the number of training vectors. In one embodiment, the processor (e.g., executing interface module 147) retrieves each computational cost data structure from a data repository. The processor generates instructions to display one or more graphics that present a bar chart and / or a surface chart defined by one or more computational cost data structures. The processor then sends instructions so that one or more graphics are displayed. The processing at process block 365 is then complete, and processing continues to end block 370, where process 300 terminates.

[0104] -analog signal-

[0105] In one embodiment, method 300 may further include steps for: (i) simulating a set of signals from one or more sensors; and (ii) providing the set of signals to the machine learning application as input to the machine learning application during execution of the machine learning application. For example, the processor executes (see above Figure 1The signal synthesis module analyzes historical data compiled by the local server 151 and generates a test data body that is statistically equivalent to the historical data to simulate a signal. The signal synthesis module stores the test data body in a data repository associated with the automatic scoping tool 103. The test execution module 143 accesses the synthesized test data body for use by the test application 133 during execution by the target cloud container stack 101.

[0106] In one embodiment, the signal synthesis module analyzes the historical data and generates a mathematical formula that can be used to generate test data that is statistically equivalent to the historical data. The signal synthesis module stores the mathematical formula in a data repository associated with the automatic scoping tool 103. The signal synthesis module generates synthetic test data on demand for use by the test application 133 during execution of the target cloud container stack 101. Using mathematical formulas to synthesize data on demand has advantages over using historical data or a body of synthesized test data in terms of required storage and portability - a body of test data can be several terabytes of data, while a mathematical formula may only be a few kilobytes.

[0107] The synthesized test data has the same deterministic and random structure as the "real" historical data, serial correlation for univariate time series, cross-correlation for multivariate time series, and random content of the noise component (variance, skewness, kurtosis). In one embodiment, the data synthesis for training vectors and for observations is performed separately. The synthesis of training vectors for the body of test data is based on historical sensor observations that represent normal operation of the system monitored or monitored by the sensors. The synthesis of observations for the body of test data is based on historical sensor observations that are unknown as to whether they represent normal operation of the system monitored or monitored by the sensors.

[0108] —Parameter variables—

[0109] In one embodiment, in method 300, the parameter value combination 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 provided to a machine learning application.

[0110] In the figure, the variable "numSig" refers to the number of signals (or discrete sensor outputs received) used for observations or training vectors. The variable "numObs" refers to the number of observation vectors (memory vectors of length numSig) to be received from the sensors of the monitored system in a given time unit (numObs may also be referred to as the sampling rate). In one embodiment, the observations are extracted from simulation data during scoping operations and from real-time data in the final deployment. The variable "numVec" refers to the number of training vectors (memory vectors of length numSig) provided to the machine learning application to train the machine learning application (numVec may also be referred to as 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.

[0111] —Non-linear relationship with computational cost—

[0112] In one embodiment, in method 300, the machine learning application results in a non-linear relationship between combinations of parameter values ​​and computational cost. As discussed above, the computational cost of streaming machine learning predictions does not scale linearly with the number of signals and the number of observations per unit time. Typically, the computational cost scales quadratically with the number of signals and linearly with the number of observations. The computational cost is further affected by the amount of available memory provided, the total GPU and CPU power provided. Therefore, a containerized machine learning application will have a non-linear relationship between combinations of parameter values ​​and computational cost.

[0113] Customer use cases typically vary widely, from simple enterprise use cases such as monitoring one machine with 10 sensors and a slow sampling rate, to multinational commercial enterprise use cases such as with hundreds of thousands of sensors with high sampling rates. The following examples illustrate the range of typical customer use case scenarios for cloud-enabled machine learning predictions:

[0114] ●Customer A has a use case of only 20 signals, sampled at a slow rate of only once per hour, making a typical year of data a few MB.

[0115] ●Customer B has a fleet of Airbus 320s, each with 75,000 sensors sampling once a second, resulting in each aircraft generating 20TB of data per month.

[0116] Other commercial enterprise customers typically fall somewhere in the very broad range of use cases between A and B.

[0117] In one embodiment, the automatic scoping tool 103 (in one embodiment, using the containerization module 141) 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 an MSET application, a multivariate state estimation technique 2 (MSET2) application, a neural network application, a support vector machine application, and an autocorrelation kernel regression application.

[0118] Figure 4 An example 400 of the method 300 for a particular use case associated with autonomous cloud node scoping for big data machine learning is shown. In the example method 400, the number of signals ranges from 10 signals to 100 signals in increments of 10 signals, as indicated by initializing the number of signals to 10 at process block 405, determining whether the number of signals is less than 100 at decision block 410, and incrementing the number of signals by 10 at process block 415. The number of observations (i.e., the sampling rate or the number of observations per unit time) ranges from 10,000 observations to 100,000 observations in increments of 10,000 observations, as indicated by initializing the number of observations to 10,000 at process block 420, determining whether the number of observations is less than 100,000 at decision block 425, and incrementing the number of observations by 10,000 at process block 430. The number of training vectors (i.e., the size of the training data set) ranges from 100 training vectors to 2,500 training vectors in increments of 100 training vectors, as indicated by initializing the number of training vectors to 100 at process block 435, determining whether the number of training vectors is less than 2,500 at decision block 440, and incrementing the number of training vectors by 100 at process block 445. In this example method 400, the machine learning application is an MSET application, as indicated by process block 450. As indicated by process block 455, the computational cost of executing the MSET application for each permutation of the number of signals, the number of observations, and the number of training vectors is recorded by the processor in a memory. As indicated by process block 460, the computational cost of executing the MSET application for each permutation of the number of signals, the number of observations, and the number of training vectors is output by the processor from the memory. For example, the output may be in the form of a graphical representation, such as a reference graph. Figures 5A-8D those shown and described.

[0119] In one embodiment, example 400 is performed by automatic scoping tool 103. Automatic scoping tool 103 (in one embodiment, using containerization module 141) accepts an MSET machine learning application as input to a pluggable machine learning application. Automatic scoping tool 103 places the MSET machine learning application in a candidate cloud container. Automatic scoping tool 103 (in one embodiment, using test execution module) causes the containerized MSET machine learning application to be executed for possible combinations of the number of signals, observations of those signals, and the size of the training data set. In one embodiment, automatic scoping tool 103 runs through all possible such combinations. In another embodiment, combinations are selected at regular intervals over the width of each parameter, as dictated by the increment associated with the parameter.

[0120] — Graphical representation of performance information —

[0121] In one embodiment, method 300 may also include steps for: (i) generating one or more graphical representations showing combinations of parameter values ​​associated with a computational cost for each combination; and (ii) creating instructions to display the one or more graphical representations on a graphical user interface to enable selection of a configuration of central processing unit(s), graphics processing unit(s), and memory of a target cloud environment for executing a machine learning application.

[0122] In one example, an automatic scoping tool is executed for MSET machine learning prediction techniques in candidate cloud containers to determine how computational cost varies with respect to the number of signals, the number of observations, and the number of training vectors, where MSET is used as a cloud service, as in example method 400. In one embodiment, the results are presented as graphical representations of information, such as bar graphs and surface graphs, showing actual computational cost measurements and observed trends to scope out cloud implementations of MSET. In one embodiment, various presentations of the results are presented as an aid to a user of the automatic scoping tool in selecting the shape of the container.

[0123] Figure 5A-5D Example three-dimensional (3D) plots are shown that were generated to show 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. These plots illustrate the parametric empirical relationship between the computational cost of the training process for the MSET technique, the number of memory vectors, and the number of observations. The number of signals in each individual Figure 5A , Figure 5B , Figure 5C and Figure 5DBased on the observation of the figure, it can be concluded that the computational cost of the training process of the MSET machine learning technique mainly depends on the number of memory vectors and the number of signals.

[0124] Figure 6A-6D Example three-dimensional (3D) plots are shown that were generated to show the computational cost of streaming monitoring using the MSET machine learning technique as a function of the number of observations and the number of training vectors. These plots illustrate the parametric empirical relationship between the computational cost, number of memory vectors, and number of observations for streaming monitoring using the MSET machine learning technique. The number of signals is calculated at each individual Fig. 6A , Figure 6B , Figure 6C and Fig.6D It can be concluded that the computational cost of streaming monitoring depends mainly on the number of observations and the number of signals.

[0125] Figure 7A-7D An example three-dimensional (3D) plot is shown that was 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. Figure 7A-7D Shows Figure 5A-5D The computational cost of the training process of the MSET machine learning technique is relative to the number of signals and the number of observations, while the number of memory vectors is proportional to the number of observations in each individual Fig. 7A , Figure 7B , Figure 7C and Fig.7D Specified in.

[0126] Figure 8A-8D An example three-dimensional (3D) plot is shown that was generated to show the computational cost of streaming monitoring using the MSET machine learning technique as a function of the number of observations and the number of signals. Figure 8A-8D Shows Figure 6A-6D Alternative layouts for streaming monitoring using MSET machine learning techniques, and the computational cost relative to the number of signals and the number of observations, while the number of memory vectors per Fig. 8A , Figure 8B , Figure 8C and Fig.8D Specified in.

[0127] Thus, the 3D results presented by the system show the user of the system a wealth of information about the performance of a selected machine learning application containerized in a selected compute shape (configuration of (one or more) central processing units, (one or more) graphics processing units, and memory) in a target cloud environment. This enables the system user to quickly evaluate the performance of the machine learning application in the selected compute shape. For example, the 3D results intuitively show the user the "computational cost" (latency of the computation) of the machine learning application, which is containerized using a particular compute shape for a given number of each of (i) sensors, (ii) observations (equivalent to the sampling rate of the input to the machine learning application), and (iii) training vectors. In one embodiment, the system can present 3D results for each compute shape that is available for (applicable to) the target cloud computing stack.

[0128] In addition, for each of these compute shapes, the system can also calculate the dollar cost associated with the shape and display them to the user. In one embodiment, pricing is based on the amount of time that each aspect of the compute shape is available for use. In one embodiment, where the service is billed by the hour, the price of a given compute shape can 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 may charge $0.06 per hour for the use of the CPU, $0.25 per hour for the use of the GPU, and $0.02 per hour for the use of 1GB of RAM. Therefore, the data center will charge $1.14 per hour to operate the first example compute shape with 8 CPUs, 2 GPUs, and 8GB of RAM; and will charge $3.28 per hour to operate the first example compute shape with 16 CPUs, 6 GPUs, and 16GB of RAM.

[0129] At a minimum, presenting the user with the 3D results and dollar cost associated with a particular shape automatically presents the user with maximum information that would otherwise take the user a long time to try to figure out from trial and error runs.

[0130] —Evaluation of various calculation shapes—

[0131] In one embodiment, the system evaluates the performance of a machine learning application for each of a set of shapes that can be deployed in a target cloud computing stack. This set may include a selection of shapes provided by a data center, or may include all possible combinations of shapes, or some other set of shapes for deployment in a target cloud computing stack. A user of the system may then select an appropriate compute shape to containerize the machine learning application. For example:

[0132] (1) If all available compute shapes satisfy the "compute cost" constraint (satisfying the machine learning application's target latency for (i) maximum number of signals, (ii) maximum sampling rate, and (iii) maximum number of training vectors), the system may recommend to the user that the compute shape with the lowest monetary cost be selected.

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

[0134] In addition, the presented 3D results and costing information give the user the information needed to evaluate reconfiguring the machine learning application (e.g., by reducing the number of sensors or the number of observations (sampling rate), or backing off the overall prediction accuracy by reducing the number of training vectors). Without system-provided results, understanding the trade-offs between reducing the number of signals, or the number of observations, or the number of training vectors to meet the user's computational cost constraints involves uncertainty, guesswork, and weeks of trial and error experiments. Using the 3D curves and costing information provided by the system, users can quickly decide, for example, "let's throw away the 10 least helpful sensors" or "let's reduce the sampling rate by 8%" or "we're overkilling the prediction accuracy, so let's reduce the number of training vectors by 25%." This opportunity to adjust model parameters to meet their own prediction metrics has never been available before from cloud providers for machine learning use cases.

[0135] In one embodiment, for each of a set of available computing shapes of the target cloud environment, the steps of setting, executing, and measuring are further repeated for each of a plurality of combinations of parameter values ​​(see Figure 2 Steps 210, 215 and 220 discussed above).

[0136] Fig. 9One embodiment of a method 900 for evaluating multiple compute shapes associated with autonomous cloud node scoping for a big data machine learning use case is illustrated. In one embodiment, method 900 is an additional outermost loop added to process 300, repeated for each of a set of compute shapes. Method 900 can be initiated based on various triggers, such as receiving a signal over a network or parsing stored data, which indicates that (i) a user (or administrator) of cloud computing system 100 has initiated method 900, (ii) method 900 is scheduled to be initiated at a defined time, or (iii) an automated process for migrating a machine learning application from a first computer system to a target cloud environment is being executed. Method 900 is initiated at start block 905 in response to parsing a received signal or retrieved stored data and determining that the signal or stored data indicates that method 900 should be initiated. Processing continues to process block 910.

[0137] At process block 910, the processor retrieves the next available computing shape from a set of computing shapes available for the target cloud environment. In one embodiment, the processor resolves the address of a computing shape library suitable for implementation on the target cloud computing environment. The library can be stored as a data structure in a storage device or memory. The library can be a table that lists the configurations of computing shapes. The processor selects the next computing shape in the library that has not been evaluated during the execution of method 900. The processor stores the configuration of the retrieved computing shape in the memory. Processing at process block 910 is completed and processing continues at process block 315.

[0138] At process block 915, the processor containerizes the machine learning application based on the retrieved compute shape. In one embodiment, the processor parses the retrieved configuration to identify a specific configuration of the compute shape, including at least the central processing unit(s) and the graphics processing unit(s) and the amount of allocated memory. The processor then builds a test application container for the machine learning application based on the compute shape. For example, the processor may execute or call (as referenced in Figure 1 The processor provides at least the machine learning application and the retrieved shape 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 based on the retrieved computational shape. Processing at process block 915 is complete and processing continues at process block 920.

[0139] At process block 920, the processor initiates process 300 and performs the steps of the process for the containerized machine learning application, as described above with reference to Figure 3 Process block 920 is completed and processing continues at decision block 925 .

[0140] At decision block 925, the processor determines whether any computational shapes in the set of computational shapes available to the target cloud environment remain unevaluated. For example, the processor may parse the next entry of the library to determine whether the next entry describes another shape, or whether the next entry is NULL, empty, or otherwise indicates that there are no other shapes. If the next entry describes another shape (decision block 925: Yes), processing returns to step 910, and method 900 repeats for the next computational shape.

[0141] Note that process block 365 (performed in process block 920) causes the computational cost information for each computational shape to be output. In one embodiment, the computational cost information is output to memory in a data structure associated with a particular computational shape for later evaluation of the performance of the computational shape in executing a machine learning application.

[0142] If the next entry in the set of calculated shapes indicates that there are no more shapes (decision block 925: NO), processing at decision block 925 is complete and processing continues to end block 930 where method 900 ends.

[0143] Thus, in one embodiment, for each container shape in a set of container shapes, for each increment of the number of signals across a range of signal numbers, for each increment of the sampling rate across a range of sampling rates, and for each increment of the number of training vectors across a range of the number of training vectors, a processor executes a machine learning application in a container configured according to the container shape based on a combination of the number of signals and the number of training vectors at the sampling rate.

[0144] In one embodiment, the systems and methods assume that the user will automatically want to use the computational shape container with the lowest monetary cost that meets the user's performance constraints (in terms of 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 for multiple computational shapes, the processor automatically presents the lowest cost option that meets the performance constraints. For example, the systems and methods may present an output to the user stating "Shape C with n CPUs and m GPUs meets your performance requirements at the lowest cost of $8.22 per hour." In this case, the processor sorts the feasible shapes that meet the customer's computational cost metric (performance constraint) and then selects the shape with the lowest monetary cost from the list of feasible shapes. In one embodiment, these steps of evaluating and sorting may be performed by the processor's implementation of the evaluation module 149.

[0145] In one embodiment, the processor automatically configures the cloud container in the target cloud environment according to the recommended configuration. For example, this can be performed by the processor implementing the containerization module 141 for the machine learning application and the (one or more) central processing unit, (one or more) graphics processing unit, and the amount of allocated memory indicated by the recommended configuration or shape.

[0146] In one embodiment, other members (some or all) of the list of feasible container shapes are presented to the user for selection. In one embodiment, the steps of these processes may be performed by a processor 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 ​​associated with the computational cost of each combination, and creates instructions to display the one or more graphical representations on a graphical user interface to allow selection of a configuration of central processing unit(s), graphics processing unit(s), and memory of a target cloud environment for executing a machine learning application. Fig.10 One embodiment of an example GUI 1000 for presenting container shapes, cost calculations, and 3D performance information curves and container shape recommendations is shown. The example GUI 1000 has a series of rows 1005, 1010, 1015 describing each possible container shape. Additional rows describing other container shapes may be visible by scrolling down in the GUI. Each of the rows 1005, 1010, 1015 also displays the performance of the machine learning application in the particular container shape described by the row in a row group of one or more graphical representations 1020, 1025, 1030. For example, the graphical representation may be a 3D graph, such as a reference Figures 5A-8D those shown and described.

[0147] Each of the rows describes configuration information (in terms of CPU, GPU, and amount of memory allocated) and costing information (in terms of fees charged per unit time) for that row. In one embodiment, the rows are displayed in ascending order of a criterion such as monetary cost, with the cheapest feasible container shapes placed in the top row. In one embodiment, the example GUI 1000 may show a specific indication 1035 that a particular container shape is recommended.

[0148] Each of the rows is associated with a component (such as a radio button, check box, or other button) for indicating a selection of the container shape associated with the row. For example, a user of GUI 1000 may decide not to select the recommended option by leaving radio button 1040b unselected, and decide to select the next most expensive option by selecting radio button 1045 (e.g., by a mouse click). The user may then complete this selection by selecting (e.g., by a mouse click) "Select Container Shape" button 1050. Thus, in one embodiment, a user may enter a selection of a configuration by selecting a radio button adjacent to a description of a desired container shape and then selecting "Select Container Shape" button 1050.

[0149] In one embodiment, in response to receiving the selection, the processor can automatically configure the cloud container in the target cloud environment according to the selected configuration. For example, this can be performed by implementing the containerization module 141 for the machine learning application and the (one or more) central processing unit(s) and (one or more) graphics processing unit(s) and the amount of allocated memory indicated by the selected configuration or shape.

[0150] GUI 1000 can also include "adjust target parameters and re-evaluate" button 1055. Selecting this button 1055 (e.g., by mouse click) indicates that GUI 1000 displays an adjustment menu that allows the user to adjust the target parameters. For example, the user can be enabled to enter the updated value of the target delay, the target number of signals and / or the target number of observations, the target number of training vectors into a text field. Alternatively, the values ​​of these variables can be adjusted by a graphical slider, button, knob or other graphical user interface element. An "accept and re-evaluate" button can be included in the adjustment menu. The selection of the "accept and re-evaluate" button will cause the processor to re-evaluate the performance data of each container shape in view of the new target parameters. In one embodiment, the steps of these processes can be performed by the processor to implement the interface module 147 and the evaluation module 149.

[0151] Thus, the systems and methods span the spectrum of customer sophistication from those customers who want maximum detailed information (not available from any other approach) to enable adjustments to the number of signals, observations, and training vectors to achieve a satisfactory cost, to those customers who simply want to be told what shape satisfies all of the desired performance metrics for the customer's predictive machine learning application at the lowest monetary cost.

[0152] — Cloud or Enterprise Implementation —

[0153] In one embodiment, the automatic scoping tool 103 and / or other systems shown and described herein are computing / data processing systems including a database application or a collection of distributed database applications. The applications and data processing systems may be configured to operate with or be implemented as a cloud-based networked system, software as a service (SaaS) architecture, platform as a service (PaaS) architecture, infrastructure as a service (IaaS) architecture, or other types of network computing solutions. In one embodiment, the cloud computing system 100 is a server-side system that provides at least the functionality disclosed herein and can be accessed by many users via computing devices / terminals that communicate with the cloud computing system 100 (acting as a server) through a computer network.

[0154] —Software Module Embodiment—

[0155] Typically, software instructions are designed to be executed by a suitably 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.

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

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

[0158] —Computing Device Embodiment—

[0159] Fig.11An example computing device is shown that is configured and / or programmed with one or more of the example systems and methods described herein, and / or equivalents. The example computing device may be a computer 1105 including a processor 1110, a memory 1115, and an input / output port 1120 operably connected via a bus 1125. In one example, the computer 1105 may include autonomous cloud node scoping logic 1130 configured to facilitate autonomous cloud node scoping for big data machine learning use cases (e.g., determining an appropriate compute shape for a cloud container for a machine learning application), similar to reference Figure 1-Figure 10 11. The logic, systems, and methods shown and described herein. In various examples, the logic 1130 may be implemented in hardware, a non-transitory computer-readable medium having stored instructions, firmware, and / or a combination thereof. Although the logic 1130 is illustrated as a hardware component attached to the bus 1125, it should be understood that in other embodiments, the logic 1130 may be implemented in the processor 1110, stored in the memory 1115, or stored in the disk 1135.

[0160] In one embodiment, logic 1130 or computer is a device (e.g., structure: hardware, non-transitory computer-readable medium, firmware) for performing the described actions. In some embodiments, the computing device can be a server operating in a cloud computing system, a server configured in a software as a service (SaaS) architecture, a smart phone, a laptop, a tablet computing device, etc.

[0161] The apparatus may be implemented as, for example, an ASIC programmed to automate process discovery and facilitation. The apparatus may also be implemented as stored computer executable instructions that are presented to the computer 1105 as data 1140 , which are temporarily stored in the memory 1115 and then executed by the processor 1110 .

[0162] The logic 1130 may also provide means (eg, hardware, non-transitory computer-readable media storing executable instructions, firmware) for performing automated process discovery and facilitation.

[0163] Generally describing an example configuration of computer 1105, processor 1110 can be a variety of processors, including dual microprocessors and other multi-processor architectures. Memory 1115 can include volatile memory and / or non-volatile memory. Non-volatile memory can include, for example, ROM, PROM, EPROM, EEPROM, etc. Volatile memory can include, for example, RAM, SRAM, DRAM, etc.

[0164] The storage disk 1135 can be operably connected to the computer 1105 via an input / output interface (e.g., card, device) 1145 and an input / output port 1120, for example, controlled by at least one input / output (I / O) controller 1147. The disk 1135 can 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. In addition, the disk 1135 can be a CD-ROM drive, a CD-R drive, a CD-RW drive, a DVD ROM, etc. For example, the memory 1115 can store processes 1150 and / or data 1140. The disk 1135 and / or the memory 1115 can store an operating system that controls and allocates resources of the computer 1105.

[0165] The computer 1105 can interact with input / output (I / O) devices through an input / output (I / O) controller 1147, an input / output (I / O) interface 1145, and input / output ports 1120. The input / output devices can be, for example, keyboards, microphones, pointing and selecting devices, cameras, video cards, displays, disks 1135, network devices 1155, etc. The input / output ports 1120 can include, for example, serial ports, parallel ports, and USB ports.

[0166] The computer 1105 can operate in a network environment and thus can be connected to a network device 1155 via the I / O interface 1145 and / or the I / O port 1120. Through the network device 1155, the computer 1105 can interact with a network 1160. Through the network 1160, the computer 1105 can be logically connected to a remote computer 1165. The networks with which the computer 1105 can interact include, but are not limited to, LANs, WANs, and other networks.

[0167] The computer 1105 may control one or more output devices through the I / O ports 1120, or may 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, touch pads, or touch screens), audio input devices 1184 (such as microphones), and video input devices 1186 (such as video cameras and still cameras).

[0168] -Definitions and Other Embodiments-

[0169] In another embodiment, the described methods and / or their equivalents may be implemented with computer executable instructions. Thus, in one embodiment, a non-transitory computer readable / storage medium is configured with stored computer executable instructions of an algorithm / executable application, which, when executed by (one or more) machines, causes the (one or more) machines (and / or associated components) to perform the method. Example machines include, but are not limited to, processors, computers, servers operating in a cloud computing system, servers configured in a software as a service (SaaS) architecture, smart phones, etc.). In one embodiment, a computing device is implemented with one or more executable algorithms that are configured to perform any disclosed method.

[0170] In one or more embodiments, the disclosed method or its equivalent is performed by any of the following: computer hardware configured to perform the method; or computer instructions embodied in a module stored in a non-transitory computer-readable medium, wherein the instructions are configured as an executable algorithm that is configured to perform the method when executed by at least one processor of a computing device.

[0171] Although for the purpose of explaining simplicity, the method shown in the figure is shown and described as a series of algorithmic frames, it should be understood that the method is not limited by the order of the frames. Some frames can occur in a different order from that shown and described and / or occur simultaneously with other frames shown and described. In addition, less than all illustrated frames can be used to implement the example method. Frames can be combined or separated into multiple actions / components. In addition, additional and / or alternative methods can adopt additional actions not illustrated in the frame.

[0172] The following includes definitions of selected terms used herein. The definitions include various examples and / or forms of components that fall within the scope of the term and can be used for implementation. The examples are not intended to be limiting. Both singular and plural forms of a term may be within a definition.

[0173] References to "one embodiment," "an embodiment," "an example," "an example," etc. indicate that the embodiment(s) or example(s) described thus may include a particular feature, structure, characteristic, attribute, element, or limitation, but not every embodiment or example must include the particular feature, structure, characteristic, attribute, element, or limitation. Furthermore, repeated use of the phrase "in one embodiment" does not necessarily refer to the same embodiment, although it may.

[0174] ASIC: Application-specific integrated circuit.

[0175] CD: Compact disc.

[0176] CD-R: Recordable CD.

[0177] CD-RW: Rewritable CD.

[0178] DVD: Digital Versatile Disc and / or Digital Video Disc.

[0179] LAN: Local Area Network.

[0180] RAM: Random Access Memory.

[0181] DRAM: Dynamic RAM.

[0182] SRAM: Synchronous RAM.

[0183] ROM: Read-only memory.

[0184] PROM: Programmable ROM.

[0185] EPROM: Erasable PROM.

[0186] EEPROM: Electrically Erasable PROM.

[0187] USB: Universal Serial Bus.

[0188] WAN: Wide Area Network.

[0189] As used herein, a "data structure" is an organization of data in a computing system stored in a memory, storage device, or other computerized system. A data structure may be, for example, any of a data field, a data file, a data array, a data record, a database, a data table, a graph, a tree, a linked list, and the like. A data structure may be formed of and contain many other data structures (e.g., a database includes many data records). Other examples of data structures are possible according to other embodiments.

[0190] As used herein, "computer-readable medium" or "computer storage medium" refers to a non-transitory medium that stores instructions and / or data, which are configured to perform one or more of the disclosed functions when executed. In some embodiments, data can be used as instructions. Computer-readable media can take the form of, but not limited to, non-volatile media and volatile media. Non-volatile media can include, for example, optical disks, magnetic disks, etc. Volatile media can include, for example, semiconductor memories, dynamic memories, etc. Common forms of computer-readable media can include, but are not limited to, floppy disks, flexible disks, hard disks, tapes, other magnetic media, application-specific integrated circuits (ASICs), programmable logic devices, compact disks (CDs), other optical media, random access memories (RAMs), read-only memories (ROMs), memory chips or cards, memory sticks, solid-state storage devices (SSDs), flash drives, and other media that computers, processors, or other electronic devices can work with. Each type of medium, if selected for implementation in one embodiment, can include storage instructions for algorithms configured to perform one or more of the disclosed and / or claimed functions.

[0191] As used herein, "logic" means a component implemented with a computer or electronic hardware, a non-transitory medium with storage instructions of executable applications or program modules, and / or a combination of these to perform any function or action as disclosed herein, and / or to cause a function or action from another logic, method, and / or system to be performed as disclosed herein. Equivalent logic may include firmware, a microprocessor programmed with an algorithm, discrete logic (e.g., ASIC), at least one circuit, an analog circuit, a digital circuit, a programming logic device, a memory device containing algorithm instructions, and the like, any of which may be configured to perform one or more of the disclosed functions. In one embodiment, logic may include one or more gates, a combination 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 incorporate multiple logics into one logic. Similarly, where a single logic is described, it may be possible to distribute the single logic between 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 is implemented may be based on the desired system conditions or indicators. For example, if higher speed is considered, hardware will be selected to implement the function. If lower cost is a consideration, stored instructions / executable applications will be chosen to implement the functionality.

[0192] An "operable connection," or a connection through which entities are "operably connected," is a connection through which signals, physical communications, and / or logical communications can be sent and / or received. An operable connection may include a physical interface, an electrical interface, and / or a data interface. An operable connection may include different combinations of interfaces and / or connections sufficient to allow operable control. For example, two entities may be operably connected to transmit signals to each other directly or through one or more intermediate entities (e.g., a processor, an operating system, logic, a non-transitory computer-readable medium). Logical and / or physical communication channels may be used to create an operable connection.

[0193] As used herein, a "user" includes, but is not limited to, one or more persons, computers or other devices, or a combination of these.

[0194] Although the disclosed embodiments have been illustrated and described in considerable detail, it is not intended that the scope of the appended claims be limited or in any way restricted to such details. Of course, it is not possible to describe every conceivable combination of components or methods for the purpose of describing various aspects of the subject matter. Therefore, the present disclosure is not limited to the specific details or illustrative examples shown and described. Therefore, the present disclosure is intended to cover changes, modifications and variations that fall within the scope of the appended claims.

[0195] To the extent the term "includes" or "including" is used in either the detailed description or the claims, it is intended to be inclusive in a manner similar to the term "comprising" in that this term, when used, is interpreted as a transitional word in the claims.

[0196] To the extent the term "or" is used in the detailed description or claims (e.g., A or B), it is intended to mean "A or B or both." When the applicants intend to indicate "only A or B but not both," then the phrase "only A or B but not both" will be used. Thus, the use of the term "or" herein is inclusive, rather than exclusive.

Claims

1. A computer-implemented method comprising: For each of multiple combinations of parameter values, (i) setting a combination of parameter values ​​that describe the usage scenario, (ii) executing a machine learning application according to said combination of parameter values ​​for candidate configurations of a central processing unit, a graphics processing unit, and a memory of the target cloud environment, and (iii) measuring the computational cost of executing the machine learning application using the candidate configuration; as well as Based on the measured computational costs and the target latency, a recommendation is generated from the candidate configurations for a recommended configuration of one or more central processing units, one or more graphics processing units, and memory of the target cloud environment for executing the machine learning application.

2. The method of claim 1, further comprising: Simulate a set of signals from one or more sensors; as well as During execution of the machine learning application, the set of signals is provided to the machine learning application as input to the machine learning application.

3. The method of claim 1, wherein the combination of parameter values ​​is a combination of: a value of a quantity of a signal from one or more sensors; the value of the number of observations streamed per unit time; and A value for the number of training vectors to provide to the machine learning application.

4. The method of claim 1, wherein the machine learning application results in a non-linear relationship between the combination of parameter values ​​and the computational cost.

5. The method of claim 1, further comprising: generating one or more graphical representations showing combinations of parameter values ​​associated with the computational costs for each different candidate combination; as well as Instructions are created to display the one or more graphical representations on a graphical user interface to enable selection of a target candidate configuration of one or more central processing units, one or more graphics processing units, and memory of the target cloud environment for executing the machine learning application. 6 . The method of claim 1 , further comprising automatically configuring a cloud container in the target cloud environment according to the recommended configuration.

7. The method of claim 1, wherein the combination of parameter values ​​is set according to a Monte Carlo simulation, the method further comprising: The parameter values ​​are provided to the machine learning application as input to the machine learning application during execution of the machine learning application.

8. The method of claim 1 further comprising repeating the steps of setting, executing, and measuring for each of a set of available configurations of one or more central processing units, one or more graphics processing units, and memory of the target cloud environment, the steps being repeated for each of a plurality of combinations of parameter values.

9. A non-transitory computer-readable medium storing computer-executable instructions which, when executed by at least a processor of a computer, cause the computer to: For each of multiple combinations of parameter values, (i) setting a combination of parameter values ​​that describe the usage scenario, (ii) executing a machine learning application according to said combination of parameter values ​​for candidate configurations of a central processing unit, a graphics processing unit, and a memory of the target cloud environment, and (iii) measuring the computational cost of executing the machine learning application using the candidate configuration; and Based on the measured computational costs and the target latency, a recommendation is generated from the candidate configurations for a recommended configuration of one or more central processing units, one or more graphics processing units, and memory of the target cloud environment for executing the machine learning application.

10. The non-transitory computer-readable medium of claim 9, further comprising instructions that, when executed by at least the processor, cause the computer to: simulating a set of signals from one or more sensors; and During execution of the machine learning application, the set of signals is provided to the machine learning application as input to the machine learning application.

11. The non-transitory computer readable medium of claim 9, wherein the combination of parameter values ​​is a combination of: a value of a quantity of a signal from one or more sensors; the value of the number of observations streamed per unit time; and A value for the number of training vectors to provide to the machine learning application.

12. The non-transitory computer-readable medium of claim 9, further comprising instructions that, when executed by at least the processor, cause the computer to: generating one or more graphical representations showing combinations of parameter values ​​associated with the computational cost for each combination; and creating instructions to display the one or more graphical representations on a graphical user interface to enable selection of a configuration of one or more central processing units, one or more graphics processing units, and memory of the target cloud environment for executing the machine learning application; and In response to receiving the selection, a cloud container in the target cloud environment is automatically configured according to the selected configuration.

13. A computing system comprising: processor; a memory operatively coupled to the processor; A non-transitory computer-readable medium storing computer-executable instructions that, when executed by at least a processor accessing a memory, cause the computing system to: For each of multiple combinations of parameter values, (i) setting a combination of parameter values ​​that describe the usage scenario, (ii) executing a machine learning application according to said combination of parameter values ​​for candidate configurations of a central processing unit, a graphics processing unit, and a memory of the target cloud environment, and (iii) measuring the computational cost of executing the machine learning application using the candidate configuration; as well as Based on the measured computational costs and the target latency, a recommendation is generated from the candidate configurations for a recommended configuration of one or more central processing units, one or more graphics processing units, and memory of the target cloud environment for executing the machine learning application.

14. The computing system of claim 13, wherein the computer-readable medium further comprises instructions that cause the computing system to: For each container shape in a set of container shapes, For each increment of the signal number across the range of signal numbers, for each increment of the sampling rate across the range of sampling rates, and For each increment in the number of training vectors across the range of the number of training vectors, The machine learning application is performed based on a combination of the number of signals at the sampling rate and the number of training vectors in a container configured according to the container shape.

15. The computing system of claim 13, wherein the computer-readable medium further comprises instructions that cause the computing system to: generating one or more graphical representations showing combinations of parameter values ​​associated with the computational cost for each combination; and creating instructions to display the one or more graphical representations on a graphical user interface to enable selection of a configuration of one or more central processing units, one or more graphics processing units, and memory of the target cloud environment for executing the machine learning application; and In response to receiving the selection, a cloud container in the target cloud environment is automatically configured according to the selected configuration.

Images