Patent ID: 12216623

DETAILED DESCRIPTION OF THE INVENTION

A system and method for random-access manipulation of compacted data files, utilizing a trainable reference codebook, a trainable random-access engine, a data deconstruction engine, and a data reconstruction engine, all of which are jointly trained in an end-to-end manner. The system may receive a data query pertaining to a data read or data write request, wherein the data file to be read from or written to is a compacted data file. A trainable random-access engine may facilitate data manipulation processes by organizing the codebook into a learnable hierarchical representation and then traversing the representation using trainable parameters to scan for specific codewords associated with a data query request. In an embodiment, a trainable estimator module is present and configured to utilize cardinality estimation with learnable parameters to determine a starting codeword to begin searching the compacted data file for the data associated with the data query. The estimator module refines the starting bit location by determining codeword boundaries through distinct value estimation and verifying if the initial bit sequence corresponds to a codeword boundary. The trainable random-access engine may encode the data to be written, insert the encoded data into a compacted data file, and update the codebook as needed, all while adapting its behavior based on end-to-end training.

A data search query may be generated by a system user. The data search query may include a search term, an identified compacted data file to read from, and a location hint. For instance, a user may search for a string in a text file and specify the location in the original file where the user thinks the string may be located. For example, a user data read query may be of the form: “search for the word ‘cosmology’ starting at the 50% mark of compacted version of an astrophysics textbook”. The system may use the location hint “50% mark” as a starting point for conducting a search of the encoded version of “cosmology” within the compacted version. The location hint may reference any point in the original data file, and the system may access the compacted data file at a point at or near the reference point contained within the location hint. In this way, any bit contained within a compacted data file may be randomly-accessed directly without the need to scan through or decode the entire compacted file. The random access engine uses the refined starting bit location from the estimator module as an initial point for traversing the hierarchical representation. When the correct encodings are found, the reference codes are retrieved and a trainable reference codebook may be used to transform the encoded version back to the original data, and the data may be sent to the user for verification. The efficiency of this process is continually improved through end-to-end training of all components.

Additionally, the system may support data write functions. A data write process begins when the system receives a data write query which may contain data to be inserted (write term) and a compacted data file to be written to. The system may re-encode the entire original data file with the inclusion of the inserted data using a trainable dyadic distribution compression and encryption module. This module uses trainable parameters for transforming the input data and compressing the main data stream. In other embodiments, an opcode representing an offset may be generated to facilitate a data write function that does not require re-encoding the entire data file, or unused bits located within the codebook can be used to create secondary encodings, which also does not require re-encoding the entire data file. These processes are optimized through joint training with other system components.

The system incorporates a large codeword model with a latent transformer core, which processes the compressed and encrypted data. The large codeword model uses a variational autoencoder (VAE) encoder to further compress the data into a latent space representation. The latent space vectors are then processed by a modified transformer that learns relationships between the vectors. Notably, this transformer does not include an embedding layer or a positional encoding layer, as these are not necessary for the latent space representation. The large codeword model is configured to adapt its processing based on the output of the dyadic distribution compression and encryption module. This allows the system to handle various types of data beyond just text, including images, audio, and time-series data. One skilled in the art would recognize that while the system is described using latent space representations, the principles and techniques could be applied to other forms of data representation and processing as well.

An end to end training subsystem coordinates the joint training of all system components, including the random-access engine, the dyadic distribution compression and encryption module, the large codeword model, and the estimator module. This joint training ensures that all components work in synergy, adapting to each other's behaviors for optimal overall performance in both compression efficiency and retrieval speed. The end to end training subsystem is configured to optimize performance across all components from initial compression and encryption to final random access capabilities.

One or more different aspects may be described in the present application. Further, for one or more of the aspects described herein, numerous alternative arrangements may be described; it should be appreciated that these are presented for illustrative purposes only and are not limiting of the aspects contained herein or the claims presented herein in any way. One or more of the arrangements may be widely applicable to numerous aspects, as may be readily apparent from the disclosure. In general, arrangements are described in sufficient detail to enable those skilled in the art to practice one or more of the aspects, and it should be appreciated that other arrangements may be utilized and that structural, logical, software, electrical and other changes may be made without departing from the scope of the particular aspects. Particular features of one or more of the aspects described herein may be described with reference to one or more particular aspects or figures that form a part of the present disclosure, and in which are shown, by way of illustration, specific arrangements of one or more of the aspects. It should be appreciated, however, that such features are not limited to usage in the one or more particular aspects or figures with reference to which they are described. The present disclosure is neither a literal description of all arrangements of one or more of the aspects nor a listing of features of one or more of the aspects that must be present in all arrangements.

Headings of sections provided in this patent application and the title of this patent application are for convenience only, and are not to be taken as limiting the disclosure in any way.

Devices that are in communication with each other need not be in continuous communication with each other, unless expressly specified otherwise. In addition, devices that are in communication with each other may communicate directly or indirectly through one or more communication means or intermediaries, logical or physical.

A description of an aspect with several components in communication with each other does not imply that all such components are required. To the contrary, a variety of optional components may be described to illustrate a wide variety of possible aspects and in order to more fully illustrate one or more aspects. Similarly, although process steps, method steps, algorithms or the like may be described in a sequential order, such processes, methods and algorithms may generally be configured to work in alternate orders, unless specifically stated to the contrary. In other words, any sequence or order of steps that may be described in this patent application does not, in and of itself, indicate a requirement that the steps be performed in that order. The steps of described processes may be performed in any order practical. Further, some steps may be performed simultaneously despite being described or implied as occurring non-simultaneously (e.g., because one step is described after the other step). Moreover, the illustration of a process by its depiction in a drawing does not imply that the illustrated process is exclusive of other variations and modifications thereto, does not imply that the illustrated process or any of its steps are necessary to one or more of the aspects, and does not imply that the illustrated process is preferred. Also, steps are generally described once per aspect, but this does not mean they must occur once, or that they may only occur once each time a process, method, or algorithm is carried out or executed. Some steps may be omitted in some aspects or some occurrences, or some steps may be executed more than once in a given aspect or occurrence.

When a single device or article is described herein, it will be readily apparent that more than one device or article may be used in place of a single device or article. Similarly, where more than one device or article is described herein, it will be readily apparent that a single device or article may be used in place of the more than one device or article.

The functionality or the features of a device may be alternatively embodied by one or more other devices that are not explicitly described as having such functionality or features. Thus, other aspects need not include the device itself.

Techniques and mechanisms described or referenced herein will sometimes be described in singular form for clarity. However, it should be appreciated that particular aspects may include multiple iterations of a technique or multiple instantiations of a mechanism unless noted otherwise. Process descriptions or blocks in figures should be understood as representing modules, segments, or portions of code which include one or more executable instructions for implementing specific logical functions or steps in the process. Alternate implementations are included within the scope of various aspects in which, for example, functions may be executed out of order from that shown or discussed, including substantially concurrently or in reverse order, depending on the functionality involved, as would be understood by those having ordinary skill in the art.

Definitions

The term “bit” refers to the smallest unit of information that can be stored or transmitted. It is in the form of a binary digit (either 0 or 1). In terms of hardware, the bit is represented as an electrical signal that is either off (representing 0) or on (representing 1).

The term “byte” refers to a series of bits exactly eight bits in length.

The term “codebook” refers to a database containing sourceblocks each with a pattern of bits and reference code unique within that library. The terms “library” and “encoding/decoding library” are synonymous with the term codebook.

The terms “compression” and “deflation” as used herein mean the representation of data in a more compact form than the original dataset. Compression and/or deflation may be either “lossless”, in which the data can be reconstructed in its original form without any loss of the original data, or “lossy” in which the data can be reconstructed in its original form, but with some loss of the original data.

The terms “compression factor” and “deflation factor” as used herein mean the net reduction in size of the compressed data relative to the original data (e.g., if the new data is 70% of the size of the original, then the deflation/compression factor is 30% or 0.3.)

The terms “compression ratio” and “deflation ratio”, and as used herein all mean the size of the original data relative to the size of the compressed data (e.g., if the new data is 70% of the size of the original, then the deflation/compression ratio is 70% or 0.7.) The term “data” means information in any computer-readable form.

The term “sourceblock” refers to a series of bits of a specified length. The number of bits in a sourceblock may be dynamically optimized by the system during operation. In one aspect, a sourceblock may be of the same length as the block size used by a particular file system, typically 512 bytes or 4,096 bytes.

The term “effective compression” or “effective compression ratio” refers to the additional amount data that can be stored using the method herein described versus conventional data storage methods. Although the method herein described is not data compression, per se, expressing the additional capacity in terms of compression is a useful comparison.

The term “data set” refers to a grouping of data for a particular purpose. One example of a data set might be a word processing file containing text and formatting information.

The term “library” refers to a database containing sourceblocks each with a pattern of bits and reference code unique within that library. The term “codebook” is synonymous with the term library.

The term “sourcepacket” as used herein means a packet of data received for encoding or decoding. A sourcepacket may be a portion of a data set.

The term “sourceblock” as used herein means a defined number of bits or bytes used as the block size for encoding or decoding. A sourcepacket may be divisible into a number of sourceblocks. As one non-limiting example, a 1 megabyte sourcepacket of data may be encoded using 512 byte sourceblocks. The number of bits in a sourceblock may be dynamically optimized by the system during operation. In one aspect, a sourceblock may be of the same length as the block size used by a particular file system, typically 512 bytes or 4,096 bytes.

The term “codeword” refers to the reference code form in which data is stored or transmitted in an aspect of the system. A codeword consists of a reference code to a sourceblock in the library plus an indication of that sourceblock's location in a particular data set.

The term “dyadic distribution” refers to a probability distribution that arises from repeatedly dividing an interval in half.

The term “latent space” refers to a compressed representation of data in a lower-dimensional space, often used in machine learning models.

The term “variational autoencoder (VAE)” refers to a type of neural network that learns to encode data into a latent space and decode it back, while also learning the probability distribution of the latent space.

The term “transformer” refers to a type of neural network architecture that uses self-attention mechanisms to process sequential data.

The term “sourceblock” refers to a fixed-size segment of data used as the basic unit for compression and encoding.

The term “random access” refers to the ability to directly access and manipulate specific parts of a compressed file without decompressing the entire file.

The term “end-to-end training” refers to a machine learning approach where all components of a system are trained simultaneously to optimize overall performance.

The term “cardinality estimation” refers to a technique for estimating the number of distinct elements in a dataset.

Conceptual Architecture

FIG.34is a block diagram illustrating an exemplary aspects of a system for data compaction which supports random access capabilities of compacted data, a data search engine3410and an estimator3420. According to the embodiment, data search engine3410and estimator3420may be components of random access engine2800as illustrated inFIG.29. In other embodiments, data search engine3410and estimator3420may be arranged in a distributed manner wherein they and the other components of random access engine2800need not be operating on the same system (e.g., computing device, server, mobile device, etc.). According to the embodiment, data search engine3410may be configured to optimize random access searches of compacted data by transforming a codebook into a hierarchical index to improve data search time and reduce the chance at returning the incorrect data.

According to the embodiment, data search engine3410can be configured to receive a data read request3401. Responsive to the data read request, data search engine3410may receive, retrieve, or otherwise obtain the codebook3402from a suitable data storage system, library manager, data deconstruction engine, or some other component of system. The obtained codebook may be processed by a codebook transformer3411configured to transform the structure of the codebook to a hierarchical index representation. Hierarchical indexing can be used to efficiently organize and access compacted sourceblocks, each associated with a unique codeword. This approach can help manage and retrieve data blocks while taking advantage of the hierarchical structure of the codewords. According to an embodiment, codebook transformer3411may determine the hierarchical structure based on your specific requirements. For example, the hierarchy may be organized based on Huffman codewords. The transformed codebook may be sent to or otherwise obtained by a hierarchical lookup module3412configured to scan the transformed codebook to retrieve the data associated with the data read request3401.

According to various embodiments, deconstruction engine and library manager may assign the shortest codewords to the most frequently occurring sourceblocks. This property can be leveraged to create a hierarchical structure. In an exemplary process, system may start with a root node of the hierarchy, which represents an empty codeword. For each codeword, follow the path from the root to the corresponding leaf node, creating intermediate nodes as needed. Each leaf node represents a unique codeword. At each leaf node, associate the data block with the codeword as a key-value pair in the codebook. This hierarchical indexing approach leverages the hierarchical nature of the assigned codewords, making it efficient for managing and accessing data blocks associated with unique codewords. It optimizes both storage and retrieval operations, taking advantage of the properties of encoding in the process.

According to an embodiment, when a new data block is to be added with its associated codeword, the system can follow the path in the hierarchy to the appropriate leaf node and insert the new key-value pair into the codebook.

According to an embodiment, to search for data blocks using partial codewords, system can traverse the hierarchy as far as the available codeword allows, which can be useful for prefix-based searches.

A hierarchical index, as described above, lends itself to efficient random access of data blocks, particularly when dealing with numerous data blocks bearing unique codewords. Hierarchical lookup module3412can facilitate the access process on a hierarchically indexed codebook. This access process initiates at the root node of the hierarchy, from which a hierarchical path traversal commences. The hierarchical traversal proceeds by interpreting each bit within the codeword, where ‘0’ and ‘l’ signify movement to the left and right, respectively. This traversal continues until the leaf node corresponding to the complete codeword is reached. The data block associated with this leaf node can then be accessed. The hierarchical structure's efficiency in random access results from reducing the search space as one traverses the hierarchy, restricting navigation to depths in correspondence with the bits in the codeword. The access process is advantageous, especially when dealing with diverse codeword lengths. User provided locational hints may be used by hierarchical lookup module3412to determine which leaf or node to commence the search from. Hierarchical lookup module3412may receive a data search request which may be associated with a start codeword. In an implementation, logically a start codeword is the initial point at which data may be retrieved to satisfy the query request. Random access engine may use lookup module3412to traverse the hierarchical representation of the codebook until a start codeword is located. The start codeword and any subsequent codewords relevant to the query request may be retrieved and returned to a decoder (e.g., data reconstruction engine) for decoding.

Also present in the embodiment is estimator3420which can provide initial estimates for a starting location to begin searching for the data associated with data read request3401as well as refine user provided hints or estimates. According to an implementation, estimator3420may estimate the one or more possible starting points using a distinct value estimate mechanism via a starting point module3421. Distinct value estimation, also known as cardinality estimation or unique value estimation, is a process used to determine the number of distinct or unique values in a dataset. Some techniques that may be used by starting point module3421to perform distinct value estimation can include, but are not limited to, counting approaches (e.g., exact counting, HyperLogLog, etc.), sampling methods (reservoir sampling, min hashing, etc.), probabilistic data structures (e.g., bloom filters, count-min sketch, etc.), and statistical estimation, to name a few. These estimates3403may be sent to data search engine3410and used by hierarchical lookup module3412as an initial node/leaf at which to begin the search.

The distinct values may be associated with a codeword and/or a codeword boundary. In some implementations, estimator3420perform a distinct value estimate to determine one or more codeword boundaries, wherein the one or more codeword boundaries may be used as starting points for facilitating a random access read of compacted data. In some implementations, an initial estimate or user provided hint may be refined be performing a distinct value estimate.

FIG.35is a flow diagram illustrating an exemplary method3500for performing random access search on a compacted data file using a transformed codebook, according to an embodiment. According to the embodiment, the process begins at step3501when random access engine receives a query request from a query process. The query process may be associated with a user, for example a user may submit a data read request to database which stores a plurality of compacted data files. In other instances, the query process may be associated with an automated system or process, for example an application subsystem performing a data write operation to a compacted data file. At step3502, random access engine, via codebook transformer3411, can transform the codebook used to compact the data file into a hierarchical representation according to methods described herein. In some implementations, these methods can include one or more or less of the following steps: determining hierarchy levels; selecting a root node; grouping and nesting data; defining relationships; selecting a data structure (e.g., dictionaries, trees, or graphs); traversing and building; visualizing; testing and validating; and performing maintenance and updates.

At a next step3503, hierarchical lookup module3412can traverse the hierarchical representation until a start codeword corresponding to the query request is located. At step3504, the start codeword is retrieved and all other subsequent, relevant codewords are also retrieved from the compacted data file. The codewords are relevant with respect to the query request. A plurality of subsequent codewords may be retrieved to satisfy the query request. As a last step3505, the retrieved codewords may be sent to a decoder and decoded. In an embodiment, data reconstruction engine108may be implemented as a decoder. The decoded data may then be returned to the appropriate endpoint associated with the request process. For example, if a user submitted a query, then the decoded data may be sent to user interface2810where it may be viewed by the user.

FIG.36is a flow diagram illustrating an exemplary method3600for performing random access search on a compacted data file using a transformed codebook and an initial estimate, according to an embodiment. According to the embodiment, this process may be triggered when a query request is received by random access engine. Data search engine3410may transform a codebook into a hierarchical representation which can be used for query response optimization. According to the embodiment, the process begins at step3601when estimator3420receives a compacted data file. The compacted data file being compacted using a codebook as described herein. At step3602, estimator module estimates a codeword boundary by performing distinct value estimation on the compacted data file. The distinct values determined by this step may be associated with the various codeword boundaries contained within the compacted data file. At step3603, random access engine can traverse the hierarchical representation using the estimated codeword boundary as an initial starting point until a start codeword corresponding to the query request is located. At step3604, the start codeword is retrieved and all other subsequent, relevant codewords are also retrieved from the compacted data file. The codewords are relevant with respect to the query request. A plurality of subsequent codewords may be retrieved to satisfy the query request. As a last step3605, the retrieved codewords may be sent to a decoder and decoded. In an embodiment, data reconstruction engine108may be implemented as a decoder. The decoded data may then be returned to the appropriate endpoint associated with the request process. For example, if an application requested a data read operation, then the decoded data would be sent back to the requesting application.

FIG.1is a diagram showing an embodiment100of the system in which all components of the system are operated locally. As incoming data101is received by data deconstruction engine102. Data deconstruction engine102breaks the incoming data into sourceblocks, which are then sent to library manager103. Using the information contained in sourceblock library lookup table104and sourceblock library storage105, library manager103returns reference codes to data deconstruction engine102for processing into codewords, which are stored in codeword storage106. When a data retrieval request107is received, data reconstruction engine108obtains the codewords associated with the data from codeword storage106, and sends them to library manager103. Library manager103returns the appropriate sourceblocks to data reconstruction engine108, which assembles them into the proper order and sends out the data in its original form109.

FIG.2is a diagram showing an embodiment of one aspect200of the system, specifically data deconstruction engine201. Incoming data202is received by data analyzer203, which optimally analyzes the data based on machine learning algorithms and input204from a sourceblock size optimizer, which is disclosed below. Data analyzer may optionally have access to a sourceblock cache205of recently-processed sourceblocks, which can increase the speed of the system by avoiding processing in library manager103. Based on information from data analyzer203, the data is broken into sourceblocks by sourceblock creator206, which sends sourceblocks207to library manager203for additional processing. Data deconstruction engine201receives reference codes208from library manager103, corresponding to the sourceblocks in the library that match the sourceblocks sent by sourceblock creator206, and codeword creator209processes the reference codes into codewords comprising a reference code to a sourceblock and a location of that sourceblock within the data set. The original data may be discarded, and the codewords representing the data are sent out to storage210.

FIG.3is a diagram showing an embodiment of another aspect of system300, specifically data reconstruction engine301. When a data retrieval request302is received by data request receiver303(in the form of a plurality of codewords corresponding to a desired final data set), it passes the information to data retriever304, which obtains the requested data305from storage. Data retriever304sends, for each codeword received, a reference codes from the codeword306to library manager103for retrieval of the specific sourceblock associated with the reference code. Data assembler308receives the sourceblock307from library manager103and, after receiving a plurality of sourceblocks corresponding to a plurality of codewords, assembles them into the proper order based on the location information contained in each codeword (recall each codeword comprises a sourceblock reference code and a location identifier that specifies where in the resulting data set the specific sourceblock should be restored to. The requested data is then sent to user309in its original form.

FIG.4is a diagram showing an embodiment of another aspect of the system400, specifically library manager401. One function of library manager401is to generate reference codes from sourceblocks received from data deconstruction engine301. As sourceblocks are received402from data deconstruction engine301, sourceblock lookup engine403checks sourceblock library lookup table404to determine whether those sourceblocks already exist in sourceblock library storage105. If a particular sourceblock exists in sourceblock library storage105, reference code return engine405sends the appropriate reference code406to data deconstruction engine301. If the sourceblock does not exist in sourceblock library storage105, optimized reference code generator407generates a new, optimized reference code based on machine learning algorithms. Optimized reference code generator407then saves the reference code408to sourceblock library lookup table104; saves the associated sourceblock409to sourceblock library storage105; and passes the reference code to reference code return engine405for sending406to data deconstruction engine301. Another function of library manager401is to optimize the size of sourceblocks in the system. Based on information411contained in sourceblock library lookup table104, sourceblock size optimizer410dynamically adjusts the size of sourceblocks in the system based on machine learning algorithms and outputs that information412to data analyzer203. Another function of library manager401is to return sourceblocks associated with reference codes received from data reconstruction engine301. As reference codes are received414from data reconstruction engine301, reference code lookup engine413checks sourceblock library lookup table415to identify the associated sourceblocks; passes that information to sourceblock retriever416, which obtains the sourceblocks417from sourceblock library storage105; and passes them418to data reconstruction engine301.

FIG.5is a diagram showing another embodiment of system500, in which data is transferred between remote locations. As incoming data501is received by data deconstruction engine502at Location1, data deconstruction engine301breaks the incoming data into sourceblocks, which are then sent to library manager503at Location1. Using the information contained in sourceblock library lookup table504at Location1and sourceblock library storage505at Location1, library manager503returns reference codes to data deconstruction engine301for processing into codewords, which are transmitted506to data reconstruction engine507at Location2. In the case where the reference codes contained in a particular codeword have been newly generated by library manager503at Location1, the codeword is transmitted along with a copy of the associated sourceblock. As data reconstruction engine507at Location2receives the codewords, it passes them to library manager module508at Location2, which looks up the sourceblock in sourceblock library lookup table509at Location2, and retrieves the associated from sourceblock library storage510. Where a sourceblock has been transmitted along with a codeword, the sourceblock is stored in sourceblock library storage510and sourceblock library lookup table504is updated. Library manager503returns the appropriate sourceblocks to data reconstruction engine507, which assembles them into the proper order and sends the data in its original form511.

FIG.6is a diagram showing an embodiment600in which a standardized version of a sourceblock library603and associated algorithms604would be encoded as firmware602on a dedicated processing chip601included as part of the hardware of a plurality of devices600. Contained on dedicated chip601would be a firmware area602, on which would be stored a copy of a standardized sourceblock library603and deconstruction/reconstruction algorithms604for processing the data. Processor605would have both inputs606and outputs607to other hardware on the device600. Processor605would store incoming data for processing on on-chip memory608, process the data using standardized sourceblock library603and deconstruction/reconstruction algorithms604, and send the processed data to other hardware on device600. Using this embodiment, the encoding and decoding of data would be handled by dedicated chip601, keeping the burden of data processing off device's600primary processors. Any device equipped with this embodiment would be able to store and transmit data in a highly optimized, bandwidth-efficient format with any other device equipped with this embodiment.

FIG.12is a diagram showing an exemplary system architecture1200, according to a preferred embodiment of the invention. Incoming training data sets may be received at a customized library generator1300that processes training data to produce a customized word library1201comprising key-value pairs of data words (each comprising a string of bits) and their corresponding calculated binary Huffman codewords. The resultant word library1201may then be processed by a library optimizer1400to reduce size and improve efficiency, for example by pruning low-occurrence data entries or calculating approximate codewords that may be used to match more than one data word. A transmission encoder/decoder1500may be used to receive incoming data intended for storage or transmission, process the data using a word library1201to retrieve codewords for the words in the incoming data, and then append the codewords (rather than the original data) to an outbound data stream. Each of these components is described in greater detail below, illustrating the particulars of their respective processing and other functions, referring toFIGS.2-4.

System1200provides near-instantaneous source coding that is dictionary-based and learned in advance from sample training data, so that encoding and decoding may happen concurrently with data transmission. This results in computational latency that is near zero but the data size reduction is comparable to classical compression. For example, if N bits are to be transmitted from sender to receiver, the compression ratio of classical compression is C, the ratio between the deflation factor of system1200and that of multi-pass source coding is p, the classical compression encoding rate is RCbit/s and the decoding rate is RDbit/s, and the transmission speed is S bit/s, the compress-send-decompress time will be

To⁢l⁢d=NRC+NC⁢S+NC⁢RD
while the transmit-while-coding time for system1200will be (assuming that encoding and decoding happen at least as quickly as network latency):

Tn⁢e⁢w=NpCS
so that the total data transit time improvement factor is

To⁢l⁢dTn⁢e⁢w=CSRC+1+SRDp
which presents a savings whenever

CSRC⁢+SRD>p-1.
This is a reasonable scenario given that typical values in real-world practice are C=0.32, RC=1.1·1012, RD=4.2·1012, S=1011, giving

CSRC+SRD=0.0⁢53⁢…,
such that system1200will outperform the total transit time of the best compression technology available as long as its deflation factor is no more than 5% worse than compression. Such customized dictionary-based encoding will also sometimes exceed the deflation ratio of classical compression, particularly when network speeds increase beyond 100 Gb/s.

The delay between data creation and its readiness for use at a receiving end will be equal to only the source word length t (typically 5-15 bytes), divided by the deflation factor C/p and the network speed S, i.e.

delayinvention=tpCS
since encoding and decoding occur concurrently with data transmission. On the other hand, the latency associated with classical compression is

delaypriorart=NRC+NC⁢S+NC⁢RD
where N is the packet/file size. Even with the generous values chosen above as well as N=512K, 1=10, and p=1.05, this results in delayinvention≈3.3·10−10while delaypriorart≈1.3·10−7, a more than 400-fold reduction in latency.

A key factor in the efficiency of Huffman coding used by system1200is that key-value pairs be chosen carefully to minimize expected coding length, so that the average deflation/compression ratio is minimized. It is possible to achieve the best possible expected code length among all instantaneous codes using Huffman codes if one has access to the exact probability distribution of source words of a given desired length from the random variable generating them. In practice this is impossible, as data is received in a wide variety of formats and the random processes underlying the source data are a mixture of human input, unpredictable (though in principle, deterministic) physical events, and noise. System1200addresses this by restriction of data types and density estimation; training data is provided that is representative of the type of data anticipated in “real-world” use of system1200, which is then used to model the distribution of binary strings in the data in order to build a Huffman code word library1200.

FIG.13is a diagram showing a more detailed architecture for a customized library generator1300. When an incoming training data set1301is received, it may be analyzed using a frequency creator1302to analyze for word frequency (that is, the frequency with which a given word occurs in the training data set). Word frequency may be analyzed by scanning all substrings of bits and directly calculating the frequency of each substring by iterating over the data set to produce an occurrence frequency, which may then be used to estimate the rate of word occurrence in non-training data. A first Huffman binary tree is created based on the frequency of occurrences of each word in the first dataset, and a Huffman codeword is assigned to each observed word in the first dataset according to the first Huffman binary tree. Machine learning may be utilized to improve results by processing a number of training data sets and using the results of each training set to refine the frequency estimations for non-training data, so that the estimation yield better results when used with real-world data (rather than, for example, being only based on a single training data set that may not be very similar to a received non-training data set). A second Huffman tree creator1303may be utilized to identify words that do not match any existing entries in a word library1201and pass them to a hybrid encoder/decoder1304, that then calculates a binary Huffman codeword for the mismatched word and adds the codeword and original data to the word library1201as a new key-value pair. In this manner, customized library generator1300may be used both to establish an initial word library1201from a first training set, as well as expand the word library1201using additional training data to improve operation.

FIG.14is a diagram showing a more detailed architecture for a library optimizer1400. A pruner1401may be used to load a word library1201and reduce its size for efficient operation, for example by sorting the word library1201based on the known occurrence probability of each key-value pair and removing low-probability key-value pairs based on a loaded threshold parameter. This prunes low-value data from the word library to trim the size, eliminating large quantities of very-low-frequency key-value pairs such as single-occurrence words that are unlikely to be encountered again in a data set. Pruning eliminates the least-probable entries from word library1201up to a given threshold, which will have a negligible impact on the deflation factor since the removed entries are only the least-common ones, while the impact on word library size will be larger because samples drawn from asymptotically normal distributions (such as the log-probabilities of words generated by a probabilistic finite state machine, a model well-suited to a wide variety of real-world data) which occur in tails of the distribution are disproportionately large in counting measure. A delta encoder1402may be utilized to apply delta encoding to a plurality of words to store an approximate codeword as a value in the word library, for which each of the plurality of source words is a valid corresponding key. This may be used to reduce library size by replacing numerous key-value pairs with a single entry for the approximate codeword and then represent actual codewords using the approximate codeword plus a delta value representing the difference between the approximate codeword and the actual codeword. Approximate coding is optimized for low-weight sources such as Golomb coding, run-length coding, and similar techniques. The approximate source words may be chosen by locality-sensitive hashing, so as to approximate Hamming distance without incurring the intractability of nearest-neighbor-search in Hamming space. A parametric optimizer1403may load configuration parameters for operation to optimize the use of the word library1201during operation. Best-practice parameter/hyperparameter optimization strategies such as stochastic gradient descent, quasi-random grid search, and evolutionary search may be used to make optimal choices for all interdependent settings playing a role in the functionality of system1200. In cases where lossless compression is not required, the delta value may be discarded at the expense of introducing some limited errors into any decoded (reconstructed) data.

FIG.15is a diagram showing a more detailed architecture for a transmission encoder/decoder1500. According to various arrangements, transmission encoder/decoder1500may be used to deconstruct data for storage or transmission, or to reconstruct data that has been received, using a word library1201. A library comparator1501may be used to receive data comprising words or codewords, and compare against a word library1201by dividing the incoming stream into substrings of length t and using a fast hash to check word library1201for each substring. If a substring is found in word library1201, the corresponding key/value (that is, the corresponding source word or codeword, according to whether the substring used in comparison was itself a word or codeword) is returned and appended to an output stream. If a given substring is not found in word library1201, a mismatch handler1502and hybrid encoder/decoder1503may be used to handle the mismatch similarly to operation during the construction or expansion of word library1201. A mismatch handler1502may be utilized to identify words that do not match any existing entries in a word library1201and pass them to a hybrid encoder/decoder1503, that then calculates a binary Huffman codeword for the mismatched word and adds the codeword and original data to the word library1201as a new key-value pair. The newly-produced codeword may then be appended to the output stream. In arrangements where a mismatch indicator is included in a received data stream, this may be used to preemptively identify a substring that is not in word library1201(for example, if it was identified as a mismatch on the transmission end), and handled accordingly without the need for a library lookup.

FIG.19is an exemplary system architecture of a data encoding system used for cyber security purposes. Much like inFIG.1, incoming data101to be deconstructed is sent to a data deconstruction engine102, which may attempt to deconstruct the data and turn it into a collection of codewords using a library manager103. Codeword storage106serves to store unique codewords from this process, and may be queried by a data reconstruction engine108which may reconstruct the original data from the codewords, using a library manager103. However, a cybersecurity gateway1900is present, communicating in-between a library manager103and a deconstruction engine102, and containing an anomaly detector1910and distributed denial of service (DDoS) detector1920. The anomaly detector examines incoming data to determine whether there is a disproportionate number of incoming reference codes that do not match reference codes in the existing library. A disproportionate number of non-matching reference codes may indicate that data is being received from an unknown source, of an unknown type, or contains unexpected (possibly malicious) data. If the disproportionate number of non-matching reference codes exceeds an established threshold or persists for a certain length of time, the anomaly detector1910raises a warning to a system administrator. Likewise, the DDoS detector1920examines incoming data to determine whether there is a disproportionate amount of repetitive data. A disproportionate amount of repetitive data may indicate that a DDoS attack is in progress. If the disproportionate amount of repetitive data exceeds an established threshold or persists for a certain length of time, the DDoS detector1910raises a warning to a system administrator. In this way, a data encoding system may detect and warn users of, or help mitigate, common cyber-attacks that result from a flow of unexpected and potentially harmful data, or attacks that result from a flow of too much irrelevant data meant to slow down a network or system, as in the case of a DDoS attack.

FIG.22is an exemplary system architecture of a data encoding system used for data mining and analysis purposes. Much like inFIG.1, incoming data101to be deconstructed is sent to a data deconstruction engine102, which may attempt to deconstruct the data and turn it into a collection of codewords using a library manager103. Codeword storage106serves to store unique codewords from this process, and may be queried by a data reconstruction engine108which may reconstruct the original data from the codewords, using a library manager103. A data analysis engine2210, typically operating while the system is otherwise idle, sends requests for data to the data reconstruction engine108, which retrieves the codewords representing the requested data from codeword storage106, reconstructs them into the data represented by the codewords, and send the reconstructed data to the data analysis engine2210for analysis and extraction of useful data (i.e., data mining). Because the speed of reconstruction is significantly faster than decompression using traditional compression technologies (i.e., significantly less decompression latency), this approach makes data mining feasible. Very often, data stored using traditional compression is not mined precisely because decompression lag makes it unfeasible, especially during shorter periods of system idleness. Increasing the speed of data reconstruction broadens the circumstances under which data mining of stored data is feasible.

FIG.24is an exemplary system architecture of a data encoding system used for remote software and firmware updates. Software and firmware updates typically require smaller, but more frequent, file transfers. A server which hosts a software or firmware update2410may host an encoding-decoding system2420, allowing for data to be encoded into, and decoded from, sourceblocks or codewords, as disclosed in previous figures. Such a server may possess a software update, operating system update, firmware update, device driver update, or any other form of software update, which in some cases may be minor changes to a file, but nevertheless necessitate sending the new, completed file to the recipient. Such a server is connected over a network2430, which is further connected to a recipient computer2440, which may be connected to a server2410for receiving such an update to its system. In this instance, the recipient device2440also hosts the encoding and decoding system2450, along with a codebook or library of reference codes that the hosting server2410also shares. The updates are retrieved from storage at the hosting server2410in the form of codewords, transferred over the network2430in the form of codewords, and reconstructed on the receiving computer2440. In this way, a far smaller file size, and smaller total update size, may be sent over a network. The receiving computer2440may then install the updates on any number of target computing devices2460a-n, using a local network or other high-bandwidth connection.

FIG.26is an exemplary system architecture of a data encoding system used for large-scale software installation such as operating systems. Large-scale software installations typically require very large, but infrequent, file transfers. A server which hosts an installable software2610may host an encoding-decoding system2620, allowing for data to be encoded into, and decoded from, sourceblocks or codewords, as disclosed in previous figures. The files for the large scale software installation are hosted on the server2610, which is connected over a network2630to a recipient computer2640. In this instance, the encoding and decoding system2650a-nis stored on or connected to one or more target devices2660a-n, along with a codebook or library of reference codes that the hosting server2610shares. The software is retrieved from storage at the hosting server2610in the form of codewords, and transferred over the network2630in the form of codewords to the receiving computer2640. However, instead of being reconstructed at the receiving computer2640, the codewords are transmitted to one or more target computing devices, and reconstructed and installed directly on the target devices2660a-n. In this way, a far smaller file size, and smaller total update size, may be sent over a network or transferred between computing devices, even where the network2630between the receiving computer2640and target devices2660a-nis low bandwidth, or where there are many target devices2660a-n.

FIG.28is an exemplary system architecture of a data encoding system with random access capabilities. Much like inFIG.1, incoming data101to be deconstructed is sent to a data deconstruction engine102, which may attempt to deconstruct the data and turn it into a collection of codeword using a library manager103. Codeword storage106serves to store unique codeword from this process, and may be queried by a data reconstruction engine108which may reconstruct the original data from the codeword, using a library manager103.

However, a random-access engine2800exists that receives a data query request from a user interface2810such as a graphical user interface. The query request may comprise identification of a compacted data file to search and a search term, and optionally a location hint. Various possible search term configurations may exist such as a byte range (i.e., begin at byte N and return M number of bytes), a string such as “volleyball” or a date such as “Nov. 6, 2020”, among others. The random access engine2800may also query the library manager103for retrieval of the reference codebook corresponding to the identified compacted data file. Additionally, the random access engine2800may query the codeword storage106for retrieval of a plurality of codeword, the plurality of codeword representing the compacted data file to be searched and read from. When the search term has been found, it may be sent to the data reconstruction engine108where it may be decoded to recover the original data, and the original data may be sent to the user interface2810. The user may verify the search result is correct. If the result is incorrect the user may refine and submit a new search request.

FIG.29is a diagram showing an embodiment of one aspect of the system, the random access engine2900. The process begins when a data query request is made to the application. A data read query may comprise identification of a compacted data file to access, a search term, and optionally a location hint serving as an initial guess as to the location of the search term within the original data file. As a simple example of a data read query, the user searches for the string “cosmology” in a compacted data file “Y” to read from, and a location hint of byte “N” to be used to estimate where in “Y” the string “cosmology” may occur. Additionally, the random access engine2900may receive a data write query which may include the write term to be written and an identified compacted data file in which to write the write term. A data query receiver2910parses both data read and data write queries and retrieves the identified compacted data file in the form of a plurality of codeword from codeword storage106. The data query receiver2910then sends the retrieved compacted data file and the search term to the data search engine2940. If the data search query includes a location hint, then the query receiver2910may send the location hint to an estimator2920. A location hint may be given that represents where in the original file the data to be read may be located, and the estimator receives the location hint and estimates that same location in the compacted version of the data file. A location hint may comprise a byte location N in the original file X, the estimator2920estimates the location (bit number) N′ in Y (compacted version of data file) corresponding to byte N in X. The estimator2920may check if the estimated location N′ is located at a codeword boundary or in the middle of a codeword. If N′ lies within a codeword, then the estimator may use bit-scrolling backward and forward to find the codeword boundary. Additionally, the location hint may comprise a user command such as “start at the 45% mark”. The estimator2920sends the estimated location of the byte range to the data search engine2940for further processing.

A codebook retriever2930receives a signal form the data query receiver2910that prompts the codebook retriever2930to request the codebook and frequency table associated with the compacted data file from a word library1201. The frequency table2950shows the most frequently occurring words or substrings within a data set, and may be used by the data search engine2940to refine the location estimate.

The data search engine2940receives a data read request in the form of a search term such as a byte range, string, or substring, and may receive an initial location estimate from the estimator2920if a location hint was included in the data read query. The data search engine2940may use a frequency table2950to refine location estimates and identify codeword boundaries in an automatic way. The estimated location may be in the middle of a codeword. If this is the case then the search results will return output that does not match the search query. For example, the search results return a sequence of bytes, the frequency table2950may be used to identify whether the sequence of bytes are unlikely to occur in the original data, or if the sequence was reasonably likely then a codeword boundary has probably been found. When a codeword boundary is found, it allows the whole compacted data file to be accessed in any order by jumping from codeword to codeword, facilitating useful search results. If the data request is in a string format and a location hint was provided, then the data search engine2940may automatically locate the search string via a binary search from the estimated starting point or a found codeword boundary. The data search engine2940may also parse a search term string into sourceblocks and create at least one or more encodings for sub-search strings derived from the original search string. An exemplary parsing process is discussed in more detail inFIG.33contained within this disclosure. Additionally, various search operators may be integrated into the search capabilities. A few examples of search operators include “near”, “and”, “or”, and “not”. These may be used to narrow the scope of the search. Once the byte range or search string has been located, the codebook may be used to decode the located reference codes belonging to the search string or byte range. In other embodiments, the located reference codes may be sent to the data reconstruction engine108which sends the decoded byte range or search string to the user for verification.

A search cache2960may optionally be used to store previous search terms and their locations within the compacted data file. The data query receiver2910may look for the requested data in the cache2960and if it is found in the cache then its location is sent to the data reconstruction engine108where the compacted data may be reconstructed and then sent to the user for review.

If the data query is a data write query, then the data query receiver2910may send a signal to the codebook retriever2930to retrieve the codebook corresponding to the identified compacted version of the data file in which the write term is to be written and send the write term to a data write engine2970. The codebook retriever2930sends the codebook to the data write engine2970. If the size of the data to be written (write term) is exactly the length of the sourceblock (sourceblock), then the data write engine2970can simply encode the data and insert it into the received codebook. More likely, the size of the data to be written does not exactly match the sourceblock length, and simply encoding and adding the codeword to the codebook would modify the output of the codewords globally, basically changing everything from that point on. In an embodiment, when some data is to be inserted into the original data file, the original file may be entirely re-encoded. In another embodiment, instead of re-encoding the entire file, an opcode is created that tells the decoder there is an offset that has to be accounted for when reconstructing the compacted data. In yet another embodiment, instead of using an opcode, there are extra unused bits available in the codebook that can be used to encode information about how many secondary bytes are coming up. A secondary byte(s) represents the newly written data that may be encoded and inserted in the codebook. In this way when encoded bit is found, the data encoder can switch to secondary encoding, encode one fewer byte, then resume normal encoding. This allows for inserting data into the original data file without having to re-encode the entire file.

FIG.37is a block diagram illustrating an exemplary system architecture3700for a unified neural intelligent transformer engine. According to the embodiment, the system3700comprises several key components: a dyadic distribution compression and encryption subsystem3800, a random access engine3900, a large codeword model with latent transformer core4000, a trainable estimator subsystem4100, and an end to end training subsystem4200.

The system3700is designed to handle various types of input and produce corresponding outputs. Input data3701represents the original data to be compressed and encrypted. This data is fed into the dyadic distribution compression and encryption subsystem3800. Search queries3702and write requests3703are directed to the random access engine3900, allowing for efficient searching and modification of the compacted data.

The dyadic distribution compression and encryption subsystem3800is responsible for the initial processing of input data3701. It analyzes the input data, creates a transformation matrix, and transforms the data into a dyadic distribution. The subsystem3800then generates a main data stream of transformed data and a secondary data stream of transformation information. Finally, it compresses the main data stream, producing compacted data3704as output.

The random access engine3900facilitates efficient searching and manipulation of the compacted data files. It receives search queries3702and write requests3703, and interacts with the compacted data3704. The engine3900organizes the reference codebook into a learnable hierarchical representation and traverses this representation to identify specific codewords. For search queries, it produces search results3705, and for write requests, it generates write results3706.

The large codeword model with latent transformer core4000processes the compressed data from subsystem3800. It uses a variational autoencoder (VAE) encoder to further compress the data into latent space vectors. These vectors are then processed by a modified transformer that learns relationships between the vectors. The processed data is then decoded through a VAE decoder to produce the final output3707.

The trainable estimator subsystem4100works in conjunction with the random access engine3900to improve search efficiency. It estimates starting bit locations in the compacted data file and refines these estimates using distinct value estimation techniques. The subsystem4100helps determine codeword boundaries and guides the traversal of the hierarchical representation.

The end to end training subsystem4200coordinates the joint training of all system components. It ensures that subsystems3800,3900,4000, and4100are trained together, allowing them to adapt to each other's behaviors and outputs. This subsystem4200optimizes performance across all components, from initial compression and encryption to final random access capabilities.

In operation, input data3701is first processed by the dyadic distribution compression and encryption subsystem3800, producing compacted data3704. This compacted data can then be efficiently searched or modified using the random access engine3900in response to search queries3702or write requests3703. The large codeword model4000and trainable estimator subsystem4100support these operations by providing advanced processing capabilities and improved search efficiency. Throughout this process, the end to end training subsystem4200continuously optimizes the performance of all components, ensuring the system adapts and improves over time.

FIG.48is a method diagram illustrating an exemplary method4800for the unified neural intelligent transformer engine, according to an embodiment. The process begins at step4801when the engine receives input data3701for processing. At step4802, the dyadic distribution compression and encryption subsystem3800analyzes the input data, creates a transformation matrix, and transforms the data into a dyadic distribution. It then generates a main data stream of transformed data and a secondary data stream of transformation information, and compresses the main data stream to produce compacted data3704. At step4803, the random access engine3900processes any search queries3702or write requests3703on the compacted data, utilizing its hierarchical representation of the codebook. At step4804, the large codeword model with latent transformer core4000further processes the compressed data, using its VAE encoder to generate latent space vectors, processing these through the modified transformer, and decoding the output via the VAE decoder. At step4805, the trainable estimator subsystem4100works in conjunction with the random access engine to provide and refine starting bit locations for efficient data access. As a last step4806, the end-to-end training subsystem4200coordinates the joint training of all components, continuously optimizing system performance by updating trainable parameters across all subsystems. The engine then outputs the processed data3707, along with any search results3705or write confirmations3706.

FIG.38is a block diagram illustrating the internal structure of the dyadic distribution compression and encryption subsystem3800. According to an embodiment, subsystem3800comprises several interconnected components: an input data analyzer3810, a transformation matrix generator3820, a dyadic distribution transformer3830, a stream generator3840, and a compression module3850.

The subsystem3800receives input data3801for compression and encryption. This input data can be of various types, including but not limited to text documents, images, audio files, video files, or time series data. The processed output of this subsystem is a compressed and encrypted data stream3851, which is then passed to other components of the system.

The input data analyzer3810is the first component to process the incoming data3801. It examines the input data to determine its properties and characteristics, such as data type, structure, and statistical properties. This analysis is crucial for optimizing the subsequent compression and encryption processes.

Based on the analysis from3810, the transformation matrix generator3820creates a transformation matrix. This matrix is designed to efficiently transform the input data into a dyadic distribution, which is more amenable to compression and encryption. The generator3820uses trainable parameters, allowing it to adapt and improve its matrix generation over time through the end to end training process.

The dyadic distribution transformer3830takes the input data and the generated transformation matrix to convert the data into a dyadic distribution. This transformation is a key step in preparing the data for efficient compression and encryption, as dyadic distributions have properties that are particularly well-suited for these processes.

After transformation, the stream generator3840creates two separate data streams: a main data stream of transformed data3841and a secondary data stream containing transformation information3842. This separation allows for more efficient compression and provides necessary context for later decompression and decryption.

Finally, the compression module3850compresses the main data stream using algorithms optimized for dyadic distributions. This module also uses trainable parameters to adapt its compression techniques based on the specific characteristics of the input data and the results of the dyadic transformation.

In operation, input data3801flows through each component of the subsystem sequentially. The input data analyzer3810first processes the data, passing its analysis to the transformation matrix generator3820. The generated matrix and the original input data are then used by the dyadic distribution transformer3830. The transformed data is passed to the stream generator3840, which creates the two separate streams. These streams are then compressed by the compression module3850, resulting in the final compressed and encrypted data stream3851.

Throughout this process, the dyadic distribution compression and encryption subsystem3800interacts with other system components, particularly the end to end training subsystem4200, which provides continuous optimization of the trainable parameters used in various stages of the compression and encryption process. This allows subsystem3800to adapt to different types of input data and improve its performance over time.

FIG.43is a method diagram illustrating an exemplary method4300for the dyadic distribution compression and encryption subsystem, according to an embodiment. The process begins at step4301when the subsystem receives input data. At step4302, the input data analyzer examines the data to determine its properties and characteristics. At step4303, the transformation matrix generator creates a transformation matrix based on the analysis from the previous step. At step4304, the dyadic distribution transformer converts the input data into a dyadic distribution using the generated transformation matrix. At step4305, the stream generator creates two separate data streams: a main data stream of transformed data and a secondary data stream containing transformation information. As a last step4306, the compression module compresses the main data stream using algorithms optimized for dyadic distributions. The compressed and encrypted data stream is then output for further processing or storage.

FIG.39is a block diagram illustrating the internal structure of the random access engine3900. According to an embodiment, the random access engine3900comprises several interconnected components: a query processor3910, a hierarchical representation generator3920, a traversal subsystem3930, and a codeword identifier3940.

The random access engine3900receives input in the form of data search queries3702and write requests3703. It interacts with the compacted data file3704and produces search results3705or write confirmations3706as output. The engine also interfaces with the trainable estimator subsystem4100to optimize its search and write operations.

The query processor3910is the first component to handle incoming requests. It parses and interprets data search queries3702and write requests3703, extracting key information such as search terms, write locations, and any provided hints or metadata. This processed information is then passed to other components of the engine for further action.

The hierarchical representation generator3920is responsible for organizing the reference codebook into a learnable hierarchical structure. This component receives the reference codebook4010and transforms it into a tree-like structure where each node represents a partial codeword, and leaf nodes correspond to complete codewords. The hierarchical structure is designed to optimize search operations and is continually refined through the end to end training process.

The traversal subsystem3930uses the hierarchical representation created by3920to efficiently navigate through the compacted data. For search queries it starts from an initial point, which may be provided by the trainable estimator subsystem4100, and moves through the hierarchy to locate the desired codeword. For write requests, it navigates to the appropriate insertion point. The traversal subsystem uses trainable parameters to optimize its path-finding strategies.

The codeword identifier3940works closely with the traversal subsystem3930. Once the traversal subsystem has located the relevant section of the hierarchical representation, the codeword identifier pinpoints the exact codeword or sequence of codewords that correspond to the search query or write request. For search operations, it retrieves the identified codewords; for write operations, it determines where new codewords should be inserted or existing ones modified.

The search results3705and write confirmations3706are sent back to the user or system component that initiated the request3941. Any modifications to the compacted data file3704are stored back in the system's data storage. The engine also provides performance data to the end to end training subsystem4200for continuous optimization

In operation, a data search query3702or write request3703is first processed by the query processor3910. The processed query information is passed to the traversal subsystem3930, which uses the hierarchical representation generated by3920to navigate through the compacted data file3704. The codeword identifier3940then pinpoints the exact codewords relevant to the query. For search queries, these codewords are retrieved and decoded to produce search results3705. For write requests, the identified location is used to modify the compacted data, and a write confirmation3706is generated.

Throughout this process, the random access engine3900interacts with other system components, particularly the trainable estimator subsystem4100, which provides initial estimates for search starting points. The engine also interfaces with the end to end training subsystem4200, which continuously optimizes the trainable parameters used in the hierarchical representation generation and traversal processes. This allows the random access engine to adapt to different types of queries and data structures, improving its performance over time.

FIG.44is a method diagram illustrating an exemplary method4400for the random access engine, according to an embodiment. The process begins at step4401when the engine receives a data search query or write request. At step4402, the query processor parses and interprets the received request. At step4403, the hierarchical representation generator organizes the reference codebook into a learnable hierarchical structure. At step4404, the traversal subsystem navigates through the hierarchical representation to locate the relevant section for the query or write request. At step4405, the codeword identifier pinpoints the exact codeword or sequence of codewords corresponding to the request. As a last step4406, for search operations, the identified codewords are retrieved and sent for decoding; for write operations, the location for inserting or modifying codewords is determined and updated.

FIG.40is a block diagram illustrating the internal structure of the large codeword model with latent transformer core4000. According to the embodiment, subsystem4000comprises several interconnected components: a codebook4010, a VAE encoder4020, a latent space representation subsystem4030, a modified transformer4040, and a VAE decoder4050.

The large codeword model4000receives input in the form of compressed data3704, which is the output from the dyadic distribution compression and encryption subsystem3800. It processes this data and produces final output data4001, which can be used for various downstream tasks or sent back to the random access engine3900for storage or further processing.

The codebook4010maintains the mapping between codewords and their corresponding data. It is used by the VAE encoder4020and VAE decoder4050for interpreting the compressed data and generating output, respectively. The codebook4010is shared with the random access engine3900to ensure consistent interpretation of codewords across the system.

The VAE encoder4020processes the incoming compressed data3704, using the codebook4010to interpret the data. It further compresses the input into a lower-dimensional latent space representation. This encoder uses a variational approach, capturing a distribution over latent space points for each input.

The latent space representation subsystem4030manages the compressed representations produced by the VAE encoder. It maintains the structure of the latent space and provides the interface between the encoder and the modified transformer. This subsystem may implement additional processing on the latent representations to facilitate performance in the transformer stage.

The modified transformer4040is the core processing unit of this subsystem. It operates directly on the latent space vectors, without embedding or positional encoding layers. It uses self-attention mechanisms to learn relationships between different parts of the latent representation. The transformer can be configured with multiple layers and attention heads to capture complex dependencies in the data.

The VAE decoder4050is the final component in the processing pipeline. It takes the output of the modified transformer and decodes it back into the original data space, using the codebook4010to ensure proper interpretation. Like the encoder, the decoder is variational, allowing it to generate outputs based on the learned latent space distribution.

The final output data4051produced by the VAE decoder4050may be returned to the random access engine3900, which can efficiently store and index the processed data for future retrieval or forwarded to other components of the larger system or to external systems for further use4052, depending on the specific application requirements. This output pathway ensures that the processed data is both stored efficiently and immediately available for any necessary downstream tasks.

In operation, compressed data3704is processed by the VAE encoder4020, which produces a latent space representation. This representation is managed by the latent space representation subsystem4030, which passes it to the modified transformer4040. The transformer processes the latent representation, learning and applying relationships between different parts of the data. The processed latent representation is then passed to the VAE decoder4050, which generates the final output data4051.

The large codeword model4000is designed to handle various types of data including text, images, audio, and time-series data. This flexibility is achieved through the use of the latent space representation, which provides a common format for different data types.

Throughout its operation, the large codeword model4000interacts with the end to end training subsystem4200, which optimizes the trainable parameters used in its components. This allows the model to adapt to different types of input data and improve its performance over time. The model also interfaces with the random access engine3900, providing processed data that can be efficiently stored and retrieved.

FIG.45is a method diagram illustrating an exemplary method4500for the large codeword model with latent transformer core, according to an embodiment. The process begins at step4501when the model receives compressed data as input. At step4502, the VAE encoder processes the incoming data, using the codebook to interpret it, and produces a latent space representation. At step4503, the latent space representation subsystem manages the compressed representations and interfaces with the modified transformer. At step4504, the modified transformer processes the latent space vectors, learning relationships between different parts of the latent representation. As a last step4505, the VAE decoder takes the output of the modified transformer and decodes it back into the original data space, producing the final output data.

FIG.41is a block diagram illustrating the internal structure of the trainable estimator subsystem4100. According to the embodiment, subsystem4100comprises several interconnected components: an initial bit location estimator4110, a distinct value estimator4120, a codeword boundary detector4130, and a hierarchical representation traversal subsystem4140.

The trainable estimator subsystem4100receives input in the form of search queries3702and write requests3703. It processes these requests to provide optimized starting points for the random access engine3900, outputting refined starting bit locations4101.

The initial bit location estimator4110is the first component to process incoming requests. For search queries3702, it uses trainable parameters to estimate an initial starting bit location in the compacted data file. For write requests3703, it estimates the location where new data should be inserted. This component leverages historical data and learned patterns to make its initial estimates.

The distinct value estimator4120performs cardinality estimation on the compressed data3704, which is the output from the dyadic distribution compression and encryption subsystem3800and is managed by the random access engine3900. It uses techniques such as HyperLogLog, min hashing, or statistical estimation to determine the number of distinct values in the dataset. This information is crucial for refining the initial bit location estimate and identifying potential codeword boundaries.

The codeword boundary detector4130works in conjunction with the distinct value estimator4120to identify likely codeword boundaries in the compacted data. It analyzes the distribution of distinct values to determine where codewords are likely to begin and end. This component uses trainable parameters to improve its boundary detection accuracy over time.

The hierarchical representation traversal subsystem4140is responsible for navigating the hierarchical representation of the codebook when the initial estimate needs refinement. If the initial bit location does not correspond to a codeword boundary, this subsystem efficiently traverses the hierarchy to locate the nearest valid codeword boundary. It uses optimized traversal strategies that adapt based on the structure of the data and historical access patterns.

In operation, the process begins when the trainable estimator subsystem4100receives either a search query3702or a write request3703from the random access engine3900. Simultaneously, it accesses the compressed data3704managed by the random access engine3900. The initial bit location estimator4110processes the search query or write request to generate an initial estimate. This estimate is then refined using information from the distinct value estimator4120, which analyzes the compressed data3704. The codeword boundary detector4130further refines this estimate based on the analysis of the compressed data and the specifics of the query or request. If necessary, the hierarchical representation traversal subsystem4140adjusts the location to ensure it corresponds to a valid codeword boundary within the compressed data3704, taking into account the requirements of the search query or write request. The final refined starting bit location4141is then output for use by the random access engine3900to fulfill the original search query or write request.

Throughout its operation, the trainable estimator subsystem4100interacts with the end to end training subsystem4200, which continuously optimizes the trainable parameters used in each component. This allows the estimator to adapt to different data structures and access patterns, improving its accuracy and efficiency over time.

The trainable estimator subsystem4100plays a crucial role in enhancing the performance of the random access engine3900by providing accurate starting points for data access operations. By leveraging statistical techniques and machine learning, it significantly reduces the search space and improves the efficiency of both read and write operations on the compacted data.

FIG.46is a method diagram illustrating an exemplary method4600for the trainable estimator subsystem, according to an embodiment. The process begins at step4601when the subsystem receives a search query or write request. At step4602, the initial bit location estimator uses trainable parameters to estimate a starting bit location in the compacted data file. At step4603, the distinct value estimator performs cardinality estimation on the compressed data to determine the number of distinct values. At step4604, the codeword boundary detector identifies likely codeword boundaries based on the distribution of distinct values. As a last step4605, if necessary, the hierarchical representation traversal subsystem navigates the hierarchy to locate the nearest valid codeword boundary, refining the initial estimate.

FIG.42is a block diagram illustrating the internal structure of the end to end training subsystem4200. According to an embodiment, subsystem4200comprises several interconnected components: a joint training coordinator4210, a performance optimizer4220, a gradient flow manager4230, and component-specific training adapters4240.

The end to end training subsystem4200interacts with all other major components of the system, including the dyadic distribution compression and encryption subsystem3800, the random access engine3900, the unified neural intelligent transformer engine4000, and the trainable estimator subsystem4100. It receives performance metrics and gradient information from these components4201and outputs optimized parameters4241.

The joint training coordinator4210orchestrates the end to end training process. It implements a multi-task learning framework that balances the objectives of different system components. This coordinator uses a dynamic weighting scheme to adjust the importance of each component's loss function during training. For example, it might increase the weight of the random access engine's loss if retrieval speed is lagging, or prioritize the transformer's loss if prediction accuracy needs improvement. The coordinator also manages a shared parameter space, identifying and updating parameters that affect multiple components to ensure cohesive optimization.

The performance optimizer4220employs a suite of analytical tools to evaluate system performance. It calculates metrics such as BLEU scores for text generation tasks, mean squared error for numerical predictions, and retrieval latency for database operations. This optimizer maintains a historical record of performance across different data types and operational scenarios. It uses statistical analysis to identify performance trends and anomalies, and employs a decision tree algorithm to determine which aspects of the system to prioritize for improvement. The optimizer also implements A/B testing to evaluate the impact of different optimization strategies.

The gradient flow manager4230utilizes advanced gradient manipulation techniques to ensure effective backpropagation across the system. It implements gradient clipping to prevent exploding gradients, and uses layer-wise adaptive rate scaling (LARS) to adjust learning rates for different layers based on their gradient statistics. This manager also employs gradient accumulation for large batch training, allowing it to simulate larger batch sizes than would fit in memory. For very deep networks, it uses gradient checkpointing to trade computation for memory, enabling training of more complex models.

The component-specific training adapters4240are a collection of specialized optimization modules. For the transformer component, the adapter implements adaptive attention span techniques to dynamically adjust the attention window. For the VAE, it uses a cyclical annealing schedule for the KL divergence term to balance reconstruction quality and latent space regularity. The adapter for the random access engine employs a custom optimization algorithm that combines elements of simulated annealing and genetic algorithms to optimize the codeword allocation strategy. Each adapter also implements its own learning rate scheduler, using techniques like cosine annealing with warm restarts to prevent convergence to suboptimal local minima.

In operation, the end to end training subsystem4200continuously monitors the performance of all system components. The joint training coordinator4210initiates training cycles, during which the performance optimizer4220analyzes system-wide metrics. Based on this analysis, the gradient flow manager4230computes and distributes gradients across the system. The component-specific training adapters4240then apply these gradients in a manner optimized for each component.

For example, when processing a batch of data, the system might identify that the random access engine3900is underperforming in retrieval speed for certain types of queries. The performance optimizer4220would flag this issue, and the joint training coordinator4210would initiate a focused training cycle. The gradient flow manager4230would ensure that relevant gradients are prominently backpropagated to the random access engine3900, while the corresponding component-specific training adapter would apply these gradients using optimization techniques tailored for the engine's architecture.

Throughout this process, the end to end training subsystem4200maintains a holistic view of the system, ensuring that improvements in one area do not come at the cost of degradation in another. It continuously adjusts its training strategies based on the evolving performance characteristics of the system and the nature of the data being processed.

The optimized parameters4241output by the end to end training subsystem4200are distributed to all other components of the system, allowing them to update their internal models and decision-making processes. This continuous optimization loop enables the unified neural intelligent transformer engine to adapt to changing data patterns and operational requirements over time, maintaining high performance across a wide range of tasks and data types.

The training subsystem4200is characterized as “end to end” due to its holistic approach to optimizing the entire unified neural intelligent transformer engine as a single, integrated system. Unlike traditional approaches that might optimize each component separately, this subsystem considers the interdependencies between all parts of the system, from the initial data input to the final output. It simultaneously trains all components of the system, including the dyadic distribution compression and encryption subsystem3800, the random access engine3900, the unified neural intelligent transformer engine4000, and the trainable estimator subsystem4100. The joint training coordinator4210ensures that improvements in one component contribute to the overall system performance, rather than optimizing locally at the expense of global efficiency. The gradient flow manager4230propagates gradients across component boundaries, allowing changes in the output to influence even the earliest stages of data processing. Performance metrics are calculated based on the system's end-to-end performance on tasks, rather than on the individual performance of each component. The component-specific training adapters4240are designed to work in concert, ensuring that optimizations in one part of the system are compatible with and beneficial to other parts.

This end-to-end approach allows the system to discover and exploit synergies between components that might not be apparent when training each part in isolation, leading to superior overall performance and adaptability.

FIG.47is a method diagram illustrating an exemplary method4700for the end-to-end training subsystem, according to an embodiment. The process begins at step4701when the subsystem receives performance metrics and gradient information from other major components (3800,3900,4000,4100). At step4702, the joint training coordinator orchestrates the training process, implementing a multi-task learning framework. At step4703, the performance optimizer calculates system-wide metrics and identifies performance trends and anomalies. At step4704, the gradient flow manager computes and distributes gradients across the system. At step4705, the component-specific training adapters apply these gradients in a manner optimized for each component. As a last step4706, the optimized parameters are output and distributed to all other components of the system, allowing them to update their internal models and decision-making processes.

Description of Method Aspects

Since the library consists of re-usable building sourceblocks, and the actual data is represented by reference codes to the library, the total storage space of a single set of data would be much smaller than conventional methods, wherein the data is stored in its entirety. The more data sets that are stored, the larger the library becomes, and the more data can be stored in reference code form.

As an analogy, imagine each data set as a collection of printed books that are only occasionally accessed. The amount of physical shelf space required to store many collections would be quite large, and is analogous to conventional methods of storing every single bit of data in every data set. Consider, however, storing all common elements within and across books in a single library, and storing the books as references codes to those common elements in that library. As a single book is added to the library, it will contain many repetitions of words and phrases. Instead of storing the whole words and phrases, they are added to a library, and given a reference code, and stored as reference codes. At this scale, some space savings may be achieved, but the reference codes will be on the order of the same size as the words themselves. As more books are added to the library, larger phrases, quotations, and other words patterns will become common among the books. The larger the word patterns, the smaller the reference codes will be in relation to them as not all possible word patterns will be used. As entire collections of books are added to the library, sentences, paragraphs, pages, or even whole books will become repetitive. There may be many duplicates of books within a collection and across multiple collections, many references and quotations from one book to another, and much common phraseology within books on particular subjects. If each unique page of a book is stored only once in a common library and given a reference code, then a book of 1,000 pages or more could be stored on a few printed pages as a string of codes referencing the proper full-sized pages in the common library. The physical space taken up by the books would be dramatically reduced. The more collections that are added, the greater the likelihood that phrases, paragraphs, pages, or entire books will already be in the library, and the more information in each collection of books can be stored in reference form. Accessing entire collections of books is then limited not by physical shelf space, but by the ability to reprint and recycle the books as needed for use.

The projected increase in storage capacity using the method herein described is primarily dependent on two factors: 1) the ratio of the number of bits in a block to the number of bits in the reference code, and 2) the amount of repetition in data being stored by the system.

With respect to the first factor, the number of bits used in the reference codes to the sourceblocks must be smaller than the number of bits in the sourceblocks themselves in order for any additional data storage capacity to be obtained. As a simple example, 16-bit sourceblocks would require 216, or 65536, unique reference codes to represent all possible patterns of bits. If all possible 65536 blocks patterns are utilized, then the reference code itself would also need to contain sixteen bits in order to refer to all possible 65,536 blocks patterns. In such case, there would be no storage savings. However, if only 16 of those block patterns are utilized, the reference code can be reduced to 4 bits in size, representing an effective compression of 4 times (16 bits/4 bits=4) versus conventional storage. Using a typical block size of 512 bytes, or 4,096 bits, the number of possible block patterns is 24,096, which for all practical purposes is unlimited. A typical hard drive contains one terabyte (TB) of physical storage capacity, which represents 1,953,125,000, or roughly 231, 512 byte blocks. Assuming that 1 TB of unique 512-byte sourceblocks were contained in the library, and that the reference code would thus need to be 31 bits long, the effective compression ratio for stored data would be on the order of 132 times (4,096/31≈132) that of conventional storage.

With respect to the second factor, in most cases it could be assumed that there would be sufficient repetition within a data set such that, when the data set is broken down into sourceblocks, its size within the library would be smaller than the original data. However, it is conceivable that the initial copy of a data set could require somewhat more storage space than the data stored in a conventional manner, if all or nearly all sourceblocks in that set were unique. For example, assuming that the reference codes are 1/10th the size of a full-sized copy, the first copy stored as sourceblocks in the library would need to be 1.1 megabytes (MB), (1 MB for the complete set of full-sized sourceblocks in the library and 0.1 MB for the reference codes). However, since the sourceblocks stored in the library are universal, the more duplicate copies of something you save, the greater efficiency versus conventional storage methods. Conventionally, storing 10 copies of the same data requires 10 times the storage space of a single copy. For example, ten copies of a 1 MB file would take up 10 MB of storage space. However, using the method described herein, only a single full-sized copy is stored, and subsequent copies are stored as reference codes. Each additional copy takes up only a fraction of the space of the full-sized copy. For example, again assuming that the reference codes are 1/10th the size of the full-size copy, ten copies of a 1 MB file would take up only 2 MB of space (1 MB for the full-sized copy, and 0.1 MB each for ten sets of reference codes). The larger the library, the more likely that part or all of incoming data will duplicate sourceblocks already existing in the library.

The size of the library could be reduced in a manner similar to storage of data. Where sourceblocks differ from each other only by a certain number of bits, instead of storing a new sourceblock that is very similar to one already existing in the library, the new sourceblock could be represented as a reference code to the existing sourceblock, plus information about which bits in the new block differ from the existing block. For example, in the case where 512 byte sourceblocks are being used, if the system receives a new sourceblock that differs by only one bit from a sourceblock already existing in the library, instead of storing a new 512 byte sourceblock, the new sourceblock could be stored as a reference code to the existing sourceblock, plus a reference to the bit that differs. Storing the new sourceblock as a reference code plus changes would require only a few bytes of physical storage space versus the 512 bytes that a full sourceblock would require. The algorithm could be optimized to store new sourceblocks in this reference code plus changes form unless the changes portion is large enough that it is more efficient to store a new, full sourceblock.

It will be understood by one skilled in the art that transfer and synchronization of data would be increased to the same extent as for storage. By transferring or synchronizing reference codes instead of full-sized data, the bandwidth requirements for both types of operations are dramatically reduced.

In addition, the method described herein is inherently a form of encryption. When the data is converted from its full form to reference codes, none of the original data is contained in the reference codes. Without access to the library of sourceblocks, it would be impossible to reconstruct any portion of the data from the reference codes. This inherent property of the method described herein could obviate the need for traditional encryption algorithms, thereby offsetting most or all of the computational cost of conversion of data back and forth to reference codes. In theory, the method described herein should not utilize any additional computing power beyond traditional storage using encryption algorithms. Alternatively, the method described herein could be in addition to other encryption algorithms to increase data security even further.

In other embodiments, additional security features could be added, such as: creating a proprietary library of sourceblocks for proprietary networks, physical separation of the reference codes from the library of sourceblocks, storage of the library of sourceblocks on a removable device to enable easy physical separation of the library and reference codes from any network, and incorporation of proprietary sequences of how sourceblocks are read and the data reassembled.

FIG.7is a diagram showing an example of how data might be converted into reference codes using an aspect of an embodiment700. As data is received701, it is read by the processor in sourceblocks of a size dynamically determined by the previously disclosed sourceblock size optimizer410. In this example, each sourceblock is 16 bits in length, and the library702initially contains three sourceblocks with reference codes 00, 01, and 10. The entry for reference code 11 is initially empty. As each 16 bit sourceblock is received, it is compared with the library. If that sourceblock is already contained in the library, it is assigned the corresponding reference code. So, for example, as the first line of data (0000 0011 0000 0000) is received, it is assigned the reference code (01) associated with that sourceblock in the library. If that sourceblock is not already contained in the library, as is the case with the third line of data (0000 1111 0000 0000) received in the example, that sourceblock is added to the library and assigned a reference code, in this case 11. The data is thus converted703to a series of reference codes to sourceblocks in the library. The data is stored as a collection of codewords, each of which contains the reference code to a sourceblock and information about the location of the sourceblocks in the data set. Reconstructing the data is performed by reversing the process. Each stored reference code in a data collection is compared with the reference codes in the library, the corresponding sourceblock is read from the library, and the data is reconstructed into its original form.

FIG.8is a method diagram showing the steps involved in using an embodiment800to store data. As data is received801, it would be deconstructed into sourceblocks802, and passed803to the library management module for processing. Reference codes would be received back804from the library management module, and could be combined with location information to create codewords805, which would then be stored806as representations of the original data.

FIG.9is a method diagram showing the steps involved in using an embodiment900to retrieve data. When a request for data is received901, the associated codewords would be retrieved902from the library. The codewords would be passed903to the library management module, and the associated sourceblocks would be received back904. Upon receipt, the sourceblocks would be assembled905into the original data using the location data contained in the codewords, and the reconstructed data would be sent out906to the requestor.

FIG.10is a method diagram showing the steps involved in using an embodiment1000to encode data. As sourceblocks are received1001from the deconstruction engine, they would be compared1002with the sourceblocks already contained in the library. If that sourceblock already exists in the library, the associated reference code would be returned1005to the deconstruction engine. If the sourceblock does not already exist in the library, a new reference code would be created1003for the sourceblock. The new reference code and its associated sourceblock would be stored1004in the library, and the reference code would be returned to the deconstruction engine.

FIG.11is a method diagram showing the steps involved in using an embodiment1100to decode data. As reference codes are received1101from the reconstruction engine, the associated sourceblocks are retrieved1102from the library, and returned1103to the reconstruction engine.

FIG.16is a method diagram illustrating key system functionality utilizing an encoder and decoder pair, according to a preferred embodiment. In a first step1601, at least one incoming data set may be received at a customized library generator1300that then1602processes data to produce a customized word library1201comprising key-value pairs of data words (each comprising a string of bits) and their corresponding calculated binary Huffman codewords. A subsequent dataset may be received, and compared to the word library1603to determine the proper codewords to use in order to encode the dataset. Words in the dataset are checked against the word library and appropriate encodings are appended to a data stream1604. If a word is mismatched within the word library and the dataset, meaning that it is present in the dataset but not the word library, then a mismatched code is appended, followed by the unencoded original word. If a word has a match within the word library, then the appropriate codeword in the word library is appended to the data stream. Such a data stream may then be stored or transmitted1605to a destination as desired. For the purposes of decoding, an already-encoded data stream may be received and compared1606, and un-encoded words may be appended to a new data stream1607depending on word matches found between the encoded data stream and the word library that is present. A matching codeword that is found in a word library is replaced with the matching word and appended to a data stream, and a mismatch code found in a data stream is deleted and the following unencoded word is re-appended to a new data stream, the inverse of the process of encoding described earlier. Such a data stream may then be stored or transmitted1608as desired.

FIG.17is a method diagram illustrating possible use of a hybrid encoder/decoder to improve the compression ratio, according to a preferred aspect. A second Huffman binary tree may be created1701, having a shorter maximum length of codewords than a first Huffman binary tree1602, allowing a word library to be filled with every combination of codeword possible in this shorter Huffman binary tree1702. A word library may be filled with these Huffman codewords and words from a dataset1702, such that a hybrid encoder/decoder1304,1503may receive any mismatched words from a dataset for which encoding has been attempted with a first Huffman binary tree1703,1604and parse previously mismatched words into new partial codewords (that is, codewords that are each a substring of an original mismatched codeword) using the second Huffman binary tree1704. In this way, an incomplete word library may be supplemented by a second word library. New codewords attained in this way may then be returned to a transmission encoder1705,1500. In the event that an encoded dataset is received for decoding, and there is a mismatch code indicating that additional coding is needed, a mismatch code may be removed and the unencoded word used to generate a new codeword as before1706, so that a transmission encoder1500may have the word and newly generated codeword added to its word library1707, to prevent further mismatching and errors in encoding and decoding.

It will be recognized by a person skilled in the art that the methods described herein can be applied to data in any form. For example, the method described herein could be used to store genetic data, which has four data units: C, G, A, and T. Those four data units can be represented as 2 bit sequences: 00, 01, 10, and 11, which can be processed and stored using the method described herein.

It will be recognized by a person skilled in the art that certain embodiments of the methods described herein may have uses other than data storage. For example, because the data is stored in reference code form, it cannot be reconstructed without the availability of the library of sourceblocks. This is effectively a form of encryption, which could be used for cyber security purposes. As another example, an embodiment of the method described herein could be used to store backup copies of data, provide for redundancy in the event of server failure, or provide additional security against cyberattacks by distributing multiple partial copies of the library among computers are various locations, ensuring that at least two copies of each sourceblock exist in different locations within the network.

FIG.18is a flow diagram illustrating the use of a data encoding system used to recursively encode data to further reduce data size. Data may be input1805into a data deconstruction engine102to be deconstructed into code references, using a library of code references based on the input1810. Such example data is shown in a converted, encoded format1815, highly compressed, reducing the example data from 96 bits of data to 12 bits of data, before sending this newly encoded data through the process again1820, to be encoded by a second library1825, reducing it even further. The newly converted data1830is shown as only 6 bits in this example, thus a size of 6.25% of the original data packet. With recursive encoding, then, it is possible and implemented in the system to achieve increasing compression ratios, using multi-layered encoding, through recursively encoding data. Both initial encoding libraries1810and subsequent libraries1825may be achieved through machine learning techniques to find optimal encoding patterns to reduce size, with the libraries being distributed to recipients prior to transfer of the actual encoded data, such that only the compressed data1830must be transferred or stored, allowing for smaller data footprints and bandwidth requirements. This process can be reversed to reconstruct the data. While this example shows only two levels of encoding, recursive encoding may be repeated any number of times. The number of levels of recursive encoding will depend on many factors, a non-exhaustive list of which includes the type of data being encoded, the size of the original data, the intended usage of the data, the number of instances of data being stored, and available storage space for codebooks and libraries. Additionally, recursive encoding can be applied not only to data to be stored or transmitted, but also to the codebooks and/or libraries, themselves. For example, many installations of different libraries could take up a substantial amount of storage space. Recursively encoding those different libraries to a single, universal library would dramatically reduce the amount of storage space required, and each different library could be reconstructed as necessary to reconstruct incoming streams of data.

FIG.20is a flow diagram of an exemplary method used to detect anomalies in received encoded data and producing a warning. A system may have trained encoding libraries2010, before data is received from some source such as a network connected device or a locally connected device including USB connected devices, to be decoded2020. Decoding in this context refers to the process of using the encoding libraries to take the received data and attempt to use encoded references to decode the data into its original source2030, potentially more than once if recursive encoding was used, but not necessarily more than once. An anomaly detector1910may be configured to detect a large amount of un-encoded data2040in the midst of encoded data, by locating data or references that do not appear in the encoding libraries, indicating at least an anomaly, and potentially data tampering or faulty encoding libraries. A flag or warning is set by the system2050, allowing a user to be warned at least of the presence of the anomaly and the characteristics of the anomaly. However, if a large number of invalid references or unencoded data are not present in the encoded data that is attempting to be decoded, the data may be decoded and output as normal2060, indicating no anomaly has been detected.

FIG.21is a flow diagram of a method used for Distributed Denial of Service (DDoS) attack denial. A system may have trained encoding libraries2110, before data is received from some source such as a network connected device or a locally connected device including USB connected devices, to be decoded2120. Decoding in this context refers to the process of using the encoding libraries to take the received data and attempt to use encoded references to decode the data into its original source2130, potentially more than once if recursive encoding was used, but not necessarily more than once. A DDoS detector1920may be configured to detect a large amount of repeating data2140in the encoded data, by locating data or references that repeat many times over (the number of which can be configured by a user or administrator as need be), indicating a possible DDoS attack. A flag or warning is set by the system2150, allowing a user to be warned at least of the presence of a possible DDoS attack, including characteristics about the data and source that initiated the flag, allowing a user to then block incoming data from that source. However, if a large amount of repeat data in a short span of time is not detected, the data may be decoded and output as normal2160, indicating no DDoS attack has been detected.

FIG.23is a flow diagram of an exemplary method used to enable high-speed data mining of repetitive data. A system may have trained encoding libraries2310, before data is received from some source such as a network connected device or a locally connected device including USB connected devices, to be analyzed2320and decoded2330. When determining data for analysis, users may select specific data to designate for decoding2330, before running any data mining or analytics functions or software on the decoded data2340. Rather than having traditional decryption and decompression operate over distributed drives, data can be regenerated immediately using the encoding libraries disclosed herein, as it is being searched. Using methods described inFIG.9andFIG.11, data can be stored, retrieved, and decoded swiftly for searching, even across multiple devices, because the encoding library may be on each device. For example, if a group of servers host codewords relevant for data mining purposes, a single computer can request these codewords, and the codewords can be sent to the recipient swiftly over the bandwidth of their connection, allowing the recipient to locally decode the data for immediate evaluation and searching, rather than running slow, traditional decompression algorithms on data stored across multiple devices or transfer larger sums of data across limited bandwidth.

FIG.25is a flow diagram of an exemplary method used to encode and transfer software and firmware updates to a device for installation, for the purposes of reduced bandwidth consumption. A first system may have trained code libraries or “codebooks” present2510, allowing for a software update of some manner to be encoded2520. Such a software update may be a firmware update, operating system update, security patch, application patch or upgrade, or any other type of software update, patch, modification, or upgrade, affecting any computer system. A codebook for the patch must be distributed to a recipient2530, which may be done beforehand and either over a network or through a local or physical connection, but must be accomplished at some point in the process before the update may be installed on the recipient device2560. An update may then be distributed to a recipient device2540, allowing a recipient with a codebook distributed to them2530to decode the update2550before installation2560. In this way, an encoded and thus heavily compressed update may be sent to a recipient far quicker and with less bandwidth usage than traditional lossless compression methods for data, or when sending data in uncompressed formats. This especially may benefit large distributions of software and software updates, as with enterprises updating large numbers of devices at once.

FIG.27is a flow diagram of an exemplary method used to encode new software and operating system installations for reduced bandwidth required for transference. A first system may have trained code libraries or “codebooks” present2710, allowing for a software installation of some manner to be encoded2720. Such a software installation may be a software update, operating system, security system, application, or any other type of software installation, execution, or acquisition, affecting a computer system. An encoding library or “codebook” for the installation must be distributed to a recipient2730, which may be done beforehand and either over a network or through a local or physical connection, but must be accomplished at some point in the process before the installation can begin on the recipient device2760. An installation may then be distributed to a recipient device2740, allowing a recipient with a codebook distributed to them2730to decode the installation2750before executing the installation2760. In this way, an encoded and thus heavily compressed software installation may be sent to a recipient far quicker and with less bandwidth usage than traditional lossless compression methods for data, or when sending data in uncompressed formats. This especially may benefit large distributions of software and software updates, as with enterprises updating large numbers of devices at once.

FIG.30is a flow diagram of an exemplary method used to search and read data from a compacted data file. For the purposes of this example drawing only, the original file is an ASCII (text) file, however, it should be understood that this method is applicable across a broad range of data types and formats. A data search query comprising a byte range or search string to be searched for and read, a compacted file to be read from, and an optional location hint from which to begin the search3001is received by the system. The data search query is parsed and both the compacted data file and its corresponding codebook is retrieved3002. If a location hint was provided in the data read query, then an estimated location within the compacted version is generated using the location hint3003. The location hint may include, but is not limited to a single byte location, a guess such as “start at the 60% mark”, and a search operator such (e.g., “near”, “not”, etc.). The next step begins to search for the byte range/search word at the estimated location by scanning the compacted version for the byte range/search string reference codes3004. This step may find the starting bit location that corresponds with the beginning of the search term (i.e., byte range, search string) and retrieve a plurality of bits beginning with the starting bit, the plurality of bits represent the compacted version of the search term. The search may be done via a binary search starting from the estimated location. The search step may further involve in generating at least one or more possible sets of encodings for the search string, creating a search pair by concatenating encodings from the same set, and then searching for the search pair within the compacted data file. Once the byte range/search string has been located, its reference codes are sent to a deconstruction engine to transform the compacted data into its original form3005. The transformed data is returned to the user as read data3006. The user may then verify that the returned data is correct and can begin a new query process3007.

FIG.31is a flow diagram of an exemplary method used to write data to a compacted data file. The process begins when a data write query is received by the system, the data write query may be comprised of a write term (data to write) and an identified compacted data file that the write term is to be inserted into3101. Then, the identified compacted data file and the codebook corresponding to the compacted data file is retrieved3102. Next, the length of the write term to be inserted is checked and compared against the length of the sourceblock. If the data is the same size as the sourceblock then it can simply be encoded3103and stored within the codebook corresponding to the compacted data file3104. If the data is not the same size as the sourceblock, then the system may generate an opcode or use bit-wise encoding to create a secondary encoding3105. Writing a data file that is larger than the sourceblock can modify the output of codewords globally. To counter this, an opcode may be generated that accounts for the newly inserted data. The opcode can alert the decoder to apply an offset when decoding, thus accounting for the insertion of data into the original data file. In another embodiment, instead of using an opcode, unused bits in the codebook are used to indicate a secondary encoding. A secondary encoding indicates that data was inserted into a file, and that at the next location there are two or more possible encodings. If such a bit is encountered it means there is a secondary encoding coming up, and the encoder can switch to secondary encoding, encode one fewer byte, and then resume encoding as before. In this way there is no need to apply an offset, just use existing extra bits to create secondary encodings which prevents having to re-encode the entire original file including the inserted data. The generated opcode or the encoded bits are stored within the codebook corresponding to the compacted data file3106. A confirmation of a successful data write process is sent to the end user3107.

FIG.32is a diagram showing an example of how data might be converted into reference codes, how the converted data randomly accessed may result in incorrect output, and how correct data may be located, according to an embodiment3200. As data is received3205, it is read by the processor in sourceblocks of a size dynamically determined by the previously disclosed sourceblock size optimizer410. In this example, each sourceblock is 16 bits in length, and the codebook3210initially contains three sourceblocks with codewords 00, 01, and 10. The entry for codeword 11 is initially empty. As each 16 bit sourceblock is received, it is compared with the codebook. If that sourceblock is already contained in the codebook, it is assigned the corresponding codeword. So, for example, as the first line of data (0000 0011 0000 0000) is received, it is assigned the codeword (01) associated with that sourceblock in the codebook. If that sourceblock is not already contained in the codebook, as is the case with the third line of data (0000 1111 0000 0000) received in the example, that sourceblock is added to the codebook and assigned a codeword, in this case 11. The data is thus converted3215to a series of codewords to sourceblocks in the codebook. The data is stored as a collection of codewords, each of which contains the codeword to a sourceblock and information about the location of the sourceblocks in the data set. Reconstructing the data is performed by reversing the process. Each stored codeword in a data collection is compared with the codewords in the codebook, the corresponding sourceblock is read from the codebook, and the data is reconstructed into its original form.

A data search query specifying a search term to read from the original data set. In this example, the selected search term captures to the first four lines of the data as received3205. The system estimates a bit location N′ in the converted data set that corresponds to byte N in the original data set. The estimated location, bit N′, may not be aligned with a codeword boundary3220. In this example, the first codeword that should be accessed and returned is supposed to be 01, but the estimate N′ location puts the pointer at the last bit in the codeword3220. When N′ is not aligned with a codeword boundary, the system will start decoding in the middle of a codeword, resulting in returned data3225that when decoded leads to incorrect output3230. Due to the boundary misalignment, the random access data returned is 10 01 11 01 3225, when the correct random access data returned should have been 01 00 11 10. The user that submits the data search query will receive the incorrect output and recognize it as garbage output. The user can manually bit scroll3235forward and backward from N′ until a codeword boundary is found and the expected output3240corresponding to the search term is returned.

In another embodiment, mile markers are stored in a file accompanying the compacted data set with a list of exact locations N′ in the compacted data set that correspond to N=100, 200, 1000, etc. The mile marker file enables more refined estimates of N′ with less seeking necessary as now the user may seek forwards and backwards in the compacted data set in codeword increments and boundary alignment is automatic. These mile markers (i.e., locations) might denote which bit corresponds to the 1000thbyte from the unencoded data, which bit corresponds to the 2000thbyte, etc. The use of mile markers prevents the possibility of starting the data read process in the middle of codeword as any search may begin at the nearest mile marker bit associated with byte N.

FIG.33is a diagram showing an exemplary process of parsing a search term using multiple encodings, according to an embodiment. In this example, the search term is a search string. The original data file was divided into sourceblocks, and the size of these sourceblocks are referred to as the sourceblock length. A search string may be reasonably long compared to the sourceblock length, such as two or three times the sourceblock length. There may be multiple possible encodings of the search string that occur, because the sourceblock might not be aligned to a boundary of the search string. For example, the if the search string was “AtomBeam”3301and the sourceblock length is three bytes, there may be three separate encodings3300,3310,3320of the search string. The first encoding3300of the search string may be “Ato”3302, “mBe”3303, and “amx”3304where “x” is something that is not relevant to the search string. The second encoding3310may be “tom”3311, “Bea”3312, and “mxy”3313where “x” and “y” are not relevant to the search string. The third3320encoding may be “omB”3321, “cam”3322, and “xyz”3323where “xyz” is not relevant to the search string. The data search engine2940may generate the encoding for each search string using the codebook corresponding to the compacted data file to assign a codeword to each sourceblock.

The compacted data file may then be searched for occurrences of the assigned codeword(s). For example, the “Ato”3302and “mBe”3303sourceblocks may each be encoded with codewords C13305and C23306respectively. These sourceblocks3302,3303were selected because they both contain only data that is part of the search string3301and do not contain non relevant data (e.g., “x”, “xy” “xyz” from preceding paragraph). The assigned codewords may be concatenated to form a codeword double (pair) CIC23307and then the search engine2940may perform a search for codeword pair CIC23307in the compacted data. This process is done for each of the possible encodings3300,3310,3320of the search string3301.

From encoding two 3310 sourceblocks containing “tom”3311and “Bea”3312are assigned a codeword such as C33314and C43315. These codewords may be concatenated to form a codeword pair C3C43316and then the search engine2940may perform a search for the codeword pair CIC23316in the compacted data file. Likewise, from encoding three 3320 sourceblocks containing “omB”3321and “cam”3322are assigned a codeword such as C53324and C63325. These codewords may be concatenated to form a codeword pair C5C63326and then the search engine2940may perform a search for the codeword pair C5C63326in the compacted data file. Each of the codeword pairs C1C23307, C3C43316, and C5C63326form three new search strings and the data search engine2940may scan through the compacted data file looking for all three of them. If any of them are found, then the codewords in the compacted data file to the left and right of the found codeword pair may be decoded to identify if the correct letter (byte) is preceding or following the codeword pair. In this example, two source blocks were used to create a codeword pair, however, it should be appreciated that number of sourceblocks concatenated is dependent upon the length of the search term and the sourceblock length. There may be codeword triples, codeword quadruples, etc., as any codeword n-tuple may be possible due to the above mentioned dependencies.

For example, if the search results return “tomBea” that means an occurrence of codeword pair C3C43316was found. The search engine2940may decode one letter to the left side and check if it is “A” and one letter to the right to check if is “m”. If those are the letters found the search string has been located, if not then it is not the correct string and the scan continues through the compacted data file until another occurrence of any one of the codeword pairs3307,3316, or3326is found. The data search engine2940performs this process automatically until the search string has been located or the entire compacted data file has been scanned and searched.

Exemplary Computing Environment

FIG.37illustrates an exemplary computing environment on which an embodiment described herein may be implemented, in full or in part. This exemplary computing environment describes computer-related components and processes supporting enabling disclosure of computer-implemented embodiments. Inclusion in this exemplary computing environment of well-known processes and computer components, if any, is not a suggestion or admission that any embodiment is no more than an aggregation of such processes or components. Rather, implementation of an embodiment using processes and components described in this exemplary computing environment will involve programming or configuration of such processes and components resulting in a machine specially programmed or configured for such implementation. The exemplary computing environment described herein is only one example of such an environment and other configurations of the components and processes are possible, including other relationships between and among components, and/or absence of some processes or components described. Further, the exemplary computing environment described herein is not intended to suggest any limitation as to the scope of use or functionality of any embodiment implemented, in whole or in part, on components or processes described herein.

The exemplary computing environment described herein comprises a computing device10(further comprising a system bus11, one or more processors20, a system memory30, one or more interfaces40, one or more non-volatile data storage devices50), external peripherals and accessories60, external communication devices70, remote computing devices80, and cloud-based services90.

System bus11couples the various system components, coordinating operation of and data transmission between, those various system components. System bus11represents one or more of any type or combination of types of wired or wireless bus structures including, but not limited to, memory busses or memory controllers, point-to-point connections, switching fabrics, peripheral busses, accelerated graphics ports, and local busses using any of a variety of bus architectures. By way of example, such architectures include, but are not limited to, Industry Standard Architecture (ISA) busses, Micro Channel Architecture (MCA) busses, Enhanced ISA (EISA) busses, Video Electronics Standards Association (VESA) local busses, a Peripheral Component Interconnects (PCI) busses also known as a Mezzanine busses, or any selection of, or combination of, such busses. Depending on the specific physical implementation, one or more of the processors20, system memory30and other components of the computing device10can be physically co-located or integrated into a single physical component, such as on a single chip. In such a case, some or all of system bus11can be electrical pathways within a single chip structure.

Computing device may further comprise externally-accessible data input and storage devices12such as compact disc read-only memory (CD-ROM) drives, digital versatile discs (DVD), or other optical disc storage for reading and/or writing optical discs62; magnetic cassettes, magnetic tape, magnetic disk storage, or other magnetic storage devices; or any other medium which can be used to store the desired content and which can be accessed by the computing device10. Computing device may further comprise externally-accessible data ports or connections12such as serial ports, parallel ports, universal serial bus (USB) ports, and infrared ports and/or transmitter/receivers. Computing device may further comprise hardware for wireless communication with external devices such as IEEE 1394 (“Firewire”) interfaces, IEEE 802.11 wireless interfaces, BLUETOOTH® wireless interfaces, and so forth. Such ports and interfaces may be used to connect any number of external peripherals and accessories60such as visual displays, monitors, and touch-sensitive screens61, USB solid state memory data storage drives (commonly known as “flash drives” or “thumb drives”)63, printers64, pointers and manipulators such as mice65, keyboards66, and other devices67such as joysticks and gaming pads, touchpads, additional displays and monitors, and external hard drives (whether solid state or disc-based), microphones, speakers, cameras, and optical scanners.

Processors20are logic circuitry capable of receiving programming instructions and processing (or executing) those instructions to perform computer operations such as retrieving data, storing data, and performing mathematical calculations. Processors20are not limited by the materials from which they are formed or the processing mechanisms employed therein, but are typically comprised of semiconductor materials into which many transistors are formed together into logic gates on a chip (i.e., an integrated circuit or IC). The term processor includes any device capable of receiving and processing instructions including, but not limited to, processors operating on the basis of quantum computing, optical computing, mechanical computing (e.g., using nanotechnology entities to transfer data), and so forth. Depending on configuration, computing device10may comprise more than one processor. For example, computing device10may comprise one or more central processing units (CPUs)21, each of which itself has multiple processors or multiple processing cores, each capable of independently or semi-independently processing programming instructions. Further, computing device10may comprise one or more specialized processors such as a graphics processing unit (GPU)22configured to accelerate processing of computer graphics and images via a large array of specialized processing cores arranged in parallel.

System memory30is processor-accessible data storage in the form of volatile and/or nonvolatile memory. System memory30may be either or both of two types: non-volatile memory and volatile memory. Non-volatile memory30ais not erased when power to the memory is removed, and includes memory types such as read only memory (ROM), electronically-erasable programmable memory (EEPROM), and rewritable solid state memory (commonly known as “flash memory”). Non-volatile memory30ais typically used for long-term storage of a basic input/output system (BIOS)31, containing the basic instructions, typically loaded during computer startup, for transfer of information between components within computing device, or a unified extensible firmware interface (UEFI), which is a modern replacement for BIOS that supports larger hard drives, faster boot times, more security features, and provides native support for graphics and mouse cursors. Non-volatile memory30amay also be used to store firmware comprising a complete operating system35and applications36for operating computer-controlled devices. The firmware approach is often used for purpose-specific computer-controlled devices such as appliances and Internet-of-Things (IoT) devices where processing power and data storage space is limited. Volatile memory30bis erased when power to the memory is removed and is typically used for short-term storage of data for processing. Volatile memory30bincludes memory types such as random access memory (RAM), and is normally the primary operating memory into which the operating system35, applications36, program modules37, and application data38are loaded for execution by processors20. Volatile memory30bis generally faster than non-volatile memory30adue to its electrical characteristics and is directly accessible to processors20for processing of instructions and data storage and retrieval. Volatile memory30bmay comprise one or more smaller cache memories which operate at a higher clock speed and are typically placed on the same IC as the processors to improve performance.

Interfaces40may include, but are not limited to, storage media interfaces41, network interfaces42, display interfaces43, and input/output interfaces44. Storage media interface41provides the necessary hardware interface for loading data from non-volatile data storage devices50into system memory30and storage data from system memory30to non-volatile data storage device50. Network interface42provides the necessary hardware interface for computing device10to communicate with remote computing devices80and cloud-based services90via one or more external communication devices70. Display interface43allows for connection of displays61, monitors, touchscreens, and other visual input/output devices. Display interface43may include a graphics card for processing graphics-intensive calculations and for handling demanding display requirements. Typically, a graphics card includes a graphics processing unit (GPU) and video RAM (VRAM) to accelerate display of graphics. One or more input/output (I/O) interfaces44provide the necessary support for communications between computing device10and any external peripherals and accessories60. For wireless communications, the necessary radio-frequency hardware and firmware may be connected to I/O interface44or may be integrated into I/O interface44.

Non-volatile data storage devices50are typically used for long-term storage of data. Data on non-volatile data storage devices50is not erased when power to the non-volatile data storage devices50is removed. Non-volatile data storage devices50may be implemented using any technology for non-volatile storage of content including, but not limited to, CD-ROM drives, digital versatile discs (DVD), or other optical disc storage; magnetic cassettes, magnetic tape, magnetic disc storage, or other magnetic storage devices; solid state memory technologies such as EEPROM or flash memory; or other memory technology or any other medium which can be used to store data without requiring power to retain the data after it is written. Non-volatile data storage devices50may be non-removable from computing device10as in the case of internal hard drives, removable from computing device10as in the case of external USB hard drives, or a combination thereof, but computing device will typically comprise one or more internal, non-removable hard drives using either magnetic disc or solid state memory technology. Non-volatile data storage devices50may store any type of data including, but not limited to, an operating system51for providing low-level and mid-level functionality of computing device10, applications52for providing high-level functionality of computing device10, program modules53such as containerized programs or applications, or other modular content or modular programming, application data54, and databases55such as relational databases, non-relational databases, and graph databases.

Applications (also known as computer software or software applications) are sets of programming instructions designed to perform specific tasks or provide specific functionality on a computer or other computing devices. Applications are typically written in high-level programming languages such as C++, Java, and Python, which are then either interpreted at runtime or compiled into low-level, binary, processor-executable instructions operable on processors20. Applications may be containerized so that they can be run on any computer hardware running any known operating system. Containerization of computer software is a method of packaging and deploying applications along with their operating system dependencies into self-contained, isolated units known as containers. Containers provide a lightweight and consistent runtime environment that allows applications to run reliably across different computing environments, such as development, testing, and production systems.

The memories and non-volatile data storage devices described herein do not include communication media. Communication media are means of transmission of information such as modulated electromagnetic waves or modulated data signals configured to transmit, not store, information. By way of example, and not limitation, communication media includes wired communications such as sound signals transmitted to a speaker via a speaker wire, and wireless communications such as acoustic waves, radio frequency (RF) transmissions, infrared emissions, and other wireless media.

External communication devices70are devices that facilitate communications between computing device and either remote computing devices80, or cloud-based services90, or both. External communication devices70include, but are not limited to, data modems71which facilitate data transmission between computing device and the Internet75via a common carrier such as a telephone company or internet service provider (ISP), routers72which facilitate data transmission between computing device and other devices, and switches73which provide direct data communications between devices on a network. Here, modem71is shown connecting computing device10to both remote computing devices80and cloud-based services90via the Internet75. While modem71, router72, and switch73are shown here as being connected to network interface42, many different network configurations using external communication devices70are possible. Using external communication devices70, networks may be configured as local area networks (LANs) for a single location, building, or campus, wide area networks (WANs) comprising data networks that extend over a larger geographical area, and virtual private networks (VPNs) which can be of any size but connect computers via encrypted communications over public networks such as the Internet75. As just one exemplary network configuration, network interface42may be connected to switch73which is connected to router72which is connected to modem71which provides access for computing device10to the Internet75. Further, any combination of wired77or wireless76communications between and among computing device10, external communication devices70, remote computing devices80, and cloud-based services90may be used. Remote computing devices80, for example, may communicate with computing device through a variety of communication channels74such as through switch73via a wired77connection, through router72via a wireless connection76, or through modem71via the Internet75. Furthermore, while not shown here, other hardware that is specifically designed for servers may be employed. For example, secure socket layer (SSL) acceleration cards can be used to offload SSL encryption computations, and transmission control protocol/internet protocol (TCP/IP) offload hardware and/or packet classifiers on network interfaces42may be installed and used at server devices.

In a networked environment, certain components of computing device10may be fully or partially implemented on remote computing devices80or cloud-based services90. Data stored in non-volatile data storage device50may be received from, shared with, duplicated on, or offloaded to a non-volatile data storage device on one or more remote computing devices80or in a cloud computing service92. Processing by processors20may be received from, shared with, duplicated on, or offloaded to processors of one or more remote computing devices80or in a distributed computing service93. By way of example, data may reside on a cloud computing service92, but may be usable or otherwise accessible for use by computing device10. Also, certain processing subtasks may be sent to a microservice91for processing with the result being transmitted to computing device10for incorporation into a larger processing task. Also, while components and processes of the exemplary computing environment are illustrated herein as discrete units (e.g., OS51being stored on non-volatile data storage device51and loaded into system memory35for use) such processes and components may reside or be processed at various times in different components of computing device10, remote computing devices80, and/or cloud-based services90.

Remote computing devices80are any computing devices not part of computing device10. Remote computing devices80include, but are not limited to, personal computers, server computers, thin clients, thick clients, personal digital assistants (PDAs), mobile telephones, watches, tablet computers, laptop computers, multiprocessor systems, microprocessor based systems, set-top boxes, programmable consumer electronics, video game machines, game consoles, portable or handheld gaming units, network terminals, desktop personal computers (PCs), minicomputers, main frame computers, network nodes, and distributed or multi-processing computing environments. While remote computing devices80are shown for clarity as being separate from cloud-based services90, cloud-based services90are implemented on collections of networked remote computing devices80.

Cloud-based services90are Internet-accessible services implemented on collections of networked remote computing devices80. Cloud-based services are typically accessed via application programming interfaces (APIs) which are software interfaces which provide access to computing services within the cloud-based service via API calls, which are pre-defined protocols for requesting a computing service and receiving the results of that computing service. While cloud-based services may comprise any type of computer processing or storage, three common categories of cloud-based services90are microservices91, cloud computing services92, and distributed computing services93.

Microservices91are collections of small, loosely coupled, and independently deployable computing services. Each microservice represents a specific computing functionality and runs as a separate process or container. Microservices promote the decomposition of complex applications into smaller, manageable services that can be developed, deployed, and scaled independently. These services communicate with each other through well-defined application programming interfaces (APIs), typically using lightweight protocols like HTTP or message queues. Microservices91can be combined to perform more complex processing tasks.

Cloud computing services92are delivery of computing resources and services over the Internet75from a remote location. Cloud computing services92provide additional computer hardware and storage on as-needed or subscription basis. Cloud computing services92can provide large amounts of scalable data storage, access to sophisticated software and powerful server-based processing, or entire computing infrastructures and platforms. For example, cloud computing services can provide virtualized computing resources such as virtual machines, storage, and networks, platforms for developing, running, and managing applications without the complexity of infrastructure management, and complete software applications over the Internet on a subscription basis.

Distributed computing services93provide large-scale processing using multiple interconnected computers or nodes to solve computational problems or perform tasks collectively. In distributed computing, the processing and storage capabilities of multiple machines are leveraged to work together as a unified system. Distributed computing services are designed to address problems that cannot be efficiently solved by a single computer or that require large-scale computational power. These services enable parallel processing, fault tolerance, and scalability by distributing tasks across multiple nodes.

Although described above as a physical device, computing device10can be a virtual computing device, in which case the functionality of the physical components herein described, such as processors20, system memory30, network interfaces40, and other like components can be provided by computer-executable instructions. Such computer-executable instructions can execute on a single physical computing device, or can be distributed across multiple physical computing devices, including being distributed across multiple physical computing devices in a dynamic manner such that the specific, physical computing devices hosting such computer-executable instructions can dynamically change over time depending upon need and availability.

In the situation where computing device10is a virtualized device, the underlying physical computing devices hosting such a virtualized computing device can, themselves, comprise physical components analogous to those described above, and operating in a like manner. Furthermore, virtual computing devices can be utilized in multiple layers with one virtual computing device executing within the construct of another virtual computing device. Thus, computing device10may be either a physical computing device or a virtualized computing device within which computer-executable instructions can be executed in a manner consistent with their execution by a physical computing device. Similarly, terms referring to physical components of the computing device, as utilized herein, mean either those physical components or virtualizations thereof performing the same or equivalent functions.

The skilled person will be aware of a range of possible modifications of the various aspects described above. Accordingly, the present invention is defined by the claims and their equivalents.