KR102532658B1 - Neural architecture search - Google Patents

Abstract

A method, system and apparatus comprising a computer program encoded on a computer storage medium for determining a neural network architecture is disclosed. One of the methods includes generating a batch of output sequences using a controller neural network, each output sequence in the batch defining a respective architecture of a child neural network configured to perform a particular neural network task; For each output sequence in the batch: training each instance of the child neural network having the architecture defined by the output sequence; evaluating performance of the trained instance of the child neural network for the specific neural network task to determine a performance metric for the trained instance of the child neural network for the specific neural network task; and adjusting current values of controller parameters of the controller neural network using the performance metric for the trained instance of the child neural network.

Description

Neural Architecture Search {NEURAL ARCHITECTURE SEARCH}

This specification relates to modifying neural network architecture.

A neural network is a machine learning model that uses one or more layers of nonlinear units to predict an output given a received input. Some neural networks include one or more hidden layers in addition to the output layer. The output of each hidden layer is used as an input to the next layer of the network, i.e. the next hidden layer or the output layer. Each layer of the network generates outputs from received inputs according to the current values of the respective parameter sets.

Some neural networks are recurrent neural networks. A recurrent neural network is a neural network that receives an input sequence and generates an output sequence from the input sequence. In particular, a recurrent neural network may use some or all of the network's internal state from a previous time step when computing an output at the current time step. An example of a recurrent neural network is an LSTM neural network that includes one or more long short term (LSTM) memory blocks. Each LSTM memory block has an input gate, a forget gate, and an output gate that allows the cell to store a previous state for the cell for use in generating, for example, the current activation or provided to other components of the LSTM neural network. It may include one or more cells each including.

This specification describes how a system implemented in computer programs on one or more computers at one or more locations uses a controller neural network to determine the architecture (structure) for a child neural network configured to perform a particular neural network task.

Certain embodiments of the subject matter described herein may be implemented to realize one or more of the following advantages. The system can efficiently and automatically select a neural network architecture that will result in a high performance neural network for a particular task, ie without user intervention. The system can effectively determine a new neural network architecture suitable for a particular task, thus allowing the resulting child neural network to have improved performance for the task. Since the system determines the architecture (structure) by learning the controller neural network through reinforcement learning, the system can effectively explore a wide space of possible architectures to identify an architecture for a child neural network suitable for a particular task. .

The details of one or more embodiments of the subject matter described in this specification are set forth in the accompanying drawings and the description below. Other features, aspects and advantages of the subject matter will be apparent from the detailed description, drawings and claims.

1 shows an exemplary neural architecture retrieval system.
2A is a diagram illustrating an example of a controller neural network generating an output sequence.
FIG. 2B is an example of a controller neural network that generates an output sequence defining an architecture that includes skip connections.
2C is a diagram illustrating an example of a controller neural network that generates an output sequence defining an architecture for a circulating cell.
3 is a flow diagram of an exemplary process for updating a current value of a controller parameter.
Like reference numbers and designations in the various drawings indicate like elements.

This specification describes a system implemented as a computer program on one or more computers in one or more locations that determines an architecture for a child neural network configured to perform specific neural network tasks using a controller neural network.

A child's neural network can be configured to receive any type of digital data input and, depending on the input, generate any type of score, classification or regression output.

For example, if the input to a Child's Neural Network is an image or features extracted from an image, the output produced by the Child's Neural Network for a given image may be a score for each of a set of object categories, each score being Indicates the estimated likelihood that the image contains images of objects belonging to the category.

As another example, an input to a child's neural network is an Internet resource (e.g., a web page), a document, or a feature extracted from an Internet resource, a document, or a portion of a document, or a portion of a document. The output produced by the child's neural network for a portion of a document may be a score for each of the set of topics, each score representing an estimated likelihood that the Internet resource, document, or document portion relates to a topic.

As another example, if the input to the child's neural network is a characteristic of the exposure context for a particular advertisement, the output generated by the child's neural network may be a score representing the estimated likelihood that the particular advertisement will be clicked.

As another example, if the input to a child's neural network is a feature of a personalized recommendation for a user, e.g., a feature that characterizes the context for the recommendation, such as a previous action taken by the user, the child's neural network The output generated by may be a score for each of the set of content items, each score representing a likelihood that the user is expected to respond favorably to recommending the content item.

As another example, if the input to a child's neural network is a sequence of text in one language, the output produced by the child's neural network may be a score for each of a set of pieces of text in another language; Each score represents the estimated likelihood that portions of text in the other language are proper translations of the input text in the other language.

As another example, if the input to the Child's Neural Network is a sequence representing an utterance (utterance), the output produced by the Child's Neural Network may be a score for each set of parts of text, each score representing a text part corresponding to an utterance. Indicates the likelihood estimated to be an accurate transcript for .

1 shows an exemplary neural architecture retrieval system 100 . Neural architecture search system 100 is an example of a system implemented as a computer program on one or more computers at one or more locations, and the systems, components, and techniques described herein may be implemented.

The neural architecture retrieval system 100 obtains training data 102 for training a neural network to perform a particular task and a validation set 104 for evaluating the performance of the neural network for a particular task, and the training data (102) and effectiveness set (104) to determine the architecture for a child neural network configured to perform a particular task. The architecture defines the number of layers in the child neural network, the operations performed by each layer, and the connectivity between the layers in the child neural network, i.e. which layers receive input from other layers in the child neural network.

In general, both training data 102 and validation set 104 include a set of neural network inputs and each target output that must be produced by the child neural network to perform a particular task for each network input. For example, a larger set of training data can be randomly partitioned to generate training data 102 and validation set 104 .

System 100 may receive training data 102 and validation set 104 in any of a variety of ways. For example, system 100 can receive training data as an upload from a remote user of the system over a data communications network using an application programming interface (API) usable by system 100, and send the uploaded data to Randomly divides into training data 102 and validation set 104 (split). As another example, system 100 can receive input from a user specifying whether data already maintained by system 100 should be used to train a neural network, and then convert the specified data to training data 102 . and validity set (104).

The neural architecture search system (100) includes a controller neural network (110), a training engine (120) and a controller parameter update engine (130).

Controller neural network 110 is a neural network having parameters referred to herein as "controller parameters" and configured to generate an output sequence according to the controller parameters. Each output sequence produced by controller neural network 110 defines each possible architecture for the child neural network.

In particular, each output sequence includes a respective output at each of a plurality of time steps, and each time step of the output sequence corresponds to a different hyperparameter of the architecture of the child's neural network. Thus, each output sequence contains each value of the corresponding hyperparameter at each time step. Collectively, the values of the hyperparameters in a given output sequence define the architecture for the child's neural network. In general, hyperparameters are values that are set before training of the child neural network starts and affect operations performed by the child neural network. The output sequence and possible hyperparameters are described in more detail below with reference to Figs. 2a-2c.

In general, system 100 determines the architecture for a child neural network by training controller neural network 110 to adjust the values of controller parameters.

In particular, during iterations of the training process, the system 100 generates batches 112 of sequences using the controller neural network 110 according to the current values of the controller parameters. For each output sequence in batch 112, training engine 120 trains an instance of a child neural network with the architecture defined by the output sequence to training data 102, and the trained instance in validation set 104. evaluate the performance of The controller parameter update engine 130 then updates the current values of the controller parameters using the evaluation results for the output sequences in the batch 112 defined by the output sequences generated by the controller neural network 110 for the task. improve the expected performance of the proposed architecture. Evaluating the performance of the trained instance and updating the current values of the controller parameters are described in more detail below with reference to FIG. 3 .

By iteratively updating the values of the controller parameters in this way, the system 100 trains the controller neural network 110 so that it has increased performance for specific tasks, i.e. the architecture proposed by the controller neural network 110. can generate an output sequence that maximizes the expected accuracy on the validity set 104 of .

Once the controller neural network 110 is trained, the system 100 may select the best performing architecture in the validation set 104 as the final architecture of the child neural network, or generate a new output sequence according to the trained values of the controller parameters. and use the architecture defined by the new output sequence as the final architecture of the child neural network.

Then, the neural network retrieval system 100 may output architecture data 150 specifying the architecture of the child neural network, that is, data specifying layers that are part of the child neural network, connectivity between layers, and operations performed by the layers. there is. For example, the neural network search system 100 may output architecture data 150 to a user who has submitted training data. In some cases, data 150 also includes trained values of parameters of the child neural network from training of a trained instance of the child neural network with the architecture.

In some implementations, instead of or in addition to outputting architecture data 150, system 100 scratches parameter values generated as a result of, for example, training an instance of a child neural network having an architecture. Train an instance of a neural network with the architecture determined above to fine-tune or from, and then use the trained neural network to process requests received by users, for example via an API provided by the system. That is, system 100 may receive input to be processed, process the input using a trained child's neural network, and data derived from output generated by the trained neural network or output generated in response to the received input. provides

In some implementations, system 100 trains the controller neural network in a distributed manner. That is, system 100 includes multiple replicas of the controller neural network. In some of these implementations where training is distributed, each replica creates a performance metric for batches of output sequences output by the replica and a dedicated controller parameter update engine that uses that performance metric to determine updates to the controller parameters. It has a dedicated training engine. If the controller parameter update engine determines to update, the controller parameter update engine can send the update to a central parameter update server accessible to all controller parameter update engines. The central parameter update server may update the value of the controller parameter maintained by the server and send the updated value to the controller parameter update engine. In some cases, a plurality of replicas and their corresponding training engines and parameter update engines, respectively, may operate asynchronously from different sets of training engines and parameter update engines.

2A is a diagram 200 of an example in which an output neural network 110 generates an output sequence.

In particular, diagram 200 illustrates the processing performed by controller neural network 110 for seven exemplary time steps 202-214 during generation of the output sequence. As described in more detail below, each of the seven time steps 202-214 corresponds to a different hyperparameter of the neural network architecture.

Controller neural network 110 is a recurrent neural network that includes one or more recurrent neural network layers, e.g., layers 220 and 230, which for each time step correspond to the preceding time step in the given output sequence. and receive values of the parameters as inputs, and process the inputs to update the current hidden state of the recurrent neural network. For example, the recurrent layers of controller neural network 110 may be long-short term memory (LSTM) layers or gated recurrent unit (GRU) layers. In the example of FIG. 2A , at time step 208 , layers 220 and 230 receive as input the value of the hyperparameter from the previous (previous) time step 206 , and obtain an updated hidden state 232 . Updates the unnic states of layers 220 and 230 from time step 206 to produce as output.

Controller neural network 110 also includes a respective output layer for each time step of the output sequence, e.g., output layers 242-254 for time steps 202-214, respectively. Each output layer is configured to receive an output layer input comprising an updated hidden state at the time step, and generate an output for the time step defining a distribution of scores for possible values of the hyperparameter at the time step. For example, each output layer first projects the output layer input into the appropriate dimension for multiple possible values of that hyperparameter, and then each output layer input for each of the multiple possible values for that hyperparameter at a time step. A softmax can be applied to the projected output layer input to generate a score. For example, the output layer 248 for the time step 208 receives an input comprising a hidden state 232 and generates a respective score for each of a plurality of possible values for the hyperparameter of the stride height. is configured to generate

Thus, to generate hyperparameter values for a given time step in an output sequence, system 100 provides the values of the hyperparameters at a previous time step in the output sequence as inputs to a controller neural network, which controls the time step produces an output for time steps defining the distribution of scores over the possible values of the hyperparameters in . Since there is no previous time step, at the very first time step in the output sequence, system 100 may instead provide a predetermined placeholder input. System 100 then samples from the possible values according to the score distribution to determine the value of the hyperparameter at the time step of the output sequence. Possible values of a given hyperparameter are fixed before training, and a plurality of possible values may be different for different hyperparameters.

In general, the number of layers to be included in the architecture defined by a given output sequence is fixed prior to generating the sequence. In some implementations, each architecture defined by the output sequences generated during training of the controller neural network has the same number of layers. In another implementation, the system uses a schedule that increases the number of layers in the child neural network as training progresses. As an example, the system may start with 6 layers during training and increase the depth to one or more layers every 1,600 samples.

In the example of FIG. 2A , the child neural network is a convolutional neural network, and the hyperparameters include hyperparameters for each convolutional neural network layer in the child neural network. In particular, in Fig. 2A, time step 202 corresponds to a hyperparameter of convolutional layer N-1 of the Child's Neural Network, time steps 204-212 correspond to hyperparameters of convolutional layer N, and Step 214 corresponds to the hyperparameters of the convolutional layer N+1. For example, convolutional layers can be arranged in a stack, where layer N receives as input the output produced by layer N−1 and produces an output that is provided as input to layer N+1.

In the example of FIG. 2A, in the case of a convolutional layer, the hyperparameters defining operations performed by the layer are the number of filters in the layer, the filter height of each filter, the filter width of each filter, and the stride to which each filter is applied. height and stride width of each filter. In another example, some of these may be eliminated, e.g. certain of these hyperparameters may be assumed to be fixed, and other hyperparameters, e.g. the type of activation function, the convolution may be dilated or (dilated) masking or not may be added, or both may be added.

In an example implementation, possible values for filter height are [1, 3, 5, 7], possible values for filter width are [1, 3, 5, 7], and possible values for number of filters are [24, 36, 48, 6 64], and possible values for stride height and width are [1, 2, 3].

In the example of Fig. 2a, the composition of the layers in the child's neural network, ie which layers receive layers from other layers, is fixed. However, in other examples, the hyperparameters include hyperparameters that define connectivity between layers of a child neural network.

FIG. 2B is a diagram 250 of an example of a controller neural network 110 that generates output sequences that define an architecture that includes skip connections.

In particular, in the example of FIG. 2B , for one or more layers of the child neural network, the hyperparameters include a skip connection hyperparameter, which defines which previous layers have skip connections to that layer. . More specifically, the time steps of the output sequence are one or more layers whose hypermeter is a skip connection hyperparameter, e.g., time step 252 for layer N-1 and time step 254 for layer N. Each anchor point time step for each of

The output layer for a given anchor point time step of a given layer contains individual nodes corresponding to each layer prior to the current layer in the child neural network. Each node has (i) an updated hidden state for the anchor point step, and (ii) an updated hidden state for the anchor point time step of the corresponding previous layer, i.e., the previous layer corresponding to the node. It is configured to process according to a set of parameters to generate a score representing a likelihood of being connected to the current layer of the child neural network. For example, a node in the output layer of layer i corresponding to previous layer j may generate a score for the corresponding previous layer that satisfies Equation 1.

는 상기 노드에 대한 파라미터들이며,

는 상기 대응하는 이전 계층 j의 앵커 포인트 시간 단계에 대한 업데이트된 은닉 상태이고,

는 계층 i의 앵커 포인트 시간 단계에 대한 업데이트된 은닉 상태이다.here,

are the parameters for the node,

is the updated concealment state for the anchor point time step of the corresponding previous layer j,

is the updated concealment state for the anchor point time step of layer i.

Then, for each previous layer, the system 100 selects a given layer as a skip connection by sampling either "yes" or "no" according to the score generated by the node corresponding to the previous layer. determine if it is connected to If the system determines that multiple layers should be connected to the given layer, then the outputs produced by all of the multiple layers are concatenated in the depth dimension to create the input to the given layer. To avoid skip connections from causing "compilation failures" in networks where one layer is incompatible with another and does not contain a layer with no inputs or outputs, (i) the layer is not connected to the input layer. Otherwise, the network input is used as the input of the layer, (ii) at the final layer, the system takes all unconnected layer outputs and concatenates them before sending the final connected output to the output layer of the network, and (iii) the input to be connected. have different sizes, the system pads the small layer to zero so that the inputs to be connected have the same size.

In some examples, a child's neural network includes a plurality of different layer types. For example, a child neural network is composed of other types of neural network layers, such as fully connected layers, pooling layers, deeply connected layers, local contrast normalization, batch normalization, output layers (e.g. softmax layers or other classifier layers). It can be a convolutional neural network including

In some of these examples, the hyperparameters and positions of the other layers are fixed, and the output sequence contains only hyperparameter values for the convolutional neural network layers of the child's neural network. For example, the position of the output layer may be fixed as the last layer of the child neural network, and some or all convolutional layers may follow or precede the batch normalization layers.

In other of these examples, the hyperparameter defined by the output sequence includes, for each layer, a value corresponding to the type of layer. Different types of layers have different hyperparameters, so in this example the system dynamically determines which hyperparameters correspond to which time steps during generation of the output sequence based on which type of neural network layer is selected for a given layer. Decide. That is, the output layer that the system uses as an output layer during a given time step depends on the most recently sampled value of the layer type hyperparameter.

In some examples, the child's neural network is a recurrent neural network. In this case, the output sequence can define the architecture of the recurrent cells, and the meek cells can be repeated many times within the child neural network to create the architecture for the neural network. As mentioned above, in some cases the number of repetitions is fixed during training, in other cases the system increases the number of repetitions as the training progresses.

FIG. 2C is a diagram 270 of an example of a controller neural network 110 that generates an output sequence defining an architecture for a circulating cell.

In particular, as shown in Fig. 2c, the output sequence includes each computational step for each node of a tree of computational steps representing the computations performed by the circulating cells. A benign cell receives two inputs: an input for the current time step (i.e. input to the child network at the time step or output generated by another component of the child network), and the cell's output from the previous time step. do. A circulating cell processes these two inputs to produce a cell output. As described below, in some cases, the circulating cell also receives a third input, namely the memory state.

More specifically, in Fig. 2c, the output sequence is distributed over three nodes of the tree: one leaf node at tree index 0, another leaf node at tree index 1, and an internal node at tree index 2. Define settings for

Each node in the tree produces an output by merging two inputs, and for each node the output sequence is (i) data identifying the combination method that combines the two inputs and (ii) two inputs to produce the output. Contains the activation function to be applied to combinations of inputs. In general, a cell's leaf node first applies its respective parameter matrix to each of the two inputs to the cell, but the inner nodes do not have any parameters. As described above, the combination method is selected from a set of possible combination methods (eg add; element wise multiply), and the activation function is selected from a set of possible activation functions (eg add; element wise multiply). , identity; tanh; sigmoid; relu).

을 생성하기 위해 수학식 2의 연산을 수행할 수 있다. For example, for a leaf node at tree index 0, the leaf node at tree index 0 in a cell is an output because the system chose "add" as the join function and "tanh" as the activation function.

The operation of Equation 2 can be performed to generate

및

는 노드의 파라미터 행렬이고,

는 시간 단계에서 셀에 대한 입력이고,

는 이전 시간 단계에서의 셀의 출력이다.here,

and

is the parameter matrix of the node,

is the input to the cell at the time step,

is the cell's output at the previous time step.

For a node at tree index 2, when the cell has no memory state, in the example of Fig. 2c, the two inputs to the node, i.e., the outputs of the two leaf nodes, are multiplied elementwise, and the elementwise sigmoid function is internally Specifies to be applied to the output of a node, i.e., the output of an element-by-element multiplication to produce the output of a cell.

Optionally, the cell's architecture may include receiving a preceding memory state as an input. In this case, the output sequence is how the cell's memory state is injected into the cell, i.e. how the preceding memory state is updated, and the node whose output is modified using the preceding memory state before being passed to the next node in the tree. contains the values defined.

Specifically, the output sequence is two cell injections that specify how the preceding memory state is combined with the output of one of the nodes in the tree (i.e., the combination method and the activation function for the combination) to produce an updated output for the node. values, and two cell index values that specify (i) the node whose output is updated using the memory state and (ii) the node whose output is set to the updated memory state (before application of the activation function to the node). do.

라고 칭함)에서의 노드의 출력을 합산할 수 있고, 그 다음 트리 인덱스 0에서 노드의 업데이트된 출력을 생성하기 위해 그 합산에 ReLU를 적용할 수 있다. 그 다음, 상기 셀은 업데이트된 출력을 트리 인덱스 2의 노드에 입력으로서 제공할 수 있다.In the example of FIG. 2C , since the value generated for the second cell index is 0, the coupling method for injection is "add", and the activation function is ReLU, the cell has a preceding cell state and a tree index of 0 (

), and then apply ReLU to the sum to create an updated output of the node at tree index 0. The cell may then provide the updated output as an input to the node at tree index 2.

Since the value generated for the first cell index is 1, the cell sets the updated memory state to the tree output at index 1 before the activation function is applied.

On the other hand, FIG. 2C shows an example in which the tree includes two leaf nodes for ease of explanation, and in practice, the number of leaf nodes may be larger, such as 4, 8 or 16.

3 is a flow diagram of an exemplary process 300 for updating a current value of a controller parameter. For convenience, process 300 will be described as being performed by a system of one or more computers located at one or more locations. For example, a properly programmed neural architecture retrieval system such as neural architecture retrieval system 100 of FIG. 1 may perform process 300 .

The system can iteratively perform process 300 to train the controller neural network, ie, to determine trained values of the controller parameters from initial values of the controller parameters.

The system uses a controller neural network and upon iteration generates a batch of output sequences according to the current values of the controller parameters (step 302). Each output sequence in a batch defines an individual architecture of the child's neural network. In particular, as noted above, because the system samples from the score distribution when generating each hyperparameter value in the output sequence, sequences of batches may differ from each other even though they are generally generated according to the same controller parameter values. A batch typically includes a predetermined number of output sequences, for example 8, 16, 32 or 64 sequences.

For each output sequence in the batch, the system trains an instance of the child neural network with the architecture defined by the output sequence to perform the particular neural network task (step 304). That is, for each output sequence in the batch, the system instantiates a neural network with an architecture defined by the output sequence, and a conventional machine learning training technique suitable for the task (e.g., backpropagation or backpropagation-through-time ) to train an instance on the received training data to perform a specific neural network task using stochastic gradient descent through . In some implementations, the system parallelizes training of the child neural network to reduce the overall training time for the controller neural network. The system can train each child neural network for a specified amount of time or for a specified number of training iterations.

For each output sequence in the batch, the system evaluates the performance of the trained instance of the child neural network for a particular neural network task to determine a performance metric for the trained instance for that particular neural network task (step 306). . For example, the performance metric may be the accuracy of a trained instance in a validation set as measured by an appropriate accuracy measure. For example, the accuracy may be a perplexity measure when the output is a sequence or a classification error rate when the task is a classification task. As another example, the performance metric can be the average or maximum of an instance's accuracy over the last 2, 5 or 10 epochs of the instance's training.

The system adjusts the current value of the controller parameter using the performance metric for the trained instance (step 308).

In particular, the system uses reinforcement learning techniques to adjust the current value by training the controller neural network to produce an output sequence that results in a child neural network with an increased performance metric. More specifically, the system trains a controller neural network to generate an output sequence that maximizes a received reward determined based on the performance metrics of the trained instances. In particular, the reward for a given output sequence is a function of the performance metric of the trained instance. For example, the reward may be one of a performance metric, a square of a performance metric, a cube of a performance metric, and a square root of a performance metric.

In some cases, the system uses a policy gradient (PG) technique to train the controller neural network to maximize the expected reward. For example, the PG technology may be a "REINFORCE technology" or a Proximal Policy Optimization (PPO) technology. For example, the system can estimate the gradient of the expected reward for the controller parameter using an estimator of the gradient that satisfies equation (3).

는 소정의 출력 시퀀스의 시간 단계(t)에서의 출력이며,

는 출력 시퀀스 k에 대한 보상이며,

는 제어기 파라미터이며, b는 베이스라인 함수, 예를 들어 이전 아키텍처 정확도의 지수(exponential) 이동 평균이다.where m is the number of sequences in the batch, T is the number of time steps of each sequence in the batch,

is the output at time step t of a given output sequence,

is the compensation for the output sequence k,

is the controller parameter, and b is the baseline function, e.g. the exponential moving average of the previous architecture accuracy.

In some implementations, the system trains the controller neural network in a distributed manner. That is, the system maintains several replicas of the controller neural network and asynchronously updates parameter values of the replicas during training. That is, the system can asynchronously perform steps 302-306 for each replica and update the controller parameters using the gradient determined for each replica.

This specification uses the term "configured" in relation to systems and computer program components. One or more computer systems configured to perform a particular operation or action means that the system causes the system to perform the operation or action due to software, firmware, hardware or a combination thereof. One or more computer programs configured to perform a particular operation or action means that the one or more computer programs, when executed by a data processing device, include instructions that cause the device to perform the operation or action.

Embodiments of subject matter and functional operation described herein may include digital electronic circuitry, tangibly-implemented computer software or firmware, computer hardware, including structures disclosed in this specification and their structural equivalents, or combinations of one or more of them. can be implemented in Embodiments of the subject matter described herein may be implemented as one or more computer programs, i.e., as one or more modules of computer program instructions, executed by a data processing device or encoded on a tangible transitory storage medium for controlling the operation of a data processing device. can be implemented The computer storage medium may be a machine readable storage device, a machine readable storage substrate, a random or serial access memory device, or a combination of one or more of these. Alternatively or additionally, the program instructions may be an artificially generated propagated signal, e.g., a machine-generated electrical signal, generated to encode information for transmission to a suitable receiver device for execution by a data processing device. , can be encoded onto an optical or electromagnetic signal.

The term “data processing apparatus” means data processing hardware and includes all kinds of apparatus, devices and machines for processing data including, for example, a programmable processor, a computer, or a plurality of processors or computers. The device may also be a special purpose logic circuit, such as a field programmable gate array (FPGA) or application specific integrated circuit (ASIC). In addition to hardware, the device may optionally include code that creates an execution environment for computer programs, such as processor firmware, a protocol stack, a database management system, an operating system, or code that constitutes a combination of one or more of these.

A computer program (which may be referred to as or described as a program, software, software application, module, software module, script, or code) may be written in a compiled or interpreted language, or any form of programming language, including a declarative or procedural language. may be distributed in any form, including stand-alone programs, modules, components, subroutines, or other devices suitable for use in a computing environment. A computer program can, but does not necessarily, correspond to a file in a file system. A program is a single file dedicated to a program, several coordinated files (for example, files that store one or more modules, subprograms, or parts of code), or other programs such as one or more scripts stored in a markup language document, or It can be stored in the part of the file that holds the data. A computer program may be distributed to be executed on a single computer or on multiple computers at one site or distributed across multiple sites and interconnected by a communication network.

In this specification, the term "database" is used broadly to refer to any collection of data, which data may or may not need to be structured in any particular way and may be stored in storage devices in one or more locations. Thus, for example, an index database may contain multiple data sets, each set may be structured and accessed differently.

Similarly, herein, the term "engine" is used broadly to refer to a software-based system, subsystem, or process programmed to perform one or more specific functions. An engine is typically implemented as one or more software modules or components and installed on one or more computers in one or more locations. In some cases, more than one computer is dedicated to a particular engine; in other cases, multiple engines may be installed and run on the same computer or computers.

The processes and logic flows described herein can be performed by one or more programmable computers executing one or more computer programs to perform functions by manipulating input data and generating output. The processes and logic flow may also be performed by a special purpose logic circuit such as a field programmable gate array (FPGA) or an application specific integrated circuit (ASIC), and an apparatus may also be implemented with the special purpose logic circuit.

A computer suitable for the execution of a computer program may include, for example, be based on a general purpose or special purpose microprocessor or both, or any other kind of central processing unit. Generally, a central processing unit will receive instructions and data from read only memory or random access memory or both. The essential components of a computer are a central processing unit for carrying out or executing instructions and one or more memory devices for storing instructions and data. Generally, a computer includes one or more mass storage devices for storing data (eg, magnetic, magneto-optical disks, or optical disks) or is operable to receive or transmit data from the one or more mass storage devices. will be combined However, a computer need not have such devices. A computer may also be used as another device, such as a mobile phone, personal digital assistant (PDA), mobile audio or video player, game console, GPS receiver, or portable storage device (such as a Universal Serial Bus (USB) flash drive). ) can be embedded.

Computer readable media suitable for storing computer program instructions and data include, for example, semiconductor memory devices such as EPROM, EEPROM and flash memory devices, magnetic disks such as internal hard disks or removable disks, magneto-optical disks, and CD ROMs. and all forms of non-volatile memory, media and memory devices including DVD-ROM disks.

To provide interaction with a user, embodiments of the subject matter described herein may include a display device such as a cathode ray tube (CRT) or liquid crystal display (LCD) monitor for providing information to a user, and input by the user. It can be implemented in a computer having a keyboard and pointing device such as a mouse or trackball that can be provided to the computer. Different types of devices may be used to provide interaction with a user, for example, the feedback provided to the user may be any form of sensory feedback, such as visual, auditory, or tactile feedback, from the user. The input of may be received in any form including acoustic, voice or tactile input. The computer can also interact with the user by sending documents to and receiving documents from the device used by the user, such as by sending a web page to a web browser on the user's client device in response to a request received from the web browser. can be performed The computer may also interact with the user by sending a text message or other form of message to the personal device (eg, a smartphone running a messaging application) and receiving a response message from the user.

A data processing device for implementing a machine learning model may also include a special purpose hardware accelerator unit for handling common and computationally centric parts of the workload, ie machine learning training or production, ie inference, for example.

Machine learning models can be implemented and deployed using machine learning frameworks such as the "TensorFlow" framework, the "Microsoft Cognitive Toolkit" framework, the "Apache Singa" framework, or the "Apache MXNet" framework.

Embodiments of the subject matter described herein may include a back end component such as a data server; middleware components such as application servers; front end components such as, for example, client computers having relational graphical user interfaces or web browsers through which users can interact with implementations of the subject matter described herein; or any combination of one or more back end, middleware, front end components. The components of the system may be interconnected by any form or medium of digital data communication, for example a communication network. Exemplary communication networks include local area networks ("LAN") and wide area networks ("WAN"), such as the Internet.

The computing system may include clients and servers. Clients and servers are usually remote from each other and usually interact through a communication network. The relationship of client and server arises due to computer programs running on the respective computers and having a client-server relationship to each other. In some embodiments, the server sends HTML pages to the user device to display data, eg, data, and to receive user input from a user interacting with the device acting as a client. Data generated by the user device, for example the result of user interaction, may be received at the server from the device.

Although this specification contains many specific implementation details, they should not be construed as limitations on any invention or on the scope that may be claimed, but rather as a description of features that may be specific to particular embodiments of a particular invention. do. Certain features that are described in this specification in the context of separate embodiments can also be implemented in combination in a single embodiment. Conversely, various features that are described in the context of a single embodiment can also be implemented in multiple embodiments separately or in any suitable subcombination. Moreover, although features may act in any combination and be described as initially claimed as described above, one or more features of a claimed combination may in some cases be eliminated from that combination, and the claimed combination may be a subcombination or Variations of that subcombination may be directed.

Similarly, while actions are depicted in the figures in a particular order, it should be understood that such actions are performed in the order shown or sequential order, or require that all actions shown be performed in order to achieve the desired actions. should not be Multitasking and parallel processing can be advantageous in certain circumstances. Further, the separation of various system modules and components in the above-described embodiments should not be understood as requiring such separation in all embodiments, and the described program components and systems are generally integrated together in a single software product or multiple software products. It should be understood that it can be packaged into products.

Specific embodiments of the invention have been described. Other embodiments are within the scope of the following claims. For example, the actions recited in the claims can be performed in a different order and still achieve desirable results. As an example, the processes depicted in the accompanying figures do not necessarily require the specific order shown or sequential order to achieve desirable results. In certain implementations, multitasking and parallel processing may be advantageous.

Claims (21)

A method performed by one or more computers, comprising:
determining, using the controller, a plurality of architectures of a child neural network configured to perform a particular neural network task;
By the training engine, for each architecture of the plurality of architectures:
training an instance of the child neural network having the respective architecture on a plurality of training inputs each associated with a respective target training output to perform the specific neural network task; and
After the training, based on evaluating the performance of the trained instance of the child neural network for the specific neural network task using an appropriate performance measure, the performance of the trained instance of the child neural network for the specific neural network task determining a performance metric; and
and adjusting, by a controller update engine, the controller using the performance metric for the trained instance of the child neural network. According to claim 1,
the controller is implemented using a controller neural network with a plurality of controller parameters;
determining the plurality of architectures of the child neural network comprises generating a batch of output sequences using the controller neural network having the plurality of controller parameters and according to current values of the plurality of controller parameters; each output sequence of the batch defines a respective architecture of the child neural network; and
and adjusting the controller using the performance metric for the trained instance of the child neural network comprises adjusting current values of the plurality of controller parameters. 3. The method of claim 2, wherein adjusting current values of controller parameters of the controller neural network using a performance metric for a trained instance of the child neural network comprises:
and training the controller neural network to generate output sequences such that the child neural network has an improved performance metric using a reinforcement learning technique. 4. The method of claim 3, wherein the reinforcement learning technique is a policy gradient (PG) technique. 5. The method of claim 4, wherein the reinforcement learning technique is a REINFORCE technique. 3. The method of claim 2, wherein determining each architecture of the child's neural network comprises determining a value for each hyperparameter of the child's neural network. The method of claim 6, wherein the controller neural network is a recurrent neural network, and the recurrent neural network,
one configured to, for a given output sequence and at each time step, receive as input a value of a hyperparameter at a preceding time step of the given output sequence, and process the input to update a current hidden state of the recurrent neural network; the above recurrent neural network layers;
including each output layer for each time step;
Each output layer, for the predetermined output sequence,
receive an output layer input comprising the updated hidden state at a time step, and generate an output for the time step defining a score distribution for possible values of the hyperparameter at the time step. A method performed by a computer. According to claim 7,
Generating, using a controller neural network having a plurality of controller parameters, a batch of output sequences, according to the current values of the controller parameters, comprises:
For each output sequence in the batch and each of the plurality of time steps,
providing the value of the hyperparameter at a preceding time step of the output sequence as an input to the controller neural network to generate an output for the time step that defines a score distribution for the possible values of the hyperparameter at the time step; and
and determining a value of a hyperparameter at a time step of the output sequence by sampling from the possible values according to the score distribution. 8. The method of claim 7, wherein the child neural network is a convolutional neural network and the hyperparameters include hyperparameters for each convolutional neural network layer of the child neural network. The method of claim 9, wherein the hyperparameters for each of the convolutional neural network layers,
by one or more computers comprising at least one of a plurality of filters, a filter height for each filter, a filter width for each filter, a stride height for each filter, and a stride width for each filter. how it is done. 8. The method of claim 7 , wherein the child neural network includes a plurality of layer types, and the hyperparameters include, for each layer, a value corresponding to the layer type. method. 12. The method of claim 11, wherein for each of the one or more layers, the hyperparameters include a skip connection hyperparameter, the skip connection hyperparameter defining which previous layers have a skip connection to the layer. A method performed by one or more computers that According to claim 12,
wherein the plurality of time steps comprises a respective anchor point time step for each of the one or more layers for which a hypermeter is a skip connection hyperparameter;
For an anchor point time step for a current layer, the output layer includes each node corresponding to each layer before the current layer of the child neural network;
Each node processes the updated hidden state for the anchor point time step for the previous layer and the updated hidden state for the anchor point time step for the previous layer according to the current values of the set of parameters, and the previous layer is the child A method performed by one or more computers, characterized in that it is configured to generate a score representing a likelihood to be connected to a current layer of a neural network. The method of claim 6, wherein the child's neural network is a recurrent neural network,
The method of claim 1 , wherein determining the architecture of each of the child neural networks comprises determining an architecture for a recurrent cell in the recurrent neural network. The method of claim 14, wherein the method,
and determining each computational step for each node in the tree of computational steps representing computations performed by said recurrent cell. According to claim 15,
Each node in the tree produces an output by merging two inputs;
For each node, determining each architecture of the child neural network includes determining a combination method for combining the two inputs and an activation function applied to the combination of the two inputs to generate the output. A method performed by one or more computers, characterized in that. The method of claim 15, wherein the method,
and determining values defining how the memory state of the circulating cell is injected into the circulating cell. The method of claim 1, wherein the method,
and determining, in accordance with the adjusted controller, a final architecture of the child's neural network. The method of claim 18, wherein the method,
and performing a specific neural network task on the received network inputs by processing the received network inputs using a child neural network having the final architecture. one or more computers; and one or more storage devices storing instructions that, when executed by the one or more computers, cause the one or more computers to perform the method of any one of claims 1 to 19. One or more computer readable storage media having stored thereon instructions which, when executed by one or more computers, cause the one or more computers to perform the method of any one of claims 1-19.

Images