TRAINING IN COMMUNICATION SYSTEMS

Description

Field

[0001] The present specification relates to training in communication systems.Background

[0002] A simple communications system includes a transmitter, a transmission channel, and a receiver. The design of such communications systems may involve the separate design and optimisation of each part of the system. An alternative approach is to consider the entire communication system as a single system and to seek to optimise the entire system. For example, Dörner et al., 11 July 2017, "Deep Learning-based Communication Over the Air" discloses the idea of deep learning communication systems. Lander et al., 01 July 2015, "EvoAE - A New Evolutionary Method for Training Autoencoders for Deep Learning Networks" discloses an evolutionary method for training autoencoders. O'Shea et al., 01 December 2017, "An Introduction to Deep Learning for the Physical Layer" discloses an autoencoder for implementing a communications system, where the transmitter and the receiver of the communications system are respectively implemented as the encoder and the decoder neural networks of the autoencoder.

[0003] Although some attempts have been made in the prior art, there remains scope for further developments in this area.Summary

[0004] The invention is set out in independent claims 1, 11 and 12. Preferred aspects of the invention are set out in the dependent claims.Brief description of the drawings

[0005] Example embodiments will now be described, by way of non-limiting examples, with reference to the following schematic drawings, in which: FIG. 1 is a block diagram of a communication system in accordance with an example embodiment; FIG. 2 is a flow chart showing an algorithm in accordance with an example embodiment; FIG. 3 is a flow chart showing an algorithm in accordance with an example embodiment; FIG. 4 is a block diagram of a system in accordance with an example embodiment; FIG. 5 is a flow chart showing an algorithm in accordance with an example embodiment; FIG. 6 is a block diagram of a components of a system in accordance with an example embodiment; and FIGS. 7A and 7B show tangible media, respectively a removable memory unit and a compact disc (CD) storing computer-readable code which when run by a computer perform operations according to embodiments. Detailed description

[0006] FIG. 1 is a block diagram of an example communication system, indicated generally by the reference numeral 1, in which example embodiments may be implemented. The system 1 includes a transmitter 2, a channel 3 and a receiver 4. Viewed at a system level, the system 1 converts an input symbol (s) (also called a message) received at the input to the transmitter 2 into an output symbol (ŝ) at the output of the receiver 4.

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

[0008] As discussed further below, the transmitter 2 may include a dense layer of one or more units 10, 11 (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.

[0009] Similarly, the receiver 4 may include a dense layer of one or more units 14, 15 (e.g. including one or more neural networks), a softmax module 16 and an arg max module 17. As described further below, the output of the softmax module is a probability vector that is provided to the input of an arg max module 17. The modules within the receiver 4 are provided by way of example and modifications are possible.

[0010] The system 1 therefore provides an autoencoder implementing an end-to-end communication system. The autoencoder can be trained with respect to an arbitrary loss function that is relevant for a certain performance metric, such as block error rate (BLER). (The terms 'autoencoder' and 'communication system' are both used below to describe the system 1.)

[0011] One obstacle to practical hardware implementation of the communication system (or autoencoder) 1 is the high memory requirement and computational complexity of the involved neural networks. Hardware acceleration may be provided to achieve reasonable inference time. However, graphical processing units (GPUs) that can be used to accelerate neural network evaluations come at a high monetary and energy cost that may not be viable in many communication systems.

[0012] By way of example, neural networks (or some other parametric algorithm) may be trained and exploited on computationally powerful platforms with graphic processing units (GPU) acceleration, supporting 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. Accordingly, the neural networks implementing the transmitter 2 and the receiver 4 of the system 1 may be compressed to meet practical constraints. This may be achieved by using a more compact representation of neural network parameters, at the cost of reduced precision. For example, as described further below, compression of weights and / or biases of the neural networks may be achieved through quantization, such that the weights are forced to take values within a codebook with a finite number of entries (e.g. at a lower precision that that provided by a training module). In extreme cases, each weight may take a binary value (e.g. either -1 or +1).

[0013] One method for quantizing the weights of a neural network (or some other algorithm) is to use K-bit fixed point arithmetic, instead of using a floating point arithmetic (such as 32-bits or 64-bits floating point arithmetic), with K typically being smaller than 32. 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 networks described herein, but can also reduce the complexity of arithmetic operators.

[0014] Using K-bits fixed point arithmetic, with K E bits used for the integer part and K F bits used for the fractional part (such that K E + K F = K), a weight w is represented by: w = ∑ i = 0 K E − 1 w e , i 2 i + ∑ j = 1 K F w f , j 2 − j where w e,i and w f,j take values in {0,1}. The number of bits K, as well as the sizes of the integer and fractional parts K E and K F are fixed. The scalar w is represented by a K+1 bit word (w s , w e,0 , ..., w e K E-1 , w f,1 , ..., w f,KF ), where w s is a sign bit (i.e. a bit indicating the sign of the weight).

[0015] In one embodiment, the transmitter 2 seeks to communicate one out of M possible messages s ∈ = {1, 2, ... , M} to the receiver 4. To this end, the transmitter 2 sends a complex-valued vector representation x = x s ∈ ℂ n of the message through the channel 3. Generally, the transmitter hardware imposes constraints on x, e.g. an energy constraint x 2 2 ≤ n, an amplitude constraint |x i | ≤ 1∀i, or an average power constraint E x i 2 ≤ 1 ∀ i. The channel 3 is described by the conditional probability density function (pdf) p(y |x ), where y ∈ ℂ n denotes the received signal. Upon reception ofy , the receiver produces the estimate ŝ of the transmitted message s.

[0016] The message index s may be fed into an embedding module, embedding: M ↦ ℝ n emb , that transforms s into an n emb -dimensional real-valued vector.

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

[0018] The output of the dense layers 10, 11 may be converted to a complex-valued vector through the mapping ℝ 2 ℂ : ℝ 2 n ↦ ℂ n , which could be implemented as ℝ 2 ℂ z = z 0 n − 1 + j z n 2 n − 1 . (This is not shown and is a purely optional step.)

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

[0020] The transmitter 2 defines the following mapping: TX : M ↦ ℝ 2 n , M = 0 , … , M − 1 .

[0021] In other words, TX maps an integer from the set to a 2n-dimensional real-valued vector. One example mapping is described above. Other neural network architectures are possible and the illustration above services just as an example.

[0022] As discussed above, the receiver 4 includes a dense layer of one or more units 14, 15 (e.g. including one or more neural networks), a softmax module 16 and an arg max module 17.

[0023] If the channel output vector y ∈ ℂ n is complex-valued, it may be transformed by the receiver 4 into a real-valued vector of 2n dimensions through the mapping ℂ 2 ℝ : ℂ n ↦ ℝ 2 n , which could be implemented as ℂ 2 ℝ z = R z T , J z T T . This step is not necessary for real-valued channel outputs y ∈ ℝ 2 n .

[0024] The result is fed into the one or more layers 14, 15, which layers may have different activation functions such as ReLU, tanh, sigmoid, linear, etc. The last layer may have M output dimensions to which a softmax activation is applied (by softmax module 16).

[0025] This generates the probability vector p ∈ ℝ M , whose ith element [p ] i can be interpreted as Pr(s = i|y ). A hard decision for the message index is obtained as ŝ = arg max(p ) by arg max module 17.

[0026] The transmitter 2 and the receiver 4 are implemented as neural networks having parameter vectors θ T and θ R respectively. If a differential channel model is available, then the channel model can be used as an intermediate non-trainable layer, such that the entire communication system 1 can be seen as a single neural network with parameters vector θ = (θ T , θ R ), which defines the mapping: f θ : M ↦ p ∈ ℝ + M ∑ i = 1 M p i = 1 × M

[0027] In some arrangements, the autoencoder 1 may be trained in a supervised manner using stochastic gradient descent (SGD). However, the use of stochastic gradient descent is difficult for an autoencoder with quantized weights, which take values in a discrete space.

[0028] FIG. 2 is a flow chart showing an algorithm, indicated generally by the reference numeral 20, in accordance with an example embodiment. The algorithm 20 uses principles of evolutionary computation to train an algorithm, such as a neural network (e.g. neural networks having quantized weights) implementing communication systems.

[0029] The algorithm 20 starts at operation 21, where a population of neural networks implementing end-to-end communication systems (or autoencoders) such as the autoencoder 1 are initialised. This can be achieved by generating parameters θ T implementing transmitter neural networks and parameters θ R implementing receiver neural networks according to some probability distribution over the possible weights values. The operation 21 may generate the parameters randomly from possible quantized weights.

[0030] At operation 22, a new population is generated from the initial population. As described further below, generating a new population may include selecting a subset of the initial / current population and generating a new population from the subset. The selection is made according to a metric (such as a loss function). Some example metrics are discussed further below.

[0031] With a new population generated, it is determined at operation 23 whether or not the algorithm 20 is complete. If so, the algorithm moves to 24. Otherwise, the algorithm moves to operation 25.

[0032] The algorithm 20 is deemed to be complete when a condition is reached; example conditions include a predefined performance level or a defined number of iterations. In one embodiment, the condition is deemed to have been reached when the best performing one (according to some metric) of the population of neural networks generated in the most recent iteration of the operation 22 reaches a predefined performance criterion according to said metric. The skilled person will be aware of other example conditions that could be used in the operation 23.

[0033] At operation 25, the new population is used as the current population and the algorithm returns to operation 22, where a new population is generated (using the population generated in the previous iteration of the operation 22 as the starting point).

[0034] The operations 22, 23 and 25 are repeated until the algorithm 20 is deemed to be complete. When the algorithm is deemed to be complete, the best performing neural network of the population of neural networks generated in the most recent iteration of the operation 22 is selected (in operation 24) and used as the output of the algorithm 20. In this way, the algorithm 20 can generate a neural network for use, for example, in the autoencoder 1 described above.

[0035] FIG. 3 is a flow chart showing an algorithm, indicated generally by the reference numeral 30, in accordance with an example embodiment. The algorithm 30 is an example implementation of the operation 22 of the algorithm 20 in which a new population is generated from a current population.

[0036] The current population comprises a population of P neural networks (also referred to as individuals). The algorithm 30 seeks to 'evolve' the population of neural networks such that, on average, the population gets better with respect to a loss function on each iteration of the algorithm 30.

[0037] The algorithm 30 starts at operation 31, where some or all of the individuals within the population are evaluated according to a metric. For example, each individual within a population may be evaluated with respect of a loss function L to compute a fitness f i of that population. The fitness may be calculated according to the formula: f i = -L(p i ) for all p i ∈ .

[0038] The operation 31 may be implemented, for example, by letting each end-to-end communication system (or autoencoder) transmit a large number of known messages for which the average loss L(p i ) is calculated using the formula L = 1 N ∑ i = 1 N − log p i s i , where -log([p i ] si ) is the categorical cross entropy between an input message and the output vector p i .

[0039] At operation 32, a subset of the neural networks of the current population is selected based on the metric (e.g. the fitness referred to above). The selection may, for example, seek to select the optimum neural networks of the population (such as the best K options) according to said metric. Alternative approaches exist, such as selecting less optimum neural networks (according to the metric) for exploration purposes (e.g. to reduce the likelihood of approaching a local minima), as discussed further below. Moreover, algorithms other than neural networks may be used.

[0040] In an example implementation of the operation 32, a subset is selected, such that = Θ(, {f i } i ), such that ⊂ , according to the fitness of the individuals {f i } i .

[0041] At operation 33, an updated population of neural networks is generated (or 'evolved') from the subset selected in operation 32. For example, a new population may be generated from the subset selected in the operation 32 as follows: P t + 1 = Ξ T t , where Ξ is an evolution operator.

[0042] The total number of neural networks in the current and updated populations may be the same. In one example, the updated population includes the best performing neural network from the current population (e.g. the neural network most meeting the relevant metric), with all other members of the updated population being generated / evolved from said subset. For example, assume that a population includes 100 neural networks. The 10 best performing neural networks of the population may be used to generate 99 neural networks, with the updated population including the 99 newly generated neural networks and the best performing neural network of the current population.

[0043] Thus, on each iteration of the operation 22 of the algorithm 20, a new updated population of neural networks is generated.

[0044] The evolution operator Ξ described above can take many forms. For example, if it assumed that all of the neural networks of the population share the same architecture, with W trainable weights, then a neural network p can be uniquely represented by a W-dimensional real vector G p ∈ ℝ W constructed by vectorization of its trainable weights.

[0045] The vector (p) may be referred to as a genome of the individual p (using genetic algorithm terminology).

[0046] A simple way to generate new individuals is to apply random perturbations to the genomes of selected individuals. Thus, a new individual p' is obtained from another individual p as follows: p' = ((p) + w), where w is a random perturbation and is the mapping between a vector of weights and its uniquely corresponding neural network. Addition could be taken on a Galois field. Such perturbations of individual genomes can be referred to as mutations (again, using genetic algorithm terminology). It is also possible to perform crossovers, by combining multiple selected individuals to produce a new one.

[0047] The weights of the neural networks are quantized, such that said weights can only take values within a codebook having a finite number of entries (as discussed above). The quantized weights may be expressed used fixed point arithmetic, as discussed above.

[0048] The evaluation of individuals within a population of neural networks (as described, for example, with respect to the algorithm 30) can be conducted in parallel; for example, by either instantiating a plurality of members of the population on a different physical hardware setup or by simulating the neural networks of the population in software. By way of example, FIG. 4 is a block diagram of a system, indicated generally by the reference numeral 40, in accordance with an example embodiment comprising a plurality of autoencoders 41a, 41b ...41n (which may be hardware implementations of autoencoders or software simulations). Each autoencoder is a transmission system comprising a transmitter, a channel and a receiver (such as the autoencoder 1), that is viewed as a single neural network (or some other algorithm) with parameters vector θ (where θ is derived from transmitter and receiver neural network parameters). Thus, each of the autoencoders 41a, 41b...41n is an example of an individual within a population of neural networks.

[0049] A loss function module 42a generates a loss function from the first autoencoder 41a.

[0050] Similar loss functions modules 42b to 42n generate loss functions for the autoencoders 41b to 41n. The outputs of the loss function modules 42a to 42n are provided to a processor 43, which processor implements the operation 32 by selecting a subset of the population of autoencoders based on the outputs of the loss function modules.

[0051] In the embodiments described above, the operation 22 of the algorithm 20 is implemented by considering the fitness of neural networks within a population of neural networks. This is not essential to all embodiments.

[0052] FIG. 5 is a flow chart showing an algorithm, indicated generally by the reference numeral 50, in accordance with an example embodiment. The algorithm 50 is an example implementation of the operation 22 in which so-called novelty is considered, instead of fitness. The novelty-based algorithm (which is described in detail below) includes the definition of a 'behaviour characteristic', which measures behaviour of a neural network (or some other algorithm), and a 'behaviour distance', which measures the distance between the behaviours of different neural networks or algorithms. The behaviour may, for example, be computed from the trainable weights, output or performance of the neural networks of a population.

[0053] The algorithm 50 starts at operation 51, where the novelty of a population is computed. That population may be the initial population generated in the operation 21 or the new population generated in the previous iteration of the operation 22 of the algorithm 20 described above. We denote by Γ the function which measures the novelty of an individual with regards to the current and previous populations. To do so, the defined behaviour characteristics and behaviour distances are used. Thus, for each neural network of a population , novelty is computed as follows: n i = Γ(p i , , , ... ) for all p i ∈ .

[0054] At operation 52, a subset of the population is selected according to novelty. In this way, the behavioural novelty of individuals within a population is rewarded, rather than the fitness of individuals. Although counter-intuitive, this subset selection process has been found to give good results.

[0055] In the operation 52, the subset may be defined as = Θ(, {n i } i ), such that ⊂ , according to the novelty of the individuals {n i } i .

[0056] At operation 53, a new population is selected from the subset selected in the operation 52. The new population may be given by = Ξ() , where Ξ is an evolution operator.

[0057] As noted above, the operation 53 may restore the size of the population (e.g. to P).

[0058] The behaviour characteristics discussed above may be domain specific. In the case of autoencoders implementing end-to-end communication systems (such as the autoencoder 1), the constellation generated by the encoder may be used as a behaviour characteristic. For example, the behaviour characteristic could be the n-by-M matrix, in which the ith column corresponds to the complex value representation of the message i, where x i ∈ ℂ n . The behaviour distance can therefore be any matrix norm. For example, given two behaviour characteristics X 1 and X 2 , the behaviour distance could be ∥X 1 - X 2 ∥ F (where ∥X∥ F is the Frobenius norm of X).

[0059] The algorithm 30 described above selects a subset by considering fitness. The algorithm 50 described above selects a subset by considering novelty. It is also possible to combine aspects of the two algorithms, such that the subset is selected by considering aspects of both fitness and novelty. For example, one may generate a new population by keeping both the K-best performing (according to some metric) and the L-most novel individuals and by creating mutations of the K best performing and the L most different individuals.

[0060] For completeness, FIG. 6 is a schematic diagram of components of one or more of the modules described previously (e.g. the transmitter or receiver neural networks), which hereafter are referred to generically as processing systems 110. A processing system 110 may have a processor 112, a memory 114 closely coupled to the processor and comprised of a RAM 124 and ROM 122, and, optionally, hardware keys 120 and a display 128. The processing system 110 may comprise one or more network interfaces 118 for connection to a network, e.g. a modem which may be wired or wireless.

[0061] The processor 112 is connected to each of the other components in order to control operation thereof.

[0062] The memory 114 may comprise a non-volatile memory, a hard disk drive (HDD) or a solid state drive (SSD). The ROM 122 of the memory 114 stores, amongst 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 the temporary storage of data. The operating system 125 may contain code which, when executed by the processor, implements aspects of the algorithms 20, 30 and 50.

[0063] The processor 112 may take any suitable form. For instance, it may be a microcontroller, plural microcontrollers, a processor, or plural processors.

[0064] The processing system 110 may be a standalone computer, a server, a console, or a network thereof.

[0065] In some embodiments, the processing system 110 may also be associated with external software applications. These may be applications stored on a remote server device and may run partly or exclusively on the remote server device. These applications may be termed cloud-hosted applications. The processing system 110 may be in communication with the remote server device in order to utilize the software application stored there.

[0066] FIGS. 7A and 7B show tangible media, respectively a removable memory unit 165 and a compact disc (CD) 168, storing computer-readable code which when run by a computer may perform methods according to embodiments described above. The removable memory unit 165 may be a memory stick, e.g. a USB memory stick, having internal memory 166 storing the computer-readable code. The memory 166 may be accessed by a computer system via a connector 167. The CD 168 may be a CD-ROM or a DVD or similar. Other forms of tangible storage media may be used.

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

[0068] Reference to, where relevant, "computer-readable storage medium", "computer program product", "tangibly embodied computer program" etc., or a "processor" or "processing circuitry" etc. should be understood to encompass not only computers having differing architectures such as single / multi-processor architectures and sequencers / parallel architectures, but also specialised circuits such as field programmable gate arrays FPGA, application specify circuits ASIC, signal processing devices and other devices. References to computer program, instructions, code etc. should be understood to express software for a programmable processor firmware such as the programmable content of a hardware device as instructions for a processor or configured or configuration settings for a fixed function device, gate array, programmable logic device, etc.

[0069] As used in this application, the term "circuitry" refers to all of the following: (a) hardware-only circuit implementations (such as implementations in only analogue and / or digital circuitry) and (b) to combinations of circuits and software (and / or firmware), such as (as applicable): (i) to a combination of processor(s) or (ii) to portions of processor(s) / software (including digital signal processor(s)), software, and memory(ies) that work together to cause an apparatus, such as a server, to perform various functions) and (c) to circuits, such as a microprocessor(s) or a portion of a microprocessor(s), that require software or firmware for operation, even if the software or firmware is not physically present.

[0070] 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 above-described functions may be optional or may be combined. Similarly, it will also be appreciated that the flow diagram of FIGS. 2, 3 and 5 are examples only and that various operations depicted therein may be omitted, reordered and / or combined.

[0071] The example embodiments have generally been described above with reference to populations of neural networks. Moreover, although example embodiments are described in which trainable parameters of the algorithm (e.g. parameters of a neural network) are updated, this is not essential to all embodiments. For example, a population of algorithms may be updated by updating one or more parameters and / or one or more structures of one or more of the algorithms of a population.

Claims

1. An apparatus comprising: means for evaluating (31) some or all of a current population of algorithms according to a metric, each algorithm of the population implementing a transmission system, wherein the transmission system comprises a transmitter (2), a channel (3) and a receiver (4), wherein the transmitter (2) includes a transmitter algorithm implemented as a transmitter neural network having at least some trainable weights and the receiver (4) includes a receiver algorithm implemented as a receiver neural network having at least some trainable weights, wherein at least some of the weights are quantized weights, wherein said quantized weights can only take values within a codebook having a finite number of entries; means for selecting (32) a subset of the algorithms of the current population based on the metric; means for generating (33) an updated population of algorithms from said subset by applying random perturbations to the trainable weights of the transmitter and receiver neural networks; means for repeating the evaluating, selecting and generating, based on the updated population, until a first condition is reached; and means for selecting one algorithm of said updated population of algorithms, when said first condition has been reached.

2. The apparatus as claimed in claim 1, further comprising means for generating an initial population of algorithms and setting said initial population as a first instance of said current population.

3. The apparatus as claimed in any one of claims 1 to 2, wherein the means for evaluating (31) some or all of the current population of algorithms comprises means for computing a fitness of said algorithms, wherein the fitness of said algorithms is computed using a loss function.

4. The apparatus as claimed in any one claims 1 to 3, wherein the means for evaluating (31) some or all of the current population of algorithms comprises means for computing a novelty of said algorithms, wherein the novelty of said algorithms is computed by determining a distance between algorithms of the population.

5. The apparatus as claimed in any one of the preceding claims, wherein the means for selecting (32) the subset of the algorithms of the current population comprises means for selecting one or more optimum algorithms of the population according to said metric.

6. The apparatus as claimed in any one of the preceding claims, wherein the updated population of algorithms includes an algorithm evaluated by the means for evaluating (31) said some or all of the current population of algorithms as most meeting said metric.

7. The apparatus as claimed in any one of the preceding claims, wherein the means for generating (33) an updated population of algorithms from said subset comprises generating one or more new algorithms from the subset of algorithms.

8. The apparatus as claimed in any one of the preceding claims, wherein the first condition is met when a best performing one of said current or updated population of algorithms reaches a predefined performance criterion according to said metric.

9. The apparatus as claimed in any one of the preceding claims, wherein the first condition comprises a defined number of iterations.

10. The apparatus as claimed in any one of the preceding claims, wherein said means for generating (33) an updated population of algorithms from said subset modifies one or more parameters and / or one or more structures of one or more of said subset of algorithms of said current population.

11. A computer-implemented method comprising: evaluating (31) some or all of a current population of algorithms according to a metric, each algorithm of the population implementing a transmission system, wherein the transmission system comprises a transmitter (2), a channel (3) and a receiver (4), wherein the transmitter (2) includes a transmitter algorithm implemented as a transmitter neural network having at least some trainable weights and the receiver (4) includes a receiver algorithm implemented as a receiver neural network having at least some trainable weights wherein at least some of the weights are quantized weights, wherein said quantized weights can only take values within a codebook having a finite number of entries; selecting a subset (32) of the algorithms of the current population based on the metric; generating (33) an updated population of algorithms from said subset by applying random perturbations to the trainable weights of the transmitter and receiver neural networks; repeating the evaluating, selecting and generating, based on the updated population, until a first condition is reached; and selecting one algorithm of said updated population of algorithms, when said first condition has been reached.

12. A computer readable medium comprising program instructions stored thereon for performing at least the following: evaluating (31) some or all of a current population of algorithms according to a metric, each algorithm of the population implementing a transmission system, wherein the transmission system comprises a transmitter (2), a channel (3) and a receiver (4), wherein the transmitter (2) includes a transmitter algorithm implemented as a transmitter neural network having at least some trainable weights and the receiver (4) includes a receiver algorithm implemented as a receiver neural network having at least some trainable weights wherein at least some of the weights are quantized weights, wherein said quantized weights can only take values within a codebook having a finite number of entries; selecting a subset (32) of the algorithms of the current population based on the metric; generating (33) an updated population of algorithms from said subset by applying random perturbations to the trainable weights of the transmitter and receiver neural networks; repeating the evaluating, selecting and generating, based on the updated population, until a first condition is reached; and selecting one algorithm of said updated population of algorithms, when said first condition has been reached.