A CPU-GPU time-energy consumption prediction and scheduling method based on operator features

Abstract

This application discloses a CPU-GPU time and energy consumption prediction method and scheduling method based on operator features. The prediction method includes: acquiring operator-level information of the training task and constructing a corresponding operator feature vector for each operator instance; establishing an operator time prediction model and an energy consumption prediction model for CPU and GPU to learn the mapping relationship from the operator feature vector to execution time and energy consumption; when the operator output tensor is moved between CPU and GPU, obtaining the corresponding transmission overhead through copy nodes; constructing each operator instance in the task segment as a node in a directed acyclic graph and constructing dependency edges; calculating the start time and completion time of the nodes through the time prediction model and scheduling simulation; predicting the overall time of the task segment based on the start time and completion time of the nodes, and predicting the overall energy consumption of the task segment based on the energy consumption prediction model. This application can quickly and accurately predict the execution time and energy consumption of the critical path on CPU and GPU based on operator characteristics and their input tensor information when the task arrives.

Description

Technical Field

[0001] This application belongs to the field of electronic digital data processing technology, and in particular relates to a CPU-GPU time energy consumption prediction method and scheduling method based on operator characteristics. Background Technology

[0002] With the large-scale training and deployment of deep learning models (especially for tasks such as computer vision and natural language processing), important pathways for realizing artificial intelligence applications have been provided. During the model training phase, forward propagation, loss calculation, backpropagation, and parameter updates generate a large number of operator / kernel executions. To effectively shorten the iteration cycle and meet the massive computational demands, the industry commonly uses GPUs or multi-GPU architectures to accelerate training. However, in complex and variable scenarios such as edge computing, hybrid heterogeneous servers, and energy-sensitive environments, relying solely on GPUs can lead to problems such as excessive energy consumption, resource congestion, increased costs, and uncontrollable scheduling. On the other hand, although executing some operators on a CPU may have advantages in terms of energy consumption, cost, or resource availability, cross-device heterogeneity introduces data transfer between devices, synchronization blocking, and a sharp increase in scheduling complexity. These negative factors often offset the advantages of heterogeneity and can even severely impact the overall time and energy consumption performance of the training critical path.

[0003] Existing solutions typically include: (1) unifying deep learning training on GPUs based on experience or static rules to take advantage of GPUs’ advantages in parallel computing; (2) obtaining operator time statistics through the Profiler tool for post-analysis and performance optimization; (3) establishing time prediction models for individual operators (e.g., estimation or regression based on FLOPs / bandwidth), but often ignoring CPU and GPU parallelism, synchronization points, multi-thread / multi-stream execution and inter-device copy overhead, resulting in limited overall task-level prediction accuracy; (4) energy consumption modeling mainly uses GPU power counting or overall power as the main means, which is difficult to refine to the critical path “task segment” level and support online scheduling decisions.

[0004] However, the existing methods mentioned above have at least the following drawbacks: (1) There is a lack of task segment-level time and energy consumption prediction models that predict online when the task arrives, making it difficult to adaptively model changes in different input tensor shapes, data types, memory layouts, etc., thus limiting the accuracy and applicability of the prediction results in the actual operating environment; (2) There is a lack of a unified and interpretable combinatorial modeling method for the parallel execution relationship between CPU and GPU, synchronous blocking mechanism, and data copy nodes between devices, resulting in a large error when deriving the overall execution time and energy consumption of the task level from the operator-level prediction results; (3) There is a lack of a scheduling abstraction mechanism consistent with the prediction model (e.g., a modeling method based on dependent directed acyclic graphs (DAG) and resource constraints), making it difficult to transform the task execution process into an optimizable, solvable, and practically deployable scheduling decision problem. Summary of the Invention

[0005] The purpose of this application is to overcome the shortcomings of the prior art and provide a CPU-GPU time and energy consumption prediction method and scheduling method based on operator characteristics. On the one hand, based on the operator input tensor and dependency constraints, it realizes interpretable and accurate prediction of the overall time and energy consumption from a single operator to the task segment level. On the other hand, based on the above prediction results, it constructs a heterogeneous scheduling model and outputs the optimal decision to ensure that the system energy consumption is minimized under the conditions of satisfying task time and cross-device transmission constraints.

[0006] The objective of this application is achieved through the following technical solution: A CPU-GPU time and energy consumption prediction method based on operator features, the method being applied before or during the execution of a deep learning model training task, the method comprising: Obtain operator-level information for the training task and construct a corresponding operator feature vector for each operator instance; Establish operator time prediction models and energy consumption prediction models for CPU and GPU; When the operator output tensor is moved between the CPU and GPU, the corresponding transfer overhead is obtained through copying nodes; Each operator instance within the task segment is constructed as a node in a directed acyclic graph, and dependency edges are constructed. The start time and completion time of the node are calculated through the time prediction model and scheduling simulation. The total time of the task segment is predicted based on the start and completion times of the nodes, and the total energy consumption of the task segment is predicted based on the energy consumption prediction model.

[0007] Furthermore, constructing the corresponding operator feature vector for each operator instance specifically includes: Get the collection of operator instances, and get the operator type identifier of each operator instance and the dependencies between operators; Obtain the structural information of the input and output tensors corresponding to the operator instance; Obtain the data type and memory layout attributes of the tensors involved in the operator instance; Based on the operator type and the aforementioned structural information, the computational cost and memory access cost of the operator instance are derived. The operator instance is labeled during the execution semantic phase of the training process, and it is identified whether the operator involves data copying operations between the host and the device or between devices.

[0008] Furthermore, the training data for the time prediction model and the energy consumption prediction model are obtained by independently executing and measuring the single operator on a CPU or GPU.

[0009] Furthermore, the method for constructing the dependency edges includes: If the output tensor generated by the operator of the first node is consumed as the input tensor by the corresponding operator of the second node, then add a directed edge from the first node to the second node. For nodes executed sequentially on the same CPU thread or the same GPU stream, add directed edges in that order. When a synchronization point node exists, determine the set of GPU nodes that have been committed and completed before the synchronization point and are required to wait for the synchronization point, and add directed edges from the GPU nodes to the synchronization point node.

[0010] Furthermore, the calculation of the start and finish times of the nodes, based on the time prediction model and scheduling simulation, includes: The nodes in the directed acyclic graph are assigned device mappings, and the predicted execution time of the nodes on the device is obtained by the operator time prediction model. Based on dependency constraints and resource availability, the start time of the simulation computing node is added to the predicted execution duration to obtain the completion time using event-driven scheduling.

[0011] Furthermore, the method also includes: Based on the real measurement data of pre-selected representative task segments, a task segment-level baseline compensation term is fitted. A predetermined number of representative task segments are selected on the target hardware platform, and their real time and real energy consumption are measured to correct the overall time and overall energy consumption of the task segments.

[0012] On the other hand, this application also provides a CPU-GPU heterogeneous scheduling method based on operator features, wherein the method is implemented using any of the aforementioned time-energy consumption prediction methods, and the method includes: A weighted objective function is constructed using the predicted values ​​of the total time and total energy consumption of the task segment; Under the constraints of directed acyclic graph, resource parallelism, and cross-device transmission, a list scheduling method based on execution constraints is used to solve the weighted objective function, and nodes are assigned to devices and resource lines that minimize the weighted objective function. When adjacent dependent nodes are mapped to different devices, a copy node is inserted on the corresponding dependent edge and incorporated into time and energy consumption prediction and scheduling, and this process is repeated until all nodes are allocated.

[0013] The beneficial effects of this application are as follows: (1) By extracting features based on the tensor structure information of the operator input, the system is able to predict the time and energy consumption of the critical path task segment online, and realize the dynamic adaptation to different batch, resolution and dtype.

[0014] (2) Based on the simulation characteristics of DAG and resource timeline, an analysis mechanism for explicit modeling of CPU / GPU parallel execution and synchronization blocking points was designed, which significantly reduced the cumulative prediction error when deriving from simple addition at the operator level to the task level.

[0015] (3) By introducing a refined error calibration mechanism at the task level, the system is guided to effectively converge systematic deviations under the condition of relying only on a small amount of real observation data, thus ensuring the controllability and quantifiability of prediction errors.

[0016] (4) Construct a heterogeneous scheduling optimization objective and constraint abstract system that is highly consistent with the underlying prediction model. On the basis of taking into account both the feasibility of engineering implementation and the rigor of theoretical research, the system minimizes the weighted sum of time and energy consumption by outputting the optimal scheduling decision. Attached Figure Description

[0017] Figure 1 This is a schematic diagram of the architecture of a CPU-GPU time-energy consumption prediction and heterogeneous scheduling system based on operator features; Figure 2 This is a flowchart of a CPU-GPU time energy consumption prediction method based on operator features; Figure 3 This is a schematic diagram of task parsing and operator feature vector construction; Figure 4 It is a schematic diagram constructed based on a directed acyclic graph; Figure 5 This is a simulation diagram of the resource timeline; Figure 6 This is a flowchart of the scheduling optimization process. Detailed Implementation

[0018] The following specific examples illustrate the implementation of this application. Those skilled in the art can easily understand other advantages and effects of this application from the content disclosed in this specification. This application can also be implemented or applied through other different specific embodiments, and various details in this specification can also be modified or changed based on different viewpoints and applications without departing from the spirit of this application. It should be noted that, unless otherwise specified, the following embodiments and features in the embodiments can be combined with each other.

[0019] Based on the embodiments in this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0020] This embodiment proposes a CPU / GPU time and energy consumption prediction and heterogeneous scheduling scheme for deep learning training critical path operators, aiming to solve: (1) how to make interpretable and generalizable predictions of the time and energy consumption of a single operator on the CPU and GPU based on the operator input tensor information; (2) how to combine operator-level predictions into task segment-level overall time and overall energy consumption predictions under the consideration of dependency constraints, parallel execution and synchronous blocking; (3) how to construct a heterogeneous scheduling model based on the above prediction results and output scheduling decisions so as to minimize energy consumption under the condition that time and cross-device transmission meet the constraints.

[0021] Reference Figure 1 The figure shows a schematic diagram of the architecture of the CPU-GPU time and energy consumption prediction and heterogeneous scheduling system based on operator features proposed in this embodiment. The system includes A) a task parsing and operator extraction module; B) an operator feature construction module; C) a CPU operator time prediction model and energy consumption prediction model; D) a GPU operator time prediction model and energy consumption prediction model; E) a cross-device transmission time and energy consumption model; F) a task segment-level combined prediction module (relying on DAG + resource timeline simulation); G) a task segment-level calibration module; and H) a heterogeneous scheduling decision module.

[0022] Based on the above system, this implementation proposes a CPU-GPU time energy consumption prediction method based on operator features, referring to... Figure 2 ,like Figure 2 The diagram shows a flowchart of a CPU-GPU time energy consumption prediction method based on operator features. The specific steps of this method are as follows: Step S1: Obtain operator-level information for the training task and construct the corresponding operator feature vector for each operator instance.

[0023] Specifically, this embodiment implements this step through a task parsing and operator extraction module. In one implementation, the module is deployed in a PyTorch-based training execution environment and obtains operator-level information of the training task through a runtime performance tracking mechanism or a computation graph capture mechanism. The runtime performance tracking mechanism includes, but is not limited to, torch.profiler, and the computation graph capture mechanism includes, but is not limited to, FX intermediate representation, computation graph generated by torch.compile, or derived graph.

[0024] Reference Figure 3 ,like Figure 3 The diagram illustrates the task parsing and operator feature vector construction. For each operator instance, the task parsing and operator feature construction module performs at least the following steps: ① Operator analysis steps: The set of operator instances is parsed from the training process, and the operator type identifier of each operator instance and the dependencies between operators are obtained. The operator type identifier includes, but is not limited to, convolution operator, matrix multiplication operator, normalization operator and element-wise operator.

[0025] ② Tensor structure analysis steps: Obtain the structural information of the input and output tensors corresponding to the operator instance. The structural information includes at least the tensor shape, batch size, number of channels, spatial resolution, or sequence length.

[0026] ③ Steps for parsing data types and memory layout: Get the data type and memory layout attributes of the tensors involved in the operator instance. The data type includes, but is not limited to, fp32, fp16, bf16 or int8, and the memory layout attributes include contiguous storage or specific channel arrangement.

[0027] ④ Performance characteristic derivation steps: Based on the operator type and tensor structure information, the computational cost and memory access cost of the operator instance are derived, where the computational cost is represented by FLOPs and the memory access cost is represented by the number of bytes read and written. Furthermore, the arithmetic strength index is calculated.

[0028] ⑤ Perform semantic annotation steps: The execution semantic phase of the operator instance during the training process is labeled. The execution semantic phase includes at least the forward computation phase, the backward computation phase, and the parameter update phase. It also identifies whether the operator involves data copying operations between the host and the device or between devices.

[0029] Through the above steps, the training task parsing and operator feature construction module constructs a corresponding operator feature vector for each operator instance. The operator feature vector serves as the input for subsequent performance prediction, operator scheduling, and execution optimization modules.

[0030] Step S2: Establish operator time prediction models and energy consumption prediction models for CPU and GPU.

[0031] Specifically, this embodiment establishes operator time prediction models and energy consumption prediction models for CPU and GPU respectively, which are used to learn from operator feature vectors. This relates to the mapping between execution time and energy consumption. In one implementation, a machine learning regression model is used to construct a prediction function, including but not limited to multilayer perceptron (MLP), gradient boosting tree (GBDT), or combinations thereof, to obtain the CPU time model. CPU power consumption model and GPU time model GPU energy consumption model .

[0032] Data is obtained by independently executing and measuring individual operators on a CPU or GPU: operator time is acquired by a high-precision timer or event timing mechanism; operator energy consumption is determined by the energy count difference or power integral value obtained from the processor-side energy counting interface or power sampling interface, where the interface includes, but is not limited to, CPU-side energy counting interfaces (such as RAPL) and GPU-side energy / power interfaces (such as NVML). To improve model generalization, input features can be normalized or logarithmically transformed, and platform-identifying features or platform correction factors can be introduced for different hardware platforms to achieve cross-platform or cross-configuration prediction adaptation.

[0033] Step S3: When the operator output tensor is moved between the CPU and GPU, the corresponding transmission overhead is obtained through the copy node.

[0034] Specifically, when a scheduling decision causes the operator output tensor to be moved between the CPU and GPU, a copy node v is inserted on the dependency edge. copy To characterize transmission overhead. In one embodiment, the copy node's time is estimated from the amount of data transmitted and the effective bandwidth, or predicted by a regression model; the copy node's energy consumption can be estimated from the transmission time and the average power on the device side, or fitted by measured energy counts. The copy node at least distinguishes between H2D, D2H, and D2D types, and considers blocking / non-blocking attributes and their impact on synchronization points.

[0035] Step S4: Construct each operator instance within the task segment into a node in a directed acyclic graph and construct dependency edges. Calculate the start and finish times of the nodes using a time prediction model and scheduling simulation.

[0036] Specifically, to address the issue that CPU and GPU operators may run in parallel, and that CPU and GPU internal processes may also run in parallel, this embodiment proposes a combined prediction method based on "DAG-dependent + resource timeline simulation" to combine operator-level predictions into task-segment-level overall time and overall energy consumption predictions. The steps are as follows: (1) Construction based on DAG: Reference Figure 4 ,like Figure 4 The diagram illustrates the construction of a directed acyclic graph (DAG). Each operator instance within a task segment (along with optional copy and synchronization events) is constructed as a node in the DAG. And construct dependency edges according to the following rules: a) Data dependency edge construction: if node The output tensor generated by the corresponding operator is controlled by the node. If the corresponding operator is consumed as the input tensor, then a directed edge is added. b) Sequential edge construction: For nodes executed in the same CPU thread or GPU stream in the order of submission / appearance, add directed edges sequentially to represent the sequential execution constraint; c) Synchronous edge construction: When there are synchronization nodes... At that time, determine the set of GPU nodes that were committed before the synchronization point and whose completion is necessary for the synchronization point to wait for, and send data from the GPU nodes to the synchronization point. Add directed edges to represent the blocking relationships caused by synchronous waiting, thereby characterizing the execution constraints of CPU waiting for GPU to complete or GPU waiting for CPU to complete.

[0037] (2) Resource model and timeline simulation: Reference Figure 5 ,like Figure 5 The image shown is a simulation diagram of the resource timeline.

[0038] Introducing a resource set: CPU resources are represented as m parallel execution lines. GPU resources are represented as k stream execution lines. In a simplified embodiment, k=1.

[0039] For each node in the task segment's dependency DAG Assign device mapping The prediction model then calculates the predicted execution time for that node on the device. Based on dependency constraints and resource availability, event-driven scheduling is used to simulate the start time of computation nodes. Completion Time The calculation rules are as follows: ; in, Represents a node The set of predecessor nodes, This indicates the earliest idle time of the resource line corresponding to the device mapped by the node. If there is cross-device data migration between nodes, a copy node is inserted on the corresponding dependency edge. It is then incorporated as a regular node into the aforementioned scheduling and simulation calculation process.

[0040] Step S5: Predict the total time of the task segment based on the start and finish times of the nodes, and predict the total energy consumption of the task segment based on the energy consumption prediction model.

[0041] Specifically, the overall time prediction module for the task segment is as follows: ; in, This represents the maximum predicted completion time for each node within the task segment, where... This includes compensation for runtime overhead that is not explicitly modeled, including but not limited to additional overhead caused by factors such as kernel / operator launch overhead, runtime scheduling overhead, caching effects, and frequency modulation. This was obtained by performing real measurements and fitting on a small number of representative task segments.

[0042] The overall energy consumption prediction for the mission segment is as follows: ; in, This is a baseline energy consumption correction term used to compensate for background energy consumption that is not explicitly modeled. Obtained by fitting real measured energy consumption data.

[0043] To reduce the systematic bias generated when combining operator-level predictions to mission-segment-level predictions, this embodiment provides a mission-segment-level calibration method. In one embodiment, a constant calibration method is used: based on real measurement data from a pre-selected small number of representative mission segments, a mission-segment-level baseline compensation term is fitted. and ,in and A constant calibration method can be used to determine this: select a predetermined number of representative task segments on the target hardware platform and measure their actual time. Compared to actual energy consumption And respectively: ; ; Thus, the calibrated and .

[0044] As one implementation method, based on the aforementioned time-energy consumption prediction method, this embodiment also proposes a goal-oriented heterogeneous scheduling decision-making method. This method uses the predicted T̂(d) and Ê(d) as objective functions to construct and solve the heterogeneous scheduling problem, minimizing the weighted sum of time and energy consumption. (Refer to...) Figure 6 ,like Figure 6 The diagram shown is a flowchart of the scheduling optimization process. This scheduling method specifically includes: Based on the predictive model and the combined model, this embodiment defines scheduling decision variables. Used to characterize nodes The execution device, and construct a weighted optimization objective: ; in, Used to characterize the trade-off between time and energy consumption, Ê(d) represents the predicted total energy consumption of the task segment under scheduling scheme d, and T̂(d) represents the predicted total execution time of the task segment (the critical path DAG) under scheduling scheme. The optimization satisfies the following constraints: dependency DAG constraint (a node can only start execution after all its predecessor nodes have been completed), resource parallelism constraint (at most one node can be executed at the same CPU execution line or the same GPU stream), and cross-device transfer constraint (when adjacent dependent nodes are mapped to different devices, a copy node is inserted on the corresponding dependency edge and included in the time and energy consumption prediction).

[0045] In one embodiment, a list-based scheduling method based on execution constraints is used to solve the optimization problem: Following the node topology order, and satisfying dependency DAG constraints, resource parallelism constraints, and cross-device transmission constraints, a list of executable nodes is maintained. The currently scheduled executable node is selected, and its candidate allocations on CPU / GPU and their corresponding available resource lines are compared. The node is then assigned to the device and resource line that minimizes the weighted objective function. Furthermore, when adjacent dependent nodes are mapped to different devices, a copy node is inserted on the corresponding dependency edge, incorporating time and energy consumption prediction and scheduling. This process is repeated until all nodes are allocated. The output includes the execution device and execution order of each node / operator, as well as the copy and synchronization insertion strategies introduced by cross-device mapping. In alternative embodiments, local search, dynamic programming, integer programming approximation, or learning-based strategies can also be used to improve the scheduling results.

[0046] This embodiment proposes a CPU / GPU time and energy consumption prediction and heterogeneous scheduling method for operators in the critical path of deep learning training (including forward propagation, loss calculation, back propagation, and parameter update). Addressing issues such as lack of generalization in single-operator prediction, neglect of parallelism and synchronous blocking in combined models, and disconnected scheduling decisions in heterogeneous computing of the critical path of deep learning training (including forward propagation, loss calculation, back propagation, and parameter update), this method proposes an operator-oriented CPU / GPU time and energy consumption prediction and heterogeneous scheduling method. On the one hand, based on operator input tensors and dependency constraints, it achieves interpretable and accurate prediction of overall time and energy consumption from single operators to task segments. On the other hand, based on the above prediction results, it constructs a heterogeneous scheduling model and outputs the optimal decision, ensuring that system energy consumption is minimized while satisfying task time and cross-device transmission constraints.

[0047] The above description is merely a preferred embodiment of this application and is not intended to limit this application. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of this application should be included within the protection scope of this application.

Claims

1. A CPU-GPU time energy consumption prediction method based on operator features, characterized in that, The method is applied before or during the execution of a deep learning model training task, and the method includes: Obtain operator-level information for the training task and construct a corresponding operator feature vector for each operator instance; Establish operator time prediction models and energy consumption prediction models for CPU and GPU; When the operator output tensor is moved between the CPU and GPU, the corresponding transfer overhead is obtained through copying nodes; Each operator instance within the task segment is constructed as a node in a directed acyclic graph, and dependency edges are constructed. The start time and completion time of the node are calculated through the time prediction model and scheduling simulation. The total time of the task segment is predicted based on the start and completion times of the nodes, and the total energy consumption of the task segment is predicted based on the energy consumption prediction model.

2. The CPU-GPU time energy consumption prediction method based on operator features as described in claim 1, characterized in that, The specific steps of constructing a corresponding operator feature vector for each operator instance include: Get the collection of operator instances, and get the operator type identifier of each operator instance and the dependencies between operators; Obtain the structural information of the input and output tensors corresponding to the operator instance; Obtain the data type and memory layout attributes of the tensors involved in the operator instance; Based on the operator type and the aforementioned structural information, the computational cost and memory access cost of the operator instance are derived. The operator instance is labeled during the execution semantic phase of the training process, and it is identified whether the operator involves data copying operations between the host and the device or between devices.

3. The CPU-GPU time energy consumption prediction method based on operator features as described in claim 1, characterized in that, The training data for the time prediction model and the energy consumption prediction model are obtained by independently executing and measuring single operators on a CPU or GPU.

4. The CPU-GPU time energy consumption prediction method based on operator features as described in claim 1, characterized in that, The methods for constructing the dependency edges include: If the output tensor generated by the operator of the first node is consumed as the input tensor by the corresponding operator of the second node, then add a directed edge from the first node to the second node. For nodes executed sequentially on the same CPU thread or the same GPU stream, add directed edges in that order. When a synchronization point node exists, determine the set of GPU nodes that have been committed and completed before the synchronization point and are required to wait for the synchronization point, and add directed edges from the GPU nodes to the synchronization point node.

5. The CPU-GPU time energy consumption prediction method based on operator features as described in claim 1, characterized in that, The start and finish times of the computation nodes, determined through the time prediction model and scheduling simulation, include: The nodes in the directed acyclic graph are assigned device mappings, and the predicted execution time of the nodes on the device is obtained by the operator time prediction model. Based on dependency constraints and resource availability, an event-driven scheduling simulation is used to calculate the start time of the computing nodes. The start time is added to the predicted execution time to obtain the completion time.

6. The CPU-GPU time energy consumption prediction method based on operator features as described in claim 1, characterized in that, The method further includes: Based on the real measurement data of pre-selected representative task segments, a task segment-level baseline compensation term is fitted. A predetermined number of representative task segments are selected on the target hardware platform, and their real time and real energy consumption are measured to correct the overall time and overall energy consumption of the task segments.

7. A CPU-GPU heterogeneous scheduling method based on operator features, characterized in that, The method is implemented based on any one of the time-based energy consumption prediction methods according to claims 1-6, and the method includes: A weighted objective function is constructed using the predicted values ​​of the total time and total energy consumption of the task segment; Under the constraints of directed acyclic graph, resource parallelism, and cross-device transmission, a list scheduling method based on execution constraints is used to solve the weighted objective function, and nodes are assigned to devices and resource lines that minimize the weighted objective function. When adjacent dependent nodes are mapped to different devices, a copy node is inserted on the corresponding dependent edge and incorporated into time and energy consumption prediction and scheduling, and this process is repeated until all nodes are allocated.

Images