US20070229323A1 - Methods of creating a dictionary for data compression - Google Patents

Methods of creating a dictionary for data compression Download PDF

Info

Publication number
US20070229323A1
US20070229323A1 US11/278,118 US27811806A US2007229323A1 US 20070229323 A1 US20070229323 A1 US 20070229323A1 US 27811806 A US27811806 A US 27811806A US 2007229323 A1 US2007229323 A1 US 2007229323A1
Authority
US
United States
Prior art keywords
child node
occurrence count
node
binary pattern
string
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Granted
Application number
US11/278,118
Other versions
US7283072B1 (en
Inventor
Piotr Plachta
Wolfram Sauer
Balakrishna Iyer
Steven White
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
GlobalFoundries Inc
Original Assignee
International Business Machines Corp
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by International Business Machines Corp filed Critical International Business Machines Corp
Priority to US11/278,118 priority Critical patent/US7283072B1/en
Assigned to IBM CORPORATION reassignment IBM CORPORATION ASSIGNMENT OF ASSIGNORS INTEREST (SEE DOCUMENT FOR DETAILS). Assignors: WHITE, STEVEN WAYNE, IYER, BALAKRISHNA RAGHAVENDRA, PLACHTA, PIOTR M., SAUER, WOLFRAM
Assigned to INTERNATIONAL BUSINESS MACHINES CORPORATION reassignment INTERNATIONAL BUSINESS MACHINES CORPORATION PLEASE CORRECT ASSIGNEE'S NAME TO READ INTERNATIONAL BUSINESS MACHINES CORPORATION FOR ASSIGNMENT PREVIOUSLY RECORDED AT REEL 017393 AND FRAME 0095 Assignors: WHITE, STEVEN WAYNE, IYER, BALAKRISHNA RAGHAVENDRA, PLATCHA, PIOTR M., SAUER, WOLFRAM
Priority to US11/781,833 priority patent/US8037034B2/en
Publication of US20070229323A1 publication Critical patent/US20070229323A1/en
Application granted granted Critical
Publication of US7283072B1 publication Critical patent/US7283072B1/en
Assigned to GLOBALFOUNDRIES U.S. 2 LLC reassignment GLOBALFOUNDRIES U.S. 2 LLC ASSIGNMENT OF ASSIGNORS INTEREST (SEE DOCUMENT FOR DETAILS). Assignors: INTERNATIONAL BUSINESS MACHINES CORPORATION
Assigned to GLOBALFOUNDRIES INC. reassignment GLOBALFOUNDRIES INC. ASSIGNMENT OF ASSIGNORS INTEREST (SEE DOCUMENT FOR DETAILS). Assignors: GLOBALFOUNDRIES U.S. 2 LLC, GLOBALFOUNDRIES U.S. INC.
Expired - Fee Related legal-status Critical Current
Anticipated expiration legal-status Critical

Links

Images

Classifications

    • HELECTRICITY
    • H03ELECTRONIC CIRCUITRY
    • H03MCODING; DECODING; CODE CONVERSION IN GENERAL
    • H03M7/00Conversion of a code where information is represented by a given sequence or number of digits to a code where the same, similar or subset of information is represented by a different sequence or number of digits
    • H03M7/30Compression; Expansion; Suppression of unnecessary data, e.g. redundancy reduction
    • H03M7/3084Compression; Expansion; Suppression of unnecessary data, e.g. redundancy reduction using adaptive string matching, e.g. the Lempel-Ziv method
    • H03M7/3088Compression; Expansion; Suppression of unnecessary data, e.g. redundancy reduction using adaptive string matching, e.g. the Lempel-Ziv method employing the use of a dictionary, e.g. LZ78

Definitions

  • the invention relates to data compression and, in particular, to methods, systems, and computer program products for creating a dictionary for use in data compression and expansion.
  • Lossy data compression methods result in a loss of some information during compression.
  • lossless data compression refers to the ability to change a data set, without losing information, so that the data set can be stored within less space after compression as compared to before compression.
  • Lossy compression methods are often employed in situations where a loss of information is tolerable (e.g. compression of audio and video data).
  • lossless compression methods are preferably employed in situations where a loss of information is undesirable and fidelity is a priority (e.g. compression of text files in a database).
  • Lossless data compression methods as particularly applied in database systems storing text information—help to reduce capital and operating costs.
  • a typical database system has a finite amount of storage (e.g. memory, disk space and the like). As the amount of information in a database increases, new allocations of storage may be required. However, adding and maintaining additional blocks of memory adds capital and operating costs. In the context of large database systems, such as those employed in the financial services sector, such capital and operating cost increases can make database management very expensive. Accordingly, compressing data is a useful way of utilizing available storage and limiting requirements for new allocations of storage.
  • LZ78 Lempel-Ziv 1978
  • a number of criteria are considered when evaluating the performance of a compression method, such as for example, computational overhead, efficiency and compression ratio.
  • a static dictionary is typically defined as having a fixed and limited size, which in turn means that only the most frequently occurring byte-strings are stored in accordance with known methods of creating a static dictionary.
  • problems there are a number of problems associated with this.
  • the most frequently occurring byte-strings are typically quite short, which means that the longest byte-strings that could be used may not be stored for use in the static dictionary since the dictionary is biased towards retaining shorter more frequently occurring byte-strings. Yet, during the actual compression process byte-strings in the data set are matched to the longest byte-strings stored in the static dictionary. Subsequently, the static dictionary contains a number of short byte-strings that are rarely used, and the resultant compression ratio of the compression process may be reduced because the longest byte-strings that could be matched may not be stored in the static dictionary for use during the compression process.
  • a preferred embodiment of the invention is directed to a method for creating a static dictionary, the method comprising: providing a plurality of data trees, each of the plurality of data trees comprising a root node, at least one of the plurality of data trees comprising at least one child node, wherein each root node and each child node stores an associated binary pattern, wherein each child node is adapted to store a symbol associated with the child node and an occurrence count value associated with the child node; defining a binary pattern string, the binary pattern string comprising a concatenation of the binary patterns in a direct path from the root node to a particular child node, and wherein an occurrence count value for the binary pattern string is the occurrence count value of the particular child node; and, incrementing the occurrence count value of the binary pattern string when the particular child node is visited.
  • the method also includes storing the respective unique symbols and corresponding pointers to particular child nodes in a symbol table.
  • the method also includes: adding child nodes to the plurality of data trees until the combined size of the plurality of the data trees is a predetermined temporary maximum size; and removing binary pattern strings using an evaluation of occurrence count values so as to reduce the combined size of the plurality of data trees down to a predetermined size.
  • incrementing the occurrence count value of a particular child node occurs only when the particular child node becomes a parent node to a new child node added to the static dictionary.
  • incrementing the occurrence count value of a particular child node occurs only when the particular child node is visited and the particular child node does not serve as a parent node to any other child nodes.
  • the predetermined size is one of a predetermined temporary pruned size and a predetermined desired final size.
  • removing binary pattern strings using an evaluation of occurrence count values comprises: identifying binary pattern strings with low occurrence count values; and, deleting at least some of the child nodes included in the binary pattern string.
  • removing binary pattern strings using an evaluation of occurrence count values comprises: identifying binary pattern strings with low efficiency values, wherein the efficiency value of a binary string is the occurrence count of the binary pattern string multiplied by the length of the binary pattern string; and, deleting at least some of the child nodes included in the binary pattern string.
  • the method further comprises: constructing a sample of the data set using the representative of the content of the data set; storing the sample in a buffer; and, performing a sample compression by matching binary pattern strings in the buffer to binary pattern strings in the static dictionary to determine the occurrence count values of binary string patterns in the static dictionary.
  • the method comprises: identifying a non-branching sequential string of child nodes with low occurrence count values; and, replacing the non-branching sequential string of child nodes with a single child node storing the corresponding binary patterns from the non-branching sequential string of nodes.
  • a system comprising: an element for providing a plurality of data trees, each of the plurality of data trees comprising a root node, at least one of the plurality of data trees comprising at least one child node, wherein each root node and each child node stores an associated binary pattern, wherein each child node is adapted to store a symbol associated with the child node and an occurrence count value associated with the child node; an element for defining a binary pattern string, the binary pattern string comprising a concatenation of the binary patterns in a direct path from the root node to a particular child node, and wherein an occurrence count value for the binary pattern string is the occurrence count value of the particular child node; and an element for incrementing the occurrence count value of the binary pattern string when the particular child node is visited.
  • system further comprises an element for storing the respective unique symbols and corresponding pointers to particular child nodes in a symbol table.
  • the system further comprises an element for adding child nodes to the plurality of data trees until the combined size of the plurality of the data trees is a predetermined temporary maximum size; and an element for removing binary pattern strings using an evaluation of occurrence count values so as to reduce the combined size of the plurality of data trees down to a predetermined size.
  • a computer program product comprising a computer usable medium including computer usable program code for creating a static dictionary for use in lossless data compression and expansion, the computer program product including: computer usable program code for providing a plurality of data trees, each of the plurality of data trees comprising a root node, at least one of the plurality of data trees comprising at least one child node, wherein each root node and each child node stores an associated binary pattern, wherein each child node is adapted to store a symbol associated with the child node and an occurrence count value associated with the child node; computer usable program code for defining a binary pattern string, the binary pattern string comprising a concatenation of the binary patterns in a direct path from the root node to a particular child node, and wherein an occurrence count value for the binary pattern string is the occurrence count value of the particular child node; and, computer usable program code for incrementing the occurrence count value of the binary pattern string when the particular child node is
  • the computer program product also includes computer usable program for storing the respective unique symbols and corresponding pointers to particular child nodes in a symbol table.
  • the computer program product also includes: computer usable program code for adding child nodes to the plurality of data trees until the combined size of the plurality of the data trees is a predetermined temporary maximum size; and, computer usable program code for removing binary pattern strings using an evaluation of occurrence count values so as to reduce the combined size of the plurality of data trees down to a predetermined size.
  • the computer program product also includes computer usable program code for incrementing the occurrence count value of a particular child node occurs only when the particular child node becomes a parent node to a new child node added to the static dictionary.
  • the computer program product also includes: computer usable program code for constructing a sample of the data set using the representative of the content of the data set; computer usable program code for storing the sample in a buffer; and, computer usable program code for performing a sample compression by matching binary pattern strings in the buffer to binary pattern strings in the static dictionary to determine the occurrence count values of binary string patterns in the static dictionary.
  • the computer program product also includes: computer usable program code for identifying a non-branching sequential string of child nodes with low occurrence count values; and, computer usable program code for replacing the non-branching sequential string of child nodes with a single child node storing the corresponding binary patterns from the non-branching sequential string of nodes.
  • FIG. 1A is a block diagram illustration of an example data tree
  • FIG. 1B is an example of a partially shown byte-string in a data set used to create the data tree illustrated in FIG. 1A ;
  • FIG. 1C is an example of a symbol table corresponding to the data tree illustrated in FIG. 1A ;
  • FIG. 2 is a flow chart illustrating a first method of building a collection of data trees and simultaneously tabulating occurrence count values in accordance with aspects of the invention
  • FIG. 3A is a flow chart illustrating a second method of building a collection of data trees and tabulating occurrence count values in accordance with aspects of the invention
  • FIG. 3B is a flow chart illustrating the specific steps for tabulating occurrence count values in FIG. 3A , after at least a portion of the data trees have been created, in accordance with aspects of the invention
  • FIG. 4A is a flow chart illustrating a third method of reducing a non-branching sequential string of nodes into a single node in accordance with aspects of the invention
  • FIG. 4B is a block diagram illustration of an example data tree before the third method illustrated in the flow chart of FIG. 4A is applied;
  • FIG. 4C is a block diagram illustration of an example data tree after the third method illustrated in the flow chart of FIG. 4A is applied.
  • FIG. 5 is a flow chart illustrating a fourth method of reducing a non-branching sequential string of nodes into a single node in accordance with aspects of the invention.
  • the longest byte-strings that could be used may not be stored for use in the static dictionary given the finite size of the static dictionary and the expected multitude short and frequently occurring byte-strings in a data set. Yet, during the actual compression process byte-strings in the data-set are matched to the longest byte-string/symbol pairs in the static dictionary. Subsequently, the static dictionary contains a number of short byte-strings that are rarely used. Moreover, the resultant compression ratio of the compression process may be reduced because the longest byte-strings that could be matched may not be available in the static dictionary.
  • At least one data tree is often included in a static dictionary.
  • a data tree has a number of nodes that are each used to store a single character from a byte-string.
  • the branching pattern of a data tree defines the relationship between nodes and thus the arrangement of byte-strings stored in the data tree.
  • each node storing a character is provided with a respective frequency count value that is incremented each time the node is visited. Accordingly, for a byte-string of arbitrary length the nodes storing characters near the beginning of the byte-string will inherently have a higher frequency count value than those nodes near the end of the byte-string, since the nodes near the beginning must be traversed to reach the nodes near the end.
  • embodiments of the present invention provide for methods, systems, and computer program products for creating a static dictionary in which longer byte-strings are preferred.
  • a new heuristic is defined to replace the aforementioned frequency count metric used to record the number of times a particular node in a data tree is visited.
  • the new heuristic is based on counting the number of times an end-node of a particular byte-string is visited, while not incrementing a count for nodes storing characters in the middle of the byte-string as often as each time such nodes are visited. The result is an occurrence count metric that favors longer byte-strings.
  • a respective occurrence count for a particular byte-string is tabulated while a static dictionary is being created.
  • An exemplary method of tabulating occurrence count values simultaneously while a static dictionary is being created is described below with reference to FIG. 2 .
  • the occurrence count values for respective byte-strings are tabulated after at least a portion of the static dictionary is created using a portion of the data set.
  • the portion of the data set used to tabulate occurrence count values is stored in a buffer.
  • a buffer is provided.
  • the buffer is used for refreshing/re-tabulating occurrence count values for symbols by performing a sample compression using the contents of the buffer. This is done immediately prior to pruning the tree.
  • Sample compression involves zeroing out the occurrence count values of all nodes, then compressing the buffer using the current static dictionary. The resulting compressed data is not retained; only, occurrence count values of nodes used are updated. This refresh will set the occurrence count values of all nodes that are not used to zero, thus possibly making the prune more accurate and possibly increasing the compression ratio.
  • a non-branching sequential string of nodes storing characters of a respective byte-string may be replaced with a single node storing the corresponding characters and having only one symbol.
  • the amount of memory allocated for one or more data trees may be reduced and symbols available in a respective symbol table may be used more effectively.
  • the last node in a non-branching sequential string of nodes may have multiple child nodes. However, every node preferably has only one parent node. The resulting collapsed path is known as a “one-way street”. Two exemplary methods of concatenating a non-branching string of sequential nodes are described below with reference to FIGS. 4A, 4B , 4 C and 5 .
  • aspects of the invention may be embodied in a number of forms.
  • various aspects of the invention can be embodied in a suitable combination of hardware, software and firmware.
  • some embodiments include, without limitation, entirely hardware, entirely software, entirely firmware or some suitable combination of hardware, software and firmware.
  • the invention is implemented in software, which includes but is not limited to firmware, resident software, microcode, etc.
  • aspects of the invention can be embodied in the form of a computer program product accessible from a computer-usable or computer-readable medium providing program code for use by or in connection with a computer or any instruction execution system.
  • a computer-usable or computer readable medium can be any apparatus that can contain, store, communicate, propagate, or transport the program for use by or in connection with the instruction execution system, apparatus, or device.
  • a computer-readable medium can be an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system (or apparatus or device) or a propagation medium.
  • Examples of a computer-readable medium include a semiconductor and/or solid-state memory, magnetic tape, a removable computer diskette, a random access memory (RAM), a read-only memory (ROM), a rigid magnetic disk and an optical disk.
  • Current examples of optical disks include, without limitation, compact disk—read only memory (CD-ROM), compact disk—read/write (CD-R/W) and DVD.
  • a data processing system suitable for storing and/or executing program code will include at least one processor coupled directly or indirectly to memory elements through a system bus.
  • the memory elements can include local memory employed during actual execution of the program code, bulk storage, and cache memories which provide temporary storage of at least some program code in order to reduce the number of times code must be retrieved from bulk storage during execution.
  • I/O devices including but not limited to keyboards, displays, pointing devices, etc.—can be coupled to the system either directly or through intervening I/O controllers.
  • Network adapters may also be coupled to the system to enable communication between multiple data processing systems, remote printers, or storage devices through intervening private or public networks. Modems, cable modems and Ethernet cards are just a few of the currently available types of network adapters.
  • a static dictionary includes a combination of a collection of one or more data trees and a symbol table. That is, a static dictionary is represented by a trie, which is a collection of multi-child trees in common prefix or common suffix form. The trie maps a byte-string to a symbol. Each data tree stores a respective set of byte-strings. The symbol table stores symbols relating to each byte-string stored in the collection of data trees. A symbol table is not necessary since the tree could always be exhaustively searched to find a given symbol.
  • FIGS. 1A and 1C are illustrative examples of a data tree 200 and a symbol table, created from a partially shown data set 22 provided in FIG. 1B .
  • a static dictionary is only addressable in a finite amount of space, which means the number of symbols that may be used is limited. Thus, it is beneficial to select the most efficient symbols.
  • a definition of efficiency is the degree to which compression ratio is improved, while reducing the dictionary size.
  • each data tree includes a single root node and possibly one or more child nodes, where each node stores an arbitrary character and a corresponding symbol unique to the node that is also stored in the symbol table.
  • a data tree extends from the root node. That is, a root node serves as a parent node to one or more child nodes storing the same or other characters as the root node.
  • a particular child node may also serve as a parent node to additional child nodes that are lower in the data tree than the particular child node. However, it is preferable that each child node has only one direct parent node. It was noted above that each data tree stores a respective set of byte-strings.
  • each data tree is a common-prefix or common-suffix representation of a byte-string.
  • retrieval of a particular byte-string involves concatenating characters encountered on a direct path from the root node to a respective child node storing the last character of the byte-string.
  • each root node stores a unique byte from the Extended ASCII Character Set as a corresponding unique 8-bit binary number.
  • a unique 8-bit binary number there are 256 such unique 8-bit binary numbers in the Extended ASCII Character Set.
  • byte and “byte-string” are only used for brevity and to help describe examples in accordance with aspects of the invention below, given that the concept of a “byte” is commonly understood in the art to include a collection of bits (e.g. 8-bits) grouped together.
  • the data tree 200 has a root node 210 , storing the character “A” and symbol “ 65 ”.
  • the root node 210 has first and second child nodes 220 and 230 , storing respective characters “b” and “l” with corresponding symbols “ 257 ” and “ 258 ”.
  • the first child node 220 has third and fourth child nodes 222 and 224 , storing respective characters “s” and “i” with corresponding symbols “ 261 ” and “ 270 ”.
  • the second child node 230 has fifth and sixth child nodes 232 and 234 , storing respective characters “i” and “t” with corresponding symbols “ 280 ” and “ 290 ”.
  • the root node 210 , and the first and second child nodes 220 and 230 are illustrated as specifically having two child nodes each, those skilled in the art will appreciate that more generally a node serving as a parent may have any number of child nodes.
  • Creating a data tree includes parsing through a data set (e.g. data set 22 ) or a sample portion of the data set and identifying repetitive byte-strings.
  • the basic process involves adding child nodes to the ends of existing byte-strings stored in data trees. Such a process starts by matching an initial character from the data set to an appropriate root node and then matching subsequent characters to child nodes until the end of the byte-string is found. A new child node is then added to the end of the byte-string, and then the next character from the data set is matched to a corresponding root node and the process repeats.
  • a detailed example method of how data trees are constructed is described below with reference to FIG. 2 .
  • a symbol table includes a listing of symbols. Each symbol is unique and corresponds to a particular node in one of the collection of data trees included in a static dictionary. Moreover, each symbol corresponds to the end of a respective byte-string. A symbol table also includes a listing of pointers, where each pointer corresponds to a particular node that a respective symbol corresponds to.
  • a static dictionary is a finite size. Thus, it is not always possible to store all byte-strings identified in a data set. Accordingly, a static dictionary is often grown in steps that include: growing the data trees until a predetermined number of nodes or symbols is reached; evaluating which nodes (and thus byte-strings) are worth keeping; removing (i.e.
  • pruning the nodes determined not to be worth keeping; repeating the growth and pruning of the data trees, as described, until the entire data set or sample portion of the data set has been processed; and finally pruning the data trees down to a desired final size (i.e. number of symbols or nodes).
  • FIG. 1C shown is a portion of an example of a symbol table 110 including only information relevant to the data tree 200 shown in FIG. 1A .
  • a symbol table more specifically includes symbols from one or more data trees used to define a static dictionary.
  • the pointer values for each symbol correspond to the reference indicia used in FIG. 1A .
  • symbol “ 270 ” is shown as having pointer “ 224 ”.
  • a pointer refers to a storage location address.
  • the symbol table 110 ( FIG. 1C ) includes an extra “character-string field” 120 showing the byte-string implied by reference to each particular node in the symbol table 110 .
  • the symbol “ 270 ” corresponds to respective byte-string “Abi” which can be retrieved from the data tree 200 by concatenating characters encountered on a direct path from the root node 210 to the fourth child node 224 .
  • the byte-string “Abi” includes the byte-string “Ab”, which can be retrieved from the data tree 200 by concatenating characters encountered on a direct path from the root node 210 to the first child node 220 .
  • FIG. 1B it is clear that the shorter byte-string “Ab” is present in the data set 22 more often than the byte-string “Abi”.
  • the byte-string “Abi” may provide a better compression ratio, and thus, in accordance with aspects of the invention, methods are provided that favor longer byte-strings, as opposed to the shorter byte-strings included near the beginning of the longer byte-strings.
  • previously known methods of building a static dictionary favor short byte-strings, such as “Ab”, that have higher frequency count values than longer byte-strings, such as “Abs”.
  • compression is accomplished by: selecting characters from the data set; traversing the data trees until a child node is encountered that does not have any child nodes of its own; and inserting the symbol of that child node in place of a byte-string in the data set that matches a corresponding byte-string obtained in a direct path from a particular root node to the child node.
  • expansion is accomplished by: parsing a compressed data set so as to identify symbols; retrieving a respective pointer for each symbol from the symbol table; and, inserting a corresponding byte-string back into the data set in place of a particular symbol, where the byte-string matches a corresponding byte-string obtained in a direct path from a particular root node to the child node.
  • compression ratio is defined as the size of data after compression divided by the size of the data before compression.
  • the size of the data before and after compression is measurable in terms of bits, bytes, words frames and the like.
  • the size of the data includes the data set itself, whereas after a data set is compressed the size of the data includes the size of the compressed data set and the memory required to store the static dictionary.
  • the compression ratio is calculated taking into account that the size of the data before compression is the sum of the sizes of the data sets, and the size of the data after compression is the sum of the sizes of the corresponding compressed data sets plus the memory required to store the static dictionary. Additionally and/or alternatively, the size of the static dictionary is not included in the calculation of compression ratio as its effect on compression is small.
  • Efficiency of a symbol is calculated as the number of times a corresponding byte-string occurs in a data set (or portion of a data set) multiplied by the length of the byte-string.
  • the first method includes identifying the first/next character in the data set. More specifically, the method starts by identifying the first character in the data set, and subsequently identifying a next character when the method loops back to step 2 - 1 as described as follows.
  • the method includes determining whether or not the character identified at step 2 - 1 —whether it be the first or a next character—is a character and/or signal value indicating that the end of the data set has been reached (i.e. has the end of file marker been retrieved). If the end of the data set has been reached (yes path, step 2 - 2 ), then the method proceeds to step 2 - 12 , which is described in greater detail below. On the other hand if the end of the data set has not been reached (no path, step 2 - 2 ), then the method proceeds to step 2 - 3 that includes selecting a respective root node. For example, as described above 256 different root nodes may be provided, where each root node corresponds to one of the characters included in the Extended ASCII Character Set.
  • the method includes identifying the next character in the data set, and at step 2 - 5 , determining whether or not the character identified at step 2 - 4 is a character and/or signal value indicating that the end of the data set has been reached. If the end of the data set has been reached (yes path, step 2 - 5 ), then the method proceeds to step 2 - 12 , which is described in greater detail below. On the other hand, if the end of the data set has not been reached (no path, step 2 - 5 ), then the method proceeds to step 2 - 6 .
  • the method includes determining whether or not the current node—whether it is a root node or a child node—has a child node already storing the character identified at step 2 - 4 . If there is a child node storing the character identified at step 2 - 4 (yes path, step 2 - 6 ), the method proceeds to step 2 - 7 , where the method follows a respective branch to the identified child node before looping back to step 2 - 4 . On the other hand, if the current node does not have a child node storing the character identified at step 2 - 4 (no path, step 2 - 6 ), the method proceeds to step 2 - 8 .
  • the method includes increasing the occurrence count for the current node, thereby indicating that the current node is the end of a byte-string that has been visited at least twice and serves as a parent to at least one child node.
  • the method includes adding a new child node to the current node, thereby making the current node a parent node to at least one child node. The newly added child node stores the character identified at step 2 - 4 .
  • Step 2 - 10 of the method includes determining whether or not the current size of the static dictionary is at a predetermined temporary maximum size. If the current size of the static dictionary is not the predetermined temporary maximum size (no path, step 2 - 10 ), then the method loops back to step 2 - 1 . On the other hand, if the current size of the static dictionary is the predetermined temporary maximum size (yes path, step 2 - 10 ), then the method proceeds to step 2 - 11 before looping back to step 2 - 1 .
  • the method includes pruning the size of static dictionary down to a predetermined temporary pruned value.
  • step 2 - 12 the static dictionary is reduced (i.e. pruned) down to the desired final size.
  • reducing the size of the static dictionary involves identifying the symbols with the low efficiency and removing them, while preserving the symbols with the high efficiency values.
  • efficiency for a symbol is determined by the combination of the respective occurrence count for the symbol and the number of characters in the byte-string represented by the symbol.
  • reducing the size of the static dictionary i.e. pruning
  • the predetermined temporary maximum size is a multiple of the desired final size of the static dictionary.
  • the predetermined temporary maximum size may be 8 times the desired final size of the static dictionary.
  • desired final size may be specified in terms of a number of symbols and/or a number of nodes.
  • the desired final size may be specified being 4096 symbols and the predetermined temporary maximum size would then be 32,768 symbols if 8 is the multiple used.
  • 4096 symbols is the desired final size
  • 12 bits can be used to represent all the symbols in the set of 4096 symbols.
  • the desired final size may be specified in terms of a specified amount of memory.
  • the predetermined temporary pruned sized size is also a multiple of the desired final size of the static dictionary.
  • the predetermined temporary pruned size may be 4 times the desired final size of the static dictionary.
  • FIGS. 3A and 3B illustrate a second method of building a collection of data trees (i.e. a trie) and tabulating occurrence count values after at least a portion of the data trees have been created in accordance with aspects of the invention.
  • data trees i.e. a trie
  • the second method includes loading a buffer with a portion of the data set. More specifically, it is preferable to load the buffer with a sample of the data set that has been deliberately constructed to be representative of the content of the data set.
  • the static dictionary is created in phases that include sequential steps of growing and pruning the static dictionary until a representative sample portion of the data set is processed or the entire data set is processed.
  • a static dictionary is a representation of the most frequently used sample of the input data. If the dictionary size is fixed at 4096 symbols, for instance, it does not usually matter whether 1,000 MB or 1,000,000 MB of data is processed. Hence, in accordance with some aspects of the invention, a static dictionary can be built from either an entire data set or just a sample of the data set loaded into a buffer.
  • One advantage of using just a sample of the data set is that less data is processed, hence, the process is faster.
  • the buffer may be used to get accurate occurrence count values by sample compression. In order for the sample to have no bias, it preferable that the sample is uniformly representative of the whole data set.
  • the method includes building a portion of a static dictionary as described above (with or without simultaneously tabulating respective occurrence count values for corresponding byte-strings) using the portion of the data set in the buffer. If the occurrence count values are tabulated while the portion of the static dictionary is being grown/built, all the occurrence count values are set to zero (or some other base value) before step 3 - 3 .
  • Step 3 - 3 includes tabulating the occurrence count values by performing a pseudo-matching step to identify the longest and most frequently occurring byte-strings. An exemplary method for tabulating the occurrence count values by performing a pseudo-matching step to identify the longest and most frequently occurring byte-strings is described below with reference to FIG. 3B .
  • Step 3 - 4 of the method includes pruning the static dictionary, as described above, down to a predetermined temporary pruned size.
  • the method includes pruning the static dictionary down to a desired final size. Then the second method ends.
  • the method includes identifying the first/next character in the buffer. More specifically, the method starts by identifying the first character in the buffer, and subsequently identifying a next character when the method loops back to step B- 1 as described as follows.
  • the method includes determining whether or not the character identified at step B- 1 —whether it be the first or a next character—is a character and/or signal value indicating that the end of the buffer has been reached. If the end of the buffer has been reached (yes path, step B- 2 ), then this portion of the method ends, and the method resumes at step 3 - 4 as described above with reference to FIG. 3A . On the other hand if the end of the buffer has not been reached (no path, step B- 2 ), then the method proceeds to step B- 3 that includes selecting a respective root node. For example, as described above 256 different root nodes may be provided, where each root node corresponds to one of the characters included in the Extended ASCII Character Set.
  • the method includes identifying the next character in the buffer, and at step B- 5 , determining whether or not the character identified at step B- 4 is a character and/or signal value indicating that the end of the data set has been reached. If the end of the buffer has been reached (yes path, step B- 5 ), then this portion of the method ends as described in the previous paragraph. On the other hand if the end of the data set has not been reached (no path, step B- 5 ), then the method proceeds to step B- 6 .
  • the method includes determining whether or not the current node—whether it is a root node or a child node—has a child node already storing the character identified at step B- 4 . If there is a child node storing the character identified at step B- 4 (yes path, step B- 6 ), the method proceeds to step B- 7 , where the method follows a respective branch to the identified child node before looping back to step B- 4 . On the other hand, if the current node does not have a child node storing the character identified at step B- 4 (no path, step B- 6 ), the method proceeds to step B- 8 .
  • the method includes determining whether or not the current node is a root node. If the current node is not a root node (no path, step B- 8 ), then the method proceeds to step B- 9 that includes incrementing the occurrence count for the current node. On the other hand, if the current node is a root node (yes path, step B- 8 ), the method loops back to step B- 1 .
  • FIGS. 4A shown is a simple flow chart illustrating a third method of reducing a non-branching sequential string of nodes into a single node in accordance with aspects of the invention.
  • FIGS. 4B and 4C show respective block diagram illustrations of an example data tree 400 and 400 ′ respectively before and after the method illustrated in the flow chart of FIG. 4A is applied.
  • the method includes identifying a non-branching sequential string of child nodes with low occurrence count values (i.e. OC's, as illustrated in FIG. 4A ).
  • Step 4 - 2 includes replacing the non-branching sequential string of child nodes with a single child node storing the corresponding characters from the non-branching sequential string of nodes.
  • the data tree 400 is illustrated as it would conceptually exist before the method illustrated in FIG. 4A is applied.
  • the data tree includes a root node 401 , a non-branching sequential string of child nodes 402 , 403 , 404 and 405 extending from the root node 401 and another child node 406 also extending from the root node 401 .
  • the last child node 405 in the non-branching sequential string of child nodes has child nodes 407 and 408 .
  • the child node 408 has two non-branching sequential strings of child nodes 409 , 410 and 411 , 412 , respectively.
  • a first byte-string represented by the child node 407 is “CANADA”, whereas a second byte-string represented by the child node 410 is “CANADIAN” and a third byte-string represented by the child node 412 is “CANADIEN”.
  • Each of the first, second and third byte-strings shares a fourth common byte-string “ANAD” represented by the child node 405 without including the root node 401 .
  • the fourth byte-string which includes the non-branching sequential string of child nodes 402 , 403 , 404 and 405 , would not have a high occurrence count as tabulated in accordance with aspects of the invention (as described for example in the specific examples above), since the fourth byte-string is simply a portion of the first, second and third byte-strings.
  • fifth and sixth byte-strings “AN” and “EN” between node 408 and nodes 410 and 412 respectively, would also not have high occurrence count values. Accordingly, when the method illustrated in FIG. 4A is applied to the data tree 400 the result is the data tree 400 ′, which represents the same byte-strings described above.
  • the data tree 400 ′ also includes the root node 401 and the child node 406 as shown in FIG. 4B .
  • the data tree 400 ′ includes a multi-character node 405 ′ storing the sequence of characters in the fourth byte-string “ANAD”.
  • the fifth and sixth byte-strings “AN” and “EN” are now stored in corresponding multi-character nodes 410 ′ and 412 ′, respectively.
  • FIG. 5 shows a flow chart illustrating a fourth method of reducing a non-branching sequential string of nodes into a single node in accordance with aspects of the invention.
  • the method includes selecting a root node.
  • the method includes resetting a count value to zero. The count value represents the number of characters pushed on to a stack.
  • Step 5 - 3 of the method includes determining whether or not the root selected at step 5 - 1 has any previously unselected child nodes.
  • step 5 - 3 If the selected root node does not have any previously unselected child nodes (no path, step 5 - 3 ), then the method loops back to step 5 - 1 . On the other hand, if the selected root node does have a previously unselected child node (yes path, step 5 - 3 ), then the method proceeds to step 5 - 4 that includes following the data tree to a previously unselected child node.
  • Step 5 - 5 of the method includes determining whether or not the child node is a parent node to multiple child nodes. If the child node is a parent to multiple child nodes (yes path, step 5 - 5 ), then the method proceeds to step 5 - 6 . On the other hand, if the child node is not a parent to multiple child nodes (no path, step 5 - 5 ), then the method proceeds to step 5 - 9 , which is described in detail further below.
  • the method includes determining whether or not more than one character has been pushed onto the stack (i.e. is count>1). If more than one character has been pushed onto the stack (yes path, step 5 - 6 ), then the method proceeds to step 5 - 7 . On the other hand, if less that two characters have been pushed onto the stack (no path, step 5 - 6 ), then the method proceeds to step 5 - 14 which is described in detail further below.
  • Step 5 - 7 of the method includes popping the characters on the stack and building a corresponding multi-character node. Subsequently, at step 5 - 8 , the method includes replacing a respective non-branching sequential string of child nodes (e.g. child nodes 402 , 403 , 404 and 405 in FIG. 4B ) with the multi-character node (e.g. 405 ′) built at step 5 - 7 , before looping back to step 5 - 2 .
  • child nodes e.g. child nodes 402 , 403 , 404 and 405 in FIG. 4B
  • Step 5 - 9 follows from the step 5 - 5 .
  • the method includes determining whether or not the child node selected at step 5 - 4 has one child node. If the child node does not have a child node (no path, step 5 - 9 ), the method follows to step 5 - 6 described above. On the other hand, if the child node has a single child node (yes path, step 5 - 9 ) the method proceeds to step 5 - 10 .
  • the method includes determining whether or not the child node selected at step 5 - 4 has a respective occurrence count value (OC) less than a minimum occurrence count threshold value (OC min ). If the respective occurrence count value is not less than a minimum occurrence count threshold value (no path, step 5 - 10 ), then the method follows to step 5 - 6 described above. If the respective occurrence count value is less than a minimum occurrence count threshold value (yes path, step 5 - 10 ), then the method proceeds to step 5 - 11 .
  • OC occurrence count value
  • OC min minimum occurrence count threshold value
  • Step 5 - 11 includes incrementing the count value to reflect the number of characters pushed to the stack.
  • Step 5 - 12 includes pushing the character stored in the child node selected at step 5 - 4 onto the stack before going to the next child at step 5 - 13 .
  • step 5 - 13 the method follows back to step 5 - 5 described above.
  • the method includes popping the stack without building a node before looping back to step 5 - 2 .

Abstract

Some aspects of the invention provide methods, systems, and computer program products for creating a static dictionary in which longer byte-strings are preferred. To that end, in accordance with aspects of the present invention, a new heuristic is defined to replace the aforementioned frequency count metric used to record the number of times a particular node in a data tree is visited. The new heuristic is based on counting the number of times an end-node of a particular byte-string is visited, while not incrementing a count for nodes storing characters in the middle of the byte-string as often as each time such nodes are visited. The result is an occurrence count metric that favours longer byte-strings, by being biased towards not incrementing the respective occurrence count values for nodes storing characters in the middle of a byte-string.

Description

    FIELD OF THE INVENTION
  • The invention relates to data compression and, in particular, to methods, systems, and computer program products for creating a dictionary for use in data compression and expansion.
  • BACKGROUND OF THE INVENTION
  • Data compression methods can be divided into two broad categories: namely, “lossy” and lossless data compression methods. Lossy data compression methods result in a loss of some information during compression. On the other hand, lossless data compression refers to the ability to change a data set, without losing information, so that the data set can be stored within less space after compression as compared to before compression. Lossy compression methods are often employed in situations where a loss of information is tolerable (e.g. compression of audio and video data). By contrast, lossless compression methods are preferably employed in situations where a loss of information is undesirable and fidelity is a priority (e.g. compression of text files in a database).
  • Lossless data compression methods—as particularly applied in database systems storing text information—help to reduce capital and operating costs. A typical database system has a finite amount of storage (e.g. memory, disk space and the like). As the amount of information in a database increases, new allocations of storage may be required. However, adding and maintaining additional blocks of memory adds capital and operating costs. In the context of large database systems, such as those employed in the financial services sector, such capital and operating cost increases can make database management very expensive. Accordingly, compressing data is a useful way of utilizing available storage and limiting requirements for new allocations of storage.
  • A particular subset of lossless data compression methods, referred to hereinafter as binary-string/symbol substitution methods, have been developed that exploit the redundancy of byte-strings repeated within a text file. Compression is accomplished by replacing frequently occurring byte-strings with shorter identifiers/placeholders, referred to hereinafter as symbols. The Lempel-Ziv 1978 (LZ78) method of data compression is at the root of this class of binary-string/symbol substitution methods. In accordance with the LZ78 method: a static dictionary is created that contains frequently occurring byte-strings and corresponding symbols; and, compression is accomplished by replacing frequently occurring byte-strings with respective symbols (i.e. exchanging text-symbol pairs).
  • A number of criteria are considered when evaluating the performance of a compression method, such as for example, computational overhead, efficiency and compression ratio. As a general rule, for compression to be considered effective, the storage allocation for the combination of a static dictionary and a respective compressed data set should be substantially smaller than that for the corresponding uncompressed data set. To that end, a static dictionary is typically defined as having a fixed and limited size, which in turn means that only the most frequently occurring byte-strings are stored in accordance with known methods of creating a static dictionary. However, there are a number of problems associated with this.
  • The most frequently occurring byte-strings are typically quite short, which means that the longest byte-strings that could be used may not be stored for use in the static dictionary since the dictionary is biased towards retaining shorter more frequently occurring byte-strings. Yet, during the actual compression process byte-strings in the data set are matched to the longest byte-strings stored in the static dictionary. Subsequently, the static dictionary contains a number of short byte-strings that are rarely used, and the resultant compression ratio of the compression process may be reduced because the longest byte-strings that could be matched may not be stored in the static dictionary for use during the compression process.
  • SUMMARY OF THE INVENTION
  • A preferred embodiment of the invention is directed to a method for creating a static dictionary, the method comprising: providing a plurality of data trees, each of the plurality of data trees comprising a root node, at least one of the plurality of data trees comprising at least one child node, wherein each root node and each child node stores an associated binary pattern, wherein each child node is adapted to store a symbol associated with the child node and an occurrence count value associated with the child node; defining a binary pattern string, the binary pattern string comprising a concatenation of the binary patterns in a direct path from the root node to a particular child node, and wherein an occurrence count value for the binary pattern string is the occurrence count value of the particular child node; and, incrementing the occurrence count value of the binary pattern string when the particular child node is visited.
  • In accordance with some aspects of the invention, the method also includes storing the respective unique symbols and corresponding pointers to particular child nodes in a symbol table.
  • In accordance with some aspects of the invention, the method also includes: adding child nodes to the plurality of data trees until the combined size of the plurality of the data trees is a predetermined temporary maximum size; and removing binary pattern strings using an evaluation of occurrence count values so as to reduce the combined size of the plurality of data trees down to a predetermined size.
  • In accordance with some aspects of the invention, incrementing the occurrence count value of a particular child node occurs only when the particular child node becomes a parent node to a new child node added to the static dictionary.
  • In accordance with some aspects of the invention, incrementing the occurrence count value of a particular child node occurs only when the particular child node is visited and the particular child node does not serve as a parent node to any other child nodes.
  • In accordance with some aspects of the invention, the predetermined size is one of a predetermined temporary pruned size and a predetermined desired final size.
  • In accordance with some aspects of the invention, removing binary pattern strings using an evaluation of occurrence count values comprises: identifying binary pattern strings with low occurrence count values; and, deleting at least some of the child nodes included in the binary pattern string.
  • In accordance with some aspects of the invention, removing binary pattern strings using an evaluation of occurrence count values comprises: identifying binary pattern strings with low efficiency values, wherein the efficiency value of a binary string is the occurrence count of the binary pattern string multiplied by the length of the binary pattern string; and, deleting at least some of the child nodes included in the binary pattern string.
  • In accordance with some aspects of the invention, the method further comprises: constructing a sample of the data set using the representative of the content of the data set; storing the sample in a buffer; and, performing a sample compression by matching binary pattern strings in the buffer to binary pattern strings in the static dictionary to determine the occurrence count values of binary string patterns in the static dictionary.
  • In accordance with some aspects of the invention, the method comprises: identifying a non-branching sequential string of child nodes with low occurrence count values; and, replacing the non-branching sequential string of child nodes with a single child node storing the corresponding binary patterns from the non-branching sequential string of nodes.
  • According to a further embodiment of the invention, there is provided a system comprising: an element for providing a plurality of data trees, each of the plurality of data trees comprising a root node, at least one of the plurality of data trees comprising at least one child node, wherein each root node and each child node stores an associated binary pattern, wherein each child node is adapted to store a symbol associated with the child node and an occurrence count value associated with the child node; an element for defining a binary pattern string, the binary pattern string comprising a concatenation of the binary patterns in a direct path from the root node to a particular child node, and wherein an occurrence count value for the binary pattern string is the occurrence count value of the particular child node; and an element for incrementing the occurrence count value of the binary pattern string when the particular child node is visited.
  • In accordance with some aspects of the invention, the system further comprises an element for storing the respective unique symbols and corresponding pointers to particular child nodes in a symbol table.
  • In accordance with some aspects of the invention, the system further comprises an element for adding child nodes to the plurality of data trees until the combined size of the plurality of the data trees is a predetermined temporary maximum size; and an element for removing binary pattern strings using an evaluation of occurrence count values so as to reduce the combined size of the plurality of data trees down to a predetermined size.
  • According to a further embodiment of the invention, there is provided a computer program product comprising a computer usable medium including computer usable program code for creating a static dictionary for use in lossless data compression and expansion, the computer program product including: computer usable program code for providing a plurality of data trees, each of the plurality of data trees comprising a root node, at least one of the plurality of data trees comprising at least one child node, wherein each root node and each child node stores an associated binary pattern, wherein each child node is adapted to store a symbol associated with the child node and an occurrence count value associated with the child node; computer usable program code for defining a binary pattern string, the binary pattern string comprising a concatenation of the binary patterns in a direct path from the root node to a particular child node, and wherein an occurrence count value for the binary pattern string is the occurrence count value of the particular child node; and, computer usable program code for incrementing the occurrence count value of the binary pattern string when the particular child node is visited.
  • In accordance with some aspects of the invention, the computer program product also includes computer usable program for storing the respective unique symbols and corresponding pointers to particular child nodes in a symbol table.
  • In accordance with some aspects of the invention, the computer program product also includes: computer usable program code for adding child nodes to the plurality of data trees until the combined size of the plurality of the data trees is a predetermined temporary maximum size; and, computer usable program code for removing binary pattern strings using an evaluation of occurrence count values so as to reduce the combined size of the plurality of data trees down to a predetermined size.
  • In accordance with some aspects of the invention, the computer program product also includes computer usable program code for incrementing the occurrence count value of a particular child node occurs only when the particular child node becomes a parent node to a new child node added to the static dictionary.
  • In accordance with some aspects of the invention, the computer program product also includes: computer usable program code for constructing a sample of the data set using the representative of the content of the data set; computer usable program code for storing the sample in a buffer; and, computer usable program code for performing a sample compression by matching binary pattern strings in the buffer to binary pattern strings in the static dictionary to determine the occurrence count values of binary string patterns in the static dictionary.
  • In accordance with some aspects of the invention, the computer program product also includes: computer usable program code for identifying a non-branching sequential string of child nodes with low occurrence count values; and, computer usable program code for replacing the non-branching sequential string of child nodes with a single child node storing the corresponding binary patterns from the non-branching sequential string of nodes.
  • Other aspects and features of the present invention will become apparent, to those ordinarily skilled in the art, upon review of the following description of specified embodiments of the invention.
  • BRIEF DESCRIPTION OF THE DRAWINGS
  • For a better understanding of the present invention, and to show more clearly how it may be carried into effect, reference will now be made, by way of example, to the accompanying drawings, which illustrate aspects of embodiments of the present invention and in which:
  • FIG. 1A is a block diagram illustration of an example data tree;
  • FIG. 1B is an example of a partially shown byte-string in a data set used to create the data tree illustrated in FIG. 1A;
  • FIG. 1C is an example of a symbol table corresponding to the data tree illustrated in FIG. 1A;
  • FIG. 2 is a flow chart illustrating a first method of building a collection of data trees and simultaneously tabulating occurrence count values in accordance with aspects of the invention;
  • FIG. 3A is a flow chart illustrating a second method of building a collection of data trees and tabulating occurrence count values in accordance with aspects of the invention;
  • FIG. 3B is a flow chart illustrating the specific steps for tabulating occurrence count values in FIG. 3A, after at least a portion of the data trees have been created, in accordance with aspects of the invention;
  • FIG. 4A is a flow chart illustrating a third method of reducing a non-branching sequential string of nodes into a single node in accordance with aspects of the invention;
  • FIG. 4B is a block diagram illustration of an example data tree before the third method illustrated in the flow chart of FIG. 4A is applied;
  • FIG. 4C is a block diagram illustration of an example data tree after the third method illustrated in the flow chart of FIG. 4A is applied; and
  • FIG. 5 is a flow chart illustrating a fourth method of reducing a non-branching sequential string of nodes into a single node in accordance with aspects of the invention.
  • DETAILED DESCRIPTION
  • There are a number of problems associated with known methods of creating a static dictionary for use in data compression. For example, there is a bias towards storing short byte-strings in the static dictionary. The bias is the result of at least two factors. The first factor is that a static dictionary is of a limited size. The second is that previously known methods of selecting byte-strings to be stored in the static dictionary rely on a frequency count metric that is often incremented at a higher rate for short byte-strings as compared to long byte-strings. In turn, in many cases short byte-strings will likely have respective frequency count values that are higher than those for longer byte-strings. As a result, the longest byte-strings that could be used may not be stored for use in the static dictionary given the finite size of the static dictionary and the expected multitude short and frequently occurring byte-strings in a data set. Yet, during the actual compression process byte-strings in the data-set are matched to the longest byte-string/symbol pairs in the static dictionary. Subsequently, the static dictionary contains a number of short byte-strings that are rarely used. Moreover, the resultant compression ratio of the compression process may be reduced because the longest byte-strings that could be matched may not be available in the static dictionary.
  • At least one data tree is often included in a static dictionary. A data tree has a number of nodes that are each used to store a single character from a byte-string. The branching pattern of a data tree defines the relationship between nodes and thus the arrangement of byte-strings stored in the data tree. In accordance with previously known methods of creating a static dictionary, each node storing a character is provided with a respective frequency count value that is incremented each time the node is visited. Accordingly, for a byte-string of arbitrary length the nodes storing characters near the beginning of the byte-string will inherently have a higher frequency count value than those nodes near the end of the byte-string, since the nodes near the beginning must be traversed to reach the nodes near the end. This biases the byte-strings stored in the static dictionary to those represented by nodes having the highest frequency count value. As a result, short byte-strings, often made up of nodes near the beginning of a longer byte-string, are preferred by such methods.
  • By contrast, embodiments of the present invention provide for methods, systems, and computer program products for creating a static dictionary in which longer byte-strings are preferred. To that end, in accordance with aspects of the present invention, a new heuristic is defined to replace the aforementioned frequency count metric used to record the number of times a particular node in a data tree is visited. The new heuristic is based on counting the number of times an end-node of a particular byte-string is visited, while not incrementing a count for nodes storing characters in the middle of the byte-string as often as each time such nodes are visited. The result is an occurrence count metric that favors longer byte-strings.
  • According to aspects of the invention, a respective occurrence count for a particular byte-string is tabulated while a static dictionary is being created. An exemplary method of tabulating occurrence count values simultaneously while a static dictionary is being created is described below with reference to FIG. 2.
  • Additionally and/or alternatively, according to other aspects of the invention the occurrence count values for respective byte-strings are tabulated after at least a portion of the static dictionary is created using a portion of the data set. In some embodiments the portion of the data set used to tabulate occurrence count values is stored in a buffer. An exemplary method of tabulating occurrence count values after at least a portion of a static dictionary is created is described below with reference to FIGS. 3A and 3B.
  • Additionally and/or alternatively, according to other aspects of the invention, a buffer is provided. The buffer is used for refreshing/re-tabulating occurrence count values for symbols by performing a sample compression using the contents of the buffer. This is done immediately prior to pruning the tree. Sample compression involves zeroing out the occurrence count values of all nodes, then compressing the buffer using the current static dictionary. The resulting compressed data is not retained; only, occurrence count values of nodes used are updated. This refresh will set the occurrence count values of all nodes that are not used to zero, thus possibly making the prune more accurate and possibly increasing the compression ratio.
  • Additionally and/or alternatively, in accordance with other aspects of the invention a non-branching sequential string of nodes storing characters of a respective byte-string may be replaced with a single node storing the corresponding characters and having only one symbol. By replacing a non-branching sequential string of nodes with a single node the amount of memory allocated for one or more data trees may be reduced and symbols available in a respective symbol table may be used more effectively. In accordance with other aspects of the invention, the last node in a non-branching sequential string of nodes may have multiple child nodes. However, every node preferably has only one parent node. The resulting collapsed path is known as a “one-way street”. Two exemplary methods of concatenating a non-branching string of sequential nodes are described below with reference to FIGS. 4A, 4B, 4C and 5.
  • Aspects of the invention may be embodied in a number of forms. For example, various aspects of the invention can be embodied in a suitable combination of hardware, software and firmware. In particular, some embodiments include, without limitation, entirely hardware, entirely software, entirely firmware or some suitable combination of hardware, software and firmware. In a preferred embodiment, the invention is implemented in software, which includes but is not limited to firmware, resident software, microcode, etc.
  • Additionally and/or alternatively, aspects of the invention can be embodied in the form of a computer program product accessible from a computer-usable or computer-readable medium providing program code for use by or in connection with a computer or any instruction execution system. For the purposes of this description, a computer-usable or computer readable medium can be any apparatus that can contain, store, communicate, propagate, or transport the program for use by or in connection with the instruction execution system, apparatus, or device.
  • A computer-readable medium can be an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system (or apparatus or device) or a propagation medium. Examples of a computer-readable medium include a semiconductor and/or solid-state memory, magnetic tape, a removable computer diskette, a random access memory (RAM), a read-only memory (ROM), a rigid magnetic disk and an optical disk. Current examples of optical disks include, without limitation, compact disk—read only memory (CD-ROM), compact disk—read/write (CD-R/W) and DVD.
  • In accordance with aspects of the invention, a data processing system suitable for storing and/or executing program code will include at least one processor coupled directly or indirectly to memory elements through a system bus. The memory elements can include local memory employed during actual execution of the program code, bulk storage, and cache memories which provide temporary storage of at least some program code in order to reduce the number of times code must be retrieved from bulk storage during execution.
  • Input/output (i.e. I/O devices)—including but not limited to keyboards, displays, pointing devices, etc.—can be coupled to the system either directly or through intervening I/O controllers.
  • Network adapters may also be coupled to the system to enable communication between multiple data processing systems, remote printers, or storage devices through intervening private or public networks. Modems, cable modems and Ethernet cards are just a few of the currently available types of network adapters.
  • In accordance with other aspects of the invention, a static dictionary includes a combination of a collection of one or more data trees and a symbol table. That is, a static dictionary is represented by a trie, which is a collection of multi-child trees in common prefix or common suffix form. The trie maps a byte-string to a symbol. Each data tree stores a respective set of byte-strings. The symbol table stores symbols relating to each byte-string stored in the collection of data trees. A symbol table is not necessary since the tree could always be exhaustively searched to find a given symbol. FIGS. 1A and 1C are illustrative examples of a data tree 200 and a symbol table, created from a partially shown data set 22 provided in FIG. 1B.
  • A static dictionary is only addressable in a finite amount of space, which means the number of symbols that may be used is limited. Thus, it is beneficial to select the most efficient symbols. In accordance with aspects of the present invention a definition of efficiency is the degree to which compression ratio is improved, while reducing the dictionary size.
  • Generally, each data tree includes a single root node and possibly one or more child nodes, where each node stores an arbitrary character and a corresponding symbol unique to the node that is also stored in the symbol table. A data tree extends from the root node. That is, a root node serves as a parent node to one or more child nodes storing the same or other characters as the root node. A particular child node may also serve as a parent node to additional child nodes that are lower in the data tree than the particular child node. However, it is preferable that each child node has only one direct parent node. It was noted above that each data tree stores a respective set of byte-strings. More specifically, each data tree is a common-prefix or common-suffix representation of a byte-string. As such, retrieval of a particular byte-string involves concatenating characters encountered on a direct path from the root node to a respective child node storing the last character of the byte-string.
  • In accordance with other aspects of the invention, each root node stores a unique byte from the Extended ASCII Character Set as a corresponding unique 8-bit binary number. Those skilled in the art will appreciate that there are 256 such unique 8-bit binary numbers in the Extended ASCII Character Set. Thus, in accordance with some aspects of the invention, there may be 256 root nodes for a corresponding set of 256 data trees included in the static dictionary. That is each of the 256 data trees is uniquely identifiable by the character stored in a respective root node. For example, a first root node may store the null character “ ”, a 65th root node may store the character “A” and a 97th root node may store the character “a”. Those skilled in the art will also appreciate that other character sets (e.g. the complex and simplified Chinese character sets) with more or less than 256 characters may also be used to define root nodes. Those skilled in the art will also appreciate that, while a byte is normally considered a binary pattern of 8-bits, aspects of the invention allow for different numbers of bits to be considered for the definition of characters and other types of information. As such, although aspects of the present invention are described below with respect to bytes, those skilled in the art will appreciate that a “byte” is interchangeable with a “binary pattern” of any length, which in turn means a “byte-string” is interchangeable with “binary pattern string”. Moreover, the terms “byte” and “byte-string” are only used for brevity and to help describe examples in accordance with aspects of the invention below, given that the concept of a “byte” is commonly understood in the art to include a collection of bits (e.g. 8-bits) grouped together.
  • Referring to FIGS. 1A and 1B, provided as an illustrative example only, shown is an example of the single data tree 200 created from the data set 22, which is partially shown including only a portion of the data set 22 relevant to the data tree 20. The data tree 200 has a root node 210, storing the character “A” and symbol “65”. The root node 210 has first and second child nodes 220 and 230, storing respective characters “b” and “l” with corresponding symbols “257” and “258”. The first child node 220 has third and fourth child nodes 222 and 224, storing respective characters “s” and “i” with corresponding symbols “261” and “270”. The second child node 230 has fifth and sixth child nodes 232 and 234, storing respective characters “i” and “t” with corresponding symbols “280” and “290”. Although the root node 210, and the first and second child nodes 220 and 230 are illustrated as specifically having two child nodes each, those skilled in the art will appreciate that more generally a node serving as a parent may have any number of child nodes.
  • Creating a data tree (e.g. tree 200) includes parsing through a data set (e.g. data set 22) or a sample portion of the data set and identifying repetitive byte-strings. The basic process involves adding child nodes to the ends of existing byte-strings stored in data trees. Such a process starts by matching an initial character from the data set to an appropriate root node and then matching subsequent characters to child nodes until the end of the byte-string is found. A new child node is then added to the end of the byte-string, and then the next character from the data set is matched to a corresponding root node and the process repeats. In accordance with aspects of the invention, a detailed example method of how data trees are constructed is described below with reference to FIG. 2.
  • A symbol table includes a listing of symbols. Each symbol is unique and corresponds to a particular node in one of the collection of data trees included in a static dictionary. Moreover, each symbol corresponds to the end of a respective byte-string. A symbol table also includes a listing of pointers, where each pointer corresponds to a particular node that a respective symbol corresponds to. As already noted, a static dictionary is a finite size. Thus, it is not always possible to store all byte-strings identified in a data set. Accordingly, a static dictionary is often grown in steps that include: growing the data trees until a predetermined number of nodes or symbols is reached; evaluating which nodes (and thus byte-strings) are worth keeping; removing (i.e. pruning) the nodes determined not to be worth keeping; repeating the growth and pruning of the data trees, as described, until the entire data set or sample portion of the data set has been processed; and finally pruning the data trees down to a desired final size (i.e. number of symbols or nodes).
  • Turning to FIG. 1C, shown is a portion of an example of a symbol table 110 including only information relevant to the data tree 200 shown in FIG. 1A. However, those skilled in the art will appreciate that a symbol table more specifically includes symbols from one or more data trees used to define a static dictionary. For the sake of illustrating the present example only, the pointer values for each symbol correspond to the reference indicia used in FIG. 1A. For example, symbol “270” is shown as having pointer “224”. Those skilled in the art will appreciate that a pointer refers to a storage location address. Moreover, also for the sake of illustrating present example only, the symbol table 110 (FIG. 1C) includes an extra “character-string field” 120 showing the byte-string implied by reference to each particular node in the symbol table 110.
  • For example, the symbol “270” corresponds to respective byte-string “Abi” which can be retrieved from the data tree 200 by concatenating characters encountered on a direct path from the root node 210 to the fourth child node 224. The byte-string “Abi” includes the byte-string “Ab”, which can be retrieved from the data tree 200 by concatenating characters encountered on a direct path from the root node 210 to the first child node 220. Moreover, with specific reference to FIG. 1B, it is clear that the shorter byte-string “Ab” is present in the data set 22 more often than the byte-string “Abi”. However, the byte-string “Abi” may provide a better compression ratio, and thus, in accordance with aspects of the invention, methods are provided that favor longer byte-strings, as opposed to the shorter byte-strings included near the beginning of the longer byte-strings. By contrast, previously known methods of building a static dictionary favor short byte-strings, such as “Ab”, that have higher frequency count values than longer byte-strings, such as “Abs”.
  • Briefly, in operation, using a static dictionary defined by a collection of data trees and a symbol table, compression is accomplished by: selecting characters from the data set; traversing the data trees until a child node is encountered that does not have any child nodes of its own; and inserting the symbol of that child node in place of a byte-string in the data set that matches a corresponding byte-string obtained in a direct path from a particular root node to the child node. On the other hand, expansion is accomplished by: parsing a compressed data set so as to identify symbols; retrieving a respective pointer for each symbol from the symbol table; and, inserting a corresponding byte-string back into the data set in place of a particular symbol, where the byte-string matches a corresponding byte-string obtained in a direct path from a particular root node to the child node.
  • Generally, compression ratio is defined as the size of data after compression divided by the size of the data before compression. The size of the data before and after compression is measurable in terms of bits, bytes, words frames and the like. Before a data set is compressed the size of the data includes the data set itself, whereas after a data set is compressed the size of the data includes the size of the compressed data set and the memory required to store the static dictionary. If multiple data sets can be compressed using the same static dictionary, then the compression ratio is calculated taking into account that the size of the data before compression is the sum of the sizes of the data sets, and the size of the data after compression is the sum of the sizes of the corresponding compressed data sets plus the memory required to store the static dictionary. Additionally and/or alternatively, the size of the static dictionary is not included in the calculation of compression ratio as its effect on compression is small.
  • Symbols can be evaluated in terms of efficiency. Efficiency of a symbol is calculated as the number of times a corresponding byte-string occurs in a data set (or portion of a data set) multiplied by the length of the byte-string.
  • Referring to FIG. 2, shown is a flow chart illustrating a first method of building a collection of data trees and simultaneously tabulating occurrence count values in accordance with aspects of the invention. For a given data set containing text characters (e.g. from the Extended ASCII Character Set), at step 2-1, the first method includes identifying the first/next character in the data set. More specifically, the method starts by identifying the first character in the data set, and subsequently identifying a next character when the method loops back to step 2-1 as described as follows.
  • At step 2-2, the method includes determining whether or not the character identified at step 2-1—whether it be the first or a next character—is a character and/or signal value indicating that the end of the data set has been reached (i.e. has the end of file marker been retrieved). If the end of the data set has been reached (yes path, step 2-2), then the method proceeds to step 2-12, which is described in greater detail below. On the other hand if the end of the data set has not been reached (no path, step 2-2), then the method proceeds to step 2-3 that includes selecting a respective root node. For example, as described above 256 different root nodes may be provided, where each root node corresponds to one of the characters included in the Extended ASCII Character Set.
  • Subsequently, at step 2-4, the method includes identifying the next character in the data set, and at step 2-5, determining whether or not the character identified at step 2-4 is a character and/or signal value indicating that the end of the data set has been reached. If the end of the data set has been reached (yes path, step 2-5), then the method proceeds to step 2-12, which is described in greater detail below. On the other hand, if the end of the data set has not been reached (no path, step 2-5), then the method proceeds to step 2-6.
  • At step 2-6, the method includes determining whether or not the current node—whether it is a root node or a child node—has a child node already storing the character identified at step 2-4. If there is a child node storing the character identified at step 2-4 (yes path, step 2-6), the method proceeds to step 2-7, where the method follows a respective branch to the identified child node before looping back to step 2-4. On the other hand, if the current node does not have a child node storing the character identified at step 2-4 (no path, step 2-6), the method proceeds to step 2-8.
  • At step 2-8, the method includes increasing the occurrence count for the current node, thereby indicating that the current node is the end of a byte-string that has been visited at least twice and serves as a parent to at least one child node. Subsequently, at step 2-9, the method includes adding a new child node to the current node, thereby making the current node a parent node to at least one child node. The newly added child node stores the character identified at step 2-4.
  • Step 2-10 of the method includes determining whether or not the current size of the static dictionary is at a predetermined temporary maximum size. If the current size of the static dictionary is not the predetermined temporary maximum size (no path, step 2-10), then the method loops back to step 2-1. On the other hand, if the current size of the static dictionary is the predetermined temporary maximum size (yes path, step 2-10), then the method proceeds to step 2-11 before looping back to step 2-1.
  • At step 2-11, the method includes pruning the size of static dictionary down to a predetermined temporary pruned value.
  • The method comes to an end after step 2-12. At step 2-12, the static dictionary is reduced (i.e. pruned) down to the desired final size.
  • In accordance with some aspects of the invention, reducing the size of the static dictionary (i.e. pruning) involves identifying the symbols with the low efficiency and removing them, while preserving the symbols with the high efficiency values. In accordance with some aspects of the invention, efficiency for a symbol is determined by the combination of the respective occurrence count for the symbol and the number of characters in the byte-string represented by the symbol. In accordance with other aspects of the invention, reducing the size of the static dictionary (i.e. pruning) involves identifying the symbols with low occurrence count values and removing them, while preserving the symbols with high occurrence count values.
  • In some embodiments the predetermined temporary maximum size is a multiple of the desired final size of the static dictionary. For example, the predetermined temporary maximum size may be 8 times the desired final size of the static dictionary. In other embodiments desired final size may be specified in terms of a number of symbols and/or a number of nodes. For example, the desired final size may be specified being 4096 symbols and the predetermined temporary maximum size would then be 32,768 symbols if 8 is the multiple used. Moreover, if 4096 symbols is the desired final size, 12 bits can be used to represent all the symbols in the set of 4096 symbols. In other embodiments, the desired final size may be specified in terms of a specified amount of memory.
  • Similarly, in some embodiments, the predetermined temporary pruned sized size is also a multiple of the desired final size of the static dictionary. For example, the predetermined temporary pruned size may be 4 times the desired final size of the static dictionary.
  • FIGS. 3A and 3B illustrate a second method of building a collection of data trees (i.e. a trie) and tabulating occurrence count values after at least a portion of the data trees have been created in accordance with aspects of the invention.
  • With specific reference to FIG. 3A, for a given data set containing text characters (e.g. from the Extended ASCII Character Set), starting at step 3-1, the second method includes loading a buffer with a portion of the data set. More specifically, it is preferable to load the buffer with a sample of the data set that has been deliberately constructed to be representative of the content of the data set. Again, it should be noted that the static dictionary is created in phases that include sequential steps of growing and pruning the static dictionary until a representative sample portion of the data set is processed or the entire data set is processed.
  • A static dictionary is a representation of the most frequently used sample of the input data. If the dictionary size is fixed at 4096 symbols, for instance, it does not usually matter whether 1,000 MB or 1,000,000 MB of data is processed. Hence, in accordance with some aspects of the invention, a static dictionary can be built from either an entire data set or just a sample of the data set loaded into a buffer. One advantage of using just a sample of the data set is that less data is processed, hence, the process is faster. Secondly, the buffer may be used to get accurate occurrence count values by sample compression. In order for the sample to have no bias, it preferable that the sample is uniformly representative of the whole data set.
  • At step 3-2, the method includes building a portion of a static dictionary as described above (with or without simultaneously tabulating respective occurrence count values for corresponding byte-strings) using the portion of the data set in the buffer. If the occurrence count values are tabulated while the portion of the static dictionary is being grown/built, all the occurrence count values are set to zero (or some other base value) before step 3-3. Step 3-3 includes tabulating the occurrence count values by performing a pseudo-matching step to identify the longest and most frequently occurring byte-strings. An exemplary method for tabulating the occurrence count values by performing a pseudo-matching step to identify the longest and most frequently occurring byte-strings is described below with reference to FIG. 3B.
  • Step 3-4 of the method includes pruning the static dictionary, as described above, down to a predetermined temporary pruned size. At step 3-5, the method includes pruning the static dictionary down to a desired final size. Then the second method ends.
  • Turing to FIG. 3B, starting at step B-1, the method includes identifying the first/next character in the buffer. More specifically, the method starts by identifying the first character in the buffer, and subsequently identifying a next character when the method loops back to step B-1 as described as follows.
  • At step B-2, the method includes determining whether or not the character identified at step B-1—whether it be the first or a next character—is a character and/or signal value indicating that the end of the buffer has been reached. If the end of the buffer has been reached (yes path, step B-2), then this portion of the method ends, and the method resumes at step 3-4 as described above with reference to FIG. 3A. On the other hand if the end of the buffer has not been reached (no path, step B-2), then the method proceeds to step B-3 that includes selecting a respective root node. For example, as described above 256 different root nodes may be provided, where each root node corresponds to one of the characters included in the Extended ASCII Character Set.
  • Subsequently, at step B-4, the method includes identifying the next character in the buffer, and at step B-5, determining whether or not the character identified at step B-4 is a character and/or signal value indicating that the end of the data set has been reached. If the end of the buffer has been reached (yes path, step B-5), then this portion of the method ends as described in the previous paragraph. On the other hand if the end of the data set has not been reached (no path, step B-5), then the method proceeds to step B-6.
  • At step B-6, the method includes determining whether or not the current node—whether it is a root node or a child node—has a child node already storing the character identified at step B-4. If there is a child node storing the character identified at step B-4 (yes path, step B-6), the method proceeds to step B-7, where the method follows a respective branch to the identified child node before looping back to step B-4. On the other hand, if the current node does not have a child node storing the character identified at step B-4 (no path, step B-6), the method proceeds to step B-8.
  • At step B-8, the method includes determining whether or not the current node is a root node. If the current node is not a root node (no path, step B-8), then the method proceeds to step B-9 that includes incrementing the occurrence count for the current node. On the other hand, if the current node is a root node (yes path, step B-8), the method loops back to step B-1.
  • Referring to FIGS. 4A, shown is a simple flow chart illustrating a third method of reducing a non-branching sequential string of nodes into a single node in accordance with aspects of the invention. Additionally, FIGS. 4B and 4C, show respective block diagram illustrations of an example data tree 400 and 400′ respectively before and after the method illustrated in the flow chart of FIG. 4A is applied.
  • With specific reference to FIG. 4A, starting at step 4-1, the method includes identifying a non-branching sequential string of child nodes with low occurrence count values (i.e. OC's, as illustrated in FIG. 4A). Step 4-2 includes replacing the non-branching sequential string of child nodes with a single child node storing the corresponding characters from the non-branching sequential string of nodes.
  • Turning to FIG. 4B, the data tree 400 is illustrated as it would conceptually exist before the method illustrated in FIG. 4A is applied. The data tree includes a root node 401, a non-branching sequential string of child nodes 402, 403, 404 and 405 extending from the root node 401 and another child node 406 also extending from the root node 401. The last child node 405 in the non-branching sequential string of child nodes has child nodes 407 and 408. The child node 408 has two non-branching sequential strings of child nodes 409, 410 and 411, 412, respectively.
  • A first byte-string represented by the child node 407 is “CANADA”, whereas a second byte-string represented by the child node 410 is “CANADIAN” and a third byte-string represented by the child node 412 is “CANADIEN”. Each of the first, second and third byte-strings shares a fourth common byte-string “ANAD” represented by the child node 405 without including the root node 401. Presumably, the fourth byte-string, which includes the non-branching sequential string of child nodes 402, 403, 404 and 405, would not have a high occurrence count as tabulated in accordance with aspects of the invention (as described for example in the specific examples above), since the fourth byte-string is simply a portion of the first, second and third byte-strings. Similarly, fifth and sixth byte-strings “AN” and “EN” between node 408 and nodes 410 and 412, respectively, would also not have high occurrence count values. Accordingly, when the method illustrated in FIG. 4A is applied to the data tree 400 the result is the data tree 400′, which represents the same byte-strings described above.
  • More specifically, with specific reference to FIG. 4C, the data tree 400′ also includes the root node 401 and the child node 406 as shown in FIG. 4B. However, instead of the non-branching sequential string of child nodes 402, 403, 404 and 405, the data tree 400′ includes a multi-character node 405′ storing the sequence of characters in the fourth byte-string “ANAD”. Similarly, the fifth and sixth byte-strings “AN” and “EN” are now stored in corresponding multi-character nodes 410′ and 412′, respectively.
  • Provided as an example, FIG. 5 shows a flow chart illustrating a fourth method of reducing a non-branching sequential string of nodes into a single node in accordance with aspects of the invention. Given a static dictionary with a collection of data trees having nodes with respective occurrence count values, starting at step 5-1, the method includes selecting a root node. At step 5-2, the method includes resetting a count value to zero. The count value represents the number of characters pushed on to a stack. Step 5-3 of the method includes determining whether or not the root selected at step 5-1 has any previously unselected child nodes. If the selected root node does not have any previously unselected child nodes (no path, step 5-3), then the method loops back to step 5-1. On the other hand, if the selected root node does have a previously unselected child node (yes path, step 5-3), then the method proceeds to step 5-4 that includes following the data tree to a previously unselected child node.
  • Step 5-5 of the method includes determining whether or not the child node is a parent node to multiple child nodes. If the child node is a parent to multiple child nodes (yes path, step 5-5), then the method proceeds to step 5-6. On the other hand, if the child node is not a parent to multiple child nodes (no path, step 5-5), then the method proceeds to step 5-9, which is described in detail further below.
  • At step 5-6 the method includes determining whether or not more than one character has been pushed onto the stack (i.e. is count>1). If more than one character has been pushed onto the stack (yes path, step 5-6), then the method proceeds to step 5-7. On the other hand, if less that two characters have been pushed onto the stack (no path, step 5-6), then the method proceeds to step 5-14 which is described in detail further below.
  • Step 5-7 of the method includes popping the characters on the stack and building a corresponding multi-character node. Subsequently, at step 5-8, the method includes replacing a respective non-branching sequential string of child nodes ( e.g. child nodes 402, 403, 404 and 405 in FIG. 4B) with the multi-character node (e.g. 405′) built at step 5-7, before looping back to step 5-2.
  • As noted above Step 5-9 follows from the step 5-5. At step 5-9, the method includes determining whether or not the child node selected at step 5-4 has one child node. If the child node does not have a child node (no path, step 5-9), the method follows to step 5-6 described above. On the other hand, if the child node has a single child node (yes path, step 5-9) the method proceeds to step 5-10.
  • At step 5-10, the method includes determining whether or not the child node selected at step 5-4 has a respective occurrence count value (OC) less than a minimum occurrence count threshold value (OCmin). If the respective occurrence count value is not less than a minimum occurrence count threshold value (no path, step 5-10), then the method follows to step 5-6 described above. If the respective occurrence count value is less than a minimum occurrence count threshold value (yes path, step 5-10), then the method proceeds to step 5-11.
  • Step 5-11 includes incrementing the count value to reflect the number of characters pushed to the stack. Step 5-12 includes pushing the character stored in the child node selected at step 5-4 onto the stack before going to the next child at step 5-13. Following step 5-13, the method follows back to step 5-5 described above.
  • At step 5-14, the method includes popping the stack without building a node before looping back to step 5-2.
  • While the above description provides example embodiments, it will be appreciated that the present invention is susceptible to modification and change without departing from the fair meaning and scope of the accompanying claims. Accordingly, what has been described is merely illustrative of the application of aspects of embodiments of the invention and numerous modifications and variations of the present invention are possible in light of the above teachings.

Claims (20)

1. (canceled)
2. A method for creating a static dictionary, the method comprising:
providing a plurality of data trees, each of the plurality of data trees comprising a root node, at least one of the plurality of data trees comprising at least one child node, wherein each root node and each child node stores an associated binary pattern, wherein each child node is adapted to store a symbol associated with the child node and an occurrence count value associated with the child node;
defining a binary pattern string the binary pattern string comprising a concatenation of the binary patterns in a direct path from the root node to a particular child node and wherein an occurrence count value for the binary pattern string is the occurrence count value of the particular child node;
incrementing the occurrence count value of the binary pattern string when the particular child node is visited; and
storing the respective unique symbols and corresponding pointers to particular child nodes in a symbol table.
3. A method for creating a static dictionary, the method comprising:
providing a plurality of data trees, each of the plurality of data trees comprising a root node, at least one of the plurality of data trees comprising at least one child node, wherein each root node and each child node stores an associated binary pattern wherein each child node is adapted to store a symbol associated with the child node and an occurrence count value associated with the child node;
defining a binary pattern string, the binary pattern string comprising a concatenation of the binary patterns in a direct path from the root node to a particular child node, and wherein an occurrence count value for the binary pattern string is the occurrence count value of the particular child node;
incrementing the occurrence count value of the binary pattern string when the particular child node is visited;
adding child nodes to the plurality of data trees until the combined size of the plurality of the data trees is a predetermined temporary maximum size; and
removing binary pattern strings using an evaluation of occurrence count values so as to reduce the combined size of the plurality of data trees down to a predetermined size.
4. The method according to claim 3, wherein incrementing the occurrence count value of a particular child node occurs only when the particular child node becomes a parent node to a new child node added to the static dictionary.
5. The method according to claim 3, wherein incrementing the occurrence count value of a particular child node occurs only when the particular child node is visited and the particular child node does not serve as a parent node to any other child nodes.
6. The method according to claim 3, wherein the predetermined size is one of a predetermined temporary pruned size and a predetermined desired final size.
7. The method according to claim 3, wherein removing binary pattern strings using an evaluation of occurrence count values comprises:
identifying binary pattern strings with low occurrence count values; and
deleting at least some of the child nodes included in the binary pattern string.
8. The method according to claim 3, wherein removing binary pattern strings using an evaluation of occurrence count values comprises:
identifying binary pattern strings with low efficiency values, wherein the efficiency value of a binary string is the occurrence count of the binary pattern string multiplied by the length of the binary pattern string; and
deleting at least some of the child nodes included in the binary pattern string.
9. The method according to claim 3 further comprising:
constructing a sample of the data set using the representative of the content of the data set;
storing the sample in a buffer; and
performing a sample compression by matching binary pattern strings in the buffer to binary pattern strings in the static dictionary to determine the occurrence count values of binary string patterns in the static dictionary.
10. The method according to claim 3 further comprising:
identifying a non-branching sequential string of child nodes with low occurrence count values; and
replacing the non-branching sequential string of child nodes with a single child node storing the corresponding binary patterns from the non-branching sequential string of nodes.
11. (canceled)
12. A system for creating a static dictionary, comprising:
an element for providing a plurality of data trees, each of the plurality of data trees comprising a root node, at least one of the plurality of data trees comprising at least one child node, wherein each root node and each child node stores an associated binary pattern, wherein each child node is adapted to store a symbol associated with the child node and an occurrence count value associated with the child node;
an element for defining a binary pattern string, the binary pattern string comprising a concatenation of the binary patterns in a direct path from the root node to a particular child node, and wherein an occurrence count value for the binary pattern string is the occurrence count value of the particular child node;
an element for incrementing the occurrence count value of the binary pattern string when the particular child node is visited; and
an element for storing the respective unique symbols and corresponding pointers to particular child nodes in a symbol table.
13. A system for creating a static dictionary, comprising:
an element for providing a plurality of data trees, each of the plurality of data trees comprising a root node, at least one of the plurality of data trees comprising at least one child node, wherein each root node and each child node stores an associated binary pattern, wherein each child node is adapted to store a symbol associated with the child node and an occurrence count value associated with the child node;
an element for defining a binary pattern string, the binary pattern string comprising a concatenation of the binary patterns in a direct path from the root node to a particular child node, and wherein an occurrence count value for the binary pattern string is the occurrence count value of the particular child node; and
an element for incrementing the occurrence count value of the binary pattern string when the particular child node is visited;
an element for adding child nodes to the plurality of data trees until the combined size of the plurality of the data trees is a predetermined temporary maximum size; and
an element for removing binary pattern strings using an evaluation of occurrence count values so as to reduce the combined size of the plurality of data trees down to a predetermined size.
14. A computer program product comprising a computer usable medium including computer usable program code for creating a static dictionary for use in lossless data compression and expansion, the computer program product including:
computer usable program code for providing a plurality of data trees, each of the plurality of data trees comprising a root node, at least one of the plurality of data trees comprising at least one child node, wherein each root node and each child node stores an associated binary pattern, wherein each child node is adapted to store a symbol associated with the child node and an occurrence count value associated with the child node;
computer usable program code for defining a binary pattern string, the binary pattern string comprising a concatenation of the binary patterns in a direct path from the root node to a particular child node, and wherein an occurrence count value for the binary pattern string is the occurrence count value of the particular child node;
computer usable program code for incrementing the occurrence count value of the binary pattern string when the particular child node is visited; and
computer usable program code for storing the respective unique symbols and corresponding pointers to particular child nodes in a symbol table.
15. (canceled)
16. The computer program product according to claim 14, further including:
computer usable program code for adding child nodes to the plurality of data trees until the combined size of the plurality of the data trees is a predetermined temporary maximum size; and
computer usable program code for removing binary pattern strings using an evaluation of occurrence count values so as to reduce the combined size of the plurality of data trees down to a predetermined size.
17. The computer program product according to claim 16, further including computer usable program code for incrementing the occurrence count value of a particular child node occurs only when the particular child node becomes a parent node to a new child node added to the static dictionary.
18. The computer program product according to claim 14, further including:
computer usable program code for constructing a sample of the data set using the representative of the content of the data set;
computer usable program code for storing the sample in a buffer; and
computer usable program code for performing a sample compression by matching binary pattern strings in the buffer to binary pattern strings in the static dictionary to determine the occurrence count values of binary string patterns in the static dictionary.
19. The computer program product according to claim 18, wherein incrementing the occurrence count value of a particular child node occurs only when the particular child node is visited during the sample compression for tabulating occurrence count values and the particular child node does not serve as a parent node to any other child nodes.
20. The computer program product according to claim 14, further including:
computer usable program code for identifying a non-branching sequential string of child nodes with low occurrence count values; and
computer usable program code for replacing the non-branching sequential string of child nodes with a single child node storing the corresponding binary patterns from the non-branching sequential string of nodes.
US11/278,118 2006-03-30 2006-03-30 Methods of creating a dictionary for data compression Expired - Fee Related US7283072B1 (en)

Priority Applications (2)

Application Number Priority Date Filing Date Title
US11/278,118 US7283072B1 (en) 2006-03-30 2006-03-30 Methods of creating a dictionary for data compression
US11/781,833 US8037034B2 (en) 2006-03-30 2007-07-23 Methods of creating a dictionary for data compression

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
US11/278,118 US7283072B1 (en) 2006-03-30 2006-03-30 Methods of creating a dictionary for data compression

Related Child Applications (1)

Application Number Title Priority Date Filing Date
US11/781,833 Continuation US8037034B2 (en) 2006-03-30 2007-07-23 Methods of creating a dictionary for data compression

Publications (2)

Publication Number Publication Date
US20070229323A1 true US20070229323A1 (en) 2007-10-04
US7283072B1 US7283072B1 (en) 2007-10-16

Family

ID=38558045

Family Applications (2)

Application Number Title Priority Date Filing Date
US11/278,118 Expired - Fee Related US7283072B1 (en) 2006-03-30 2006-03-30 Methods of creating a dictionary for data compression
US11/781,833 Expired - Fee Related US8037034B2 (en) 2006-03-30 2007-07-23 Methods of creating a dictionary for data compression

Family Applications After (1)

Application Number Title Priority Date Filing Date
US11/781,833 Expired - Fee Related US8037034B2 (en) 2006-03-30 2007-07-23 Methods of creating a dictionary for data compression

Country Status (1)

Country Link
US (2) US7283072B1 (en)

Cited By (124)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20080114765A1 (en) * 2005-06-30 2008-05-15 Fujitsu Limited Computer program, method, and apparatus for data sorting
US20100115137A1 (en) * 2008-11-05 2010-05-06 Samsung Electronics Co., Ltd. Data compression method and data communication system utilizing the same
US20100235780A1 (en) * 2009-03-16 2010-09-16 Westerman Wayne C System and Method for Identifying Words Based on a Sequence of Keyboard Events
US8838551B2 (en) 2011-10-21 2014-09-16 International Business Machines Corporation Multi-level database compression
US8892446B2 (en) 2010-01-18 2014-11-18 Apple Inc. Service orchestration for intelligent automated assistant
US8994660B2 (en) 2011-08-29 2015-03-31 Apple Inc. Text correction processing
US9086802B2 (en) 2008-01-09 2015-07-21 Apple Inc. Method, device, and graphical user interface providing word recommendations for text input
US9189079B2 (en) 2007-01-05 2015-11-17 Apple Inc. Method, system, and graphical user interface for providing word recommendations
US9262612B2 (en) 2011-03-21 2016-02-16 Apple Inc. Device access using voice authentication
US9300784B2 (en) 2013-06-13 2016-03-29 Apple Inc. System and method for emergency calls initiated by voice command
US9330720B2 (en) 2008-01-03 2016-05-03 Apple Inc. Methods and apparatus for altering audio output signals
US9338493B2 (en) 2014-06-30 2016-05-10 Apple Inc. Intelligent automated assistant for TV user interactions
US9368114B2 (en) 2013-03-14 2016-06-14 Apple Inc. Context-sensitive handling of interruptions
US9430463B2 (en) 2014-05-30 2016-08-30 Apple Inc. Exemplar-based natural language processing
US9483461B2 (en) 2012-03-06 2016-11-01 Apple Inc. Handling speech synthesis of content for multiple languages
US9495129B2 (en) 2012-06-29 2016-11-15 Apple Inc. Device, method, and user interface for voice-activated navigation and browsing of a document
US9502031B2 (en) 2014-05-27 2016-11-22 Apple Inc. Method for supporting dynamic grammars in WFST-based ASR
US9535906B2 (en) 2008-07-31 2017-01-03 Apple Inc. Mobile device having human language translation capability with positional feedback
US9576574B2 (en) 2012-09-10 2017-02-21 Apple Inc. Context-sensitive handling of interruptions by intelligent digital assistant
US9582608B2 (en) 2013-06-07 2017-02-28 Apple Inc. Unified ranking with entropy-weighted information for phrase-based semantic auto-completion
US9606986B2 (en) 2014-09-29 2017-03-28 Apple Inc. Integrated word N-gram and class M-gram language models
US9620104B2 (en) 2013-06-07 2017-04-11 Apple Inc. System and method for user-specified pronunciation of words for speech synthesis and recognition
US9620105B2 (en) 2014-05-15 2017-04-11 Apple Inc. Analyzing audio input for efficient speech and music recognition
US9626955B2 (en) 2008-04-05 2017-04-18 Apple Inc. Intelligent text-to-speech conversion
US9633674B2 (en) 2013-06-07 2017-04-25 Apple Inc. System and method for detecting errors in interactions with a voice-based digital assistant
US9633660B2 (en) 2010-02-25 2017-04-25 Apple Inc. User profiling for voice input processing
US9633004B2 (en) 2014-05-30 2017-04-25 Apple Inc. Better resolution when referencing to concepts
US9646609B2 (en) 2014-09-30 2017-05-09 Apple Inc. Caching apparatus for serving phonetic pronunciations
US9646614B2 (en) 2000-03-16 2017-05-09 Apple Inc. Fast, language-independent method for user authentication by voice
US9668121B2 (en) 2014-09-30 2017-05-30 Apple Inc. Social reminders
US9697822B1 (en) 2013-03-15 2017-07-04 Apple Inc. System and method for updating an adaptive speech recognition model
US9697820B2 (en) 2015-09-24 2017-07-04 Apple Inc. Unit-selection text-to-speech synthesis using concatenation-sensitive neural networks
US9711141B2 (en) 2014-12-09 2017-07-18 Apple Inc. Disambiguating heteronyms in speech synthesis
US9715875B2 (en) 2014-05-30 2017-07-25 Apple Inc. Reducing the need for manual start/end-pointing and trigger phrases
US9721566B2 (en) 2015-03-08 2017-08-01 Apple Inc. Competing devices responding to voice triggers
US9734193B2 (en) 2014-05-30 2017-08-15 Apple Inc. Determining domain salience ranking from ambiguous words in natural speech
US9760559B2 (en) 2014-05-30 2017-09-12 Apple Inc. Predictive text input
US9785630B2 (en) 2014-05-30 2017-10-10 Apple Inc. Text prediction using combined word N-gram and unigram language models
US9818400B2 (en) 2014-09-11 2017-11-14 Apple Inc. Method and apparatus for discovering trending terms in speech requests
US9842101B2 (en) 2014-05-30 2017-12-12 Apple Inc. Predictive conversion of language input
US9842105B2 (en) 2015-04-16 2017-12-12 Apple Inc. Parsimonious continuous-space phrase representations for natural language processing
US9858925B2 (en) 2009-06-05 2018-01-02 Apple Inc. Using context information to facilitate processing of commands in a virtual assistant
US9865280B2 (en) 2015-03-06 2018-01-09 Apple Inc. Structured dictation using intelligent automated assistants
US9886953B2 (en) 2015-03-08 2018-02-06 Apple Inc. Virtual assistant activation
US9886432B2 (en) 2014-09-30 2018-02-06 Apple Inc. Parsimonious handling of word inflection via categorical stem + suffix N-gram language models
US9899019B2 (en) 2015-03-18 2018-02-20 Apple Inc. Systems and methods for structured stem and suffix language models
US9922642B2 (en) 2013-03-15 2018-03-20 Apple Inc. Training an at least partial voice command system
US9934775B2 (en) 2016-05-26 2018-04-03 Apple Inc. Unit-selection text-to-speech synthesis based on predicted concatenation parameters
US9953088B2 (en) 2012-05-14 2018-04-24 Apple Inc. Crowd sourcing information to fulfill user requests
US9959870B2 (en) 2008-12-11 2018-05-01 Apple Inc. Speech recognition involving a mobile device
US9966068B2 (en) 2013-06-08 2018-05-08 Apple Inc. Interpreting and acting upon commands that involve sharing information with remote devices
US9966065B2 (en) 2014-05-30 2018-05-08 Apple Inc. Multi-command single utterance input method
US9971774B2 (en) 2012-09-19 2018-05-15 Apple Inc. Voice-based media searching
US9972304B2 (en) 2016-06-03 2018-05-15 Apple Inc. Privacy preserving distributed evaluation framework for embedded personalized systems
US10043516B2 (en) 2016-09-23 2018-08-07 Apple Inc. Intelligent automated assistant
US10049663B2 (en) 2016-06-08 2018-08-14 Apple, Inc. Intelligent automated assistant for media exploration
US10049668B2 (en) 2015-12-02 2018-08-14 Apple Inc. Applying neural network language models to weighted finite state transducers for automatic speech recognition
US10057736B2 (en) 2011-06-03 2018-08-21 Apple Inc. Active transport based notifications
US10067938B2 (en) 2016-06-10 2018-09-04 Apple Inc. Multilingual word prediction
US10074360B2 (en) 2014-09-30 2018-09-11 Apple Inc. Providing an indication of the suitability of speech recognition
US10078631B2 (en) 2014-05-30 2018-09-18 Apple Inc. Entropy-guided text prediction using combined word and character n-gram language models
US10079014B2 (en) 2012-06-08 2018-09-18 Apple Inc. Name recognition system
US10083688B2 (en) 2015-05-27 2018-09-25 Apple Inc. Device voice control for selecting a displayed affordance
US10089072B2 (en) 2016-06-11 2018-10-02 Apple Inc. Intelligent device arbitration and control
US10101822B2 (en) 2015-06-05 2018-10-16 Apple Inc. Language input correction
US10127220B2 (en) 2015-06-04 2018-11-13 Apple Inc. Language identification from short strings
US10127911B2 (en) 2014-09-30 2018-11-13 Apple Inc. Speaker identification and unsupervised speaker adaptation techniques
US10134385B2 (en) 2012-03-02 2018-11-20 Apple Inc. Systems and methods for name pronunciation
US10170123B2 (en) 2014-05-30 2019-01-01 Apple Inc. Intelligent assistant for home automation
US10176167B2 (en) 2013-06-09 2019-01-08 Apple Inc. System and method for inferring user intent from speech inputs
US10186254B2 (en) 2015-06-07 2019-01-22 Apple Inc. Context-based endpoint detection
US10185542B2 (en) 2013-06-09 2019-01-22 Apple Inc. Device, method, and graphical user interface for enabling conversation persistence across two or more instances of a digital assistant
US10192552B2 (en) 2016-06-10 2019-01-29 Apple Inc. Digital assistant providing whispered speech
US10199051B2 (en) 2013-02-07 2019-02-05 Apple Inc. Voice trigger for a digital assistant
US10223066B2 (en) 2015-12-23 2019-03-05 Apple Inc. Proactive assistance based on dialog communication between devices
US10241752B2 (en) 2011-09-30 2019-03-26 Apple Inc. Interface for a virtual digital assistant
US10241644B2 (en) 2011-06-03 2019-03-26 Apple Inc. Actionable reminder entries
US10249300B2 (en) 2016-06-06 2019-04-02 Apple Inc. Intelligent list reading
US10255907B2 (en) 2015-06-07 2019-04-09 Apple Inc. Automatic accent detection using acoustic models
US10269345B2 (en) 2016-06-11 2019-04-23 Apple Inc. Intelligent task discovery
US10276170B2 (en) 2010-01-18 2019-04-30 Apple Inc. Intelligent automated assistant
US10283110B2 (en) 2009-07-02 2019-05-07 Apple Inc. Methods and apparatuses for automatic speech recognition
US10289433B2 (en) 2014-05-30 2019-05-14 Apple Inc. Domain specific language for encoding assistant dialog
US10297253B2 (en) 2016-06-11 2019-05-21 Apple Inc. Application integration with a digital assistant
US10318871B2 (en) 2005-09-08 2019-06-11 Apple Inc. Method and apparatus for building an intelligent automated assistant
US10332518B2 (en) 2017-05-09 2019-06-25 Apple Inc. User interface for correcting recognition errors
US10356243B2 (en) 2015-06-05 2019-07-16 Apple Inc. Virtual assistant aided communication with 3rd party service in a communication session
US10354011B2 (en) 2016-06-09 2019-07-16 Apple Inc. Intelligent automated assistant in a home environment
US10366158B2 (en) 2015-09-29 2019-07-30 Apple Inc. Efficient word encoding for recurrent neural network language models
US10410637B2 (en) 2017-05-12 2019-09-10 Apple Inc. User-specific acoustic models
US10446141B2 (en) 2014-08-28 2019-10-15 Apple Inc. Automatic speech recognition based on user feedback
US10446143B2 (en) 2016-03-14 2019-10-15 Apple Inc. Identification of voice inputs providing credentials
US10482874B2 (en) 2017-05-15 2019-11-19 Apple Inc. Hierarchical belief states for digital assistants
US10490187B2 (en) 2016-06-10 2019-11-26 Apple Inc. Digital assistant providing automated status report
US10496753B2 (en) 2010-01-18 2019-12-03 Apple Inc. Automatically adapting user interfaces for hands-free interaction
US10509862B2 (en) 2016-06-10 2019-12-17 Apple Inc. Dynamic phrase expansion of language input
US10521466B2 (en) 2016-06-11 2019-12-31 Apple Inc. Data driven natural language event detection and classification
US10552013B2 (en) 2014-12-02 2020-02-04 Apple Inc. Data detection
US10553209B2 (en) 2010-01-18 2020-02-04 Apple Inc. Systems and methods for hands-free notification summaries
US10567477B2 (en) 2015-03-08 2020-02-18 Apple Inc. Virtual assistant continuity
US10568032B2 (en) 2007-04-03 2020-02-18 Apple Inc. Method and system for operating a multi-function portable electronic device using voice-activation
US10592095B2 (en) 2014-05-23 2020-03-17 Apple Inc. Instantaneous speaking of content on touch devices
US10593346B2 (en) 2016-12-22 2020-03-17 Apple Inc. Rank-reduced token representation for automatic speech recognition
US10659851B2 (en) 2014-06-30 2020-05-19 Apple Inc. Real-time digital assistant knowledge updates
US10671428B2 (en) 2015-09-08 2020-06-02 Apple Inc. Distributed personal assistant
US10679605B2 (en) 2010-01-18 2020-06-09 Apple Inc. Hands-free list-reading by intelligent automated assistant
US10691473B2 (en) 2015-11-06 2020-06-23 Apple Inc. Intelligent automated assistant in a messaging environment
US10705794B2 (en) 2010-01-18 2020-07-07 Apple Inc. Automatically adapting user interfaces for hands-free interaction
US10706373B2 (en) 2011-06-03 2020-07-07 Apple Inc. Performing actions associated with task items that represent tasks to perform
US10733993B2 (en) 2016-06-10 2020-08-04 Apple Inc. Intelligent digital assistant in a multi-tasking environment
US10747498B2 (en) 2015-09-08 2020-08-18 Apple Inc. Zero latency digital assistant
US10755703B2 (en) 2017-05-11 2020-08-25 Apple Inc. Offline personal assistant
US10762293B2 (en) 2010-12-22 2020-09-01 Apple Inc. Using parts-of-speech tagging and named entity recognition for spelling correction
US10789945B2 (en) 2017-05-12 2020-09-29 Apple Inc. Low-latency intelligent automated assistant
US10789041B2 (en) 2014-09-12 2020-09-29 Apple Inc. Dynamic thresholds for always listening speech trigger
US10791176B2 (en) 2017-05-12 2020-09-29 Apple Inc. Synchronization and task delegation of a digital assistant
US10791216B2 (en) 2013-08-06 2020-09-29 Apple Inc. Auto-activating smart responses based on activities from remote devices
US10810274B2 (en) 2017-05-15 2020-10-20 Apple Inc. Optimizing dialogue policy decisions for digital assistants using implicit feedback
US11010550B2 (en) 2015-09-29 2021-05-18 Apple Inc. Unified language modeling framework for word prediction, auto-completion and auto-correction
US11025565B2 (en) 2015-06-07 2021-06-01 Apple Inc. Personalized prediction of responses for instant messaging
US11068444B2 (en) 2014-12-27 2021-07-20 Ascava, Inc. Using a distributed prime data sieve for efficient lossless reduction, search, and retrieval of data
US11217255B2 (en) 2017-05-16 2022-01-04 Apple Inc. Far-field extension for digital assistant services
US11281993B2 (en) 2016-12-05 2022-03-22 Apple Inc. Model and ensemble compression for metric learning
US11587559B2 (en) 2015-09-30 2023-02-21 Apple Inc. Intelligent device identification

Families Citing this family (72)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US7460033B2 (en) * 2006-12-28 2008-12-02 International Business Machines Corporation Method for creating an in-memory physical dictionary for data compression
US8185551B2 (en) * 2007-06-08 2012-05-22 Massachusetts Institute Of Technology Disk-resident streaming dictionary
US10002189B2 (en) 2007-12-20 2018-06-19 Apple Inc. Method and apparatus for searching using an active ontology
US8326605B2 (en) * 2008-04-24 2012-12-04 International Business Machines Incorporation Dictionary for textual data compression and decompression
US8326604B2 (en) * 2008-04-24 2012-12-04 International Business Machines Corporation Dictionary for textual data compression and decompression
US8676904B2 (en) 2008-10-02 2014-03-18 Apple Inc. Electronic devices with voice command and contextual data processing capabilities
US20100185652A1 (en) * 2009-01-16 2010-07-22 International Business Machines Corporation Multi-Dimensional Resource Fallback
WO2011089450A2 (en) 2010-01-25 2011-07-28 Andrew Peter Nelson Jerram Apparatuses, methods and systems for a digital conversation management platform
US8392433B2 (en) * 2011-04-14 2013-03-05 Amund Tveit Self-indexer and self indexing system
US10417037B2 (en) 2012-05-15 2019-09-17 Apple Inc. Systems and methods for integrating third party services with a digital assistant
US10652394B2 (en) 2013-03-14 2020-05-12 Apple Inc. System and method for processing voicemail
US10748529B1 (en) 2013-03-15 2020-08-18 Apple Inc. Voice activated device for use with a voice-based digital assistant
US8933829B2 (en) * 2013-09-23 2015-01-13 International Business Machines Corporation Data compression using dictionary encoding
US10296160B2 (en) 2013-12-06 2019-05-21 Apple Inc. Method for extracting salient dialog usage from live data
US10152299B2 (en) 2015-03-06 2018-12-11 Apple Inc. Reducing response latency of intelligent automated assistants
US10460227B2 (en) 2015-05-15 2019-10-29 Apple Inc. Virtual assistant in a communication session
US10200824B2 (en) 2015-05-27 2019-02-05 Apple Inc. Systems and methods for proactively identifying and surfacing relevant content on a touch-sensitive device
US20160378747A1 (en) 2015-06-29 2016-12-29 Apple Inc. Virtual assistant for media playback
US10331312B2 (en) 2015-09-08 2019-06-25 Apple Inc. Intelligent automated assistant in a media environment
US10740384B2 (en) 2015-09-08 2020-08-11 Apple Inc. Intelligent automated assistant for media search and playback
US10956666B2 (en) 2015-11-09 2021-03-23 Apple Inc. Unconventional virtual assistant interactions
US11227589B2 (en) 2016-06-06 2022-01-18 Apple Inc. Intelligent list reading
US10474753B2 (en) 2016-09-07 2019-11-12 Apple Inc. Language identification using recurrent neural networks
US11204787B2 (en) 2017-01-09 2021-12-21 Apple Inc. Application integration with a digital assistant
US10417266B2 (en) 2017-05-09 2019-09-17 Apple Inc. Context-aware ranking of intelligent response suggestions
US10395654B2 (en) 2017-05-11 2019-08-27 Apple Inc. Text normalization based on a data-driven learning network
US10726832B2 (en) 2017-05-11 2020-07-28 Apple Inc. Maintaining privacy of personal information
US11301477B2 (en) 2017-05-12 2022-04-12 Apple Inc. Feedback analysis of a digital assistant
US20180336892A1 (en) 2017-05-16 2018-11-22 Apple Inc. Detecting a trigger of a digital assistant
US10311144B2 (en) 2017-05-16 2019-06-04 Apple Inc. Emoji word sense disambiguation
US10403278B2 (en) 2017-05-16 2019-09-03 Apple Inc. Methods and systems for phonetic matching in digital assistant services
US20180336275A1 (en) 2017-05-16 2018-11-22 Apple Inc. Intelligent automated assistant for media exploration
US10657328B2 (en) 2017-06-02 2020-05-19 Apple Inc. Multi-task recurrent neural network architecture for efficient morphology handling in neural language modeling
US10445429B2 (en) 2017-09-21 2019-10-15 Apple Inc. Natural language understanding using vocabularies with compressed serialized tries
US10755051B2 (en) 2017-09-29 2020-08-25 Apple Inc. Rule-based natural language processing
US10956440B2 (en) 2017-10-16 2021-03-23 International Business Machines Corporation Compressing a plurality of documents
US10636424B2 (en) 2017-11-30 2020-04-28 Apple Inc. Multi-turn canned dialog
US10733982B2 (en) 2018-01-08 2020-08-04 Apple Inc. Multi-directional dialog
US10733375B2 (en) 2018-01-31 2020-08-04 Apple Inc. Knowledge-based framework for improving natural language understanding
US10789959B2 (en) 2018-03-02 2020-09-29 Apple Inc. Training speaker recognition models for digital assistants
US10592604B2 (en) 2018-03-12 2020-03-17 Apple Inc. Inverse text normalization for automatic speech recognition
US10818288B2 (en) 2018-03-26 2020-10-27 Apple Inc. Natural assistant interaction
US10909331B2 (en) 2018-03-30 2021-02-02 Apple Inc. Implicit identification of translation payload with neural machine translation
US11145294B2 (en) 2018-05-07 2021-10-12 Apple Inc. Intelligent automated assistant for delivering content from user experiences
US10928918B2 (en) 2018-05-07 2021-02-23 Apple Inc. Raise to speak
US10984780B2 (en) 2018-05-21 2021-04-20 Apple Inc. Global semantic word embeddings using bi-directional recurrent neural networks
DK180639B1 (en) 2018-06-01 2021-11-04 Apple Inc DISABILITY OF ATTENTION-ATTENTIVE VIRTUAL ASSISTANT
DK201870355A1 (en) 2018-06-01 2019-12-16 Apple Inc. Virtual assistant operation in multi-device environments
DK179822B1 (en) 2018-06-01 2019-07-12 Apple Inc. Voice interaction at a primary device to access call functionality of a companion device
US10892996B2 (en) 2018-06-01 2021-01-12 Apple Inc. Variable latency device coordination
US11386266B2 (en) 2018-06-01 2022-07-12 Apple Inc. Text correction
US11076039B2 (en) 2018-06-03 2021-07-27 Apple Inc. Accelerated task performance
US11010561B2 (en) 2018-09-27 2021-05-18 Apple Inc. Sentiment prediction from textual data
US11170166B2 (en) 2018-09-28 2021-11-09 Apple Inc. Neural typographical error modeling via generative adversarial networks
US11462215B2 (en) 2018-09-28 2022-10-04 Apple Inc. Multi-modal inputs for voice commands
US10839159B2 (en) 2018-09-28 2020-11-17 Apple Inc. Named entity normalization in a spoken dialog system
US11475898B2 (en) 2018-10-26 2022-10-18 Apple Inc. Low-latency multi-speaker speech recognition
US11309908B2 (en) * 2018-11-26 2022-04-19 Fungible, Inc. Static dictionary-based compression hardware pipeline for data compression accelerator of a data processing unit
US11638059B2 (en) 2019-01-04 2023-04-25 Apple Inc. Content playback on multiple devices
US11348573B2 (en) 2019-03-18 2022-05-31 Apple Inc. Multimodality in digital assistant systems
US11475884B2 (en) 2019-05-06 2022-10-18 Apple Inc. Reducing digital assistant latency when a language is incorrectly determined
US11423908B2 (en) 2019-05-06 2022-08-23 Apple Inc. Interpreting spoken requests
US11307752B2 (en) 2019-05-06 2022-04-19 Apple Inc. User configurable task triggers
US11217251B2 (en) 2019-05-06 2022-01-04 Apple Inc. Spoken notifications
US11140099B2 (en) 2019-05-21 2021-10-05 Apple Inc. Providing message response suggestions
US11289073B2 (en) 2019-05-31 2022-03-29 Apple Inc. Device text to speech
DK180129B1 (en) 2019-05-31 2020-06-02 Apple Inc. User activity shortcut suggestions
US11496600B2 (en) 2019-05-31 2022-11-08 Apple Inc. Remote execution of machine-learned models
DK201970510A1 (en) 2019-05-31 2021-02-11 Apple Inc Voice identification in digital assistant systems
US11360641B2 (en) 2019-06-01 2022-06-14 Apple Inc. Increasing the relevance of new available information
WO2021056255A1 (en) 2019-09-25 2021-04-01 Apple Inc. Text detection using global geometry estimators
US11038934B1 (en) 2020-05-11 2021-06-15 Apple Inc. Digital assistant hardware abstraction

Citations (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5151697A (en) * 1990-10-15 1992-09-29 Board Of Regents Of The University Of Washington Data structure management tagging system
US5936560A (en) * 1996-12-04 1999-08-10 Fujitsu Limited Data compression method and apparatus performing high-speed comparison between data stored in a dictionary window and data to be compressed
US6657564B2 (en) * 2001-12-13 2003-12-02 International Business Machines Corporation Method and apparatus for compressing data in which dictionary sizes are reduced
US7164370B1 (en) * 2005-10-06 2007-01-16 Analog Devices, Inc. System and method for decoding data compressed in accordance with dictionary-based compression schemes

Family Cites Families (3)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
JP3522331B2 (en) * 1994-04-22 2004-04-26 株式会社セタ Data compression method
JP2006503502A (en) * 2002-10-18 2006-01-26 シンボル テクノロジーズ インコーポレイテッド Method for efficiently reading a set of radio frequency identification tags having a unique identification number in the presence of a noisy radio
US6988180B2 (en) * 2003-09-29 2006-01-17 Microsoft Corporation Method and apparatus for lock-free, non-blocking hash table

Patent Citations (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5151697A (en) * 1990-10-15 1992-09-29 Board Of Regents Of The University Of Washington Data structure management tagging system
US5936560A (en) * 1996-12-04 1999-08-10 Fujitsu Limited Data compression method and apparatus performing high-speed comparison between data stored in a dictionary window and data to be compressed
US6657564B2 (en) * 2001-12-13 2003-12-02 International Business Machines Corporation Method and apparatus for compressing data in which dictionary sizes are reduced
US7164370B1 (en) * 2005-10-06 2007-01-16 Analog Devices, Inc. System and method for decoding data compressed in accordance with dictionary-based compression schemes

Cited By (171)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US9646614B2 (en) 2000-03-16 2017-05-09 Apple Inc. Fast, language-independent method for user authentication by voice
US8122064B2 (en) * 2005-06-30 2012-02-21 Fujitsu Limited Computer program, method, and apparatus for data sorting
US20080114765A1 (en) * 2005-06-30 2008-05-15 Fujitsu Limited Computer program, method, and apparatus for data sorting
US10318871B2 (en) 2005-09-08 2019-06-11 Apple Inc. Method and apparatus for building an intelligent automated assistant
US8930191B2 (en) 2006-09-08 2015-01-06 Apple Inc. Paraphrasing of user requests and results by automated digital assistant
US9117447B2 (en) 2006-09-08 2015-08-25 Apple Inc. Using event alert text as input to an automated assistant
US8942986B2 (en) 2006-09-08 2015-01-27 Apple Inc. Determining user intent based on ontologies of domains
US10592100B2 (en) 2007-01-05 2020-03-17 Apple Inc. Method, system, and graphical user interface for providing word recommendations
US11112968B2 (en) 2007-01-05 2021-09-07 Apple Inc. Method, system, and graphical user interface for providing word recommendations
US11416141B2 (en) 2007-01-05 2022-08-16 Apple Inc. Method, system, and graphical user interface for providing word recommendations
US9189079B2 (en) 2007-01-05 2015-11-17 Apple Inc. Method, system, and graphical user interface for providing word recommendations
US9244536B2 (en) 2007-01-05 2016-01-26 Apple Inc. Method, system, and graphical user interface for providing word recommendations
US10568032B2 (en) 2007-04-03 2020-02-18 Apple Inc. Method and system for operating a multi-function portable electronic device using voice-activation
US9330720B2 (en) 2008-01-03 2016-05-03 Apple Inc. Methods and apparatus for altering audio output signals
US10381016B2 (en) 2008-01-03 2019-08-13 Apple Inc. Methods and apparatus for altering audio output signals
US11474695B2 (en) 2008-01-09 2022-10-18 Apple Inc. Method, device, and graphical user interface providing word recommendations for text input
US9086802B2 (en) 2008-01-09 2015-07-21 Apple Inc. Method, device, and graphical user interface providing word recommendations for text input
US11079933B2 (en) 2008-01-09 2021-08-03 Apple Inc. Method, device, and graphical user interface providing word recommendations for text input
US9865248B2 (en) 2008-04-05 2018-01-09 Apple Inc. Intelligent text-to-speech conversion
US9626955B2 (en) 2008-04-05 2017-04-18 Apple Inc. Intelligent text-to-speech conversion
US9535906B2 (en) 2008-07-31 2017-01-03 Apple Inc. Mobile device having human language translation capability with positional feedback
US10108612B2 (en) 2008-07-31 2018-10-23 Apple Inc. Mobile device having human language translation capability with positional feedback
US20100115137A1 (en) * 2008-11-05 2010-05-06 Samsung Electronics Co., Ltd. Data compression method and data communication system utilizing the same
US9959870B2 (en) 2008-12-11 2018-05-01 Apple Inc. Speech recognition involving a mobile device
US20100235780A1 (en) * 2009-03-16 2010-09-16 Westerman Wayne C System and Method for Identifying Words Based on a Sequence of Keyboard Events
US10795541B2 (en) 2009-06-05 2020-10-06 Apple Inc. Intelligent organization of tasks items
US11080012B2 (en) 2009-06-05 2021-08-03 Apple Inc. Interface for a virtual digital assistant
US9858925B2 (en) 2009-06-05 2018-01-02 Apple Inc. Using context information to facilitate processing of commands in a virtual assistant
US10475446B2 (en) 2009-06-05 2019-11-12 Apple Inc. Using context information to facilitate processing of commands in a virtual assistant
US10283110B2 (en) 2009-07-02 2019-05-07 Apple Inc. Methods and apparatuses for automatic speech recognition
US11423886B2 (en) 2010-01-18 2022-08-23 Apple Inc. Task flow identification based on user intent
US10276170B2 (en) 2010-01-18 2019-04-30 Apple Inc. Intelligent automated assistant
US8892446B2 (en) 2010-01-18 2014-11-18 Apple Inc. Service orchestration for intelligent automated assistant
US8903716B2 (en) 2010-01-18 2014-12-02 Apple Inc. Personalized vocabulary for digital assistant
US9318108B2 (en) 2010-01-18 2016-04-19 Apple Inc. Intelligent automated assistant
US10496753B2 (en) 2010-01-18 2019-12-03 Apple Inc. Automatically adapting user interfaces for hands-free interaction
US10553209B2 (en) 2010-01-18 2020-02-04 Apple Inc. Systems and methods for hands-free notification summaries
US10679605B2 (en) 2010-01-18 2020-06-09 Apple Inc. Hands-free list-reading by intelligent automated assistant
US9548050B2 (en) 2010-01-18 2017-01-17 Apple Inc. Intelligent automated assistant
US10705794B2 (en) 2010-01-18 2020-07-07 Apple Inc. Automatically adapting user interfaces for hands-free interaction
US10706841B2 (en) 2010-01-18 2020-07-07 Apple Inc. Task flow identification based on user intent
US10049675B2 (en) 2010-02-25 2018-08-14 Apple Inc. User profiling for voice input processing
US9633660B2 (en) 2010-02-25 2017-04-25 Apple Inc. User profiling for voice input processing
US10762293B2 (en) 2010-12-22 2020-09-01 Apple Inc. Using parts-of-speech tagging and named entity recognition for spelling correction
US9262612B2 (en) 2011-03-21 2016-02-16 Apple Inc. Device access using voice authentication
US10102359B2 (en) 2011-03-21 2018-10-16 Apple Inc. Device access using voice authentication
US10241644B2 (en) 2011-06-03 2019-03-26 Apple Inc. Actionable reminder entries
US10057736B2 (en) 2011-06-03 2018-08-21 Apple Inc. Active transport based notifications
US11120372B2 (en) 2011-06-03 2021-09-14 Apple Inc. Performing actions associated with task items that represent tasks to perform
US10706373B2 (en) 2011-06-03 2020-07-07 Apple Inc. Performing actions associated with task items that represent tasks to perform
US9798393B2 (en) 2011-08-29 2017-10-24 Apple Inc. Text correction processing
US8994660B2 (en) 2011-08-29 2015-03-31 Apple Inc. Text correction processing
US10241752B2 (en) 2011-09-30 2019-03-26 Apple Inc. Interface for a virtual digital assistant
US8838551B2 (en) 2011-10-21 2014-09-16 International Business Machines Corporation Multi-level database compression
US10134385B2 (en) 2012-03-02 2018-11-20 Apple Inc. Systems and methods for name pronunciation
US9483461B2 (en) 2012-03-06 2016-11-01 Apple Inc. Handling speech synthesis of content for multiple languages
US9953088B2 (en) 2012-05-14 2018-04-24 Apple Inc. Crowd sourcing information to fulfill user requests
US10079014B2 (en) 2012-06-08 2018-09-18 Apple Inc. Name recognition system
US9495129B2 (en) 2012-06-29 2016-11-15 Apple Inc. Device, method, and user interface for voice-activated navigation and browsing of a document
US9576574B2 (en) 2012-09-10 2017-02-21 Apple Inc. Context-sensitive handling of interruptions by intelligent digital assistant
US9971774B2 (en) 2012-09-19 2018-05-15 Apple Inc. Voice-based media searching
US10978090B2 (en) 2013-02-07 2021-04-13 Apple Inc. Voice trigger for a digital assistant
US10199051B2 (en) 2013-02-07 2019-02-05 Apple Inc. Voice trigger for a digital assistant
US9368114B2 (en) 2013-03-14 2016-06-14 Apple Inc. Context-sensitive handling of interruptions
US9697822B1 (en) 2013-03-15 2017-07-04 Apple Inc. System and method for updating an adaptive speech recognition model
US9922642B2 (en) 2013-03-15 2018-03-20 Apple Inc. Training an at least partial voice command system
US9582608B2 (en) 2013-06-07 2017-02-28 Apple Inc. Unified ranking with entropy-weighted information for phrase-based semantic auto-completion
US9966060B2 (en) 2013-06-07 2018-05-08 Apple Inc. System and method for user-specified pronunciation of words for speech synthesis and recognition
US9633674B2 (en) 2013-06-07 2017-04-25 Apple Inc. System and method for detecting errors in interactions with a voice-based digital assistant
US9620104B2 (en) 2013-06-07 2017-04-11 Apple Inc. System and method for user-specified pronunciation of words for speech synthesis and recognition
US10657961B2 (en) 2013-06-08 2020-05-19 Apple Inc. Interpreting and acting upon commands that involve sharing information with remote devices
US9966068B2 (en) 2013-06-08 2018-05-08 Apple Inc. Interpreting and acting upon commands that involve sharing information with remote devices
US10185542B2 (en) 2013-06-09 2019-01-22 Apple Inc. Device, method, and graphical user interface for enabling conversation persistence across two or more instances of a digital assistant
US10176167B2 (en) 2013-06-09 2019-01-08 Apple Inc. System and method for inferring user intent from speech inputs
US9300784B2 (en) 2013-06-13 2016-03-29 Apple Inc. System and method for emergency calls initiated by voice command
US10791216B2 (en) 2013-08-06 2020-09-29 Apple Inc. Auto-activating smart responses based on activities from remote devices
US9620105B2 (en) 2014-05-15 2017-04-11 Apple Inc. Analyzing audio input for efficient speech and music recognition
US10592095B2 (en) 2014-05-23 2020-03-17 Apple Inc. Instantaneous speaking of content on touch devices
US9502031B2 (en) 2014-05-27 2016-11-22 Apple Inc. Method for supporting dynamic grammars in WFST-based ASR
US10170123B2 (en) 2014-05-30 2019-01-01 Apple Inc. Intelligent assistant for home automation
US9430463B2 (en) 2014-05-30 2016-08-30 Apple Inc. Exemplar-based natural language processing
US9715875B2 (en) 2014-05-30 2017-07-25 Apple Inc. Reducing the need for manual start/end-pointing and trigger phrases
US9734193B2 (en) 2014-05-30 2017-08-15 Apple Inc. Determining domain salience ranking from ambiguous words in natural speech
US9785630B2 (en) 2014-05-30 2017-10-10 Apple Inc. Text prediction using combined word N-gram and unigram language models
US10083690B2 (en) 2014-05-30 2018-09-25 Apple Inc. Better resolution when referencing to concepts
US9842101B2 (en) 2014-05-30 2017-12-12 Apple Inc. Predictive conversion of language input
US10169329B2 (en) 2014-05-30 2019-01-01 Apple Inc. Exemplar-based natural language processing
US10078631B2 (en) 2014-05-30 2018-09-18 Apple Inc. Entropy-guided text prediction using combined word and character n-gram language models
US10289433B2 (en) 2014-05-30 2019-05-14 Apple Inc. Domain specific language for encoding assistant dialog
US9966065B2 (en) 2014-05-30 2018-05-08 Apple Inc. Multi-command single utterance input method
US9760559B2 (en) 2014-05-30 2017-09-12 Apple Inc. Predictive text input
US10497365B2 (en) 2014-05-30 2019-12-03 Apple Inc. Multi-command single utterance input method
US9633004B2 (en) 2014-05-30 2017-04-25 Apple Inc. Better resolution when referencing to concepts
US11133008B2 (en) 2014-05-30 2021-09-28 Apple Inc. Reducing the need for manual start/end-pointing and trigger phrases
US11257504B2 (en) 2014-05-30 2022-02-22 Apple Inc. Intelligent assistant for home automation
US9338493B2 (en) 2014-06-30 2016-05-10 Apple Inc. Intelligent automated assistant for TV user interactions
US10659851B2 (en) 2014-06-30 2020-05-19 Apple Inc. Real-time digital assistant knowledge updates
US10904611B2 (en) 2014-06-30 2021-01-26 Apple Inc. Intelligent automated assistant for TV user interactions
US9668024B2 (en) 2014-06-30 2017-05-30 Apple Inc. Intelligent automated assistant for TV user interactions
US10446141B2 (en) 2014-08-28 2019-10-15 Apple Inc. Automatic speech recognition based on user feedback
US10431204B2 (en) 2014-09-11 2019-10-01 Apple Inc. Method and apparatus for discovering trending terms in speech requests
US9818400B2 (en) 2014-09-11 2017-11-14 Apple Inc. Method and apparatus for discovering trending terms in speech requests
US10789041B2 (en) 2014-09-12 2020-09-29 Apple Inc. Dynamic thresholds for always listening speech trigger
US9606986B2 (en) 2014-09-29 2017-03-28 Apple Inc. Integrated word N-gram and class M-gram language models
US9668121B2 (en) 2014-09-30 2017-05-30 Apple Inc. Social reminders
US9886432B2 (en) 2014-09-30 2018-02-06 Apple Inc. Parsimonious handling of word inflection via categorical stem + suffix N-gram language models
US9986419B2 (en) 2014-09-30 2018-05-29 Apple Inc. Social reminders
US9646609B2 (en) 2014-09-30 2017-05-09 Apple Inc. Caching apparatus for serving phonetic pronunciations
US10074360B2 (en) 2014-09-30 2018-09-11 Apple Inc. Providing an indication of the suitability of speech recognition
US10127911B2 (en) 2014-09-30 2018-11-13 Apple Inc. Speaker identification and unsupervised speaker adaptation techniques
US10552013B2 (en) 2014-12-02 2020-02-04 Apple Inc. Data detection
US11556230B2 (en) 2014-12-02 2023-01-17 Apple Inc. Data detection
US9711141B2 (en) 2014-12-09 2017-07-18 Apple Inc. Disambiguating heteronyms in speech synthesis
US11068444B2 (en) 2014-12-27 2021-07-20 Ascava, Inc. Using a distributed prime data sieve for efficient lossless reduction, search, and retrieval of data
US9865280B2 (en) 2015-03-06 2018-01-09 Apple Inc. Structured dictation using intelligent automated assistants
US9721566B2 (en) 2015-03-08 2017-08-01 Apple Inc. Competing devices responding to voice triggers
US9886953B2 (en) 2015-03-08 2018-02-06 Apple Inc. Virtual assistant activation
US10311871B2 (en) 2015-03-08 2019-06-04 Apple Inc. Competing devices responding to voice triggers
US11087759B2 (en) 2015-03-08 2021-08-10 Apple Inc. Virtual assistant activation
US10567477B2 (en) 2015-03-08 2020-02-18 Apple Inc. Virtual assistant continuity
US9899019B2 (en) 2015-03-18 2018-02-20 Apple Inc. Systems and methods for structured stem and suffix language models
US9842105B2 (en) 2015-04-16 2017-12-12 Apple Inc. Parsimonious continuous-space phrase representations for natural language processing
US10083688B2 (en) 2015-05-27 2018-09-25 Apple Inc. Device voice control for selecting a displayed affordance
US10127220B2 (en) 2015-06-04 2018-11-13 Apple Inc. Language identification from short strings
US10356243B2 (en) 2015-06-05 2019-07-16 Apple Inc. Virtual assistant aided communication with 3rd party service in a communication session
US10101822B2 (en) 2015-06-05 2018-10-16 Apple Inc. Language input correction
US10255907B2 (en) 2015-06-07 2019-04-09 Apple Inc. Automatic accent detection using acoustic models
US10186254B2 (en) 2015-06-07 2019-01-22 Apple Inc. Context-based endpoint detection
US11025565B2 (en) 2015-06-07 2021-06-01 Apple Inc. Personalized prediction of responses for instant messaging
US11500672B2 (en) 2015-09-08 2022-11-15 Apple Inc. Distributed personal assistant
US10747498B2 (en) 2015-09-08 2020-08-18 Apple Inc. Zero latency digital assistant
US10671428B2 (en) 2015-09-08 2020-06-02 Apple Inc. Distributed personal assistant
US9697820B2 (en) 2015-09-24 2017-07-04 Apple Inc. Unit-selection text-to-speech synthesis using concatenation-sensitive neural networks
US10366158B2 (en) 2015-09-29 2019-07-30 Apple Inc. Efficient word encoding for recurrent neural network language models
US11010550B2 (en) 2015-09-29 2021-05-18 Apple Inc. Unified language modeling framework for word prediction, auto-completion and auto-correction
US11587559B2 (en) 2015-09-30 2023-02-21 Apple Inc. Intelligent device identification
US10691473B2 (en) 2015-11-06 2020-06-23 Apple Inc. Intelligent automated assistant in a messaging environment
US11526368B2 (en) 2015-11-06 2022-12-13 Apple Inc. Intelligent automated assistant in a messaging environment
US10049668B2 (en) 2015-12-02 2018-08-14 Apple Inc. Applying neural network language models to weighted finite state transducers for automatic speech recognition
US10223066B2 (en) 2015-12-23 2019-03-05 Apple Inc. Proactive assistance based on dialog communication between devices
US10446143B2 (en) 2016-03-14 2019-10-15 Apple Inc. Identification of voice inputs providing credentials
US9934775B2 (en) 2016-05-26 2018-04-03 Apple Inc. Unit-selection text-to-speech synthesis based on predicted concatenation parameters
US9972304B2 (en) 2016-06-03 2018-05-15 Apple Inc. Privacy preserving distributed evaluation framework for embedded personalized systems
US10249300B2 (en) 2016-06-06 2019-04-02 Apple Inc. Intelligent list reading
US10049663B2 (en) 2016-06-08 2018-08-14 Apple, Inc. Intelligent automated assistant for media exploration
US11069347B2 (en) 2016-06-08 2021-07-20 Apple Inc. Intelligent automated assistant for media exploration
US10354011B2 (en) 2016-06-09 2019-07-16 Apple Inc. Intelligent automated assistant in a home environment
US10490187B2 (en) 2016-06-10 2019-11-26 Apple Inc. Digital assistant providing automated status report
US10509862B2 (en) 2016-06-10 2019-12-17 Apple Inc. Dynamic phrase expansion of language input
US10192552B2 (en) 2016-06-10 2019-01-29 Apple Inc. Digital assistant providing whispered speech
US10067938B2 (en) 2016-06-10 2018-09-04 Apple Inc. Multilingual word prediction
US10733993B2 (en) 2016-06-10 2020-08-04 Apple Inc. Intelligent digital assistant in a multi-tasking environment
US11037565B2 (en) 2016-06-10 2021-06-15 Apple Inc. Intelligent digital assistant in a multi-tasking environment
US10521466B2 (en) 2016-06-11 2019-12-31 Apple Inc. Data driven natural language event detection and classification
US10297253B2 (en) 2016-06-11 2019-05-21 Apple Inc. Application integration with a digital assistant
US10269345B2 (en) 2016-06-11 2019-04-23 Apple Inc. Intelligent task discovery
US11152002B2 (en) 2016-06-11 2021-10-19 Apple Inc. Application integration with a digital assistant
US10089072B2 (en) 2016-06-11 2018-10-02 Apple Inc. Intelligent device arbitration and control
US10553215B2 (en) 2016-09-23 2020-02-04 Apple Inc. Intelligent automated assistant
US10043516B2 (en) 2016-09-23 2018-08-07 Apple Inc. Intelligent automated assistant
US11281993B2 (en) 2016-12-05 2022-03-22 Apple Inc. Model and ensemble compression for metric learning
US10593346B2 (en) 2016-12-22 2020-03-17 Apple Inc. Rank-reduced token representation for automatic speech recognition
US10332518B2 (en) 2017-05-09 2019-06-25 Apple Inc. User interface for correcting recognition errors
US10755703B2 (en) 2017-05-11 2020-08-25 Apple Inc. Offline personal assistant
US10791176B2 (en) 2017-05-12 2020-09-29 Apple Inc. Synchronization and task delegation of a digital assistant
US11405466B2 (en) 2017-05-12 2022-08-02 Apple Inc. Synchronization and task delegation of a digital assistant
US10410637B2 (en) 2017-05-12 2019-09-10 Apple Inc. User-specific acoustic models
US10789945B2 (en) 2017-05-12 2020-09-29 Apple Inc. Low-latency intelligent automated assistant
US10810274B2 (en) 2017-05-15 2020-10-20 Apple Inc. Optimizing dialogue policy decisions for digital assistants using implicit feedback
US10482874B2 (en) 2017-05-15 2019-11-19 Apple Inc. Hierarchical belief states for digital assistants
US11217255B2 (en) 2017-05-16 2022-01-04 Apple Inc. Far-field extension for digital assistant services

Also Published As

Publication number Publication date
US7283072B1 (en) 2007-10-16
US20070285958A1 (en) 2007-12-13
US8037034B2 (en) 2011-10-11

Similar Documents

Publication Publication Date Title
US7283072B1 (en) Methods of creating a dictionary for data compression
US7973680B2 (en) Method and system for creating an in-memory physical dictionary for data compression
US8838551B2 (en) Multi-level database compression
US9235651B2 (en) Data retrieval apparatus, data storage method and data retrieval method
US8255398B2 (en) Compression of sorted value indexes using common prefixes
JP5895545B2 (en) Program, compressed file generation method, compression code expansion method, information processing apparatus, and recording medium
US8659451B2 (en) Indexing compressed data
US8497788B1 (en) Efficient techniques for aligned fixed-length compression
US7783855B2 (en) Keymap order compression
US5151697A (en) Data structure management tagging system
JP2018501752A (en) Lossless data loss by deriving data from basic data elements present in content-associative sheaves
US9760593B2 (en) Data dictionary with a reduced need for rebuilding
JP2005531051A (en) Store and query relational data in a compressed storage format
US9665590B2 (en) Bitmap compression for fast searches and updates
JP7426907B2 (en) Advanced database decompression
US9584156B1 (en) Creating a dynamic Huffman table
KR20140038441A (en) Compression match enumeration
JP2019502154A (en) Reduction of voice data and data stored on block processing storage systems
US6388585B1 (en) Method for data compression and decompression using decompression instructions
US8463759B2 (en) Method and system for compressing data
RU2473960C2 (en) Method of finding maximum repeating sections of sequence of characters of finite alphabet and method of calculating auxiliary array
US20080215606A1 (en) Focal point compression method and apparatus
US20220345315A1 (en) Associative hash tree
JP3053656B2 (en) Dictionary registration method in data compression
CN116775588A (en) Data deleting method and device based on subfiles and readable medium

Legal Events

Date Code Title Description
AS Assignment

Owner name: IBM CORPORATION, NEW YORK

Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:PLACHTA, PIOTR M.;SAUER, WOLFRAM;IYER, BALAKRISHNA RAGHAVENDRA;AND OTHERS;REEL/FRAME:017393/0095;SIGNING DATES FROM 20060327 TO 20060329

FEPP Fee payment procedure

Free format text: PAYOR NUMBER ASSIGNED (ORIGINAL EVENT CODE: ASPN); ENTITY STATUS OF PATENT OWNER: LARGE ENTITY

AS Assignment

Owner name: INTERNATIONAL BUSINESS MACHINES CORPORATION, NEW Y

Free format text: PLEASE CORRECT ASSIGNEE'S NAME TO READ INTERNATIONAL BUSINESS MACHINES CORPORATION FOR ASSIGNMENT PREVIOUSLY RECORDED AT REEL 017393 AND FRAME 0095;ASSIGNORS:PLATCHA, PIOTR M.;SAUER, WOLFRAM;IYER, BALAKRISHNA RAGHAVENDRA;AND OTHERS;REEL/FRAME:019545/0379;SIGNING DATES FROM 20060327 TO 20060329

REMI Maintenance fee reminder mailed
LAPS Lapse for failure to pay maintenance fees
STCH Information on status: patent discontinuation

Free format text: PATENT EXPIRED DUE TO NONPAYMENT OF MAINTENANCE FEES UNDER 37 CFR 1.362

FP Lapsed due to failure to pay maintenance fee

Effective date: 20111016

AS Assignment

Owner name: GLOBALFOUNDRIES U.S. 2 LLC, NEW YORK

Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:INTERNATIONAL BUSINESS MACHINES CORPORATION;REEL/FRAME:036550/0001

Effective date: 20150629

AS Assignment

Owner name: GLOBALFOUNDRIES INC., CAYMAN ISLANDS

Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:GLOBALFOUNDRIES U.S. 2 LLC;GLOBALFOUNDRIES U.S. INC.;REEL/FRAME:036779/0001

Effective date: 20150910