End-to-end learning in communication systems

Abstract

An apparatus, method, and computer program are described, comprising: initializing parameters of a transmission system, wherein the transmission system comprises a transmitter, a channel, and a receiver, wherein the transmitter comprises a transmitter algorithm having at least some trainable weights, and the receiver comprises a receiver algorithm having at least some trainable weights; updating the trainable parameters of the transmission system based on a loss function, wherein the trainable parameters comprise trainable weights of the transmitter and trainable weights of the receiver, and wherein the loss function comprises a penalty term; quantizing the trainable parameters so that the weights can only take values ​​within a codebook having a finite number of entries, the finite number of entries being a subset of possible values ​​available during the update; and repeating the updating and quantizing until a first condition is met.

Description

Technical Field

[0001] This specification relates to learning in communication systems. Background Art

[0002] A simple communication system consists of a transmitter, a transmission channel, and a receiver. Designing such a communication system can involve the individual design and optimization of each component of the system. An alternative approach is to consider the entire communication system as a single system and seek to optimize the entire system. While some attempts have been made in the prior art, there remains room for further development in this area. Summary of the Invention

[0003] In a first aspect, the present specification provides an apparatus comprising: means (such as an initialization or control module) for initializing parameters of a transmission system, wherein the transmission system comprises a transmitter, a channel, and a receiver, wherein the transmitter comprises a transmitter algorithm having at least some trainable weights and the receiver comprises a receiver algorithm having at least some trainable weights; means (such as a training module) for updating the trainable parameters of the transmission system based on a loss function, wherein the trainable parameters comprise trainable weights for the transmitter and trainable weights for the receiver, and wherein the loss function comprises a penalty term; means (such as a quantization module) for quantizing the trainable parameters so that the weights can only take values ​​within a codebook having a finite number of entries, the finite number of entries being a subset of possible values ​​available during an update (or training); and means (such as a control module) for repeating the updating and quantizing until a first condition is met. Given that any hardware implementation only offers a finite precision, the use of a codebook in the first aspect can be considered to involve selecting a lower precision provided by the hardware on which the system is trained.

[0004] The penalty term may include a variable that is adjusted (e.g., increased) at each iteration of updating and quantization so that at each iteration, greater weight is given in the loss function to the difference between the trainable parameters and the quantized trainable parameters. In this way, the trainable parameters can be gradually forced to adopt values ​​close to (or within) a restricted set (i.e., a codebook).

[0005] The component for quantizing the trainable parameters can use fixed-point arithmetic to express the quantized weights. When compared with floating-point arithmetic often used in neural network implementations, fixed-point arithmetic (e.g., k-bit fixed arithmetic) can reduce memory requirements and simplify arithmetic operations.

[0006] Some embodiments may also include a control module or some other component for updating the variable at each repetition.

[0007] The first condition may be satisfied when the difference between the trainable parameter and the quantized trainable parameter is below a threshold level.Alternatively or additionally, the first condition may include a defined (eg, preset) number of iterations.

[0008] Some embodiments may also include a multiplier (or some other component) for scaling a signal received at the receiver (e.g., before being processed by the receiver) by a scaling factor. The scaling factor may be a function of the input. The scaling factor may be learned. In some embodiments, the scaling factor may be such that the dynamic range of the received signal matches the codebook.

[0009] In some embodiments, the transmitter may be implemented as a lookup table.

[0010] The loss function may be related to one or more of block error rate, bit error rate, and categorical cross entropy.

[0011] The means for updating the trainable parameters of the transmission system may include optimizing one or more of: a batch size of the transmitter training message sequence, a learning rate, and a distribution of perturbations applied to a perturbed version of the transmitter training message sequence.

[0012] At least some of the weights of the transmitter algorithm and the receiver algorithm may be trained using stochastic gradient descent.

[0013] The transmitter algorithm may include a transmitter neural network.Alternatively or additionally, the receiver algorithm may include a receiver neural network.

[0014] The means may include: at least one processor; and at least one memory including computer program code, the at least one memory and the computer program being configured to, with the at least one processor, cause execution of the apparatus.

[0015] In a second aspect, the present specification provides a method comprising: initializing parameters of a transmission system, wherein the transmission system comprises a transmitter, a channel, and a receiver, wherein the transmitter comprises a transmitter algorithm having at least some trainable weights, and the receiver comprises a receiver algorithm having at least some trainable weights; updating the trainable parameters of the transmission system based on a loss function, wherein the trainable parameters comprise trainable weights of the transmitter and trainable weights of the receiver, and wherein the loss function comprises a penalty term; quantizing the trainable parameters so that the weights can only take values ​​within a codebook having a finite number of entries, the finite number of entries being a subset of possible values ​​available during the update (or training); and repeating the updating and quantizing until a first condition is met.

[0016] The penalty term may comprise a variable that is adjusted (e.g., increased) at each iteration of updating and quantization so that at each iteration, greater weight is given in the loss function to the difference between the trainable parameters and the quantized trainable parameters.

[0017] Quantized trainable parameters may use fixed-point arithmetic to express the quantized weights.

[0018] The first condition may be satisfied when a difference between the trainable parameter and the quantized trainable parameter is below a threshold level.Alternatively or additionally, the first condition may include a defined number of iterations.

[0019] In some embodiments, the transmitter may be implemented as a lookup table.

[0020] At least some of the weights of the transmitter algorithm and the receiver algorithm may be trained using stochastic gradient descent.

[0021] In a third aspect, this specification describes any apparatus configured to perform any method as described with reference to the second aspect.

[0022] In a fourth aspect, this specification describes a work product comprising a lookup table or array created by any of the methods described with reference to the second aspect.

[0023] In a fifth aspect, this specification describes computer readable instructions that, when executed by a computing device, cause the computing device to perform any of the methods as described with reference to the second aspect.

[0024] In a sixth aspect, the present specification describes a computer program comprising instructions for causing an apparatus to at least perform the following: initialize parameters of a transmission system, wherein the transmission system comprises a transmitter, a channel, and a receiver, wherein the transmitter comprises a transmitter algorithm having at least some trainable weights and the receiver comprises a receiver algorithm having at least some trainable weights; update the trainable parameters of the transmission system based on a loss function, wherein the trainable parameters comprise trainable weights of the transmitter and trainable weights of the receiver, and wherein the loss function comprises a penalty term; quantize the trainable parameters so that the weights can only take values ​​within a codebook having a finite number of entries, the finite number of entries being a subset of possible values ​​available during the update; and repeat the updating and quantization until a first condition is met. The penalty term may comprise a variable that is adjusted (e.g., increased) upon each repetition of the updating and quantization so that, upon each repetition, greater weight is given in the loss function to the difference between the trainable parameters and the quantized trainable parameters.

[0025] In a seventh aspect, the present specification describes a computer-readable medium (such as a non-transitory computer-readable medium) comprising program instructions stored thereon for performing at least the following: initializing parameters of a transmission system, wherein the transmission system comprises a transmitter, a channel, and a receiver, wherein the transmitter comprises a transmitter algorithm having at least some trainable weights and the receiver comprises a receiver algorithm having at least some trainable weights; updating the trainable parameters of the transmission system based on a loss function, wherein the trainable parameters comprise trainable weights of the transmitter and trainable weights of the receiver, and wherein the loss function comprises a penalty term; quantizing the trainable parameters so that the weights can only take values ​​within a codebook having a finite number of entries, the finite number of entries being a subset of possible values ​​available during the update; and repeating the updating and quantization until a first condition is met.

[0026] In an eighth aspect, the present specification describes an apparatus comprising: at least one processor; and at least one memory comprising computer program code, which, when executed by the at least one processor, causes the apparatus to: initialize parameters of a transmission system, wherein the transmission system comprises a transmitter, a channel, and a receiver, wherein the transmitter comprises a transmitter algorithm having at least some trainable weights, and the receiver comprises a receiver algorithm having at least some trainable weights; update the trainable parameters of the transmission system based on a loss function, wherein the trainable parameters comprise trainable weights of the transmitter and trainable weights of the receiver, and wherein the loss function comprises a penalty term; quantize the trainable parameters so that the weights can only take values ​​within a codebook having a finite number of entries, the finite number of entries being a subset of possible values ​​available during the update; and repeat the updating and quantization until a first condition is met.

[0027] In a ninth aspect, the present specification describes an apparatus comprising: an initialization module for initializing parameters of a transmission system, wherein the transmission system comprises a transmitter, a channel, and a receiver, wherein the transmitter comprises a transmitter algorithm having at least some trainable weights and the receiver comprises a receiver algorithm having at least some trainable weights; a training module for updating the trainable parameters of the transmission system based on a loss function, wherein the trainable parameters comprise trainable weights of the transmitter and trainable weights of the receiver, and wherein the loss function comprises a penalty term; a quantization module for quantizing the trainable parameters so that the weights can only take values ​​within a codebook having a finite number of entries, the finite number of entries being a subset of possible values ​​available during the update; and a control module for repeating the updating and quantization until a first condition is met. BRIEF DESCRIPTION OF THE DRAWINGS

[0028] Example embodiments will now be described by way of non-limiting examples with reference to the following schematic drawings, in which:

[0029] Figure 1 is a block diagram of an example end-to-end communication system;

[0030] Figure 2 is a flowchart illustrating an algorithm according to an example embodiment;

[0031] Figure 3 is a flowchart illustrating an algorithm according to an example embodiment;

[0032] Figure 4 is a block diagram of a receiver of an example end-to-end communication system according to an example embodiment;

[0033] Figure 5 is a block diagram of a transmitter of an example end-to-end communication system according to an example embodiment;

[0034] Figure 6 is a block diagram of components of a system according to an example embodiment; and

[0035] Figure 7A and Figure 7B Tangible media are shown, which are a removable memory unit and a compact disk (CD), respectively, storing computer readable code that, when executed by a computer, performs operations according to the embodiments. DETAILED DESCRIPTION

[0036] Figure 1 is a block diagram of an example end-to-end communication system implemented as a neural network, generally indicated by the reference numeral 1, in which example embodiments may be implemented. The system 1 includes a transmitter 2, a channel 4, and a receiver 6. Viewed at a system level, the system 1 converts input symbols (s) (also referred to as messages) received at an input to the transmitter 2 into output symbols at an output of the receiver 6.

[0037] The transmitter 2 implements a transmitter algorithm. Similarly, the receiver 6 implements a receiver algorithm. As described in detail below, the algorithms of the transmitter 2 and receiver 6 are trained to optimize the performance of the system 1 as a whole.

[0038] System 1 thus provides an autoencoder that implements an end-to-end communication system. The autoencoder can be trained with respect to any loss function associated with some performance metric, such as block error rate (BLER). (Both the terms "autoencoder" and "communication system" are used below to describe System 1.)

[0039] As discussed further below, one obstacle to practical hardware implementation of the communication system (or autoencoder) 1 is the high memory requirements and computational complexity of the neural network involved. Hardware acceleration may be required to achieve reasonable interference times. However, graphics processing units (GPUs), which can be used to accelerate neural network evaluation, come at a high monetary and energy cost, which may not be feasible in many communication systems.

[0040] The transmitter algorithm implemented by transmitter 2 may be implemented as a differentiable parameter function and may include at least some trainable weights (which may be trainable via stochastic gradient descent). Similarly, the receiver algorithm implemented by receiver 6 may be implemented as a differentiable parameter function and may include at least some trainable weights (which may be trainable via stochastic gradient descent).

[0041] Transmitter 2 seeks to send out M possible messages One of them is transmitted to the receiver 6. For this purpose, the transmitter 2 sends the complex-valued vector representation of the message via the channel 4 Typically, the transmitter hardware imposes constraints on x, e.g., energy constraints Amplitude Constraint or average power constraint The channel is described by the conditional probability density function (pdf) p(y|x), where represents the received signal. Upon receiving y, the receiver generates an estimate of the transmitted message s

[0042] like Figure 1 As shown in FIG, the transmitter 2 includes dense layers 10, 11 of one or more units (e.g., including one or more neural networks) and a normalization module 12. The dense layers 10, 11 may include an embedding module. The modules within the transmitter 2 are provided by way of example, and modifications are possible.

[0043] The message index s can be fed to the embed module, embed: It transforms s into n emb -dimensional real-valued vector.

[0044] The embedding module may be followed by several dense neural network (NN) layers 10, 11 with possibly different activation functions such as ReLU, tanh, signmoid, linear, etc. The final layer of the neural network may have a linear activation function and 2n output dimensions. If no dense layers are used, then n emb =2n.

[0045] The output of dense layers 10 and 11 can be mapped is converted into a complex-valued vector, the mapping can be implemented as (This is not shown and is a purely optional step.)

[0046] Normalization is applied by the normalization module 12, which ensures that power constraints, amplitude constraints or other constraints are met. The result of the normalization process is the transmit vector x of the transmitter 2 (where ). As indicated above, modifications may be made to the transmitter 2, for example, the order of complex vector generation and normalization may be reversed.

[0047] Emitter 2 defines the following mappings:

[0048]

[0049] In other words, TX will come from the set The integers in are mapped to 2n-dimensional real-valued vectors. An example mapping is described above. Other neural network architectures are possible and the above description is only used as an example.

[0050] like Figure 1 As shown in FIG, the receiver 6 includes dense layers 14, 15 of one or more units (e.g., including one or more neural networks), a softmax module 16, and an arg max module 17. As further described below, the output of the softmax module is a probability vector that is provided as an input to the arg max module 17. The modules within the receiver 6 are provided by way of example and modifications are possible.

[0051] If the channel output vector is complex valued, it can be mapped by the receiver 6 Transformed into a 2n-dimensional real-valued vector, the mapping can be implemented as This step is for real-valued channel output Not required.

[0052] The result is fed into one or more layers 14, 15, which may have different activation functions such as ReLU, tanh, sigmoid, linear, etc. The final layer may have M output dimensions, to which a softmax activation (via a softmax module 16) is applied. This generates a probability vector Its i-th element [p] i can be interpreted as Pr(s=i|y). The hard decision for the message index is obtained by the arg max module 17 as

[0053] The transmitter 2 and the receiver 6 can be implemented as having parameter vectors θ T and θ RIf a differentiable channel model is available, the channel model can be used as an intermediate non-trainable layer, so that the entire communication system 1 can be viewed as having a parameter vector θ = (θ T +θ R ) that defines the mapping:

[0054]

[0055] Neural networks are often trained and utilized on computationally powerful platforms with general purpose processing unit (GPU) acceleration that supports high-precision floating point arithmetic (e.g., 32-bit or 64-bit floating point arithmetic). Such hardware may not be available for some communication systems. Therefore, the neural networks implementing the transmitter 2 and receiver 6 of the system 1 described above can be compressed to meet practical constraints. This can be achieved by using a more compact representation of the neural network parameters, at the expense of reduced precision. For example, as further described below, compression of the weights and / or biases of the neural network can be achieved by quantization, whereby the weights are forced to adopt values ​​within a codebook having a limited number of entries (e.g., at a lower precision provided by the training module).

[0056] Figure 2 is a flow chart illustrating an algorithm generally indicated by reference numeral 20 according to an example embodiment.

[0057] Algorithm 20 begins at operation 22 where an autoencoder (such as autoencoder / communication system 1) is trained.

[0058] For example, the autoencoder 1 can be trained in a supervised manner using the following stochastic gradient descent (SGD) algorithm:

[0059] 1. From Uniformly sample a random set of N messages

[0060] 2. For i=1,…,N, calculate (where, as discussed above, θ = (θ T ,θ R )).

[0061] 3. Use loss function Applying a step of stochastic gradient descent (SGD) to the trainable parameters (or weights) of the neural network(s) where is the input message and the output vector p i The categorical cross entropy between .

[0062] 4. Stop the repetition according to some stopping criteria.

[0063] At operation 24, the parameters generated by operation 22 are calculated using the following function θ q =Π(θ) is quantized, where:

[0064] · θ defines the parameters of the neural network as described above θ = (θ T +θ R ).

[0065] ·θ q defining quantified parameters;

[0066] ·П: is an element-wise quantization operation; and

[0067] · is the quantization codebook.

[0068] Algorithm 20 then terminates at operation 26. System 1 can then use the quantized parameter θ q This approach significantly reduces the memory requirements within the neural network of the system 1 and reduces the complexity of the arithmetic operations, but results in reduced accuracy.

[0069] Figure 3 is a flow chart illustrating an algorithm generally indicated by reference numeral 30 according to an example embodiment.

[0070] Algorithm 20 begins at operation 31 where the transmitter 2 and receiver 6 of the transmission system 1 are initialized, thereby providing means for initializing parameters of the transmission system.

[0071] Operations 32 through 34 implement a learning operation 32, a compression operation 33, and a parameter update operation 34, which, as discussed further below, collectively implement a "learn-compress" algorithm. At operation 35, a determination is made as to whether the "learn-compress" algorithm is complete. If not, operations 32 through 34 are repeated. When operation 35 determines that the "learn-compress" algorithm is complete (e.g., if a sufficient number of iterations of operations 32 through 34 have been completed, or if a given performance threshold has been met), algorithm 30 terminates at operation 36.

[0072] Learning operation 32 adjusts the weights of the neural networks of transmitter 2 and receiver 6 in the unquantized space. Operation 32 is similar to training operation 22 described above, but includes an additional penalty term associated with the allowed codebook values ​​in the quantized space. Thus, learning operation 32 implements a component for updating the trainable parameters of the transmission system based on the loss function.

[0073] More specifically, we use To denote the cross entropy, the cross entropy is the loss function to be minimized during training and is defined as follows:

[0074]

[0075] Learning operation 32 solves the following optimization problem:

[0076]

[0077] in:

[0078] μ is a parameter that increases as training progresses (thus decrease);

[0079] ·θ q is the projection of the solution of the previous learning step onto the codebook; and

[0080] λ is the Lagrange multiplier estimate.

[0081] At compression operation 33, a compression process is performed wherein the adjusted weights are quantized. Thus, compression operation 33 implements means for quantizing the trainable parameters of the transmission system.

[0082] More specifically, the compression operation 33 may perform Element-wise quantization of :

[0083]

[0084] where θ is computed during learning operation 32. We use To represent the codebook. The quantification can be expressed as:

[0085]

[0086] This just means that in the quantization codebook Find the closest element within.

[0087] At operation 34 , various parameters of the algorithm 30 are updated, as discussed further below.

[0088] Thus, the algorithm 30 iterates between a learning operation 32 and a compression operation 33. At the end of each operation, the Lagrange multiplier elements are updated. The algorithm 30 can be expressed mathematically as set forth below.

[0089] Initialization operation 31 may include:

[0090] 1.

[0091] 2. θ q (0) ←Π(θ (0) )

[0092] 3.λ (0)←0

[0093] 4. Initialize μ with a positive value (0)

[0094] 5.i←1

[0095] The learning operation 32 may include:

[0096] 1.

[0097] The compression operation 33 may include:

[0098] 1.

[0099] The update parameter operation 34 may include:

[0100] 1. Update the Lagrange multiplier estimate:

[0101]

[0102] 2. Set μ (i) So that μ (i) >μ (i+1)

[0103] 3.i←i+1

[0104] Completing operation 35 may include:

[0105] 1. If If the value is small enough (ie, below the threshold), the process proceeds to operation 36 ; otherwise, the process returns to operation 32 .

[0106] However, the criteria for completing operation 35 may be implemented in other ways.

[0107] Algorithm 30 converges to μ (i) →∞. This can be achieved, for example, by following the multiplication schedule μ (i) ←μ (i-1) a to achieve, where a>1 and μ (0) are the parameters of the algorithm.

[0108] It should be noted that the sequence μ (i) can be generated in many ways. Using the multiplication schedule (as discussed above), μ (0) The initial values ​​of and a are optimization parameters (and may be optimized as part of the training operation 32 described above).

[0109] It should also be noted that the batch size N and the learning rate (and possibly other parameters of the chosen SGD variant, such as ADAM, RMSProp, momentum) can be optimization parameters of the training operations 22 and 32 described above.

[0110] As discussed above, quantization of the weights of the transmitter and receiver algorithms may result in a loss of accuracy, which is reflected in the received signal (e.g., Figure 1 In order to keep the received signal within the range approximated by the codebook, the signal y in the codebook may result in poor performance. In the approximate value range, the receiver input may be scaled by a value η, which may or may not depend on the received signal.

[0111] Figure 4 is a block diagram of a receiver 40 of an example end-to-end communication system according to an example embodiment. The receiver 40 includes the Figure 1 32 . The softmax module 16 and arg max module 17 described above are also described. In addition, the receiver includes dense layers 42, 44 and 46 of one or more units (similar to layers 14 and 15 described above). The input stage includes a multiplier 48, by which the input is scaled by a scaling factor η. The scaling factor η can be a directly trainable factor (which can be trained as part of the learning operation 32), a fixed value, or the output of another neural network whose weights are optimized in the training process described above. Scaling can therefore be used to ensure that the dynamic range of the signal y matches the quantization codebook.

[0112] In some embodiments, once an autoencoder (e.g., autoencoder 1) is trained, the transmitter of the autoencoder can be implemented by a simple lookup table that converts the message Mapping to a quantized real vector or complex vector (depending on the emitter implementation), where the elements and Quantized into codebook Therefore, the transmitter weight θ T Compressions of are not necessary in such an arrangement, as they would not be needed when utilizing an autoencoder. For example, if the set of messages to be transmitted is relatively small, then a set of quantized neural network weights for each message can be stored.

[0113] Figure 5 is a block diagram of a transmitter 50 of an example end-to-end communication system according to an example embodiment. The transmitter 50 includes the dense layers 10, 11 and the normalization layer 12 of the elements of the transmitter 2 described above. The system 50 also includes a quantization layer 52 in which the signal x is transformed into a quantized output x q . Considering that the output of the transmitter is quantized, the quantization layer 52 allows the training of the autoencoder. Once the training is completed, the transmitter 50 is used to generate the output of the autoencoder for each message. The generated vector x q is stored in a lookup table implementing the transmitter.

[0114] It should be noted that the quantization operation π is generally non-differentiable. For backpropagation, a simple workaround is to assign a custom derivative to π, such as That is, during the forward pass of the neural network, quantization is performed by the quantization layer 52, but during the backward pass (to compare gradients), the quantization is treated as an identity function.

[0115] As described above, one approach for quantizing weights is to use K-bit fixed-point arithmetic instead of using floating-point arithmetic (such as 32-bit or 64-bit floating-point arithmetic). Combining the principles of quantization and the use of fixed-point arithmetic not only results in using fewer bits to represent the weights of the neural network described herein, but also greatly reduces the complexity of arithmetic operators.

[0116] Using K-bit fixed-point arithmetic, K E The ones digit is used for the integer part and K F The units digit is used for the fractional part (thus K E +K F =K), the weight w is expressed by the following formula:

[0117]

[0118] where w e,i and w f,j Takes values ​​in {0,1}. The number of digits K and the size of the integer part and fractional part K E and K F The scalar w consists of a K+1-bit word Indicates that w s is the sign bit (ie, the bit indicating the sign of the weight).

[0119] For completeness, Figure 6 1 is a schematic diagram of the components of one or more of the previously described modules (e.g., transmitter or receiver neural networks), which are hereinafter generally referred to as processing system 110. Processing system 110 may have a processor 112, memory 114 tightly coupled to the processor and consisting of RAM 124 and ROM 122, and optionally hardware keys 120 and a display 128. Processing system 110 may include one or more network interfaces 118 for connecting to a network, which may be, for example, a wired or wireless modem.

[0120] The processor 112 is connected to each of the other components so as to control the operation thereof.

[0121] The memory 114 may include non-volatile memory, a hard disk drive (HDD), or a solid-state drive (SSD). The ROM 122 of the memory 114 stores, among other things, an operating system 125 and may store software applications 126. The RAM 124 of the memory 114 is used by the processor 112 for temporary storage of data. The operating system 125 may contain code that, when executed by the processor, implements aspects of Algorithms 20 and 30.

[0122] The processor 112 may take any suitable form, for example, a microcontroller, multiple microcontrollers, a processor, or multiple processors.

[0123] Processing system 110 may be a stand-alone computer, a server, a console, or a network thereof.

[0124] In some embodiments, processing system 110 may also be associated with external software applications. These external software applications may be applications stored on a remote server device and may be partially or completely executed on the remote server device. These applications may be referred to as cloud-hosted applications. Processing system 110 may communicate with the remote server device to utilize the software applications stored therein.

[0125] Figure 7A and Figure 7B Tangible media are shown, namely a removable memory unit 165 and a compact disk (CD) 168, which store computer-readable code that, when executed by a computer, can perform the method according to the embodiments described above. Removable memory unit 165 can be a memory stick, such as a USB memory stick, having an internal memory 166 storing the computer-readable code. Memory 166 can be accessed by the computer system via connector 167. CD 168 can be a CD-ROM, DVD, or the like. Other forms of tangible storage media may be used.

[0126] Embodiments of the present invention may be implemented using software, hardware, application logic, or a combination of software, hardware, and application logic. The software, application logic, and / or hardware may reside in memory or on any computer medium. In an example embodiment, the application logic, software, or instruction set is maintained on any of a variety of conventional computer-readable media. In the context of this document, "memory" or "computer-readable medium" may be any non-transitory medium or component that can contain, store, convey, propagate, or transmit instructions for use by or in conjunction with an instruction execution system, apparatus, or device, such as a computer.

[0127] Where relevant, references to "computer-readable storage medium," "computer program product," "tangibly embodied computer program," etc., or "processor" or "processing circuitry," etc., should be understood to encompass not only computers having different architectures (such as single / multi-processor architectures and sequencer / parallel architectures), but also special purpose circuits such as field programmable gate arrays (FPGAs), application specific circuits (ASICs), signal processing devices, and other devices. References to computer programs, instructions, code, etc., should be understood to convey software for programmable processor firmware, such as the programmable content of a hardware device, as instructions for a processor, or configured settings or configuration settings for a fixed function device, gate array, programmable logic device, etc.

[0128] As used in this application, the term "circuitry" refers to all of the following: (a) hardware circuit implementations alone (such as implementations solely in analog and / or digital circuitry), and (b) combinations of circuitry and software (and / or firmware), such as, as applicable: (i) a combination of (multiple) processors, or (ii) portions of (multiple) processors / software (including (multiple) digital signal processors), software, and memory(ies) that work together to enable a device (such as a server) to perform various functions, and (c) circuitry that requires software or firmware for operation even if the software or firmware is not physically present, such as microprocessor(s) or portion(s) of microprocessor(s).

[0129] If desired, the different functions discussed herein may be performed in a different order and / or concurrently with each other. Furthermore, if desired, one or more of the functions described above may be optional or may be combined. Similarly, it will also be understood that Figure 2 and Figure 3 The flowcharts are merely examples, and various operations depicted herein may be omitted, reordered, and / or combined.

[0130] It will be understood that the exemplary embodiments described above are purely illustrative and do not limit the scope of the invention. Other variations and modifications will be apparent to those skilled in the art upon reading this specification.

[0131] Furthermore, the disclosure of this application should be understood to include any novel feature or any novel combination of features disclosed herein, whether explicitly or implicitly, or any generalization thereof, and new claims may be conceived during the prosecution of this application or any application derived therefrom to cover any such feature and / or combination of such features.

[0132] Although various aspects of the invention are set out in the independent claims, further aspects of the invention comprise other combinations of features from the described embodiments and / or dependent claims with features of the independent claims, and not only the combinations explicitly set out in the claims.

[0133] It is also noted herein that, although various examples are described above, these descriptions should not be viewed in a limiting sense. Rather, there are several variations and modifications that may be made without departing from the scope of the invention as defined in the appended claims.

Claims

1. A device for communication, comprising: means for initializing parameters of a transmission system, wherein the transmission system comprises a transmitter, a channel, and a receiver, wherein the transmitter comprises a transmitter algorithm having at least some trainable weights and the receiver comprises a receiver algorithm having at least some trainable weights; means for updating trainable parameters of the transmission system based on a loss function, wherein the trainable parameters include the trainable weights of the transmitter and the trainable weights of the receiver, and wherein the loss function includes a penalty term; means for quantizing the trainable parameters so that the weights can only take on values ​​within a codebook having a finite number of entries, the finite number of entries being a subset of possible values ​​available during an update; as well as means for repeating said updating and said quantizing until a first condition is met, wherein the penalty term comprises a variable that is adjusted at each repetition of the updating and the quantizing such that at each repetition, greater weight is given in the loss function to the difference between the trainable parameter and the quantized trainable parameter. 2 . The apparatus of claim 1 , wherein the means for quantizing the trainable parameters uses fixed-point arithmetic to express the quantized weights.

3. The apparatus according to claim 1, further comprising: Widget used to update a variable on each repetition. 4 . The apparatus of claim 1 , wherein the first condition is satisfied when a difference between the trainable parameter and the quantized trainable parameter is below a threshold level. The apparatus of claim 1 , wherein the first condition comprises a defined number of iterations.

6. The apparatus according to claim 1, further comprising: Means for scaling a signal received at the receiver by a scaling factor.

7. The apparatus of claim 6, wherein the scaling factor causes a dynamic range of the received signal to match the codebook. The apparatus of claim 1 , wherein the transmitter is implemented as a lookup table.

9. The apparatus of claim 1, wherein the loss function is related to one or more of a block error rate, a bit error rate, and a classification cross entropy.

10. The apparatus of claim 1 , wherein the means for updating trainable parameters of the transmission system comprises optimizing one or more of: a batch size of a transmitter training message sequence, a learning rate, and a distribution of perturbations applied to a perturbed version of the transmitter training message sequence.

11. The apparatus of claim 1 , wherein the at least some of the trainable weights of the transmitter algorithm and the receiver algorithm are trained using stochastic gradient descent.

12. The apparatus of claim 1, wherein the transmitter algorithm comprises a transmitter neural network, and / or the receiver algorithm comprises a receiver neural network.

13. The device according to any one of the preceding claims, wherein the component comprises: at least one processor; as well as At least one memory including computer program code, the at least one memory and the computer program being configured, together with the at least one processor, to cause execution of the apparatus.

14. A method for communication, comprising: Initializing parameters of a transmission system, wherein the transmission system comprises a transmitter, a channel, and a receiver, wherein the transmitter comprises a transmitter algorithm having at least some trainable weights and the receiver comprises a receiver algorithm having at least some trainable weights; updating trainable parameters of the transmission system based on a loss function, wherein the trainable parameters include the trainable weights of the transmitter and the trainable weights of the receiver, and wherein the loss function includes a penalty term; quantizing the trainable parameters so that the weights can only take values ​​within a codebook having a finite number of entries, the finite number of entries being a subset of possible values ​​available during an update; as well as repeating the updating and the quantizing until a first condition is met, wherein the penalty term comprises a variable that is adjusted at each repetition of the updating and the quantizing such that at each repetition, greater weight is given in the loss function to the difference between the trainable parameter and the quantized trainable parameter.

15. An apparatus for communication comprising a look-up table or array created by means of the method of claim 14.

16. A computer program product comprising instructions for causing an apparatus to at least perform the following: Initializing parameters of a transmission system, wherein the transmission system comprises a transmitter, a channel, and a receiver, wherein the transmitter comprises a transmitter algorithm having at least some trainable weights and the receiver comprises a receiver algorithm having at least some trainable weights; updating trainable parameters of the transmission system based on a loss function, wherein the trainable parameters include the trainable weights of the transmitter and the trainable weights of the receiver, and wherein the loss function includes a penalty term; quantizing the trainable parameters so that the weights can only take values ​​within a codebook having a finite number of entries, the finite number of entries being a subset of possible values ​​available during an update; as well as repeating the updating and the quantizing until a first condition is met, wherein the penalty term comprises a variable that is adjusted at each repetition of the updating and the quantizing such that at each repetition, greater weight is given in the loss function to the difference between the trainable parameter and the quantized trainable parameter.

Images