Unit-Norm Codebook Design and Quantization

Abstract

The invention relates to an encoder for encoding a vector comprising channel state information and/or a pilot sequence, the encoder comprising a determining unit configured to determine a cell of a sphere mesh, wherein the cell includes the vector, a mesh refinement unit configured to determine a refined sphere mesh based on an initial sphere mesh, and a representation unit configured to determine a binary representation of a first identifier of an initial cell of the initial sphere mesh that includes the vector and a second identifier of a refined cell of the refined sphere mesh that includes the vector.

Claims

1. An encoder for encoding a vector comprising channel state information and/or a pilot sequence, the encoder comprising: a determining unit configured to determine a cell of a sphere mesh, wherein the cell includes the vector, a mesh refinement unit configured to determine a refined sphere mesh based on an initial sphere mesh, and a representation unit configured to determine a binary representation of a first identifier of an initial cell of the initial sphere mesh that includes the vector and a second identifier of a refined cell of the refined sphere mesh that includes the vector.

2. The encoder of claim 1, wherein the mesh refinement unit is configured to determine the refined sphere mesh by iteratively splitting a cell of the initial sphere mesh.

3. The encoder of claim 1, wherein the mesh refinement unit is configured to determine the refined sphere mesh by defining a grid on a cell of the initial sphere mesh.

4. The encoder of claim 1, wherein the vector is a complex-valued vector and the initial sphere mesh is a sphere mesh on a complex-valued sphere.

5. The encoder of claim 1, wherein the vector is a real-valued vector that is determined by a vector conversion unit based on a complex input vector.

6. The encoder of claim 1, wherein the encoder is configured to determine a binary representation for each of a plurality of vectors comprising channel state information and/or pilot sequences corresponding to a plurality of antennas of a multiple-antenna user equipment.

7. The encoder (100) of claim 1, further comprising a transmission unit configured to transmit the binary representation over a wireless connection.

8. A decoder for decoding a vector comprising channel state information and/or a pilot sequence from a binary representation, the decoder comprising: an initial vector unit configured to determine an initial cell vector based on a first part of the binary representation and an initial sphere mesh, a mesh refinement unit configured to determine a refined sphere mesh based on the initial sphere mesh, and a refined vector unit configured to determine a refined cell vector based on the refined sphere mesh and a second part of the binary representation.

9. The decoder of claim 8, wherein the mesh refinement unit is configured to: determine the refined sphere mesh by iteratively splitting a cell of the initial sphere mesh into two cells, and/or determine the refined sphere mesh by defining a grid on a cell of the initial sphere mesh.

10. A method for encoding a vector comprising channel state information and/or a pilot sequence, the method comprising: determining an initial cell of an initial sphere mesh, wherein the initial cell includes the vector, refining the initial sphere mesh to obtain a refined sphere mesh, determining a refined cell of the refined sphere mesh that includes the vector, and representing a first identifier of the initial cell and a second identifier of the refined cell as a binary representation.

11. The method of claim 10, wherein refining the initial sphere mesh comprises iteratively splitting a cell of the initial sphere mesh.

12. The method of claim 10, wherein the vector is a real-valued vector and the method comprises an initial step of converting a complex input vector into the real-valued vector.

13. A method for decoding a vector comprising channel state information and/or a pilot sequence from a binary representation, the method comprising: determining an initial cell vector based on a first part of the binary representation and an initial sphere mesh, determining a refined sphere mesh based on the initial sphere mesh, and determining a refined cell vector based on the refined sphere mesh and a second part of the binary representation.

14. A computer-readable storage medium storing program code, the program code comprising instructions that when executed by a processor, wherein the program codes comprise instructions for: determining an initial cell of an initial sphere mesh, wherein the initial cell includes the vector, refining the initial sphere mesh to obtain a refined sphere mesh, determining a refined cell of the refined sphere mesh that includes the vector, and representing a first identifier of the initial cell and a second identifier of the refined cell as a binary representation.

15. The computer-readable storage medium storing program code according to claim 14, wherein the program codes further comprise instructions for: wherein refining the initial sphere mesh comprises iteratively splitting a cell of the initial sphere mesh.

16. The computer-readable storage medium storing program code according to claim 14, wherein the vector is a real-valued vector and the method comprises an initial step of converting a complex input vector into the real-valued vector.

Description

BRIEF DESCRIPTION OF THE DRAWINGS

[0057] To illustrate the technical features of embodiments of the present invention more clearly, the accompanying drawings provided for describing the embodiments are introduced briefly in the following. The accompanying drawings in the following description are merely some embodiments of the present invention. Modifications on these embodiments are possible without departing from the scope of the present invention as defined in the claims.

[0058] FIG. 1 is a block diagram illustrating an encoder in accordance with an embodiment of the present invention,

[0059] FIG. 2 is a block diagram illustrating a decoder in accordance with a further embodiment of the present invention,

[0060] FIG. 3 is a block diagram illustrating a system in accordance with a further embodiment of the present invention,

[0061] FIG. 4 is a flow chart of a method for encoding a vector in accordance with a further embodiment of the present invention,

[0062] FIG. 5 is a flow chart of a method for decoding a vector in accordance with a further embodiment of the present invention,

[0063] FIG. 6 is a schematic illustration of codebooks on a sphere in accordance with a further embodiment of the present invention,

[0064] FIG. 7 is a schematic illustration of the computation of the representative vector in accordance with a further embodiment of the present invention,

[0065] FIGS. 8a is a schematic illustration of the initial mesh on a sphere in accordance with a further embodiment of the present invention,

[0066] FIG. 8b is a schematic illustration of the first split of a cell of the initial mesh of FIG. 8a in accordance with a further embodiment of the present invention,

[0067] FIG. 8c is a schematic illustration of a further sphere, where all cells of an initial sphere mesh have been split in accordance with a further embodiment of the present invention, and

[0068] FIG. 9 is a schematic illustration of the mapping to the unit-cube and subsequent quantization in accordance with a further embodiment of the present invention.

DETAILED DESCRIPTION OF THE EMBODIMENTS

[0069] FIG. 1 shows an encoder 100 for encoding a vector comprising channel state information and/or a pilot sequence. The encoder comprises a determining unit 110, a mesh refinement unit 120 and a representation unit 130. The encoder 100 can be realized for example on a processor of a base station or a user equipment (not shown in FIG. 1).

[0070] The determining unit 110 is configured to determine a cell of a sphere mesh, wherein the cell includes the vector. For example, the determining unit 110 can be configured to determine an initial cell of an initial sphere mesh, wherein the initial cell includes the vector. The determining unit 110 can further be configured to determine a refined cell of a refined sphere mesh, wherein the refined cell includes the vector.

[0071] The mesh refinement unit 120 is configured to determine a refined sphere mesh based on an initial sphere mesh.

[0072] The representation unit 130 is configured to determine a binary representation of a first identifier of an initial cell of the initial sphere mesh that includes the vector and a second identifier of a refined cell of the refined sphere mesh that includes the vector.

[0073] FIG. 2 shows a decoder 200 for decoding a vector comprising channel state information and/or a pilot sequence from a binary representation.

[0074] The decoder comprises an initial vector unit 210, a mesh refinement unit 220 and a refined vector unit 230.

[0075] The initial vector unit 210 is configured to determine an initial cell vector based on a first part of the binary representation and an initial sphere mesh. The initial sphere mesh can be predetermined sphere mesh, e.g. stored in a memory of the decoder.

[0076] The mesh refinement unit 220 is configured to determine a refined sphere mesh based on the initial sphere mesh.

[0077] The refined vector unit 230 is configured to determine a refined cell vector based on the refined sphere mesh and a second part of the binary representation.

[0078] FIG. 3 shows a communication system 300 comprising a first node 310 and a second node 320.

[0079] The first node 310 comprises an encoder 100, e.g. the encoder 100 of FIG. 1. The second node 320 comprises a decoder 200, e.g. the decoder 200 of FIG. 2.

[0080] FIG. 4 shows a method for encoding a vector comprising channel state information and/or pilot sequence. The method comprises a first step 410 of determining an initial cell of an initial sphere mesh, wherein the initial cell includes the vector.

[0081] The method comprises a second step 420 of refining the initial sphere mesh to obtain a refined sphere mesh.

[0082] The method comprises a third step 430 of determining a refined cell of the refined sphere mesh that includes the vector.

[0083] The method comprises a fourth step 440 of representing a first identifier of the initial cell and a second identifier of the refined cell as a binary representation. The method 400 can be carried out e.g. by the encoder 100 of FIG. 1. The method 400 can for example be carried out by an encoder 100 located at a UE.

[0084] Suppose that a non-precise process leads the UE to know a D.sub.0-dimensional vector comprising the channel state information, wherein D.sub.0 is the number of antennas at the base station, the vector denoted by h0. h0 may refer for example to a tap in the time domain of the channel between all D.sub.0 antennas of Base Station and the antenna of UE.

[0085] The fact that the CSI is represented only as a vector (and not a matrix) is due to the assumption that the UE has a single antenna. This assumption is done for the sake of simplicity. If the UE has multiple antennas, one can use the single-antenna case as detailed further below.

[0086] The UE can compute a unit-norm vector h from ho representing e.g. a part of the channel state information.

[0087] In a first embodiment, the unit-norm vector h can be computed as:

[00001]$h=\frac{h_0}{.Math.h_0.Math.}$

In that case the dimension of the vector h is D=D.sub.0.

[0088] In a second embodiment, h can be computed as:

[00002]$h=\frac{U^H.Math.h_0}{.Math.U^H.Math.h_0.Math.}$

where U is a D.sub.0xD unitary matrix. The dimension of h is then equal to D.

[0089] A third embodiment may be considered through another scenario. A base station may be configured to compute a complex vector representing a pilot sequence P that another communication device (for example, a user equipment) should transmit. In that case, the pilot sequence needs to be quantized, that is to say represented through bits in order that these bits can be transmitted to the communication device. In that case, the unit vector can be the normalized version of this pilot:

[00003]$h=\frac{p}{.Math.p.Math.}$

[0090] The task of the encoder can be to compute a binary representation, e.g. a sequence of bits (b1, . . . , bB), representing a unit-norm vector h.

[0091] We use the notion of codebook as a list of representative vectors approximating the true vector h. Herein, a codebook is a list of vectors (or codewords denoted by v(1), . . . , v(2.sup.B)) on the sphere that can be sent over the air through the binary representation of their index (comprised between 1 and 2.sup.B).

[0092] FIG. 5 shows a method 500 for decoding a vector comprising channel state information and/or a pilot sequence from a binary representation.

[0093] The method 500 comprises a first step 510 of determining an initial cell vector based on a first part of the binary representation and an initial sphere mesh.

[0094] The method 500 comprises a second step 520 of determining a refined sphere mesh based on the initial sphere mesh.

[0095] The method 500 comprises a third step 530 of determining a refined cell vector based on the refined sphere mesh and a second part of the binary representation.

[0096] FIG. 6 is an illustration of a codebook on a sphere 600. The black dots 610 indicate the codewords 610 while the cells 620 are the set of the closest points on the sphere to each codeword 610.

[0097] The mesh of the sphere can then be seen as a set of vectors of the sphere 600 closest to each codeword 610. One can then equivalently either define the codewords 610 and compute the mesh 605 related to these codewords 610 or design the mesh 605 and consider the center of each cell 620 of the mesh 605 as a codeword. Once these codewords 610 (or this mesh 605) are defined, the encoder can consider the vector to be quantized (the unit-norm vector h) and find the closest codeword to this vector (namely quantized vector which is then an approximation of the true vector h). The binary representation of the index of this quantized vector can then be sent to decoder, e.g. a base station.

[0098] FIG. 7 is a schematic illustration of the computation of the representative vector. The normalized CSI to be quantized is indicated by a dot 730 on sphere 700. The aim of an encoder is to compute a representative vector, denoted by quantized vector 710. To each representative vector corresponds a unique index, a binary representation of which can be sent as feedback.

[0099] A proposed encoder numerically computes a sequence of bits from a unit-norm CSI vector (denoted above by h). We will propose in next section three different preferred embodiments of the following major steps:

[0100] Step 1: Compute a real representative of h (only for first two embodiments). For example, by noting =arg(h.sub.1) the angle of the first coordinate of h, one can define a rotated equivalent vector h.sup.(r) as h.sup.(r)=he.sup.i and we convert h.sup.(r) into a unit-norm real vector:

[00004]$g=\left(\begin{array}{c}\mathrm{Re}\left(h_1^{\left(r\right)}\right)\\ \mathrm{.Math.}\\ \mathrm{Re}\left(h_D^{\left(r\right)}\right)\\ \mathrm{Im}\left(h_2^{\left(r\right)}\right)\\ \mathrm{.Math.}\\ \mathrm{Im}\left(h_D^{\left(r\right)}\right)\end{array}\right).$

[0101] In the following, d will denote the size of g (that is to say d=2D-1).

[0102] Step 2: Compute an initial representative vector and its corresponding index as well as its binary representation; this constitutes the first bits of the sent sequence.

[0103] Step 3: Compute the remaining bits defining the relative position of the codeword with respect to the initial representative vector.

[0104] In a first preferred embodiment, an initial mesh is iteratively divided on the sphere by cutting in two parts each cell of the mesh. FIG. 8a is a schematic illustration of the initial mesh 805 on a sphere 800.

[0105] The definition of the initial mesh can be constituted by d codewords (v(1), . . . ,v(d)) of coordinates v(1)=(1,0,0,0, . . . ), v(2)=(0,1,0,0, . . . ), . . . v(d)=(0,0, . . . , 0,1).

[0106] In the initial mesh, the index of the cell 820 containing g is computed through:

i*=arg max(|g.sub.1|, . . . , |g.sub.d|).

[0107] The d cells of the mesh are the set of points closest to each codeword. The idea is to iteratively split these cells. The division of a cell 820 into two cells 822, 824 can be performed with respect to a plan whose equation depends on the cell. The two new cells 822, 824 correspond to two new codewords 812, 814.

[0108] It is not necessary for the encoder to build all the cells of the refined mesh. It can be sufficient to iteratively find the refined cell among the two cells obtained by splitting the initial cell 820.

[0109] FIG. 8b is a schematic illustration of the first split of the cell 820 of the initial mesh 805 of FIG. 8a, thus yielding refined sphere mesh 815. Note that in this case the refined sphere mesh 815 omits those cells of the initial sphere mesh 805 that do not comprise the input vector.

[0110] Each split then multiplies the total number of codewords in the codebook by 2. With this method, we are able to define codebooks with different size (the number of codewords depends on the number of splits in the construction). The construction method also provides a way to compute the representative codeword. The idea is that at each step (that is to say at each split) of the codebook construction, we identify the cell in which the vector to be quantized belongs.

[0111] In a second preferred embodiment, a grid is built on the initial cell, which is defined as the cell in the initial mesh considered in FIG. 8a, which includes the input vector.

[0112] FIG. 8c is a schematic illustration of a further sphere 800, where all cells of an initial sphere mesh have been split into two cells, e.g. using the grid. This yields a refined sphere mesh 815. The cells of the refined sphere mesh 815 include two cells 822, 824 that refine an initial cell of the initial sphere mesh.

[0113] For each cell of the initial mesh, we are able to define an abstract mapping between each cell and the unit (d-1)-dimensional cube. Let C.sub.i*be the initial cell computed at step 2. We define a mapping T.sub.i* between C.sub.i* and the unit cube by:

T.sub.i*: C.sub.i* .fwdarw.[0;1].sup.d-1

g=(g.sub.1, . . . , g.sub.d).sup.T(u.sub.1, . . . , u.sub.d-1).sup.T

[0114] with for any 1id-1

[00005]$\{\begin{array}{cc}{u}_i=\frac{2}{}.Math.{\tan }^{-1}\left(\frac{g_i}{g_{i^{*}}}\right)+\frac{1}{2}& \mathrm{for}.Math..Math.i<i^{*}\\ u_i=\frac{2}{}.Math.{\tan }^{-1}\left(\frac{g_{i+1}}{g_{i^{*}}}\right)+\frac{1}{2}& \mathrm{for}.Math..Math.i{i}^{*}\end{array}.$

[0115] One then defines a regular grid on this unit cube. The sent sequence of bits in Step 3 is then the binary representation of the closest point on this grid (the representative codeword on the sphere is then the inverse mapping of this closest point), i.e. the concatenation of the binary representation of

[00006]$.Math.2^{B_i}.Math.u_i-\frac{1}{2}.Math.$

where B.sub.i is the number of bits used to quantize u.sub.i.

[0116] In a third preferred embodiment, a grid 930 is built on each cell 920 of the initial mesh considered in FIG. 8a, but directly for the complex sphere 900. FIG. 9 is a schematic illustration of the mapping to the unit-cube and subsequent quantization. The index which binary representation will be sent is then the index of the point 904 on the grid of points 930, which is closest to the vector 902 to be quantized.

[0117] This leads to the definition of a different mapping from the initial cell to the unit cube. The remaining steps are the same as in the third embodiment. More precisely, the index of the initial cell is computed as:

i*=arg max(|h.sub.1|, . . . , |h.sub.D)

[0118] and if C.sub.i* is this initial cell computed at step 2, the mapping S.sub.i* used at Step 3 is defined by:

S.sub.i*: C.sub.i* .fwdarw.[0;1].sup.2D-2

x=(h.sub.1, . . . , h.sub.D).sup.Ta=(u.sub.1, v.sub.1, . . . , u.sub.D-1, v.sub.d-1).sup.T

with for any 1iD1, u.sub.i=N(Re(w.sub.i)) and v.sub.i=N(Im(w.sub.i)) (where N is the cumulative distribution function of the univariate standard Gaussian distribution) and

[00007]$\{\begin{array}{cc}{w}_i=\sqrt{2}.Math.{\log \left(\frac{1}{1-r_i}\right)}^{1/2}.Math.\frac{h_i}{h_{i^{*}}}.Math..Math.\frac{h_{i^{*}}}{h_i}.Math.& \mathrm{for}.Math..Math.i<i^{*}\\ w_i=\sqrt{2}.Math.{\log \left(\frac{1}{1-r_i}\right)}^{1/2}.Math.\frac{h_{i+1}}{h_{i^{*}}}.Math..Math.\frac{h_{i^{*}}}{h_{i+1}}.Math.& \mathrm{for}.Math..Math.i{i}^{*}\end{array}.Math..Math.\mathrm{and}.Math..Math.r_i=\frac{1}{1-1/\sqrt{2}}.Math.\left(1-\cos \left({\tan }^{-1}.Math..Math.\frac{h_i}{h_{i^{*}}}.Math.\right)\right).$

[0119] Finally the sent sequence of bits is the concatenation of the concatenation of the binary representation of

[00008]$.Math.2^{B_i}.Math.u_i-\frac{1}{2}.Math.$

where B.sub.i is the number of bits used to quantize a.sub.i, the i-th component of vector a.

[0120] A decoder is configured to perform a reverse operation to the above-described operation of the encoder. It computes the representative vector from a sequence of bits. For example, a decoder can be configured to, in a first step, compute the codeword index form the sequence of bits. In a second step, it can compute the codeword associated to this index.

[0121] The decoder implementation can have a similar structure as the encoder. In an embodiment, the decoder can be configured to: [0122] deduce from first bits of a binary representation an initial representative vector, [0123] compute the representative vector in the cell constituted by the initial representative vector from the remaining bits, and [0124] compute the complex representative from the real codeword.

[0125] The mathematical details are symmetric with respect to the encoder part with the same distinction between the three possible implementations.

[0126] The above-described feedback methods can be used e.g. for a single-antenna UE. A simple extension is to extend the method to multiple-antenna UE (denote the number of antennas at UE by N). In that case, the CSI to feedback can be a set of N unit-norm vectors. Typically, a preprocessing to compute these N unit-norm vectors has to be performed.

[0127] One can then separately encode the N vectors and feed back the corresponding bits through the aforementioned method.

[0128] The following table summarizes characteristics of prior art methods and an embodiment of the proposed method suitable for large codebooks of 2.sup.B elements in a space of size D.

TABLE-US-00001 Coding Available complexity Efficiency Method dimensions in D and B (accuracy/bits) Fourier codebook low/high Polynomial in D Tends to 0 for (Bell Labs) and B large codebooks Progressive Low (D = 2.sup.n) Polynomial in B high refinement of codebooks via local codebooks (Huawei USA) Lattice method- low/high Exponential in B high QAM/Reflected polynomial in D Simplex (Ryan et al.) Scalar quan- low/high Linear in D low tization Cube Split low/high Linear in D high (our proposition)

[0129] Embodiments of the present invention can have one or more of the following advantages:

[0130] Very low complexity of coding and decoding algorithm.

[0131] No storage needed at either BS and UE.

[0132] Performances competes with prior art.

[0133] Flexibility.

[0134] No parameterization or calibration needed.

[0135] Any precision can be reached.

[0136] Codebook available for any number of antennas.

[0137] Possible scaling with the number of antennas and the number of needed bits.

[0138] The foregoing descriptions are only implementation manners of the present invention, the scope of the present invention is not limited to this. Any variations or replacements can be easily made through person skilled in the art. Therefore, the protection scope of the present invention should be subject to the protection scope of the attached claims.