JP3093879B2 - Vector quantization codebook creation and search device - Google Patents

Abstract

PURPOSE:To execute error increment calculation and distortion calculation to be required for the formation of a vector quantizing code book and searching and to collectively evaluate and close the partial sum of error increment and distortion and an element value constituting a lower limit value. CONSTITUTION:A code book forming part 1 has a code book formation sorting part 11, an error increment calculating part 13, a code book formation lower limit value calculating part 14, a code book formation comparing part 16, and a clustor centroid calculating part 17. An optimum vector searching part 2 has a code book search sorting part 21, a distortion calculating part 22, a code book search lower limit value calculating part 23, and a code book search comparing part 25. Required error increment calculation and distortion calculation are executed by the calculating parts 13, 22 and the partial sum of the error increment and distortion and an element value constituting a lower limit value are collectively evaluated and canceled by the comparing parts 16, 25.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a vector quantization codebook creating and searching apparatus used in the digital information processing field and searching for a created codebook.

[0002]

2. Description of the Related Art Conventionally, vector quantization has been used for quantization of voice and images as an efficient data compression method. This vector quantization is performed by input vector X = (x
1, x2,..., Xm)
2,..., Yn}, an output vector Yk = (yk1, yk2,..., Ykm) with the smallest distortion from X is searched, and X is mapped to Yk.

A codebook used for this vector quantization is currently based on LBG [Y. Linde, A. Buzo, and R. Gray: "An Algorithm", which is an extension of Lloyd's algorithm.
forVector Quantizer Design ”, IEEE Trans. COM, Vo
l.28, No.1, pp562-574. (1980)]. These are initially the initial codebook (cluster)
And the center of the cluster at that time is repeatedly updated with the center of gravity of the vector group belonging to the cluster so that the distortion with respect to the data sequence of the learning vector is minimized, thereby obtaining an optimal class. .

However, according to this algorithm, depending on the given initial cluster, the local minimum (lo
cal minimum) state, and the performance of the generated codebook is known to be significantly dependent on the given initial cluster. Further, a general method for providing an appropriate initial cluster is not known.

On the other hand, a PNN (Pairwise N) algorithm is used as an algorithm that does not cause a risk of falling into a local minimum state.
earest Neighbor Clustering) method [WHEquitz, “A Ne
w Vector Quantization Clustering Algorithm ”, IEEE
Trans. ASSP, Vol.37, No.10, pp.1568-1575. (1989)]
It has been known. This assumes that all learning vectors initially belong to the same number of separate clusters, and the two closest clusters in the sense that the increase in errors due to merging is minimal until the desired number of optimal clusters is obtained. , In this order.

This algorithm has an excellent feature that it does not fall into the local minimum state.
However, to find two clusters closest, relative to the set of all clusters, requires calculation of the order of N ³ seeking increase in error due to merging, practical when it becomes much learning vector Not. For this, the kd tree [JHFriedman, JLBentley,
and RAFinkel, “AnAlgorithm for Finding Best Mat
ches in Logarithmic Expected Time ”, ACM Trans. on
Math., Vol. 3, pp. 209-226. (1977)], a FastPNN method has been proposed in which an input vector space is divided in advance and limited to a small number of clusters to search for clusters to be merged.
This Fast PNN method can create a cluster at high speed, but does not search the entire cluster space.
The accuracy was inferior to that of the PNN method.

On the other hand, the present applicant has filed a Japanese Patent Application No. 4-107.
In No. 554, in order to reduce the calculation of the amount of increase in the error that appears in the PNN method, the upper limit and the lower limit of the amount of increase in the error are obtained, and the calculation of the amount of increase in the error can be discontinued by matching the upper and lower limits. A method was proposed.

On the other hand, with respect to this type of vector quantization codebook search apparatus for searching for a vector quantization codebook created by the above-described means and the like, various methods have been proposed for the purpose of increasing the speed. ing.

That is, a tree search method (A. Buz) using a structural codebook to reduce the number of searched vectors
o, AHGray, Jr.RMGray, and JDMarkel: "Speech
coding based upon vector quantization ", IEEE Tran
s. Acoust., Speech & Signal Process., ASSP-28, 10,
pp.562-574, Oct., 1980), As a method to reduce the number of distortion calculations, the distance between codebooks (Imai, Kuwata, Yokobori, Usui: "A method of high-speed vector quantization in image signals", IEICE Tech. Vol. J69-B, No.12, 1986, pp.1702-171
0) (Japanese Unexamined Patent Publication No. Hei 1-218279) and mean values in vectors (Chuide, Aizawa, Harashima: "High-speed orthogonal transform domain search method of vector quantization, IEICE, pp.1102-1110, Vol J69-
B, No. 10, 1986) to terminate the search.

However, among these vector quantization methods, the tree search method minimizes distortion.
There is a disadvantage that an optimum vector cannot always be obtained. Even in the method of reducing the number of distortion calculations, it is necessary to perform some processing at least once on all the codebook vectors. That is,
These conventional search methods have a disadvantage that the search for the optimum vector cannot be sufficiently speeded up.

On the other hand, the present applicant has filed a Japanese Patent Application No. Hei 2-280.
In 988, a method was proposed in which an upper limit value and a lower limit value of the amount of distortion were obtained in order to reduce the amount of distortion calculation, and the distortion calculation could be discontinued by matching them.

[0012]

That is, the high-speed technique for the vector quantization codebook creating apparatus proposed by the present applicant in Japanese Patent Application No. 4-107554 is LB.
It is excellent in overcoming the drawbacks of the G method, the PNN method, and the Fast PNN method, but there is a demand to remove more calculation of the error increase in order to further increase the speed.

The applicant of the present invention has also filed Japanese Patent Application No. 2-280988.
According to the speedup method for the vector quantization codebook search device proposed in No. 2, the shortcoming of the conventional method is overcome, and it is excellent in that a high-speed search becomes possible. There is still a need to remove more distortion calculations in order to speed up.

SUMMARY OF THE INVENTION The present invention has been made in view of the above-mentioned problem, and more efficiently terminates the calculation of the amount of error in the creation of the vector quantization codebook and the calculation of the distortion in the search of the vector quantization codebook. And a vector quantization codebook capable of quickly searching for an optimal codebook vector for all input vectors, while enabling the same codebook to be created in a short time and with a short calculation time. It is an object to provide a search device.

[0015]

That is, according to the present invention, the distance between the vectors constituting the initial codebook is sorted for each dimension, and the distance between the vectors is sorted each time a centroid vector is generated by merging clusters. A first sorter for maintaining an aligned state by calculating the error increase associated with the merging of the clusters, and an error increase amount calculator for updating as an upper limit every time the minimum value is obtained; A first lower limit value calculating unit for obtaining a lower limit value of the error increase amount based on a sorting result by the sort unit, and an optimal cluster pair merging and error increase amount by comparing using the upper limit value and the lower limit value First comparing means for determining the termination of the calculation, and a cluster weight for calculating the center of gravity of the cluster pair to be merged, registering it in the codebook, and deleting the center of gravity of the cluster before merging. A vector quantization codebook creating unit having calculation means; second sorting means for sorting the elements of the vector constituting the codebook for each dimension; and distortion for each dimension between the input vector and the codebook vector. And a second lower limit value calculating means for calculating a lower limit value of the distortion based on a result of the sorting by the second sorting means; A vector quantization codebook search unit having a second comparison means for performing comparison using the upper limit value and the lower limit value and determining termination of optimal codebook vector search and termination of distortion calculation. And

[0016]

According to the present invention, in creating a vector quantization codebook, the center of gravity vectors of each cluster are classified for each dimension, and an element of a vector which is the target of calculating an increase in error due to merging is calculated. The error increment is calculated in order from the cluster having the centroid vector to which the element belongs.
Also, the minimum error increment is calculated for each dimension from the barycenter vector of each cluster other than the cluster found not to be the optimal pair for merging and the target vector for error increment calculation, and the sum is calculated as the error. The lower limit value of the increase amount (a value that the error increase amount does not become smaller than that value).
On the other hand, the minimum error increment given by the center-of-gravity vector of the cluster for which the error increment calculation has been completed is set as the upper limit of the error increment (the minimum error increment in the searched range). Then, when the lower limit value and the upper limit value of the error increase amount match, the cluster pair is merged. Further, for the codebook vector to be subjected to the error increase calculation, the calculated error increase component for the dimension for which the error increase calculation has been completed, and the lower limit of the error increase for the dimension for which the error increase calculation has not been completed. The error increase component constituting the value is added, and if the added value is equal to or larger than the upper limit, the calculation of the error increase for the codebook vector is terminated. The same classification result is used for the determination of the order of selecting the codebook vectors to be subjected to the above-described calculation of the error increase and the calculation of the lower limit.

In the vector quantization codebook search, for each dimension of the codebook vector and the input vector, a minimum distortion given by a codebook vector other than a codebook vector determined not to provide an optimal vector is calculated. The sum is defined as a lower limit value of distortion (a value at which distortion does not become smaller than that value). On the other hand, the minimum distortion given by the searched codebook vector is defined as the upper limit of the distortion (the minimum distortion amount in the searched range). The search is terminated when the lower limit and the upper limit of the distortion match. Further, for the codebook vector to be subjected to the distortion calculation, the calculated distortion component for the dimension for which the distortion calculation has been completed and the distortion component constituting the lower limit value of the distortion for the dimension for which the distortion calculation has not been completed are added. , If the sum is equal to or greater than the upper limit, the distortion calculation for the codebook vector is terminated. The same classification result is used for determining the order of selecting the codebook vector to be subjected to the distortion calculation and calculating the lower limit.

As a result, by efficiently terminating the calculation of the amount of error increase, the same code book as that obtained by the PNN method can be created at a high speed in a short calculation time. In addition, by efficiently terminating the distortion calculation, it is possible to quickly search for an optimal codebook vector for all input vectors.

[0019]

Embodiments of the present invention will be described below with reference to the drawings. In the embodiment described below, the square distortion is used as an example of the distortion relating to the calculation of the error increase amount of the codebook creating apparatus, and the absolute difference distortion is used as the example of the distortion relating to the codebook searching apparatus. Can be similarly applied.

FIG. 1 is a block diagram showing a configuration of a vector quantization codebook creating and searching apparatus according to a first embodiment of the present invention. This apparatus is roughly composed of a codebook creating unit 1 and an optimal vector searching unit 2.

The codebook creation unit 1 includes a codebook creation sort unit 11, a search order determination unit 12, an error increase calculation unit 13 for calculating an increase in error caused by merging clusters, and a codebook creation unit. Lower limit calculator 14
, A codebook creation memory 15, a codebook creation comparison unit 16, and a cluster centroid calculation unit 17.

The code book creation sort unit 11 includes:
The distance between the vectors constituting the codebook 31 with the initial codebook as the initial state is sorted for each dimension to create a codebook creation sort table 32. Also, each time a cluster is merged to generate a new centroid vector,
The code book creation sort table 32 is updated.

The search order determining unit 12 determines the search order using the codebook creation sort table 32 so as to start calculating the error increment from the cluster pair that is likely to be merged. Further, the codebook creation lower limit calculation unit 14 uses the codebook creation sort table 32 to find the lower limit of the error increase.

The codebook creation memory 15 stores a partial distortion amount, a lower limit value, and a minimum error increase amount as an upper limit value. Then, using the upper limit value and the partial sum of the distortions, and the upper limit value and the lower limit value, the codebook creating comparison unit 16 determines termination of the upper limit value calculation and merging of the optimal cluster pair.

Further, the cluster centroid calculator 17 calculates the centroid of the cluster pair to be merged, and registers the result in the codebook 31 as a new codebook. At the same time, the center of gravity of the cluster before merging is deleted.

On the other hand, the optimal vector search section 2 includes a codebook search sort section 21, a distortion calculation section 22, a codebook search lower limit calculation section 23, a codebook search memory 24, and a codebook search memory 24. The comparison unit 25 is configured.

The code book search sorting unit 21 comprises:
This is for sorting the code book 31 created by the code book creating section 1 to create a sort table 33 for code book search. Further, when the input vector X is input, the distortion calculator 22 calculates the sum of the distortion for each dimension with the codebook vector.

The codebook search lower limit calculator 23 calculates
The lower limit value of the distortion is obtained by using the codebook search sorting table 33. The codebook search memory 24 stores the partial distortion amount, the lower limit value, and the minimum distortion amount as the upper limit value. Codebook search comparison unit 25
Determines the termination of the distortion calculation and the end of the search using the upper sum and the partial sum of the distortion and the upper limit and the lower limit. Next, the operation of the vector quantization codebook creation and search apparatus will be described. In the following description, the number of codebook vectors is N, the number of vector dimensions (elements) is M, and the codebook vector indicated by index i is represented by Yi.

First, as a pre-process, the codebook creating sorter 11 sorts the codebook 31 composed of the initial codebook from the codebook 31 composed of the initial codebook by sorting the magnitude of the distortion between the elements for each dimension. Table 32 is generated.

Next, the search order determination unit 12 determines the search order so that the error increment calculation is started from the cluster pair that is likely to be merged. here,
Using the sort table 32, cluster pairs to which the minimum distortion is given in each dimension are sequentially set as calculation candidates. However, besides this, the search order is determined such that the next candidate cluster pair is checked through all the dimensions of the sort table and the candidate cluster pair is selected from the candidate cluster pairs in the most dimensions. The index can be changed based on the calculation effort and effect.

Next, based on the distortion of the cluster pair, the amount of increase in error due to the merging of the pair is calculated.
Here, for example, when the square distortion is used, the error that is increased by merging the clusters is equal to the average square distance weighted by the number of vectors belonging to each of the merged clusters as follows. Become.

Ci: i-th cluster, ni: number of vectors belonging to Ci, xi: centroid of vectors belonging to Ci,
Si: A vector represented by Equation 1 belonging to Ci, an average square distance of Xi, and a cluster formed by combining Ci and Cj with a subscript ij, the relationship between Equations 2, 3, and 4 It looks like an expression.

[0033]

(Equation 1)

[0034]

(Equation 2)

[0035]

(Equation 3)

[0036]

(Equation 4)

The derivation of these equations is described in Kondo and Itakura, "Study of PNN Method for Segment Quantization Used for Very Low Bit Rate Coding," IEICE Technical Report SP91-71 (DSP
91-64). Next, the procedure of the calculation based on the above equation (4) will be described with reference to the flowchart of FIG.

First, it is determined whether or not a desired cluster has been merged (step S1). Data relating to the cluster pair Ci and Cj selected by the search order determination unit 12 is obtained from the codebook 31 by the error increase amount calculation unit 13 Is read (step S2). Next, for the cluster pair that is read first, the error increase amount calculation unit 13 calculates the increase amount of the error due to the merging according to the relational expression of the above Expression 4 (step S3). And this is the upper limit (H
LV) is sent to the codebook creation comparing section 16.

On the other hand, the lower limit calculation unit 1 for creating a code book
In step S4, the lower limit (LLV) of the error increase is calculated based on the combination of the minimum values in the codebook creation sort table 32 (step S4), and sent to the codebook creation comparison unit 16. The upper limit value and the lower limit value are written in the code book creation memory 15 and compared in the code book creation comparison unit 16 (step S5).

In this comparison, if they match, the cluster pairs are merged (step S6),
A new cluster is created. Then, the center of gravity of the cluster pair to be merged is calculated by the cluster center of gravity calculation unit 17, registered in the codebook 31 as a new codebook, and the center of gravity of the two clusters before merging is deleted. Further, the codebook creation sort table 11 updates the codebook creation sort table 32.

If the upper and lower limits do not match in step S5, the next cluster pair is selected by the search order determining unit 12 (step S7). Next, the error increment calculator 13 calculates a partial sum (Y) of the error increment due to the merging in accordance with the relational expression of Equation 4 (step S8).

On the other hand, a value Z obtained by subtracting the sum of the components constituting the lower limit value for the dimension not yet added to Y from the upper limit value is obtained as an object to be compared with Y (step S).
9). Then, the calculation is terminated by comparing these Y and Z. That is, Y and Z are compared (step S10), and if Y is equal to or greater than Z, the cluster pair of the cluster pair is added even if all of the unadded dimensions are composed of the elements constituting the lower limit. It can be seen that the increase in error due to merging is not the minimum. Therefore, in the code book creation comparing section 16, this cluster pair is excluded from the target of the lower limit value calculation of the sorted table (step S11). Thereafter, the process returns to the calculation of the LLV in the codebook creation lower limit calculator 14 in step S4.

On the other hand, in step S10, Y <
In the case of Z, after the index k is incremented (step S12), it is determined whether or not k> M (step S13). Here, if k is equal to or smaller than M, the value of Y is calculated again (step S
14), and return to step S9.

Then, after calculating the relational expression of Expression 4, if the value Y becomes smaller than HLV, Y becomes a new H.
LV (step S15). So, until then,
It can be seen that the increase in error due to the merging of the cluster pair given the LV is not minimal. Therefore,
In the codebook creation comparing section 16, this cluster pair is excluded from the target of calculation of the lower limit value of the sort table (step S16). Thereafter, the codebook creation lower limit calculator 14 returns to the calculation of the LLV in step S4. According to the above steps, merging is continued until the desired number of clusters is reached. As a result of the above, the created codebook 31 is used for the search in the optimum vector search unit 2.
Next, the operation of the optimal vector search unit 2 as an encoding unit will be described with reference to the flowchart in FIG.

First, as preprocessing, the codebook 31 is sorted by the codebook search sorting unit 21 in accordance with the magnitude relationship of distortion between elements for each dimension, and a codebook search sort table 33 is generated. FIGS. 4A and 4B are schematic diagrams as an example of the format of the codebook 31 and the codebook creation sort table 32 described above.

FIG. 4A is composed of the component values of the codebook vector divided by the number of dimensions and the number of codebook vectors, the base value number, and the number of dimensions. And
FIG. 4B is composed of the basis values and the number of vectors classified and arranged according to the basis value number and the number of dimensions corresponding to the codebook vector.

Thus, the optimum codebook vector is searched for as described below. First, the input vector X is input to the distortion calculator 22. This distortion calculator 2
In 2, the codebook vector Y1 corresponding to the index 1 is extracted from the codebook 31. And
The distortion with the input vector X is calculated. Thereby, the sum HLV of the distortions of all dimensions and the index min (here, 1) are stored in the codebook search memory 24 (step S21).

On the other hand, the codebook search lower limit calculator 2
3, the absolute values Ds (k) and Db (k) of the difference between the input vector X and the base value of the codebook vector are calculated using the codebook search sort table 33. Is calculated as

[0049]

(Equation 5)

[0050]

(Equation 6)

Here, as shown in FIG. 5, when the k-th component of the codebook vector is classified as a base value, the t-th base value counted from the smallest one is Vk (t)
And pointers indicating the base value closest to the input vector X (nearest base value) are indicated by p and q. Further, the difference between the input vector X and the base value of the codebook vector is defined as Ds (k) and Db (k), and the difference Ds (k)
Represents the difference on the side smaller than X. Then, the lower limit LLV is calculated by the relational expression of Expression 7, and is stored in the codebook search memory 24 (Step S22).

[0052]

(Equation 7)

Subsequently, the code book search comparing section 25 compares the upper limit value HLV and the lower limit value LLV stored in the code book search memory 24 (step S2).
3). At this time, if HLV and LLV match, HLV
Is the minimum distortion, the index min is output (step S24), and the processing ends. On the other hand, HLV and LL
If V does not match, the index i is incremented for comparison with the next codebook vector (step S25).

The distortion calculator 22 calculates the index i
, The codebook vector Yi is extracted from the codebook 31, and the distortion with respect to the input vector X is calculated (step S26). Here, as represented by the relational expression of Expression 8, the partial sum S of the distortion from the low-order component to the j-th component in order
j is obtained and sent to the codebook search comparing section 25.

[0055]

(Equation 8)

On the other hand, a value Z obtained by subtracting from the upper limit the sum of the components constituting the lower limit for the dimension not yet added to Sj is obtained as an object to be compared with Sj (step S27). The codebook search comparing unit 25 compares the partial sum Sj with Z (step S28). And
At the time when the relational expression of Sj ≧ Z is satisfied, it can be seen that even if all the dimensions that have not been added are composed of the elements constituting the lower limit, the distortion from the codebook vector is not the minimum. Therefore, further distortion calculations are aborted.

When the distortion calculation is aborted, the index i + 1 corresponding to the next codebook vector is sent to the distortion calculator 22, and the target is shifted to the next codebook vector. Further, since it has been found that the vector indicated by the index i does not give the minimum distortion, the number of vectors belonging to the base value corresponding to this vector is reduced by 1 (step S29).

On the other hand, if the distortion calculation is not terminated, it is determined whether the order j of the vector is M or more (step S30). If j ≧ M, j is incremented and transmitted to the distortion calculation unit 22. Is performed (step S31).
Even if the degree j of the vector is equal to M, if the partial sum Sj (= SM) of the distortion is smaller than the previous minimum distortion HLV, this is stored in the codebook search memory 24 as a new minimum distortion HLV. . In this case, since it is found that the vector indicated by the index min does not give the minimum distortion, the number of vectors belonging to the base value corresponding to this vector is reduced by 1 (step S32).

Then, the index i at this time is stored in the codebook search memory 24 as a new index min. Thus, as the number of vectors belonging to the base value corresponding to the codebook vector found not to give the minimum distortion is reduced by one, whether or not there is a nearest base value in which the number of belonging vectors has become 0 Is determined (step S34).

In step S34, if there is a closest base value, the corresponding closest base value pointer p or q is shifted to the base value in which the vector to which it belongs (step S35). Thereafter, the process returns to step S22, and the lower limit value is calculated again in the lower limit value calculating unit 23 for codebook search.

On the other hand, if the number of vectors belonging to the nearest base value has not become zero in step S34, the process proceeds to step S23, and the processing is continued without changing the lower limit value. The above procedure is performed until the upper limit and the lower limit match.

According to the above-described procedure for creating a vector quantization codebook, the same codebook as that obtained without the fear of falling into the local minimum state by the PNN method can be obtained. There is no need to calculate the increase in error due to merging for all vector combinations. That is, during the calculation of the error increase amount, the calculation of the error increase amount can be interrupted on the way by comparing the upper limit value with the element value constituting the lower limit value.

Further, by comparing the upper limit value with the lower limit value, it is possible to reduce the number of cluster pairs for which the error increase is calculated. This makes it possible to greatly reduce the number of calculations for obtaining the same codebook as obtained by the PNN method without worrying about falling into the local minimum state.

According to the above-described procedure of the vector quantization codebook search, although the same solution as the optimal solution obtained by performing a full search of the codebook vector can be obtained, the search is stopped halfway. Can be discontinued. Also, regarding the distortion calculation for each vector quantization codebook vector, the distortion calculation can be interrupted halfway by comparing the distortion calculation with the upper limit value including the element values constituting the lower limit value. Thus, an optimal codebook vector for an input vector can be efficiently obtained with a small number of calculations.

Furthermore, in this embodiment, the codebook creating unit 1 and the optimum vector searching unit 2 are separated for the sake of simplicity of explanation, but the present invention is not limited to this.
That is, the codebook creation sort unit 11 and the codebook search sort unit 21, the error increase amount calculation unit 13 and the distortion calculation unit 22, the codebook creation lower limit calculation unit 14 and the codebook search lower limit calculation unit 23, The codebook creation memory 15 and the codebook search memory 24, and the codebook creation comparison unit 16 and the codebook search comparison unit 25 perform almost the same processing, respectively. It can be downsized. Alternatively, by making the codebook creating unit 1 and the optimal vector searching unit 2 completely independent devices, it is possible to reduce the size of each device.

Further, in the above-described embodiment, the calculation of the amount of increase in the error and the calculation of the distortion are performed in the order of the vector dimension in order to simplify the description, but the present invention is not limited to this. That is, of the elements constituting the lower limit,
It is also possible to incorporate in the calculation of the partial sum first from the dimension where the element value is small. According to this, there is an effect that the possibility of exceeding the upper limit value is increased even earlier.

[0067]

In the codebook vector creation and search processing, the necessary error increment calculation and distortion calculation are performed.
The partial sum of the error increase and the distortion and the element value forming the lower limit are evaluated together and terminated. This makes it possible to determine the termination of the calculation at an earlier point in time than simply comparing the partial sum of the error increase and the distortion with the upper limit value. That is, it has become possible to generate a codebook vector with a very small amount of calculation and to efficiently and quickly obtain an optimal codebook vector.

[Brief description of the drawings]

FIG. 1 is a block diagram showing a configuration of a vector quantization codebook creating and searching device according to a first embodiment of the present invention.

FIG. 2 is a flowchart illustrating an operation of the codebook creating unit 1 of FIG.

FIG. 3 is a flowchart illustrating an operation of an optimal vector search unit 2 of FIG.

FIG. 4 is a schematic diagram illustrating an example of a format of a codebook 31 and a sort table 32 for creating a codebook.

FIG. 5 is a diagram illustrating a relationship between an input vector X and a base value of a codebook vector.

[Explanation of symbols]

1 codebook creation unit 2 optimal vector search unit 1
DESCRIPTION OF SYMBOLS 1 ... Sort part for codebook creation, 12 ... Search order determination part, 13 ... Error calculation part, 14 ... Codebook creation lower limit calculation part, 15 ... Codebook creation memory, 1
Reference numeral 6: codebook creation comparison unit, 17: cluster centroid calculation unit, 21: codebook search sort unit, 22: distortion calculation unit, 23: codebook search lower limit calculation unit, 24
... Codebook search memory, 25. Codebook search comparison unit, 31. Codebook, 32. Codebook creation sort table, 33. Codebook search sort table.

Continuation of the front page (56) References JP-A-58-218242 (JP, A) JP-A-59-77730 (JP, A) JP-A-60-172844 (JP, A) JP-A-1-205638 (JP) JP-A-2-131621 (JP, A) JP-A-2-237270 (JP, A) Linde, A .; Buzo, and R.S. Gray: "An Algorithm for Vector Quantizer Design", IE EE Trans. COM, Vol. 1, pp84-95. (Jan. 1980) (58) Field surveyed (Int. Cl. ⁷ , DB name) H03M 7/30

Claims (1)

(57) [Claims] 1. A method of sorting distances between vectors constituting an initial codebook for each dimension and sorting distances between vectors each time a centroid vector is generated by merging clusters, to maintain an aligned state. Sorting means,
An error increase amount calculating means for calculating an error increase amount due to the merging of the clusters, and updating the error increase amount as an upper limit every time the minimum value is obtained; and an error increase amount based on a sorting result by the first sorting means. First lower limit value calculating means for obtaining a lower limit value, first comparing means for comparing using the above upper limit value and the lower limit value to determine the optimal merging of cluster pairs and the termination of calculation of an error increase amount, A vector quantization codebook creating unit having a cluster centroid calculating means for calculating a centroid of a cluster pair to be registered and registering the centroid of a cluster before merging, and deleting a centroid of a cluster before merging; A second sorting unit that sorts the input vector and the codebook vector, and calculates a sum of distortions for each dimension of the input vector and the codebook vector, and sets an upper limit each time the minimum value is obtained. A distortion calculating means for updating as a value, a second lower limit calculating means for obtaining a lower limit value of distortion based on a result of sorting by the second sorting means, and a comparison between the upper limit value and the lower limit value, and optimization. A vector quantization codebook creation and search apparatus, comprising: a vector quantization codebook search unit having a second comparison unit that determines termination of a codebook vector search and termination of distortion calculation.