Seasonal enhanced federated learning for storage management

Abstract

The invention relates to seasonal enhanced federated learning for storage management. In some examples, a method includes obtaining request metadata corresponding to a request received at a storage device to generate a local training data set; performing training of a local ML model at the storage device to predict future data access and to classify data to be stored in a storage type accessible to the storage device; updating the shared local ML model; obtaining a global ML model incorporating the local ML model update and ML model updates from other storage devices; performing additional training using the global ML model until the global ML model converges into a trained global ML model; executing the trained global ML model at the storage device to determine a storage type for storing a data unit and predict a future data request; and storing data units in one or more of the storage types based on an output of the trained global ML model.

Description

Background Technology

[0001] Data is typically stored in various types of storage media. These storage media are operatively connected to storage devices, which provide other computing devices with access to the data stored on them. Storage media can have different characteristics, such as data access speed and cost. Therefore, storing data in different types of storage media can lead to different results, costs, etc. Attached Figure Description

[0002] Certain examples discussed herein will be described with reference to the accompanying drawings listed below. However, the drawings are merely illustrative of certain aspects or embodiments of the examples described herein and are not intended to limit the scope of the claims. Various aspects of this disclosure are best understood from the following detailed description when read in conjunction with the accompanying drawings. For a more complete understanding of this disclosure and its advantages, reference will now be made to the following description, in conjunction with the accompanying drawings, in which:

[0003] Figure 1 This is a block diagram of an example data storage environment based on one or more examples disclosed herein.

[0004] Figure 2 This is a block diagram of the example request metadata data structure based on one or more examples disclosed herein.

[0005] Figure 3 The illustration provides an overview of example methods for performing federated learning to train machine learning (ML) models for data storage, based on one or more examples disclosed herein.

[0006] Figure 4 The illustration provides an overview of example methods for data storage using a trained federated learning ML model, based on one or more examples disclosed herein.

[0007] Figure 5 A block diagram of a computing device according to one or more examples disclosed herein is shown.

[0008] The diagrams are drawn to illustrate various aspects disclosed herein, and these diagrams are not necessarily drawn to scale.

[0009] manual

[0010] The following disclosure provides many different examples for implementing various features. Specific examples of components and arrangements are described below to simplify this disclosure. Of course, these are merely examples and are not intended to be limiting.

[0011] Storage architectures can exist in which any number of host computing devices make data-related requests (e.g., reads, updates, etc.) to any number of storage devices. Each storage device may correspond to or be otherwise configured to access storage back-end components. Storage back-end components can be of various types, each with different characteristics. As an example, a set of storage components accessible to host computing devices via any number of storage devices may include a first type of storage component that is relatively fast (e.g., capable of providing data access with less latency) but more expensive (e.g., flash storage devices), a second type of storage component that is relatively slow but cheaper (e.g., some kind of hard disk drive storage device), and a third type of storage component whose speed and cost each fall between those associated with the first and second storage types.

[0012] In this storage architecture, it is often useful to store data in different types of storage components in some way to achieve one or more objectives. These objectives may include, but are not limited to, reducing or minimizing the overall latency of data requests, reducing or minimizing the cost of storing data in various storage types, reducing carbon emissions caused by storing data in various storage types and accessing data from them, meeting service level objectives, and / or any other objectives related to data storage and access to such data.

[0013] To effectively achieve this goal, the examples disclosed herein use machine learning (ML) models to predict (e.g., access to data blocks, data objects, data files, etc.) future data accesses and use the predicted accesses and other information to perform reasoning or classification indicating where the data should be stored to best satisfy any set of objectives related to a given scenario. Such ML models can be, for example, transformer models, recurrent neural networks, etc.

[0014] In one or more examples, ML can be implemented as federated learning, where training data is collected locally at each of a set of storage devices, a local ML model is trained using the local data, and updates to the local ML models (not the actual local data) are shared and aggregated to generate a global ML model, which can be shared with (or generated by) the storage devices participating in the federated learning. The global ML model can then be used to perform predictions and classifications to predict when data might be accessed, determine where data should be stored (e.g., in what type of storage device), and / or help determine whether or when data should be moved between storage types (e.g., prefetching, eviction). In one or more examples, using a federated ML model technique with multiple storage devices participating in the federated learning can improve the resilience of the global ML model because the training and execution (e.g., classification, inference) of the global ML model can still function as expected even if one or more participating storage devices are temporarily or otherwise lost (e.g., offline).

[0015] In one or more examples, each storage device receives requests for data from each of any number of host computing devices that send data-related requests (e.g., read, update, delete, etc.) over time. In one or more examples, these requests are used to obtain metadata about the requests, which may be stored in a suitable data structure (e.g., array, table, etc.). As an example, for each request, the metadata may include the data unit of the request (e.g., block, file, object, etc.), the type of request (e.g., insert, retrieve, update, delete, etc.), information identifying the host computing device from which the request was received, and other relevant information (e.g., timestamp of the request, relationship between the request and other requests, etc.). This metadata can be collected for any configured amount of time (e.g., minutes, hours, days, weeks, etc.) or other metrics (e.g., request volume). In one or more examples, this set of metadata associated with the incoming requests is used at least in part to form a local dataset for training a local ML model.

[0016] Training a local model may involve using request metadata to train a local ML model to predict when a data unit will be accessed in the future. As an example, certain hosts may access certain data at certain times and / or according to certain access patterns (e.g., during certain times of a day on certain days within certain parts of a month). As another example, access to a given data unit may involve access to certain other data units that may occur at the same time as access to a particular data unit. Without departing from the scope of the examples disclosed herein, any other data access patterns exhibited by data access requests from host computing devices or relationships between requested data may be relevant. In one or more examples, request metadata is used at least in part to train a local ML model on each storage device to predict future data requests, determine what type of storage medium the data unit will be stored in the storage backend, and / or when the data unit will be moved (e.g., prefetched, evicted) between different storage types.

[0017] In one or more examples, predictions of future access to data units can be used in conjunction with other considerations to classify the data units as appropriate, thereby storing them in one or more storage types available to the storage device. As examples, predicted future access, monetary costs, carbon emission impacts, performance requirements, etc., can all be factors used to classify where data should be stored and / or whether certain data units should be moved between storage types.

[0018] In one or more examples, once a local ML model is trained on a particular storage device, model updates (e.g., weights, gradients, etc.) can be shared, allowing model updates from locally trained ML models on any number of storage devices configured to participate in federated learning to generate a global ML model. In one or more examples, each storage device shares its model updates with all other storage devices participating in federated learning, and each storage device aggregates the received model updates with its own to generate a global ML model. Alternatively, in one or more examples, individual devices can be configured to receive model updates from storage devices participating in federated learning and aggregate these updates to generate a global ML model, which can then be redistributed to the storage devices participating in federated learning. Other techniques for aggregating model updates to generate a global ML model (e.g., a hierarchy of storage devices sending model updates, which are iteratively updated to higher-level ML models until a final global ML model is generated and redistributed to storage devices) can be used without departing from the scope of the examples disclosed herein.

[0019] In one or more examples, regardless of the technique used to aggregate model updates to generate a global ML model, each storage device eventually obtains a global ML model, which can then be further trained until the global ML model converges (e.g., stops improving and / or reaches an acceptable performance threshold). The above training process can be iterative at both the local and / or global levels, and is therefore performed until each storage device participating in federated learning has a converged global ML model.

[0020] Each storage device in the storage system can then use a trained global ML model to at least partially determine where the data should be stored to best satisfy any set of objectives related to the data storage scenario in which the storage device exists and / or predict when a request for a data item might be received (this could, for example, cause data to move between storage types). In one or more examples, determining in which type of storage device the data unit should be stored can then allow the data to be stored in different types of storage devices at different times. This can include moving data between different storage types via data prefetching and / or evicting data from one storage type to another. As an example, based on time-based data access patterns, monetary cost targets, and carbon emission targets, when data access is unlikely, data can be stored in slower, cheaper, and lower-carbon-emission storage types, and when data access is anticipated, data can be moved to faster, more expensive, and potentially higher-carbon-emission storage types to satisfy data access time requirements.

[0021] The examples disclosed herein can provide techniques for using federated learning to efficiently predict when a data request might be received, to store data across various types of storage devices, and to move data between said storage devices, in order to effectively balance various objectives, such as improving storage performance, reducing costs, reducing carbon emissions, and / or reducing power consumption. For example, this improvement can be achieved by using local training of an ML model on a storage device, performing federated learning to generate a global model via aggregation of the local training results, and having the storage device use the global model to efficiently manage where data is stored to optimize data access based on various objectives.

[0022] Figure 1This is a block diagram of an example data storage environment based on one or more examples disclosed herein. The data storage environment may include any number of computing devices (e.g., computing device A 100, computing device B 102, computing device N 104), any number of storage devices (storage device A 106, storage device N 114), and a storage backend 122. Each storage device may include ML components (e.g., ML components A 108, ML components N 116), request metadata data structures (e.g., request metadata data structures A 110, N 118), and storage maps (e.g., storage map A 112, storage map N 120). The storage backend 122 may include any number of storage types (e.g., storage type A 124, storage type B 126, storage type C 128). Each of these components is described below.

[0023] In one or more examples, the data storage environment includes any number of computing devices (e.g., computing device A100, computing device B102, computing device N104). In one or more examples, as used herein, the computing devices (e.g., computing device A100, computing device B102, computing device N104) can be any single computing device, a group of computing devices, a portion of one or more computing devices, or any other physical, virtual, and / or logical grouping of computing resources. An example of a computing device is... Figure 5 As shown in the diagram and described below, in one or more examples, a computing device as used herein (e.g., computing device A 100, computing device B 102, computing device N 104) can be any type of computing device configured to transmit data-related requests (e.g., read, write, insert, retrieve, update, delete, etc.) to a storage device (e.g., storage device A 106, storage device N 114), which includes and / or is operatively connected to a storage backend (e.g., storage backend 122) that stores data in one or more storage types (e.g., storage type A 124, storage type B 126, storage type C 128). As an example, a computing device seeking to read data (e.g., computing device A 100, computing device B 102, computing device N 104) can send a read data request to a storage device (discussed further below), which can provide the requested data from a data storage location to the computing device receiving the request.

[0024] In one or more examples, a computing device is any device, part of a device, or any collection of devices capable of processing instructions electronically, and may include, but is not limited to, any one of the following: one or more processors (e.g., components including circuitry), memory (e.g., random access memory (RAM)), input and output devices (multiple), non-volatile storage hardware (e.g., solid-state drives (SSDs), persistent memory (Pmem) devices, hard disk drives (HDDs) (not shown)), one or more physical interfaces (e.g., network ports, storage ports), any number of other hardware components (not shown), and / or any combination thereof.

[0025] Examples of computing devices include, but are not limited to, servers (e.g., blade servers in blade server chassis, rack servers in racks, desktop servers, any other type of server equipment), desktop computers, mobile devices (e.g., laptops, smartphones, personal digital assistants, tablets, automotive computing systems, and / or any other mobile computing devices), storage devices (e.g., disk drive arrays, Fibre Channel storage devices, Internet Small Computer System Interface (iSCSI) storage devices, tape storage devices, flash storage arrays, network-attached storage devices, any other type of storage devices), network devices (e.g., switches, routers, multi-tier switches, any other type of network devices), virtual machines, virtualized computing environments, logical containers (e.g., for one or more applications), container groups, Internet of Things (IoT) devices, node arrays of computing resources, supercomputing devices, data centers or any part thereof, and / or any other type of computing device having the foregoing requirements. As will be understood by those skilled in the art, any of the above examples of computing devices necessarily requires at least some hardware components. By way of example, when virtual machines, containers, and / or container pods are considered computing devices herein, they include the underlying hardware on which virtual machines, containers, and / or container groups are executed.

[0026] In one or more examples, the storage devices and / or memory of a computing device or computing device system can be and / or include one or more data repositories for storing any number of data structures (which store any number of data, such as information). In one or more examples, a data repository is any type of storage unit and / or device for storing data (e.g., file system, database, table collection, RAM, hard disk drive, solid-state drive, and / or any other storage mechanism or medium). Furthermore, a data repository can include multiple different storage units and / or devices. These multiple different storage units and / or devices may or may not be of the same type or may or may not be located in the same physical location.

[0027] In one or more examples, any storage device and / or memory of a computing device or computing device system may be considered, in whole or in part, as a non-transitory computer-readable medium storing software and / or firmware that, when executed by one or more processors, causes one or more processors to perform operations according to one or more examples disclosed herein (e.g., execute one or more computer programs).

[0028] In one or more examples, although Figure 1 An example data storage environment including three computing devices (e.g., computing device A 100, computing device B 102, and computing device N 104) is shown, but the data storage environment may include any number of computing devices without departing from the scope of the examples disclosed herein.

[0029] In one or more examples, each computing device in the data storage environment (e.g., computing device A 100, computing device B 102, computing device N 104) can be operatively connected to any number of storage devices (discussed further below) configured to provide the computing devices with access to the stored data. Figure 1 In the example data storage environment shown, each of computing device A 100, computing device B 102, and computing device N 104 is shown as being operatively connected to each of storage devices (e.g., storage device A 106, storage device N 114). However, the examples disclosed herein are not limited to this configuration. Any particular computing device can be operatively connected to any number of storage devices (e.g., all or any part of the storage devices in the data storage environment), and the set of one or more storage devices operatively connected to a particular computing device can vary for different computing devices.

[0030] In one or more examples, the storage device (e.g., storage device A 106, storage device N 114) can be any hardware and / or software, firmware, etc., executed on hardware configured to receive and serve data requests from one or more computing devices (e.g., computing device A 100, computing device B 102, computing device N 104). As an example, the storage device (e.g., storage device A 106, storage device N 114) can be all or any part of the computing device (discussed above and further elaborated below). Figure 5(Discussed in the description). In one or more examples, storage devices (e.g., storage device A 106, storage device N 114) can be operatively connected to any number of computing devices (e.g., computing device A 100, computing device B 102, computing device N 104), wherein each computing device is operatively connected to one or more interfaces of the storage devices (e.g., storage device A 106, storage device N 114). In one or more examples, each storage device (e.g., 108, 114) is configured to receive data requests from one or more operatively connected computing devices and to serve such data requests (e.g., by retrieving and serving data, by updating data, by adding new data, by deleting data, etc.) by accessing one or more data units of storage corresponding to the received data request in the storage backend (e.g., 122).

[0031] although Figure 1 A data storage environment comprising two storage devices (106, 114) is illustrated; however, without departing from the scope of the examples disclosed herein, a data storage environment may include any number of storage devices. Each storage device (e.g., storage device A 106, storage device N 114) may be operatively connected to any number of computing devices (e.g., computing device A 100, computing device B 102, computing device N 104). Each storage device may or may not be operatively connected to the same set of computing devices as other storage devices in the data storage environment (e.g., a first storage device may be operatively connected to a first set of computing devices, a second storage device may be operatively connected to a second set of computing devices, and these two sets of computing devices may or may not completely overlap).

[0032] In one or more examples, each storage device in the data storage environment (e.g., storage device A 106, storage device N 114) is operatively connected to a storage backend (e.g., storage backend 122). In one or more examples, as used herein, a storage backend (e.g., storage backend 122) refers to any collection of devices, components, data repositories, etc., which may be separate from any number of storage devices (e.g., storage device A 106, storage device N 114) and operatively connected to any number of storage devices, and / or wholly or partially included in such storage devices. In one or more examples, storage backend 122 is configured to store data of any type.

[0033] Data can be stored using any technology, solution, etc., used for storing data, such as block storage technology (e.g., using non-volatile fast memory (NVMe)), file storage technology (e.g., using network file storage), object-based storage technology, etc., or combinations of these technologies. Storage backend 122 can implement one or more data storage technologies and protocols (e.g., Fibre Channel, iSCSI, network-attached storage, etc.) either alone or in combination with one or more storage devices (e.g., storage device A 106, storage device N 114). Any other data storage technology, science, protocol, etc., can be used in storage backend 122 without departing from the scope of the examples disclosed herein.

[0034] In one or more examples, storage backend 122 includes any number of different storage types (e.g., storage type A 124, storage type B 126, storage type C 128). In one or more examples, as used herein, a storage type refers to a specific type of storage medium used to store data. Examples of such storage types include, but are not limited to, hard disk drives, solid-state drives, flash memory storage devices, optical storage devices, magnetic tape storage devices, removable storage devices, etc. Other storage types may be used without departing from the scope of the examples disclosed herein. In one or more examples, each storage type (e.g., storage type A 124, storage type B 126, storage type C 128) is configured to store data as data units. In one or more examples, as used herein, a data unit may refer to any discrete data item, such as, for example, a data block, a data file, a data object, etc.

[0035] In one or more examples, different storage types (e.g., storage type A 124, storage type B 126, storage type C 128) may have different characteristics. As an example, some storage types may provide faster or slower access to the data stored therein relative to other storage types. As another example, some storage types may be more expensive or cheaper than others in terms of storing data. As yet another example, some data types may require more or less power than others, which may, for example, result in relatively more or less carbon emissions when used to store data and provide access to that data. Storage types may differ in other characteristics without departing from the scope of the examples disclosed herein.

[0036] In one or more examples, storage types can be viewed as different storage tiers based on one or more different characteristics between them. As an example, a given storage backend (e.g., storage backend 122) can be a fast tier (e.g., storage type A 124), a slower tier (e.g., storage type B 126), and a slowest tier (e.g., storage type C 128), as defined by the data access speed that the storage type in each tier can provide. These tiers can also differ in other characteristics. As an example, a relatively fast tier storage type may be more expensive, while a relatively slow tier may be relatively cheaper.

[0037] Therefore, determining which storage type (and correspondingly, which tier) within a storage backend (e.g., storage backend 122) to store data units can depend on any number of considerations. Such considerations can include, but are not limited to, providing optimal data access time, managing data storage costs, managing the ancillary effects of stored data (e.g., carbon emissions), storage efficiency (e.g., avoiding data fragmentation), meeting defined service level objectives, etc. Given such considerations, in one or more examples, data may be moved from time to time between different storage types to help balance these considerations and / or achieve one or more data storage objectives (e.g., balancing data access time with data storage costs). As an example, data expected to be accessed in the near future may be prefetched from a relatively slow and cheaper storage type to a relatively fast and more expensive data type, and / or data unlikely to be accessed soon may be evicted from a faster, more expensive storage type to a slower, cheaper data type.

[0038] although Figure 1 Storage backend 122 is shown as including three storage types (e.g., storage type A 124, storage type B 126, and storage type C 128), but without departing from the scope of the examples disclosed herein, the storage backend may include any number of storage types. Additionally, although Figure 1 Each storage device in the data storage environment (e.g., storage device A 106, storage device N 114) is shown as operatively connected to the same storage backend 122, which includes three storage types (e.g., storage type A 124, storage type B 126, storage type C 128), but the examples disclosed herein are not limited thereto. Each storage device may be operatively connected to all or any part of the storage type of the storage backend and is therefore configured to provide access to the storage type of the storage backend, and which storage types a storage device is operatively connected to may vary between different storage devices.

[0039] As discussed above, storage devices (e.g., storage device A 106, storage device N 114) can be configured to receive data requests. In one or more examples, a data request is any type of request received at the storage device (e.g., storage device A 106, storage device N 114) from a computing device (e.g., computing device A 100, computing device B 102, computing device N 104) that relates to data stored in one or more storage types (e.g., storage type A 124, storage type B 126, storage type C 128) on a storage backend (e.g., storage backend 122).

[0040] In one or more examples, the data request received at the storage device can be any request for an operation related to one or more data units, including but not limited to reading data, writing data, updating data, deleting data, moving data, etc. In one or more examples, each storage device (e.g., storage device A 106, storage device N 114) is configured to receive such a data request and obtain metadata associated with the data request and store it in a request metadata data structure (e.g., metadata data structure A 110 for storage device A 106, request metadata data structure N 118 for storage device N 114). The data request and request metadata data structure will be described below. Figure 2 Further discussion will follow in the description.

[0041] In one or more examples, each storage device includes a storage map (e.g., storage map 112 for storage device A 106, storage map N 120 for storage device N 114). In one or more examples, the storage maps (e.g., 110, 118) are information maintained by the storage devices (e.g., 106, 114) that tracks what data units are stored in each storage type (e.g., 124, 126, 128) to which the storage devices are operatively connected at a given time. Therefore, the storage maps can be updated when data moves between storage types, data is added to or removed from one or more storage types, etc. In one or more examples, the storage maps (e.g., 110, 118) are used by the storage devices (e.g., 106, 114) to locate data units associated with data requests received from computing devices (e.g., 102, 104, 106).

[0042] In one or more examples, each storage device includes an ML component (e.g., ML component 108 of storage device A 106, ML component N 116 of storage device N 114). In one or more examples, the ML component (e.g., 108, 116) is any hardware and / or software executed on a hardware component and configured to perform various activities, operations, communications, etc., to facilitate the training and execution of ML algorithms. As an example, the ML component (e.g., 108, 116) can be executed using at least a portion of the computing resources of the storage device (e.g., 106, 114).

[0043] In one or more examples, all or any part of a storage device (e.g., 106, 114) in a data center environment can be configured to participate in federated learning. In one or more examples, federated learning is a technique in which a local ML model is trained locally at the device participating in the federated learning, the results of the local training are shared, a global ML model is generated using the shared results, the global ML model is obtained by the device participating in the federated learning, and the trained global ML model is used at the device participating in the federated learning after one or more training cycles. In one or more examples, the storage device (e.g., 106, 114) is configured with ML components (e.g., 108, 116) that perform actions, operations, communications, etc., of the various parts implementing local learning and federated learning.

[0044] In one or more examples, the ML component (e.g., 108, 116) can be configured to use at least a portion of the request metadata from the request metadata data structure (e.g., 110, 118) as at least a portion of the training data to train a local ML model. The ML model can be any form of ML model that, once trained, can perform prediction, classification, inference, etc., by providing input data, and generates results at least in part based on said input data. Examples of such ML models include, but are not limited to, transformer models, recurrent neural networks, etc.

[0045] To perform local training, the ML component (e.g., 108, 106) may be equipped with a local ML model. In one or more examples, the ML component (108, 116) is equipped with a copy of the same ML model, which may be similarly initialized (e.g., using an initial set of weights, gradients, etc.). The ML component (e.g., 108, 116) can then use request data from a request metadata data structure (e.g., 110, 118) as training data to train the local ML model for prediction and classification. In one or more examples, prediction may include training the local ML model to predict when a request for a data unit will be received, and classification may include training the local ML model to classify requests as best served by storing the data in one or more storage types (e.g., faster, less fast, slowest). The ML model may be configured to use any information to make such predictions and classifications, such as timestamps of requests, patterns of request reception (both regarding patterns of requests for specific data units and relationships between requests for various data units), and other factors such as cost, carbon emissions, service level objectives, etc.

[0046] In one or more examples, after one or more epochs (e.g., iterations) of training a local ML model, ML components (e.g., 108, 116) can be configured to transfer ML model updates (e.g., weights, gradients, etc., obtained via the aforementioned training to minimize the loss function of the ML model). These ML model updates can be shared, allowing the aggregation of ML model updates from each of the ML components (e.g., 108, 116) from various storage devices (e.g., 106, 114) participating in the federated learning to update the global ML model. In one or more examples, each storage device (e.g., 106, 114) shares its local ML model update with each other storage device participating in the federated learning, and each storage device then aggregates its own model update with model updates from other storage devices to update the global ML model, such that each storage device obtains a copy of the global ML model. In one or more examples, each storage device (e.g., 106, 114) shares its local ML model updates with a separate aggregation device (not shown, which may be referred to as an ML model aggregation device). This separate aggregation device is configured to aggregate local ML model updates from various storage devices to update the global ML model, and then redistribute it to the storage devices such that each storage device has a copy of the updated global ML model. In one or more examples, a hierarchical scheme is implemented among the storage devices such that partial local ML model updates from storage devices are used to generate intermediate global models, which are then aggregated into a final global ML model, which is then redistributed to the storage devices such that each storage device has a copy of the updated global ML model. In one or more examples, the updated global ML model obtained at each ML component (e.g., 108, 116) may undergo additional training at the storage devices, e.g., until model convergence is achieved (e.g., improvement stops and / or an acceptable performance threshold is reached). In one or more examples, the above aggregation of local ML model training results via model updates can be performed even when one or more of the storage devices involved in federated learning are unavailable, which can provide resilience to the federated ML model.

[0047] In one or more examples, once the ML component (e.g., 108, 116) of each of the storage devices (e.g., 106, 114) participating in federated learning has obtained an updated trained global ML model, the ML component can use the trained global ML model to predict when future requests for data units stored on storage back-ends (e.g., 122) on one or more storage types (e.g., 124, 126, 128) may be received, and / or to classify where the data units should be stored based on when requests related to the data units are expected to be received and any number of other factors (e.g., cost, service level targets, carbon emissions, etc.).

[0048] In one or more examples, based at least in part on such prediction and classification, storage devices (e.g., 106, 114) can execute algorithms for prefetching data units from one storage type to another and / or evicting data units from certain storage types to other storage data types. This prefetching and / or eviction of data units can be determined, for example, based at least in part on a validity function that stores data units in different tiers of storage types, and can take into account the hit rate at each tier (e.g., whether the requested data unit exists in a particular storage type) plus other relevant additional cost factors.

[0049] Although Figure 1 A specific configuration of the component is shown, but other configurations may be used without departing from the scope of the examples described herein. For example, although Figure 1 While some components may be shown as part of the same device, any component can be grouped into a collection of one or more components that can exist and function as part of any number of independent and operationally connected devices. As another example, a single component can be configured to perform actions... Figure 1 All or any part of the components shown perform all or any part of the functions. Therefore, the examples disclosed herein should not be limited to... Figure 1 The component configuration shown.

[0050] Figure 2 This is a block diagram of the example request metadata data structure 200 based on one or more examples disclosed herein. Figure 2 An example of organizing request metadata in tabular form is shown. However, those skilled in the art who benefit from this disclosure will understand that any form of data structure for organizing request metadata can be used without departing from the scope of the examples disclosed herein. Request metadata data structure 200 could be, for example, Figure 1 An example of the request metadata data structure A110 and / or request metadata data structure N118 shown.

[0051] like Figure 2 As shown, the requested metadata data structure 200 includes data stored on a storage device (e.g., Figure 1 The column corresponding to each data request received at storage device A106, storage device N114. In one or more examples, for each received data request, an entry is added to the request metadata data structure 200. In one or more examples, each entry includes metadata related to the data request.

[0052] In one or more examples, the various metadata items corresponding to the received data request include an identifier of the data unit to which the data request belongs, such as... Figure 2 As shown in the examples. Without departing from the scope of the examples disclosed herein, such identification can be any form of information used to identify a unit of data. Examples include, but are not limited to, block identifiers, filenames, object identifiers, etc.

[0053] In one or more examples, the various metadata items corresponding to the received data request include information identifying the request type, such as... Figure 2 As shown in the examples. In one or more examples, a data request can be any of a variety of request types related to data. Examples of possible request types include, but are not limited to, insertion (e.g., adding data), retrieval (e.g., reading data), update (e.g., modifying data), and deletion (e.g., removing data). Other request types may be used without departing from the scope of the examples disclosed herein. In one or more examples, such a request type may be encoded using an encoding technique that uniquely identifies the request type from a set of possible request types. As an example, encoding techniques such as one-hot encoding or a tokenizer may be used to represent each request type as a binary vector (e.g., insertion = [1,0,0,0]; retrieval = [0,1,0,0]; update = [0,0,1,0]; deletion = [0,0,0,1]).

[0054] In one or more examples, the various metadata items corresponding to the received data request include information identifying the source of the data request, such as... Figure 2 As shown in the examples. In one or more examples, the source of the data request is the computing device from which the data request is received. The request source identifier can be any type of information that uniquely identifies the data request source among a set of possible data request sources. Examples of this type of information include, but are not limited to, Internet Protocol (IP) addresses, sequence numbers, Universally Unique Identifiers (UUIDs), etc.

[0055] In one or more examples, various metadata items corresponding to the received data request include the request timestamp, such as... Figure 2As shown in the examples. In one or more examples, a request timestamp is any information item that identifies the time when a data request was received at the storage device. A request timestamp can be any form of information that conveys information about when the data request was received, including but not limited to the time of day, date, the location of the storage device's clock, etc.

[0056] In one or more examples, the various metadata items corresponding to the received data request include other request information, such as... Figure 2 As shown in the examples. In one or more examples, additional request information is any other information related to the received data request. Although Figure 1 A data structure with one entry for each data request is shown, but any number of additional request information items may be included as metadata associated with the data request without departing from the scope of the examples disclosed herein. Additional request information is intended to broadly represent any additional metadata associated with the data request that may be added to the request metadata data structure, and that such information may be available from any source and may not necessarily be related to the timing of receiving the data request. Examples include, but are not limited to, informational relationships between data items (e.g., a request for a particular data unit typically follows a data request for related data units), real-world events driving data requests (e.g., celebrity actions, the occurrence of significant events, product launches, etc.), and any other type of non-time-related information that may drive the receipt of a request associated with a particular data unit.

[0057] In one or more examples, the request metadata data structure 200 stores metadata related to any number of data requests received at a storage device from one or more operatively connected computing devices. This request metadata can be stored permanently or deleted according to any form of timetable (e.g., request metadata older than a certain age can be deleted). In one or more examples, the request metadata can be at least partially stored by ML components (e.g., Figure 1 The ML components A 108 and ML components 116 are used as training data to train a local ML model (e.g., to predict when future data requests will be received) and / or to perform additional training on the global ML model to achieve model convergence. In one or more examples, the request metadata of the request metadata data structure 200 may also be used on a continuous basis as at least a portion of the input to a trained global ML model executed by the ML components of the storage device to predict when future requests for data units will be received and / or to classify such requests into one or more storage types in which the predicted data requests should be stored.

[0058] In one or more examples, the ML component of the storage device may use all or any portion of the data stored in the request metadata data structure 200. As an example, the ML component may implement a configurable context window that restricts the request metadata used to train the ML model to a certain number of requests, or only requests received within a specific time window. In the configurable case, this context window can be adjusted as needed based on, for example, the dataset formed by the request metadata, the performance requirements of the ML model, etc.

[0059] Figure 3 The illustration provides an overview of an example method 300 for performing federated training of an ML model for data storage, based on one or more examples disclosed herein. Method 300 may be at least partially comprised of one or more storage devices (e.g., Figure 1 Storage device A 106, storage device N 114), and any component of such storage device (e.g., Figure 1 ML component A108, ML component N116) and / or any computing device implementing such storage device and / or ML component (e.g., Figure 5 The computing device is used to execute the commands.

[0060] Although Figure 3 The steps in the flowchart shown are presented and described sequentially, but some or all steps may be performed in a different order, some or all steps may be combined or omitted, and some or all steps may be combined with... Figure 3 and / or Figure 4 The other steps are performed in parallel (discussed below).

[0061] In step 302, method 300 includes initializing the ML model. In one or more examples, initializing the ML model includes setting initial values ​​for the parameters of the ML model. ML model initialization can be used in any form without departing from the scope of the examples disclosed herein. As an example, initialization may include setting initial weights or gradient values ​​for the ML model. ML model initialization may be performed before the ML model is provided to a storage device that will train and use the ML model, or each storage device may receive the ML model and perform the initialization.

[0062] In step 304, method 300 includes obtaining data request metadata to generate a training dataset for performing local training of the ML model. In one or more examples, the data request metadata may be obtained, for example, from the ML component of a storage device (e.g., Figure 1 The data request metadata is obtained from ML component A 108 and ML component N 116. In one or more examples, the data request metadata is obtained from the request metadata data structure (e.g., Figure 2 Request metadata data structure 200 Figure 1 Request metadata data structure A110, Figure 1 The requested metadata is obtained from the request metadata data structure N 118. The requested metadata obtained and used as the training dataset can be all or any part of the requested metadata included in the request metadata data structure.

[0063] In step 306, method 300 includes training a local ML model at the storage device participating in the federated learning. In one or more examples, training may be performed, for example, by the ML component of the storage device (e.g., Figure 1 The ML component A 108 and ML component N 116 are executed. In one or more examples, each storage device in the data storage environment is configured to participate in the federated learning system and is equipped with a copy of the ML model as a local ML model. After initializing such a model (as in step 302) and obtaining training data (as in step 304), the training data can be used as input to the local ML model to perform training of the local ML model. Training may include providing the local ML model with data requests for training data, evaluating the model's output (e.g., how well the model predicts future data requests), and tuning model parameters (e.g., weights, gradients, etc.). Training the local ML model can be an iterative process in which any number of training loops or iterations are performed. Training may end after a certain number of iterations, after achieving an accuracy threshold for the local ML model, or after the loss function of the local ML model has been minimized to an acceptable level, etc.

[0064] In step 308, method 300 includes sharing local ML model updates. In one or more examples, sharing may be achieved, for example, by the ML component of a storage device (e.g., Figure 1 The ML components A 108 and N 116 are executed. In one or more examples, each storage device participating in the federated learning uses local training data obtained by the storage device based on received data requests to train a local ML model. In one or more examples, once the local ML model training is complete, the storage devices can share the model parameters of the trained local model as local ML model updates. In one or more examples, sharing local ML model updates includes providing local ML model updates to each other storage device participating in the federated learning, such that each storage device can generate a global ML model. In one or more examples, sharing local ML model updates includes providing local ML model updates to a specific device configured to generate a global ML model.

[0065] In step 310, method 300 includes aggregating local ML model updates to generate a global ML model. Any technique for aggregating ML model parameters may be used without departing from the scope of the examples disclosed herein. As an example, local ML model updates received from various storage devices participating in federated learning can be aggregated by determining the average of the local ML model updates for various parameters of the ML model to generate parameters for the global ML model.

[0066] In step 312, method 300 includes obtaining a global ML model from a storage device participating in federated learning. In one or more examples, the global ML model may be, for example, derived from the ML component of the storage device (e.g., Figure 1 The global ML model is obtained from ML components A 108 and N 116. As discussed above, the global ML model is generated by aggregating (e.g., averaging) local ML model parameters. In some examples, this aggregation is performed at each storage device after receiving local ML model updates from each of the other storage devices, thereby allowing the storage device to obtain the global ML model by acting as the entity performing the aggregation. In other examples, where local ML model updates are shared with a specific device (e.g., a designated storage device within the storage devices, or any other device configured to perform ML model update aggregation), obtaining the global model involves receiving the global ML model from the device performing the aggregation.

[0067] In step 314, method 300 includes performing additional training on the global ML model by a storage device. In one or more examples, the additional training may be performed, for example, by the ML component of the storage device (e.g., Figure 1 The training is performed using ML component A 108 and ML component N116. In one or more examples, additional training is performed again using local request data from the request metadata data structure of the storage device.

[0068] In step 316, method 300 includes determining whether the global ML model has converged. In one or more examples, model convergence may be determined, for example, by the ML component of the storage device (e.g., Figure 1 The ML component A 108 and ML component N 116 are used to determine this. In one or more examples, additional training as in step 314 is performed until model convergence is achieved. In one or more examples, model convergence is achieved when the global model stops improving (e.g., minimization of the loss function stops) and / or when an acceptable threshold for model performance is reached. In one or more examples, if the model has not yet converged, method 300 returns to step 314 for additional training of the global ML model. In one or more examples, if model convergence has been achieved, method 300 proceeds to step 318.

[0069] In step 318, method 300 proceeds to... Figure 4 Method 400, as shown and discussed below.

[0070] Figure 4 The illustration provides an overview of an example method 400 for data storage using a trained federated learning ML model, based on one or more examples disclosed herein. Method 400 may be at least partially comprised of one or more storage devices (e.g., Figure 1 The storage device A 106 and storage device N 114) are executed.

[0071] Although Figure 4 The steps in the flowchart shown are presented and described sequentially, but some or all steps may be performed in a different order, some or all steps may be combined or omitted, and some or all steps may be combined with... Figure 4 and / or Figure 3 The other steps are executed in parallel.

[0072] In step 402, method 400 includes using a trained global ML model (as described above) Figure 3 (As discussed in the description) to categorize requests into storage types. In one or more examples, at this stage, predictions of future data requests are used to categorize which storage type the data unit corresponding to the data request should be placed in. As an example, based at least in part on future predictions, some data units may be categorized as stored in relatively fast storage devices, medium-speed storage devices, or relatively slow storage devices.

[0073] In step 404, method 400 includes using a trained global ML model to predict future data requests. In one or more examples, a trained global model, trained at least in part using data request history and associated information stored in a request metadata data structure on the storage device, begins to predict when a future request for a particular unit of data might be received.

[0074] In step 406, method 400 includes determining whether one or more data units should be moved between storage types based on predictions of future data requests from a trained global ML model. As an example, a validity algorithm may be executed to determine whether a data unit should: remain in whatever storage type the data unit is currently stored in; prefetch from one storage type to another; or be evicted from one storage type to another. In one or more examples, the execution of the validity function determines what data units should be stored in certain storage types. In one or more examples, the validity function is based at least in part on the expected hit rate of data remaining in each storage type, which may be modified, for example, by one or more cost factors (e.g., fees, carbon emissions, etc.). In one or more examples, if the predicted validity of keeping a data unit in a particular storage type is lower than the predicted validity of storing the data unit in another storage type, the data unit may be moved (e.g., prefetched or evicted) between storage types. In one or more examples, the validity of keeping a data unit in a particular storage type may be continuously re-evaluated over time. As an example, as the time it takes for a data unit to be predicted by a trained global ML model as part of a received data request approaches, it may become more efficient to move data from a relatively slow and cheaper storage tier to a faster and more expensive storage tier, which could, for example, increase the response time of a data request when it is received, while reducing data storage costs at other times.

[0075] In one or more examples, although Figure 4Not shown, but at this stage, multiple objectives related to where the data is stored and when it might move between storage types can be considered. In one or more examples, each objective of a set of multiple objectives for data storage (e.g., cost, performance, data fragmentation, carbon emissions, etc.) can be considered as a factor or dimension for determining a Pareto optimal state, which is the state in which the data exists best on one dimension (e.g., energy efficiency) (e.g., the state of storing the data), and no other state is equally efficient and better on the other dimensions being analyzed. In one or more examples, once such a Pareto optimal state has been determined, dynamic analysis can be performed to determine the effect of changing the model to optimize other outcomes as priorities (e.g., those of data storage customers, data storage providers, etc.) change over time. As an example, at different times, response time to data requests may have higher priority than other factors such as cost or environmental impact, or a lower-cost power source (e.g., solar energy) may become available, making it more attractive to store data in a faster but more power-consuming storage type. In one or more examples, once these trade-offs are understood, the parameters of the trained global ML model can be tuned to achieve any scenario most desired by the relevant stakeholders in the data storage environment.

[0076] In step 408, method 400 includes serving a data request. In one or more examples, when a data request is received, data units accessible to a particular storage device are optimally stored in one or more storage types of the data storage environment, based on predictions and classifications of a trained global ML model and any optimizations thereof. In one or more examples, when a request associated with a data unit is received, the storage device can (e.g., using the storage mapping of the storage device) determine which storage type the data unit is currently stored in and can use the data unit to perform any request type included in the data request.

[0077] In one or more examples, although Figure 4 The process of training and using the trained global ML model described above can be repeated over time, though not shown in the diagram. As an example, both the local and global ML models can be retrained periodically because data request patterns and other factors may change over time. As another example, the trained global ML model can be configured to run based on a context window that may change over time (e.g., based on information learned over time about the seasonality of receiving data requests). Because executing the trained global ML model results in predictions of when data requests might be received and the possible movement of data between storage types, different context window sizes (e.g., hourly, daily, etc.) may be suitable for different data storage scenarios.

[0078] Figure 5 A block diagram of a computing device according to one or more examples of this disclosure is illustrated. As discussed above, the examples described herein can be implemented using a computing device, and Figure 5 The computing device 500 shown can be such a computing device. For example, Figure 1 All or any part of the components shown (computing devices 100, 102, 104, storage devices 106, 114) can be implemented using computing device 500 at least in part, and may include Figure 5 All or any part of the components of the computing device 500 shown and described below. Additionally, Figure 3 and / or Figure 4 All or any part of the methods shown can be performed using one or more computing devices (such as computing device 500).

[0079] In one or more examples, a computing device (e.g., computing device 500) is any device, part of a device, or any collection of devices capable of electronically processing instructions, and may include, but is not limited to, any of the following: one or more processors (e.g., components including circuitry) (e.g., processor 502), memory (e.g., random access memory (RAM)) (not shown), (multiple) input and output devices (e.g., non-persistent storage device 506), non-volatile storage hardware (e.g., solid-state drive (SSD), persistent memory (Pmem) device, hard disk drive (HDD) (not shown)), one or more physical interfaces (e.g., network port, storage port) (e.g., persistent storage device 506), any number of other hardware components (not shown), and / or any combination thereof. As used herein, a processor can be any component that can be configured to perform operations, processes, threads, etc. Examples of processors include, but are not limited to, central processing units (CPUs), multi-core CPUs, application-specific integrated circuits (ASICs), accelerators (e.g., graphics processing units (GPUs)), and field-programmable gate arrays (FPGAs). Other examples of processor types may be included in computing device 500 without departing from the scope of the examples disclosed herein. In some examples, the computing device (e.g., computing device 500) may include any number of heterogeneous processors.

[0080] The computing device 500 may include a communication interface 512 (e.g., a Bluetooth interface, an infrared interface, a network interface, an optical interface, or any other type of communication interface), an input device 510, an output device 508, and many other components (not shown) and functions. Each of these components is described below.

[0081] In one or more examples, the computer processor(s) 502 may be an integrated circuit for processing instructions. For example, the computer processor(s) may be one or more cores or microcores of a processor. Processor 502 may be a general-purpose processor configured to execute program code included in software executed on computing device 500. Processor 502 may be a special-purpose processor, in which certain instructions are incorporated into the processor design. Processor 502 may be an application-specific integrated circuit (ASIC), graphics processing unit (GPU), data processing unit (DPU), tensor processing unit (TPU), associative processing unit (APU), vision processing unit (VPU), quantum processing unit (QPU), and / or various other processing units using special-purpose hardware (e.g., field-programmable gate array (FPGA), system-on-a-chip (SoC), digital signal processor (DSP)). Although in Figure 5 Only one processor 502 is shown, but without departing from the scope of the examples disclosed herein, computing device 500 may include any number of processors.

[0082] The computing device 500 may also include one or more input devices 510, such as a touchscreen, keyboard, mouse, microphone, touchpad, electronic pen, motion sensor, or any other type of input device. Input devices 510 allow users to interact with the computing device 500. In one or more examples, the computing device 500 may include one or more output devices 508, such as a screen (e.g., a liquid crystal display (LCD), plasma display, touchscreen, cathode ray tube (CRT) monitor, projector, or other display device), printer, external storage device, or any other output device. One or more output devices may be the same as or different from the input devices(s). The input and output devices(s) may be locally or remotely connected to the computer processor(s) 502, non-persistent storage device(s) 504, and persistent storage device(s) 506. Many different types of computing devices exist, and the aforementioned input and output devices(s) may take other forms. In some instances, a multi-mode system allows users to provide multiple types of input / output to communicate with the computing device 500.

[0083] Furthermore, the communication interface 512 can facilitate connecting the computing device 500 to a network (not shown) (e.g., a local area network (LAN), a wide area network (WAN) such as the Internet, a mobile network, or any other type of network) and / or another device (such as another computing device). The communication interface 512 can use wired and / or wireless transceivers of any type and / or technology to perform or facilitate the reception and / or transmission of wired or wireless communications. Examples include, but are not limited to, utilizing audio jacks / plugs, microphone jacks / plugs, Universal Serial Bus (USB) ports / plugs, etc. Ports / plugs, Ethernet ports / plugs, fiber optic ports / plugs, proprietary wired ports / plugs Wireless signal transmission, BLE wireless signal transmission Wireless signal transmission, including RFID wireless signal transmission, Near Field Communication (NFC) wireless signal transmission, Dedicated Short Range Communication (DSRC) wireless signal transmission, 802.11 WiFi wireless signal transmission, WLAN signal transmission, Visible Light Communication (VLC), Global Microwave Access Interoperability (WiMAX), IR communication wireless signal transmission, Public Switched Telephone Network (PSTN) signal transmission, Integrated Services Digital Network (ISDN) signal transmission, 3G / 4G / 5G / LTE cellular data network wireless signal transmission, ad hoc network signal transmission, radio wave signal transmission, microwave signal transmission, infrared signal transmission, visible light signal transmission, ultraviolet light signal transmission, wireless signal transmission along the electromagnetic spectrum, or combinations thereof. Communication interface 512 may also include one or more Global Navigation Satellite System (GNSS) receivers or transceivers for determining the location of computing device 500 based on one or more signals received from one or more satellites associated with one or more GNSS systems. GNSS systems include, but are not limited to, the US GPS, the Russian GLONASS, the Chinese BeiDou Navigation Satellite System (BDS), and the European Galileo GNSS. There are no limitations on operation on any particular hardware layout, and therefore the basic features here can be easily replaced with improved hardware or firmware layouts as hardware or firmware layouts evolve.

[0084] The term "computer-readable medium" includes, but is not limited to, portable or non-portable storage devices, optical storage devices, and various other media capable of storing, containing, or carrying instructions and / or data. Computer-readable media may include non-transitory media, in which data may be stored and does not include carrier waves and / or transient electronic signals propagated wirelessly or via a wired connection. Examples of non-transitory media include, but are not limited to, magnetic disks or magnetic tapes, optical storage media such as CDs or DVDs, flash memory, memory, or memory devices. Code and / or machine-executable instructions may be stored on a computer-readable medium, which may represent any combination of processes, functions, subroutines, programs, routines, subroutines, modules, software packages, classes, or instructions, data structures, or program statements. A code segment can be coupled to another code segment or hardware circuitry by passing and / or receiving information, data, arguments, parameters, or memory contents. Information, arguments, parameters, data, etc., can be passed, forwarded, or transmitted via any suitable means, including memory sharing, messaging, token passing, network transmission, etc.

[0085] All or any part of the components of computing device 500 may be implemented in a circuit. For example, the components may include and / or may be implemented using electronic circuitry or other electronic hardware, which may include one or more programmable electronic circuits (e.g., microprocessors, GPUs, DSPs, FPGAs, CPUs, CAMs, and / or other suitable electronic circuits), and / or may include and / or be implemented using computer software, firmware, or any combination thereof to perform the various operations described herein. In some aspects, computer-readable storage devices, media, and memories may include wired or wireless signals containing bit streams, etc. However, when referred to, non-transitory computer-readable storage media expressly exclude media such as energy, carrier signals, electromagnetic waves, and the signals themselves.

[0086] In the foregoing description, numerous details have been set forth as examples of what is described herein. Those skilled in the art (and who also benefit from this disclosure) will understand that one or more of the examples described herein can be practiced without these specific details, and that many variations or modifications can be made without departing from the scope of the examples described herein. Certain details known to those skilled in the art may have been omitted to avoid obscuring the description.

[0087] Specific details have been provided in the foregoing description to provide a thorough understanding of the aspects and examples presented herein. However, those skilled in the art will understand that these aspects and examples can be practiced without these specific details. For clarity, in some instances, the technology may be presented as comprising functional blocks that may include devices, device components, steps or routines in a software-embodied method, or a combination of hardware and software. Additional components may be used in addition to those shown in the figures and / or described herein. For example, circuits, systems, networks, processes, and other components may be shown as components in block diagram form to avoid obscuring these aspects with unnecessary detail. In other instances, well-known circuits, processes, algorithms, structures, and techniques may be shown without unnecessary detail to avoid obscuring the aspects of the examples disclosed herein.

[0088] The above can describe individual aspects as processes or methods depicted as flowcharts, flow diagrams, data flow diagrams, structure diagrams, or block diagrams. While flowcharts can describe operations as sequential processes, many operations can be performed in parallel or simultaneously. Furthermore, the order of operations can be rearranged. When the operations of a process are completed, the process can terminate, but may have additional steps not included in the diagram. A process can correspond to a method, function, flow, subroutine, subprogram, etc. When a process corresponds to a function, the termination of the process can correspond to the function returning to the calling function or the main function.

[0089] The processes and methods described in the examples above can be implemented using computer-executable instructions stored in or otherwise obtained from a computer-readable medium. Such instructions may include, for example, instructions and data to cause a general-purpose computer, special-purpose computer, or processing device to perform a specific function or group of functions, or to otherwise configure a general-purpose computer, special-purpose computer, or processing device to perform a specific function or group of functions. Some of the computer resources used may be accessible via a network. The computer-executable instructions may be, for example, binary files, intermediate format instructions (such as assembly language, firmware, source code, etc.). Examples of computer-readable media that may be used to store instructions, information used, and / or information created during the methods according to the examples include disks or optical discs, flash memory, USB devices equipped with non-volatile memory, networked storage devices, etc.

[0090] In the foregoing description of the accompanying drawings, in the various examples described herein, any component described with respect to a drawing may be equivalent to one or more components with the same or similar names and / or numbers described with respect to any other drawing. For the sake of brevity, the description of these components may not be repeated for each drawing. Thus, every example of a component in each drawing is incorporated by reference and is assumed to be optionally present in every other drawing having one or more components with the same or similar names and / or numbers. Furthermore, any description of a component in a drawing, based on the various examples described herein, should be interpreted as an optional example that may be implemented as a supplement, combination, or substitution to the examples described with respect to one or more corresponding components with the same or similar names and / or numbers in any other drawing.

[0091] Throughout the application, ordinal numbers (e.g., first, second, third, etc.) may be used as adjectives for elements (i.e., any noun in the application). The use of ordinal numbers does not imply or create any particular order of elements, nor does it limit any element to being a single element, unless explicitly stated otherwise, such as through the use of the terms “before,” “after,” “single,” and other such terms. Rather, ordinal numbers are used to distinguish elements. For example, the first element is different from the second element, and the first element may contain more than one element and be after (or before) the second element in the element order.

[0092] As used herein, the phrase "operationally connected" or "operationally linked" means that there exists a direct or indirect connection between elements / components / devices that allows the elements to interact with each other in a certain way. For example, the phrase "operationally connected" can refer to any direct connection (e.g., a direct wired connection between two devices or components) or an indirect connection (e.g., a wired and / or wireless connection between any number of devices or components that are operationally connected). Therefore, any path through which information can pass can be considered an operational connection.

[0093] While the examples discussed herein have been described with reference to a limited number of examples, those skilled in the art who benefit from this disclosure will understand that other examples can be devised without departing from the scope of the examples disclosed herein. Accordingly, the scope of the examples described herein should be limited only by the appended claims.

Claims

1. An apparatus comprising: One or more processors; as well as One or more non-transitory computer-readable media storing instructions that, when executed by the one or more processors, cause the one or more processors to: Obtain data request metadata corresponding to multiple data requests received at the storage device to generate a local training dataset; Training a local machine learning (ML) model is performed on the storage device, wherein the training includes ML model training for predicting future data accesses and classifying data to be stored in at least one of a variety of storage types accessible by the storage device. Share local ML model updates based on the training with at least one other device; Obtain a global ML model that incorporates the local ML model update and multiple ML model updates from other storage devices; Additional training is performed using the global ML model until the global ML model converges to the trained global ML model; Execute the trained global ML model at the storage device to determine one or more storage types among the multiple storage types for storing data units and to predict future data requests; and The data units are stored in one or more of the multiple storage types based on the output of the trained global ML model.

2. The apparatus of claim 1, wherein, The data request metadata for each of the plurality of data requests includes the request type and an identifier that identifies the computing device as the source of the data request; And a timestamp indicating the time when the data request was received.

3. The apparatus of claim 1, wherein, The execution of the instructions by the one or more processors further enables the one or more processors to: The local ML model update is shared by sharing the local ML model update with each of a plurality of other storage devices configured to participate in federated learning. The global ML model is obtained by generating the global ML model at the storage device.

4. The apparatus of claim 1, wherein, The execution of the instructions by the one or more processors further enables the one or more processors to: The local ML model update is shared by sharing the local ML model update with an ML model aggregation device configured to generate the global ML model, and The global ML model is obtained by receiving the global ML model from the ML model aggregation device via the storage device.

5. The apparatus of claim 1, wherein, Each data unit in the data unit includes a data block, a data file, or a data object.

6. The apparatus of claim 1, wherein, The trained global ML model includes either a transformer model or a recurrent neural network.

7. The apparatus of claim 1, wherein: The various storage types each include different characteristics, and The different characteristics include different data access response times and different costs associated with data storage.

8. The apparatus of claim 1, wherein, The execution of the instructions by the one or more processors further enables the one or more processors to: After storing the data unit, the data unit is moved from one of the multiple storage types to another based on the output of the trained global ML model.

9. The apparatus of claim 1, wherein, The execution of the instructions by the one or more processors further enables the one or more processors to: One or more model parameters of the trained global ML model are adjusted, at least in part, based on the determination of the Pareto optimal data storage state of the data unit taking into account multiple data storage factors.

10. A computer-implemented method, comprising: Obtain data request metadata corresponding to multiple data requests received at the storage device to generate a local training dataset; The training dataset is used to train a local machine learning (ML) model on the storage device, wherein the training includes ML model training for predicting future data accesses and classifying data in at least one of a variety of storage types accessible by the storage device. Share local ML model updates based on the training with at least one other device; Obtain a global ML model that incorporates the local ML model update and multiple ML model updates from other storage devices; Additional training is performed using the global ML model until the global ML model converges to the trained global ML model; Execute the trained global ML model at the storage device to determine one or more storage types among the multiple storage types for storing data units and to predict future data requests; and The data units are stored in one or more of the multiple storage types based on the output of the trained global ML model.

11. The computer-implemented method of claim 10, wherein, The data request metadata for each of the plurality of data requests includes the request type and an identifier that identifies the computing device as the source of the data request; And a timestamp indicating the time when the data request was received.

12. The computer-implemented method of claim 10, wherein: Sharing the local ML model update includes sharing the local ML model update with each of a plurality of other storage devices configured to participate in federated learning, and Obtaining the global ML model includes generating the global ML model at the storage device.

13. The computer-implemented method of claim 10, wherein: Sharing the local ML model update includes sharing the local ML model update with an ML model aggregation device configured to generate the global ML model, and Obtaining the global ML model includes receiving the global ML model from the ML model aggregation device by the storage device.

14. The computer-implemented method of claim 10, wherein, Each data unit in the data unit includes a data block, a data file, or a data object.

15. The computer-implemented method of claim 10, wherein, The trained global ML model includes either a transformer model or a recurrent neural network.

16. The computer-implemented method of claim 10, wherein: The various storage types each include different characteristics, and The different characteristics include different data access response times and different costs associated with data storage.

17. The computer-implemented method of claim 10, further comprising: After storing the data unit, the data unit is moved from one of the multiple storage types to another based on the output of the trained global ML model.

18. The computer-implemented method of claim 10, further comprising: One or more model parameters of the trained global ML model are adjusted, at least in part, based on the determination of the Pareto optimal data storage state of the data unit taking into account multiple data storage factors.

19. A non-transitory computer-readable medium storing a programming program for execution by one or more processors, the programming program including instructions for performing the following operations: Obtain data request metadata corresponding to multiple data requests received at the storage device to generate a local training dataset; Training a local machine learning (ML) model is performed on the storage device, wherein the training includes ML model training for predicting future data accesses and classifying data to be stored in at least one of a variety of storage types accessible by the storage device. Share local ML model updates based on the training with at least one other device; Obtain a global ML model that incorporates the local ML model update and multiple ML model updates from other storage devices; Additional training is performed using the global ML model until the global ML model converges to the trained global ML model; Execute the trained global ML model at the storage device to determine one or more storage types among the multiple storage types for storing data units and to predict future data requests; and The data units are stored in one or more of the multiple storage types based on the output of the trained global ML model.

20. The non-transitory computer-readable medium of claim 19, wherein: To share the local ML model updates, the program includes additional instructions for sharing the local ML model updates with each of a plurality of other storage devices configured to participate in federated learning, and To obtain the global ML model, the programming program includes additional instructions for generating the global ML model at the storage device.

Images