Learning model generation device, learning model generation method, and learning model generation program

Abstract

In the present invention, a learning model generation device (1) comprises: a data collection unit (110) which collects, for a server to be measured (200), performance information and power consumption, such collection carried out by sending load application indication information which indicates the application of load and by sending a performance information acquisition request which requests acquisition of performance information and a power consumption acquisition request which requests acquisition of the power consumption; a dataset creation unit (120) which generates a grouping of the performance information and the power consumption as a dataset (100) and generates a learning dataset (101) and a testing dataset (102); a learning unit (130) which uses the learning dataset (101) to generate a learning model based on a predetermined machine learning algorithm; and an evaluation unit (140) which uses the testing dataset (102) to evaluate the accuracy of the learning model.

Description

[Technical field]

[0001] The present invention relates to a learning model generation device, a learning model estimation method, and a learning model generation program that generate a learning model for estimating power consumption of a server. [Background technology]

[0002] The spread of cloud services has led to an increase in the amount of data processed and stored, which has led to an increase in the power consumption of servers due to data-intensive workloads. As a countermeasure, system consolidation technology using virtualization technologies such as VM (Virtual Machine) and containers, CPU power consumption control technology using DVFS (Dynamic Voltage and Frequency Scaling), etc. are being considered. In these power consumption reduction technologies, the importance of accurately monitoring (detecting) and estimating the power consumption of servers is increasing.

[0003] There are two main methods for monitoring the power consumption of a server: one is physical measurement using a measuring device, and the other is estimation through modeling. In physical measurements using a measuring instrument, for example, a power meter is connected to each server to measure power consumption. However, this requires a power meter for each server, and is not suitable for monitoring a large number of servers at once due to factors such as equipment costs and the burden of installation work on existing servers. There is also a technology to measure power consumption using a power sensor installed in a server, such as IPMI (Intelligent Platform Management Interface). However, there is a problem in that not all servers are equipped with a power sensor.

[0004] Modeling estimation involves constructing a power consumption model based on metrics (evaluation measures) data obtained from the OS (operating system), HW (hardware), etc., and performing estimated calculations. Methods for estimating power consumption include modeling the power consumption of the entire server, and modeling each component that makes up the server (CPU, memory, disk, etc.) to build a more accurate model.

[0005] In addition, the input parameters used in constructing the model include (1) performance and status data provided by the HW subsystem (hereinafter referred to as "HW-based"), (2) data representing usage at the system level (hereinafter referred to as "OS-based"), and (3) a combination of the above data (1) and (2) (hereinafter referred to as "hybrid type").

[0006] In the HW-based approach, performance and status data (e.g., instruction fetching, cache miss, memory access, etc.) is obtained from the HW subsystem. This performance and status data can be obtained, for example, by a performance analysis tool such as perf in Linux (registered trademark). However, unlike CPU and memory, it is difficult for existing HW-based performance analysis tools to directly obtain performance and status data that can be used as metrics for disks. On an OS basis, CPU usage, memory utilization, disk read / write size, etc. can be obtained using profiling tools such as the sar command and the dstat command.

[0007] In the technology described in Non-Patent Document 1, a power consumption model using OS-based machine learning (RNN: Recurrent Neural Network) is proposed, and a model is constructed and evaluated for applications that place a heavy load on the CPU, memory, and disk. In addition, the technology described in Non-Patent Document 2 proposes a hybrid type model construction in which a process that concentrates the load on the CPU and memory is modeled using HW-based data, and a process that concentrates the load on the disk is modeled using OS-based data. Note that Non-Patent Document 2 uses regression analysis as the modeling algorithm. [Prior art documents] [Non-patent literature]

[0008] [Non-Patent Document 1] Lin, Weiwei, et al. “An artificial neural network approach to power consumption model construction for servers in cloud data centers.” IEEE Transactions on Sustainable Computing (2019). [Non-Patent Document 2] Yang, Shu, et al. “Performance events based full system estimation on application power consumption.” 2016 IEEE 18th International Conference on High Performance Computing and Communications; IEEE 14th International Conference on Smart City; IEEE 2nd International Conference on Data Science and Systems (HPCC / SmartCity / DSS). IEEE, 2016. [Non-Patent Document 3] Mobius, Christoph, et al. “Power consumption estimation models for processors, virtual machines, and servers.” IEEE Transactions on Parallel and Distributed Systems 25.6 (2013): 1600-1614. [Non-Patent Document 4] Colmant, Maxime, et al. “Process-level power estimation in vm-based systems.” Proceedings of the Tenth European Conference on Computer Systems. 2015. [Non-Patent Document 5] Kansal, Aman, et al. “Virtual machine power metering and provisioning.” Proceedings of the 1st ACM symposium on Cloud computing. 2010. Summary of the Invention [Problem to be solved by the invention]

[0009] However, models using OS-based data have accuracy issues, including: The types and definitions of data that can be acquired by measurement tools provided by an OS vary depending on the type and version of the OS. In addition, the assumption that there is a correlation between resource usage (e.g., CPU usage rate) and power consumption at the system level may lack accuracy (see Non-Patent Document 3), and the technology described in Non-Patent Document 4 employs performance and status data from the processor, which is a lower-level and more accurate information source.

[0010] Non-Patent Document 5 examines the relationship between CPU utilization measured when a load is applied to a VM (Virtual Machine) and server power consumption, and shows that the variance of power consumption relative to CPU utilization is very large. For this reason, there is a risk that the accuracy of estimations made using models built on resource utilization information expressed as a "ratio" such as CPU utilization in a service platform using virtualization technology may deteriorate.

[0011] According to Non-Patent Document 5, the relationship between CPU utilization and power consumption is given by a linear model when a uniform load is applied to the server, and linearity is not maintained for multiple different loads. Here, multiple different loads refer to, for example, loads in a state where multiple VMs are installed on one server. In this case, different applications may be running in each VM, resulting in uneven loads across the entire server.

[0012] On the other hand, in hybrid-based model construction, it is necessary to use different data acquisition tools depending on whether they are HW-based or OS-based when creating a dataset (or monitoring performance or status).This switching of data acquisition tools or using multiple tools simultaneously can cause overhead, which is expected to cause degradation of application services.

[0013] The present invention has been made in consideration of these points, and an objective of the present invention is to improve the accuracy of an estimation model in estimating power consumption of a server while reducing the overhead associated with changing data acquisition tools. [Means for solving the problem]

[0014] The learning model generation device according to the present invention is a learning model generation device that generates a learning model for estimating the power consumption of a measurement target server, and includes a data collection unit that collects the performance information and the power consumption for each time the load is applied, a data collection unit that compiles a set of the performance information and the power consumption for each time the load is applied, and ... a data set creation unit that creates a learning data set as a dataset and divides the created dataset at a predetermined ratio to generate a learning data set and a test data set; a learning unit that uses the learning data set to generate a learning model based on a predetermined machine learning algorithm in which the power consumption of the measurement target server is a target variable and the performance information is an explanatory variable; and an evaluation unit that uses the test data set to input the performance information into the generated learning model to output power consumption, and evaluates accuracy of the learning model by comparing the output power consumption with power consumption corresponding to the performance information shown in the test data set. The data collection unit sets, in the load application instruction information, a first pattern consisting of a combination of a predetermined variation in the number of threads and a predetermined variation in the size of write data related to disk I / O (Input / Output) processing as a load. It is characterized by: Effect of the Invention

[0015] According to the present invention, in estimating power consumption of a server, it is possible to reduce overhead associated with changing a data acquisition tool and improve the accuracy of an estimation model. [Brief description of the drawings]

[0016] [Figure 1] 1 is a diagram showing the overall configuration of a server power consumption estimation system including a learning model generation device according to an embodiment of the present invention. [Diagram 2] 4 is a flowchart showing a flow of processing of the learning model estimation device according to the present embodiment. [Diagram 3]This figure shows the evaluation results of a learning model when the range of data sizes expected to be processed by an application is not determined (App requirement "A"). [Figure 4A] This figure shows the evaluation results of a learning model when the range of data sizes expected to be processed by an application is not determined (App requirement "A"). [Figure 4B] This figure shows the evaluation results of a learning model when the range of data sizes expected to be processed by an application is fixed (App requirement "B"). [Diagram 5] This figure compares the error, which is the evaluation result, between a learning model generated using the dataset of App requirement "A" and a learning model generated using the dataset of App requirement "B". [Figure 6] A hardware configuration diagram showing an example of a computer that realizes the functions of the learning model generation device according to this embodiment. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0017] Next, an embodiment of the present invention (hereinafter, referred to as the present embodiment) will be described. First, an outline of the present invention will be described.

[0018] The learning model generating device according to the present embodiment is a device that generates a learning model for estimating the power consumption of a server. This learning model generating device generates a learning model by machine learning based on performance and status data provided by the HW subsystem. As a result, in addition to estimating the power consumption of a server in a process in which the load is concentrated on the CPU or memory, which has been used conventionally, it is possible to estimate the power consumption of a server in a process in which the load is concentrated on the disk, which was difficult to do with conventional technology, based on the performance and status data obtained from the HW as input data.

[0019] In other words, compared to abstract data such as the resource usage status of the entire system (OS-based), generating a learning model based on the performance and status data provided by the HW subsystem enables more accurate estimation of power consumption. Also, in addition to processes that place a heavy load on the CPU and memory, it can be applied to processes that place a heavy load on the disk, and since there is no need to change the data acquisition tool to estimate the power consumption of the server, it is possible to build a model that reduces the overhead of collecting and monitoring data. Furthermore, the present learning model generation device can improve the accuracy of the learning model by creating learning data that takes into account the data size of the processing data, particularly for processes that place a heavy load on the disk (details will be provided below). It should be noted that the disk in this embodiment refers to, for example, a data storage medium such as a hard disk drive (HDD), or a storage area on HW that serves as a resource for a virtual machine. The learning model generating device and the like of the present invention will be specifically described below.

[0020] FIG. 1 is a diagram showing the overall configuration of a server power consumption estimation system 1000 including a learning model generating device 1 according to this embodiment. 1, the learning model generating device 1 is communicatively connected to a measurement target server 200 equipped with power consumption measuring means such as an IPMI 3 and a power meter 4. A load is applied to the measurement target server 200 by implementing a VM 20, a container (not shown), or an application (App) 30, etc., and the learning model generating device 1 acquires HW-based performance and status data at that time via a HW subsystem (not shown) equipped in the measurement target server 200.

[0021] 1 shows three examples of the implementation of load application and power consumption measurement means in the measurement target server 200. The learning model generation device 1 is connected to the measurement target server 200 configured in any one of the following three examples, for example, and generates a learning model for estimating power consumption.

[0022] The measurement target server 200A includes an IPMI 3 as a power consumption measuring means. Also, in Fig. 1, an example is shown in which a load is applied to the measurement target server 200A by a VM 20. Note that a load may be applied to the measurement target server 200A by a container (not shown) instead of the VM 20 (same below). The measurement target server 200B includes a power meter 4 as a power consumption measuring means. Also, Fig. 1 shows an example in which a load is applied to the measurement target server 200B by a plurality (two) of VMs 20 (or containers). The measurement target server 200C includes, as a power consumption measuring means, the IPMI 3. Also, in Fig. 1, an example is shown in which a load is applied to the measurement target server 200C by installing an application (App) 30.

[0023] The implementation of the load application and the power consumption measurement means in the measurement target server 200 in this embodiment are not limited to these three examples, and may be anything that can apply a load to the measurement target server 200 and measure the power consumption at that time. Furthermore, the measurement target server 200 may be a compute that is currently in operation, or may be a server of the same type and with the same specifications as a server that is currently in operation or will be in operation in the future.

[0024] Learning model generation device Next, the learning model generating device 1 and the like according to this embodiment will be described. The learning model generation device 1 acquires HW-based performance and status data (hereinafter, sometimes referred to as "performance information") and power consumption values ​​as input data from the measurement target server 200 to which a load is applied, and creates a data set. The learning model generation device 1 then divides the created data set into a learning data set 101 and a test data set 102, and generates a learning model using the learning data set 101 by a predetermined machine learning method (machine learning algorithm). The learning model generation device 1 also uses the test data set 102 to evaluate the accuracy of the generated learning model. The learning model generation device 1 then evaluates each learning model trained by a plurality of machine learning algorithms, and adopts the learning model with the smallest error from the actual power consumption, thereby improving the accuracy of the learning model that estimates the power consumption of the server. The learning model generated by the learning model generating device 1 is a power consumption estimation model that outputs (estimates) power consumption when performance information of the measurement target server 200 is input. As shown in FIG. 1, the learning model generation device 1 includes a control unit 10, an input / output unit 11, and a storage unit 12.

[0025] The input / output unit 11 inputs and outputs information between it and other devices, etc. For example, the input / output unit 11 transmits and receives information between the measurement target server 200, the power meter 4, etc. This input / output unit 11 is composed of a communication interface that transmits and receives information via a communication line, and an input / output interface that inputs and outputs information between it and an input device such as a keyboard (not shown) and an output device such as a monitor.

[0026] The storage unit 12 is configured with a hard disk, a flash memory, a RAM (Random Access Memory), or the like. A data set 100 including performance and status data (performance information) collected by a data collection unit 110 (described later) and values ​​of power consumption at the time of collection is created by a data set creation unit 120 and stored in the storage unit 12. Details of this data set 100 will be described later. The storage unit 12 further temporarily stores a program for executing each functional unit of the control unit 10 (a learning model generation program) and information required for the processing of the control unit 10.

[0027] The control unit 10 is responsible for all of the processes executed by the learning model generating device 1, and includes a data collection unit 110, a data set creation unit 120, a learning unit 130, and an evaluation unit 140.

[0028] The data collection unit 110 applies a load to the measurement target server 200 by transmitting load application instruction information (e.g., a stress command) for applying a load to the VM 20 of the measurement target server 200. Note that it is assumed here that the load is applied to the measurement target server 200 by a process (or application) that places a concentrated load on the disk.

[0029] At this time, the data collection unit 110 transmits load application instruction information to the measurement target server 200, instructing it to apply I / O (Input / Output) processing, which places a load on the disk, as a load application instruction information with variations in the number of threads and write data size.

[0030] Specifically, the data collecting unit 110 issues an instruction to apply a load using data that combines the following settings, for example. Number of threads: 1, 2, 3, 4, 5 (5 ways) Write data size: 32KB, 256KB, 512KB, 32MB, 256MB, 512MB, 1GB, 3GB, 5GB, 7GB (10 options) The data collection unit 110 issues an instruction to apply a load with 50 combinations of the above settings. As a result, the data collection unit 110 acquires various performance information each time a load is applied under the above conditions (e.g., 50 patterns), and acquires the power consumption at that time from the measurement target server 200.

[0031] Furthermore, the data collection unit 110 may set a load in accordance with the data size of processing data set as a requirement of the application, and collect data. For example, the following data collection policy is adopted as an application requirement (App requirement).

[0032] (App requirement “A”) If the range of data sizes expected to be processed by an application is not fixed, collect data under load patterns that vary in data size (for example, sizes ranging from a few kilobytes to a few gigabytes, such as the 10 patterns mentioned above). In this case, the data collection unit 110 sets a load pattern (first pattern) consisting of a combination of variations in a predetermined number of threads (e.g., 5 variations) and variations in a predetermined write data size (e.g., 10 variations) as load application instruction information.

[0033] (App requirement “B”) When the range of data sizes of data to be processed in an application is fixed, two types of data sets 100 are prepared. -Similar to (App requirement "A"), load with varying data size - Load limited to the data size appropriate for the purpose In other words, in addition to data similar to App requirement "A," if the data size of the data expected to be processed by the application is set to a range of 32KB to 512KB, multiple examples of write data sizes within the data size appropriate for the application (32KB to 512KB) (for example, three examples: 32KB, 256KB, and 512KB) will be added and data will be collected. In this case, the data collection unit 110 sets the load of a pattern (second pattern) consisting of a combination of variations in a predetermined number of threads (e.g., five variations) and variations in write data size that fall within the data size range (e.g., three variations) as load application instruction information in addition to the load of the first pattern.

[0034] Furthermore, the data collection unit 110 transmits load application instruction information for applying a load to the VMs 20 and containers of the measurement target server 200 as described above, and causes the load to be applied, and also transmits a performance information acquisition request (e.g., a perf command) and a power consumption acquisition request to the measurement target server 200. The data collection unit 110 applies load to the measurement target server 200 for a predetermined time (e.g., 500 seconds), for example, to collect each piece of performance information and the power consumption value of the measurement target server 200 corresponding to the time of data acquisition. That is, under the above conditions (for example, 50 patterns of App requirement "A"), the data collector 110 acquires from the measurement target server 200 various pieces of performance information and the power consumption at that time each time a load is applied.

[0035] The data set creating unit 120 creates a set of each piece of performance information and power consumption collected by the data collecting unit 110 as a data set for each application of a load. The data set creation unit 120 may perform preprocessing for creating a data set, such as reducing the number of types of input data and normalizing the data, using a feature selection method or the like, as necessary. Furthermore, the dataset creation unit 120 divides the created dataset at a predetermined ratio (for example, a ratio of 8:2) to generate a training dataset 101 and a test dataset 102. The dataset creation unit 120 stores the training dataset 101 and the test dataset 102 as the dataset 100 in the storage unit 12. The learning dataset 101 is used to generate (learn) a learning model, and the test dataset 102 is used to evaluate (verify) the generated learning model.

[0036] The learning unit 130 uses the learning dataset 101 created by the dataset creation unit 120 to generate a learning model based on a predetermined machine learning method in which the power consumption of the measurement target server 200 is used as the objective variable and the performance / status data (performance information) is used as the explanatory variable. As machine learning methods (machine learning algorithms), one or more of multiple regression analysis, random forest, SVR (Support Vector Regression), neural networks, etc. are used.

[0037] The evaluation unit 140 evaluates the learning model generated by the learning unit 130, using the test dataset 102 created by the dataset creation unit 120. Specifically, the evaluation unit 140 inputs each piece of performance information in the test dataset 102 into the learning model generated by the learning unit 130, thereby outputting a value (estimated value) of power consumption of the measurement target server 200. Then, the evaluation unit 140 calculates an error by comparing with the data of actual power consumption (true value) indicated in the test dataset 102, and evaluates the accuracy of the generated learning model.

[0038] Furthermore, the evaluation unit 140 compares the error between the correct answer data and each of the learning models generated by two or more different types of machine learning methods (e.g., neural networks other than random forest) for the same dataset 100 (the learning dataset 101 and the test dataset 102).The evaluation unit 140 then selects the machine learning method with the smallest error (highest accuracy) and determines the learning model generated by that method as the learning model to be finally adopted.

[0039] <Processing of learning model generation device> Next, the process executed by the learning model generating device 1 will be described. FIG. 2 is a flowchart showing the flow of processing performed by the learning model generating device 1 according to this embodiment.

[0040] First, the data collection unit 110 of the learning model generating device 1 transmits load application instruction information (for example, a stress command) for applying a load to the VM 20 of the measurement target server 200 (step S1). This load application instruction information includes instructions so that the number of variations in the number of threads (e.g., 1 to 5) and the write data size set according to the application requirements become the variations defined in App requirement "A" or App requirement "B".

[0041] Next, the data collecting unit 110 transmits a performance information acquisition request and a power consumption acquisition request to the measurement target server 200 to acquire data on each piece of performance information and power consumption data (step S2). In the performance information acquisition request, for example, in the case of Linux (registered trademark), a request is made to acquire performance and status data (about 100 types) that can be acquired by a performance analysis tool perf via the subsystem of the measurement target server 200. In addition, in the power consumption acquisition request, an instruction is given to start measuring power consumption according to the power consumption measuring means provided in the measurement target server 200 and to transmit the measured data to the learning model generating device 1. In the case where the power consumption measuring means is IPMI3, the power consumption measured by a power sensor provided in the measurement target server 200 is transmitted to the learning model generating device 1 via IPMI3. In the case where the power consumption measuring means is a power meter 4, the data collecting unit 110 may transmit a power consumption acquisition request to the power meter 4 to acquire power consumption data.

[0042] Next, the data set creating unit 120 creates a set of each piece of performance information and power consumption collected by the data collecting unit 110 as a data set for each time a load is applied (step S3). At this time, the data set creation unit 120 may perform preprocessing for creating the data set, such as reducing the number of types of input data and normalizing the data, using a feature selection method or the like, as necessary. Next, the data set creation unit 120 divides the created data set at a predetermined ratio to generate a learning data set 101 and a test data set 102 (step S4).

[0043] Then, the learning unit 130 uses the learning dataset 101 created by the dataset creation unit 120 to generate a learning model based on a predetermined machine learning method (machine learning algorithm) in which the power consumption of the measurement target server 200 is used as the objective variable and the performance / status data (performance information) is used as the explanatory variable (step S5). The learning unit 130 may use the same learning dataset 101 to generate multiple learning models with multiple machine learning algorithms.

[0044] Next, the evaluation unit 140 evaluates the learning model generated by the learning unit 130 using the test dataset 102 created by the dataset creation unit 120 (step S6). Specifically, the evaluation unit 140 inputs each piece of performance information in the test dataset 102 into the learning model generated by the learning unit 130, thereby outputting a value (estimated value) of power consumption of the measurement target server 200. Then, the evaluation unit 140 calculates an error by comparing with the data of actual power consumption indicated in the test dataset 102, and evaluates the accuracy of the generated learning model.

[0045] Furthermore, the evaluation unit 140 compares the error between the learning models generated by different machine learning methods (machine learning algorithms) and the correct answer data for the same data set 100 (the learning data set 101 and the test data set 102).The evaluation unit 140 then selects the machine learning algorithm with the smallest error (highest accuracy) and determines the learning model generated by that machine learning algorithm as the learning model to be finally adopted (step S7).

[0046] In this way, the learning model generation device 1 for estimating the power consumption of a server according to this embodiment generates a learning model based on performance and status data (performance information) provided by the HW subsystem, compared to abstract data such as the resource usage status (OS-based) of the entire system, thereby enabling estimation of power consumption with improved accuracy. Furthermore, the learning model generation device 1 can be applied to processes that concentrate loads on the disk in addition to processes that concentrate loads on the CPU and memory, and does not require changes to the data acquisition tool for server power consumption estimation, making it possible to build a model that reduces overhead during data collection and monitoring. Furthermore, the learning model generation device 1 can improve the accuracy of the learning model by creating learning data that takes into account the data size of the processing data, particularly for processing that places a heavy load on the disk.

[0047] An example of a server power consumption estimation system 1000 including the learning model generating device 1 according to this embodiment will be described below. The server used as the measurement target server 200 is a "Dell R720" ("Dell": registered trademark), Dell 8 cores, 2 sockets (16 cores), CPU 2.9GHz, memory 16G, HDD 1.6TB.

[0048] <Example 1> Example 1 is an example of modeling to estimate power consumption during execution of an application that causes frequent disk writes and places a heavy load on the disk, where the application requirements do not specify the range of data sizes expected to be processed by the application (App requirement "A").

[0049] As a measurement environment, a measurement target server 200 running a container is connected to the learning model generation device 1. The learning model generation device 1 applies loads with variations in the number of threads and write size to the measurement target server 200 for 500 seconds as I / O processing that concentrates the load on the disk (i.e., switches the pattern of the number of threads and the write size every 500 seconds). The learning model generation device 1 also collects performance information and power consumption of the measurement target server 200 every second. The learning model generation device 1 divides the set of the learning dataset 101 and the test dataset 102 at a ratio of 9:1.

[0050] [Load application information]...Disk I / O load measured by the stress command. [Number of threads and write data size patterns] Measure the load with a total of 50 combinations of the settings below. Number of threads: 1, 2, 3, 4, 5 (5 ways) Write data size: 32KB, 256KB, 512KB, 32MB, 256MB, 512MB, 1GB, 3GB, 5GB, 7GB (10 options) [Power consumption measurement tool]···IPMI [Performance and status data measurement tool] Linux perf command

[0051] The perf command can obtain nearly 100 types of performance information, such as L1-dcache-load, branch-instructions, uncore_imc_0 / cas_count_write / , and LLC-loads. If necessary, the types of input data may be reduced using a feature selection method or the like. For example, if a feature importance analysis is performed separately in server construction with concentrated disk load, the importance of performance information related to memory processing, such as node (value related to NUMA (Non-Uniform Memory Access) node), uncore (part other than the CPU core), LLC (Last Level Cache), and TLB (Translation Look-aside Buffer), becomes high. Therefore, by reducing performance information (features) with low importance in model construction, it is possible to reduce the processing load of the learning model generation device 1 without reducing accuracy.

[0052] FIG. 3 shows the evaluation results of a learning model generated by the learning model generation device 1 using random forest as a machine learning method, comparing estimated values ​​(solid lines in the graph) calculated using performance information of the test dataset 102 with actual measured values ​​(dashed lines in the graph) indicated by the power consumption values ​​of the test dataset 102. Figure 3 shows that the estimated values ​​calculated using the learning model are able to track the power consumption that varies with each load.

[0053] <Example 2> Example 2 is an example of a case where the application requirements define a range of data sizes of data processed by the application (App requirements "B") in modeling for estimating power consumption during execution of an application that frequently writes data to the disk and places a heavy load on the disk. Here, the data sizes of data processed by the application are defined as 32KB to 512KB. The other measurement environments are the same as those in Example 1. In <Example 2>, in addition to the data used in <Example 1>, data under the following load patterns are obtained.

[0054] [Number of threads and write data size patterns] In addition to the 50 patterns in <Example 1>, measurements are performed with the following 15 combinations of settings. Number of threads: 1, 2, 3, 4, 5 (5 ways) Write data size: 32KB, 256KB, 512KB (3 types)

[0055] FIG. 4 is a diagram showing a comparison between an estimated value (solid line in the graph) calculated using performance information of a test data set 102 and an actual measured value (dashed line in the graph) indicated by the power consumption value of the test data set 102 in a learning model generated by the learning model generating device 1 using random forest as a machine learning method. FIG. 4A shows an evaluation result of a learning model in <Example 1> when the range of data size of processing data assumed in an application is not determined (App requirement "A"). FIG. 4B shows an evaluation result of a learning model in <Example 2> when the range of data size of processing data assumed in an application is determined (App requirement "B"). FIG. 5 shows an error evaluation of the learning model in Example 1 and that in Example 2.

[0056] Both Fig. 4A and Fig. 4B show that the estimated value calculated using the learning model can track the power consumption that varies for each load. However, looking at the error evaluation shown in Fig. 5, the error value of the learning model of <Example 2> is small in both MAE (Mean Absolute Error) and RMSE (Root Mean Squared Error). Therefore, in this case, the evaluation unit 140 of the learning model generation device 1 selects the learning model generated by <Example 2>, which has higher accuracy.

[0057] Depending on the adopted machine learning method (machine learning algorithm), the conditions of the measurement target server 200, and the load pattern settings, the learning model of <Example 1> may be more accurate than the learning model of <Example 2>. Therefore, the learning model generation device 1 selects the most accurate learning model from among those with changed machine learning algorithms, data sets 100, and parameters.

[0058] <Hardware configuration> The learning model generating device 1 according to this embodiment is realized by a computer 900 having a configuration as shown in FIG. 6 is a hardware configuration diagram showing an example of a computer 900 that realizes the functions of the learning model generation device 1 according to this embodiment. The computer 900 has a CPU (Central Processing Unit) 901, a ROM (Read Only Memory) 902, a RAM 903, an HDD (Hard Disk Drive) 904, an input / output I / F (Interface) 905, a communication I / F 906, and a media I / F 907.

[0059] The CPU 901 operates based on a program (learning model generation program) stored in the ROM 902 or the HDD 904, and performs control by the control unit 10 (FIG. 1). The ROM 902 stores a boot program executed by the CPU 901 when the computer 900 is started, programs related to the hardware of the computer 900, and the like.

[0060] The CPU 901 controls an input device 910 such as a mouse or a keyboard, and an output device 911 such as a display or a printer, via an input / output I / F 905. The CPU 901 acquires data from the input device 910 via the input / output I / F 905, and outputs generated data to the output device 911. Note that a GPU (Graphics Processing Unit) or the like may be used as a processor together with the CPU 901.

[0061] The HDD 904 stores programs executed by the CPU 901 and data used by the programs, etc. The communication I / F 906 receives data from other devices via a communication network (e.g., NW (Network) 920) and outputs the data to the CPU 901, and also transmits data generated by the CPU 901 to other devices via the communication network.

[0062] The media I / F 907 reads a program (learning model generation program) or data stored in the recording medium 912, and outputs it to the CPU 901 via the RAM 903. The CPU 901 loads a program related to a target process from the recording medium 912 onto the RAM 903 via the media I / F 907, and executes the loaded program. The recording medium 912 is an optical recording medium such as a DVD (Digital Versatile Disc) or a PD (Phase change rewritable Disc), a magneto-optical recording medium such as an MO (Magneto Optical disk), a magnetic recording medium, a semiconductor memory, or the like.

[0063] For example, when the computer 900 functions as the learning model generation device 1 of the present invention, the CPU 901 of the computer 900 executes a program loaded onto the RAM 903 to realize the functions of the learning model generation device 1 (the data collection unit 110, the data set creation unit 120, the learning unit 130, and the evaluation unit 140). The data in the RAM 903 is also stored in the HDD 904. The CPU 901 reads and executes a program related to a target process from the recording medium 912. In addition, the CPU 901 may read a program related to a target process from another device via a communication network (NW 920).

[0064] <Effects> The effects of the learning model generating device and the like according to the present invention will be described below. The learning model generation device according to the present invention is a learning model generation device 1 that generates a learning model for estimating the power consumption of a measurement target server 200, and transmits load application instruction information instructing the measurement target server 200 to apply a load, and transmits a performance information acquisition request requesting the acquisition of performance information obtainable from a HW (hardware) subsystem equipped in the measurement target server 200, and a power consumption acquisition request requesting the acquisition of the power consumption of the measurement target server 200 by a power consumption measurement means equipped in the measurement target server 200. In this way, a data collection unit 110 collects performance information and power consumption for each load application, and creates a set of performance information and power consumption for each load application as a data set. and a data set creation unit 120 that creates a learning data set 101 and a test data set 102 by dividing the created data set at a predetermined ratio; a learning unit 130 that uses the learning data set 101 to create a learning model based on a predetermined machine learning algorithm that uses the power consumption of the measurement target server 200 as a target variable and the performance information as an explanatory variable; and an evaluation unit 140 that uses the test data set 102 to input performance information into the generated learning model to output power consumption, and evaluates the accuracy of the learning model by comparing the output power consumption with the power consumption corresponding to the performance information shown in the test data set 102.

[0065] In this way, the learning model generation device 1 enables more accurate estimation of power consumption by generating a learning model based on performance information provided by the HW subsystem of the measurement target server 200. Furthermore, the learning model generation device 1 can be applied to processes that intensively load the disk in addition to processes that intensively load the CPU and memory, and does not require changes to the data acquisition tool for server power consumption estimation, making it possible to build a model that reduces overhead during data collection and monitoring.

[0066] In addition, in the learning model generating device 1, the data collection unit 110 is characterized in that it sets, as a load in the load application instruction information, a first pattern consisting of a combination of variations in a predetermined number of threads and variations in a predetermined write data size related to disk I / O (Input / Output) processing.

[0067] In this way, when the range of data sizes of the processing data expected in the application installed in the measurement target server 200 is not fixed, the learning model generating device 1 can apply a load while considering the variation in the number of threads and the data sizes of the processing data, and create the data set 100. This can improve the accuracy of the learning model.

[0068] Furthermore, in the learning model generating device 1, when the range of data sizes of processing data expected in the application installed in the measurement target server 200 is fixed, the data collection unit 110 sets a second pattern load consisting of a combination of variations in a predetermined number of threads and variations in write data sizes that fall within the range of data sizes, in addition to the first pattern load.

[0069] In this way, when the range of data sizes of processing data expected in the application installed in the measurement target server 200 is fixed, the learning model generating device 1 can apply load by adding variations in write data sizes that fall within the range of data sizes, and create the data set 100. This can improve the accuracy of the learning model.

[0070] Furthermore, in the learning model generating device 1, the evaluation unit 140 is characterized in that it compares the accuracy of a learning model generated using the dataset 100 created by applying a load of the first pattern to the server to be measured 200 with the accuracy of a learning model generated using the dataset 100 created by applying loads of the first pattern and the second pattern to the server to be measured 200, and selects the learning model with the higher accuracy.

[0071] This allows the learning model generating device 1 to select a more accurate learning model, taking into consideration the data size of the processing data in the application installed in the measurement target server 200.

[0072] Furthermore, in the learning model generation device 1, the learning unit 130 uses the learning dataset 101 to generate multiple learning models by two or more different types of predetermined machine learning algorithms, and the evaluation unit 140 compares the accuracy of the multiple generated learning models and selects the learning model with the higher accuracy.

[0073] This allows the learning model generation device 1 to select a more accurate learning model from among the learning models generated by a plurality of machine learning algorithms.

[0074] The present invention is not limited to the above-described embodiment, and many modifications can be made by those having ordinary skill in the art within the technical scope of the present invention. For example, in the learning model generation device 1 according to the present embodiment, the evaluation unit 140 calculates the error between the actual power consumption data and each of the learning models generated by different machine learning methods (machine learning algorithms), and selects the learning model with the smallest error. In contrast, the evaluation unit 140 may include a display unit that displays the error of each of the learning models generated by different machine learning methods (machine learning algorithms) on a display device, and may display the error, which is the evaluation result of each learning model, on the display device, and may accept input of selection information for the learning device to be adopted. In this way, the administrator of the learning model generation device 1 or the like can determine the learning model to be finally adopted based on the evaluation result of each learning model. [Explanation of symbols]

[0075] 1. Learning model generation device 3. IPMI 4 Power Meter 10 Control section 11 Input / output section 12 Storage section 20 VM 30 App 100 Datasets 101 Training Dataset 102 Test Dataset 110 Data Collection Unit 120 Data Set Creation Department 130 Learning Department 140 Evaluation Department 200 Measurement target servers 1000 Server Power Consumption Estimation System

Claims

1. A learning model generation device that generates a learning model for estimating power consumption of a measurement target server, comprising: a data collection unit that collects the performance information and the power consumption each time the load is applied by transmitting load application instruction information to the measurement target server, a performance information acquisition request that requests the acquisition of performance information obtainable from a HW (hardware) subsystem of the measurement target server, and a power consumption acquisition request that requests the acquisition of power consumption of the measurement target server by a power consumption measuring means of the measurement target server; a dataset creation unit that creates a dataset of the performance information and the power consumption for each load application, and divides the created dataset at a predetermined ratio to generate a learning dataset and a test dataset; a learning unit that uses the learning dataset to generate a learning model based on a predetermined machine learning algorithm that uses the power consumption of the measurement target server as a response variable and the performance information as an explanatory variable; an evaluation unit that uses the test data set to generate the learning model, inputs the performance information to the learning model, outputs power consumption, and evaluates accuracy of the learning model by comparing the output power consumption with power consumption corresponding to the performance information shown in the test data set; Equipped with The data collection unit sets, in the load application instruction information, a first pattern consisting of a combination of a predetermined variation in the number of threads and a predetermined variation in the size of write data related to disk I / O (Input / Output) processing as a load. A learning model generation device comprising:

2. When the range of data sizes expected to be processed by the application installed on the measurement target server is determined, The data collection unit sets a second pattern of load, which is a combination of a variation of the predetermined number of threads and a variation of a write data size that falls within the range of the data size, in addition to the first pattern of load. The learning model generating device according to claim 1 .

3. The evaluation unit compares accuracy of a learning model generated using a data set created by applying a load of the first pattern to the server to be measured with accuracy of a learning model generated using a data set created by applying a load of the first pattern and a load of the second pattern to the server to be measured, and selects the learning model having higher accuracy. The learning model generating device according to claim 2 .

4. The learning unit generates a plurality of learning models using the learning dataset by two or more different types of the predetermined machine learning algorithms, The evaluation unit compares the accuracy of the multiple generated learning models and selects a learning model with higher accuracy.

3. The learning model generating device according to claim 1 or 2,

5. A learning model generation method for a learning model generation device that generates a learning model for estimating power consumption of a measurement target server, comprising: The learning model generation device includes: a step of collecting the performance information and the power consumption each time the load is applied by transmitting load application instruction information to the measurement target server, the performance information acquisition request requesting acquisition of performance information obtainable from a HW subsystem of the measurement target server, and a power consumption acquisition request requesting acquisition of the power consumption of the measurement target server by a power consumption measuring means of the measurement target server; creating a data set of the performance information and the power consumption for each load application, and dividing the created data set at a predetermined ratio to generate a learning data set and a test data set; generating a learning model based on a predetermined machine learning algorithm using the learning dataset, the power consumption of the measurement target server being a response variable and the performance information being an explanatory variable; a step of outputting power consumption by inputting the performance information into the generated learning model using the test data set, and evaluating accuracy of the learning model by comparing the output power consumption with the power consumption corresponding to the performance information shown in the test data set; Run In the step of collecting the performance information and the power consumption for each time the load is applied, A first pattern consisting of a combination of variations in a predetermined number of threads and variations in a predetermined write data size related to disk I / O (Input / Output) processing is set as a load in the load application instruction information. A learning model generation method characterized by:

6. A learning model generating program for causing a computer to function as the learning model generating device according to any one of claims 1 to 4.

Images