Knowledge distillation for autonomous vehicles

Abstract

Methods, systems, and apparatus, including computer programs encoded on computer storage media, for performing knowledge distillation for autonomous vehicles. One of the methods includes obtaining sensor data characterizing an environment, wherein the sensor data has been captured by one or more sensors onboard a vehicle in the environment; for each of one or more surrounding agents in the environment, processing a network input generated from the sensor data using a neural network to generate an agent discomfort prediction characterizing a discomfort level of the agent; combining the one or more agent discomfort predictions to generate an aggregated discomfort score; and providing the aggregated discomfort score to a path planning system of the vehicle in order to generate a future path for the vehicle.

Description

Background Technology

[0001] This manual pertains to autonomous vehicles.

[0002] Autonomous vehicles include self-driving cars, boats, and aircraft. Autonomous vehicles use a variety of onboard sensors and computer systems to detect nearby objects and use this detection to make control and navigation decisions.

[0003] Some autonomous vehicles have onboard computer systems that implement neural networks, other types of machine learning models, or both, for a variety of prediction tasks, such as object classification in images. For example, a neural network can be used to determine that an image captured by an onboard camera is likely an image of a nearby car. A neural network, or simply a network, is a machine learning model that employs multiple layers of operations to predict one or more outputs from one or more inputs. Neural networks typically include one or more hidden layers between input and output layers. The output of each layer serves as input to another layer in the network (e.g., the next hidden layer or output layer).

[0004] Each layer of a neural network specifies one or more transformation operations to be performed on the inputs of that layer. Some neural network layers have operations called neurons. Each neuron receives one or more inputs and generates an output that is received by another neural network layer. Typically, each neuron receives inputs from other neurons, and each neuron provides outputs to one or more other neurons.

[0005] The structure of a neural network specifies which layers are included in the network and their properties, as well as how the neurons in each layer are connected. In other words, the structure specifies which layers provide their outputs as input to which other layers and how that output is provided.

[0006] The transformation operations at each layer are performed by a computer that has installed software modules that implement the transformation operations. Therefore, a layer described as performing operations means that the computer implementing the transformation operations at that layer performs the operations.

[0007] Each layer generates one or more outputs using the current values ​​of a set of parameters used for that layer. Therefore, training a neural network involves continuously performing forward passes on the input, computing gradient values, and updating the current values ​​of that set of parameters for each layer using the computed gradient values ​​(e.g., using gradient descent). Once the neural network is trained, the final set of parameter values ​​can be used for prediction in a production system. Summary of the Invention

[0008] This specification describes how a system mounted on a vehicle (e.g., an autonomous or semi-autonomous vehicle) in an environment can generate predictions of the level of discomfort imposed by the vehicle on surrounding agents in the environment. Specifically, for each of one or more surrounding agents, the system can generate agent discomfort predictions characterizing the level of discomfort imposed on the agent by the vehicle. The system can then combine one or more individual agent discomfort predictions to generate an aggregate discomfort score and use the aggregate discomfort score to make autonomous driving decisions.

[0009] In this specification, "discomfort" in a vehicle or intelligent agent is an estimate of how comfortable a human driver or passenger would feel in the current state of the vehicle or intelligent agent. For example, if the vehicle brakes suddenly, i.e., if the vehicle's acceleration or deceleration exceeds a certain threshold, the person in the vehicle may feel uncomfortable. As another example, if a second vehicle is too close to a first vehicle, i.e., if the distance between the two vehicles is less than a certain threshold, the person in the first vehicle may feel uncomfortable. As another example, if the vehicle turns, sways, or slows down within its lane, the person in the vehicle may feel uncomfortable. As yet another example, if the vehicle does not continue moving when turning at a four-way stop sign, the person in the vehicle may feel uncomfortable.

[0010] In this specification, if the driving behavior of the vehicle causes discomfort to the agent, the discomfort is "imposed" on the agent by the vehicle; that is, if the vehicle is not in the environment, the agent will not experience discomfort.

[0011] This specification also describes how the training system trains an agent discomfort model (e.g., a neural network) to generate agent discomfort predictions, i.e., predictions of the level of discomfort exerted by the vehicle on surrounding agents.

[0012] For example, a training system can use training data representing the vehicle itself and training labels representing the vehicle's level of discomfort to train an agent's discomfort model; that is, the training system can treat the training data and training labels as representing the surrounding agents and train the agent's discomfort model to generate predictions about the surrounding agents. Since the vehicle can directly determine its own level of discomfort but cannot determine the level of discomfort of the surrounding agents, using training labels representing the vehicle allows the training system to run supervised learning.

[0013] Specifically, the training system can obtain training examples generated from sensor data collected by vehicles operating in the real world. These training examples can include training labels characterizing the level of discomfort of the vehicle when the sensor data is collected. The training system can process the training examples using an agent feature extractor to generate vehicle feature data characterizing the vehicle when the sensor data is collected. The system can then process the vehicle feature data to generate vehicle discomfort predictions characterizing the predicted level of discomfort of the vehicle, and update the parameters of the agent discomfort model based on the error between the vehicle discomfort predictions and the training labels. Therefore, the training system can train the agent discomfort model to receive agent feature data characterizing surrounding agents and generate agent discomfort predictions.

[0014] An agent feature extractor can be configured to extract feature data characterizing surrounding agents from sensor data captured by the vehicle. During training, the training system can use the agent feature extractor to generate feature data characterizing the vehicle itself, as if it were a surrounding agent. Then, during inference, the vehicle can use the agent feature extractor to generate feature data characterizing each surrounding agent in the environment, and then process the feature data using a trained agent-adversity model to predict the level of adversity of the surrounding agents. In other words, during training, the agent feature extractor can be configured to process sensor data captured by the vehicle's sensors to generate a representation of the vehicle that matches the representations of surrounding agents that the agent feature extractor will generate from the sensor data during inference.

[0015] In this specification, a feature extractor is a system configured to receive input data and process the input data to generate output data in a form available to a downstream model, i.e., in a form that the downstream model is configured to receive as input. For example, an agent feature extractor is configured to receive sensor data captured by a vehicle and generate feature data characterizing the surrounding agent, which can be processed by an agent-adaptive model.

[0016] As another example, the training system can first train a vehicle discomfort model configured to receive vehicle feature data characterizing the vehicle, generated from sensor data captured by one or more sensors mounted on the vehicle, and generate a prediction of the vehicle's discomfort level. To train the vehicle discomfort model, the training system can use training labels characterizing the vehicle's discomfort level captured directly from the vehicle. The training system can then use the vehicle discomfort model to process agent feature data characterizing the surrounding agents, generated from sensor data captured by one or more sensors mounted on the vehicle, to generate training labels characterizing the discomfort levels of the surrounding agents. The training system can then use the generated training labels and agent feature data to train an agent discomfort model configured to receive agent feature data and generate predictions of the vehicle's discomfort level. In other words, the training system can use model distillation to train the agent discomfort model, where the agent discomfort model is the "teacher" model and the agent discomfort model is the "student" model.

[0017] The training system described in this specification can be used to train many different agent models, other than agent-adaptive models, configured to generate predictions representing surrounding agents in an environment. For example, the training system can be configured to train an agent-safe model that predicts whether a vehicle imposes unsafe conditions on one or more surrounding agents. As another example, the training system can be configured to train an agent-progress model that predicts whether a vehicle causes one or more surrounding agents to be unable to progress along their routes as quickly or efficiently as desired.

[0018] Specific embodiments of the subject matter described in this specification may be implemented in order to achieve one or more of the following advantages.

[0019] When autonomous or semi-autonomous vehicles operate in an environment, it is important for the vehicle to predict how other agents in the environment will respond to its driving behavior. In particular, it is crucial for the vehicle to predict whether its behavior will cause discomfort to other agents. Using the techniques described in this specification, the system can generate individual agent discomfort predictions, representing the level of discomfort imposed by the vehicle on individual surrounding agents, and aggregated discomfort scores, representing the cumulative level of discomfort imposed by the vehicle on agents in the environment.

[0020] Autonomous or semi-autonomous vehicles typically possess a much larger and more accurate amount of data to represent themselves than the data used to represent surrounding agents. Therefore, it is difficult to train a system to predict the current state or future behavior of other agents. Using the techniques described in this specification, a training system can leverage the available data from the representation vehicle to train a model to generate predictions representing surrounding agents.

[0021] Details of one or more embodiments of the subject matter of this specification are set forth in the accompanying drawings and the following description. Other features, aspects, and advantages of the subject matter will become apparent from the specification, drawings, and claims. Attached Figure Description

[0022] Figure 1 This is a diagram of the example system.

[0023] Figure 2 This is a diagram of an example environment that includes a vehicle and multiple surrounding intelligent agents.

[0024] Figure 3 and Figure 4 This is a diagram of an example training system used to train an agent model.

[0025] Figure 5 This is a flowchart for an example of a process used to determine discomfort imposed on surrounding agents by a vehicle.

[0026] Figure 6 and Figure 7 This is a flowchart of an example process used to train a neural network to predict discomfort imposed on surrounding agents by a vehicle.

[0027] The same reference numerals and names in different figures denote the same elements. Detailed Implementation

[0028] This specification describes how a vehicle (e.g., an autonomous or semi-autonomous vehicle) can use a trained machine learning model to generate predictions of the level of discomfort that the vehicle imposes on surrounding agents in the environment.

[0029] Figure 1 This is a diagram of example system 100, which includes loading system 110 and training system 120.

[0030] The loading system 110 is mounted on the vehicle 102. Figure 1 The vehicle 102 is shown as a car, but the loading system 102 can be mounted on any suitable vehicle type. The vehicle 102 can be a fully autonomous vehicle that determines and executes fully autonomous driving decisions for navigation in its environment. The vehicle 102 can also be a semi-autonomous vehicle that uses prediction to assist a human driver. For example, if a prediction indicates that a collision with another vehicle is imminent, the vehicle 102 can autonomously apply braking.

[0031] The loading system 110 includes one or more sensor subsystems 140. The sensor subsystem 140 includes a combination of components that receive electromagnetic radiation reflections, such as a lidar system for detecting laser reflections, a radar system for detecting radio wave reflections, and a camera system for detecting visible light reflections.

[0032] Sensor data generated by a given sensor typically represents distance, direction, and the intensity of reflected radiation. For example, a sensor can emit one or more pulses of electromagnetic radiation in a specific direction and can measure the intensity of any reflection and the time it takes to receive it. Distance can be calculated by determining the time elapsed between a pulse and its corresponding reflection. A sensor can continuously scan a specific space in angle, azimuth, or both. For example, azimuth scanning allows a sensor to detect multiple objects along the same line of sight.

[0033] Other components of the sensor subsystem 140 or vehicle 102 can also classify one or more raw sensor measurement sets from one or more sensors as measurements of another agent. A set of sensor measurements can be represented in any of a variety of ways, depending on the type of sensor measurements captured. For example, each set of raw laser sensor measurements can be represented as a 3D point cloud, where each point has intensity and position. In some implementations, position is represented as a range and elevation pair. Each set of camera sensor measurements can be represented as an image patch, such as an RGB image patch.

[0034] Once the sensor subsystem 140 classifies one or more sets of raw sensor measurements into measurements of the corresponding surrounding agents, the sensor subsystem 140 can compile the raw sensor measurements into a set of raw data 142 and send the raw data 142 to the agent feature extractor 150.

[0035] An agent feature extractor 150, also mounted on vehicle 102, receives raw sensor data 142 from sensor system 140 and generates agent feature data 152. For each of one or more identified surrounding agents in the environment of vehicle 102, agent feature data 152 includes data characterizing the agent. For example, for a particular agent, agent feature data 152 may include a top-down image of the environment, e.g., a top-down image centered on the agent. As another example, for a particular agent, agent feature data 152 may include motion parameters of the agent (e.g., the agent's velocity, acceleration, and / or jerk), the agent's size, and / or the distance between the agent and vehicle 102. As another example, for a particular agent, agent feature data 152 may include the agent's current position and / or the agent's predicted future position, e.g., the predicted future position of the agent generated by the agent prediction system of vehicle 102. As another example, agent feature data 152 may include features of the environment, e.g., an environmental road map. In this specification, a road map is data representing known features of the environment, such as a top-down image of the environment, which may include representations of road features in the environment, such as road lanes, pedestrian crossings, traffic lights, stop signs, etc. In some implementations, agent feature data 152 may include one or more features derived from raw data of the captured environment; for example, for a particular agent, agent feature data 152 may include features representing one or more of the following: whether the agent is currently turning, whether the agent is currently at an intersection, or what the current state of the traffic lights is.

[0036] In some implementations, the agent feature data 152 is human-interpretable, meaning that each element of the agent feature data 152 can have a real-world meaning, such as scalar velocity or acceleration. In some other implementations, the agent feature data 152 is not human-interpretable; for example, the agent feature data corresponding to a specific agent can be a learned embedding of the raw sensor data 142. In this specification, an embedding is an ordered set of numerical values ​​representing inputs in a specific embedding space. For example, an embedding can be a vector of floating-point or other numerical values ​​with a fixed dimension.

[0037] Agent feature extractor 150 provides agent feature data 152 to discomfort prediction system 130, which is also mounted on vehicle 102. Discomfort prediction system 130 uses agent feature data 152 to generate agent discomfort prediction 132 for each of one or more identified surrounding agents, representing the level of discomfort imposed on the agent by vehicle 102. For example, agent discomfort prediction 132 for a particular agent can be a floating-point value between 0 and 1, where 0 is the lowest level of discomfort and 1 is the highest level of discomfort.

[0038] In some implementations, the discomfort prediction system 130 further combines one or more agent discomfort predictions 132 to generate an aggregate discomfort score characterizing the collective discomfort of surrounding agents in the environment imposed by the vehicle 102. See below. Figure 4 Let's discuss this process in more detail.

[0039] The discomfort prediction system 130 can provide agent discomfort prediction 132 and / or aggregated discomfort scores to the path planning system 160, the user interface system 170, or both.

[0040] A path planning system 160, also mounted on vehicle 102, generates a planned vehicle path that represents the route vehicle 102 will take in the future. When the path planning system 160 receives an agent discomfort prediction 132, it can use the agent discomfort prediction 132 to generate a new planned vehicle path that represents the route vehicle 102 will take in the future. For example, the agent discomfort prediction 132 can identify a specific surrounding agent that vehicle 102 is causing discomfort (e.g., by driving too close to surrounding agents). In this example, the path planning system 160 can generate a new planned vehicle path that navigates vehicle 102 to a location farther away from the surrounding agents, thereby mitigating the discomfort inflicted on the surrounding agents.

[0041] When user interface system 170 receives agent discomfort prediction 132, user interface system 170 can use agent discomfort prediction 132 to present information to the driver of agent 102 to assist the driver in operating agent 102 safely. User interface system 170 can present information to the driver of agent 102 in any appropriate manner, such as through audio messages emitted via the speaker system of agent 102 or through alarms displayed on the visual display system of agent 102 (e.g., an LCD display on the dashboard of agent 102). In a particular example, agent discomfort prediction 132 may identify a specific surrounding agent that is causing discomfort in vehicle 102. In this example, user interface system 170 may present an alarm message to the driver of agent 102 with instructions to adjust the trajectory of agent 102 to alleviate the applied discomfort or to notify the driver of the applied discomfort.

[0042] In some implementations, the user interface system can collect user feedback regarding the discomfort level 172 of vehicle 102. That is, the user can provide a user discomfort level 172 that characterizes the current discomfort of a user as a passenger of vehicle 102. For example, vehicle 102 can provide an interface for the driver or passenger of vehicle 102 to identify when an uncomfortable event occurred and to identify the severity of the discomfort. As a specific example, the user can use a scalar user discomfort level 172 (e.g., 0.5 for "low", 0.75 for "medium", and 1.0 for "high") to identify the severity of the discomfort.

[0043] User interface system 170 can provide user discomfort level 1762 to discomfort prediction system 130 for generating training examples 134 for training discomfort prediction system 130. For example, discomfort prediction system 130 can generate training examples 134 representing vehicle 102 from raw sensor data, where the training label corresponding to training example 134 is the reported user discomfort level 172. Training system 120 can use the training examples to train discomfort prediction system 130 to generate agent discomfort predictions, treating the training examples (their representation vehicle 102) as surrounding agents in the environment of their representation vehicle 102. (Refer to below...) Figure 6 and Figure 7 The example training process will be discussed in more detail.

[0044] In order to generate an agent's adverse prediction 132, the adverse prediction system 130 can use the trained parameter values ​​196 obtained from the adverse model parameter memory 194 in the training system 120.

[0045] The training system 120 is typically hosted within a data center 124, which may be a distributed computing system with hundreds or thousands of computers in one or more locations.

[0046] Training system 120 includes training data storage 180, which stores all training data used to train parameter values ​​for the ill-adapted prediction system 130. Training data storage 180 receives training examples 134 from agents operating in the real world. For example, training data storage 180 may receive training examples 134 from agent 102 and one or more other agents communicating with training system 120. (Refer to below...) Figure 3 and Figure 4 The example training system 190 will be discussed in more detail.

[0047] Training data storage 180 provides training example 182 to training system 190, which is also housed in training system 120. Training system 190 uses training example 182 to update model parameters that will be used by the ill-fitting prediction system 130, and provides the updated model parameters 192 to ill-fitting model parameter storage 194. Once the parameter values ​​of ill-fitting prediction system 130 have been fully trained, training system 120 can send the trained parameter values ​​196 to ill-fitting prediction system 130 (e.g., via a wired or wireless connection).

[0048] Figure 2 This is a diagram of an example environment 200 that includes a vehicle 202 and multiple surrounding agents 204, 206 and 208.

[0049] Vehicle 202 is merging from the middle lane into the left lane. While doing so and / or before doing so, vehicle 202 may use an adverse event prediction system (e.g., Figure 1 The discomfort prediction system 130 depicted in the diagram processes sensor data captured by one or more sensors mounted on vehicle 202 to generate agent discomfort predictions characterizing the level of discomfort imposed by vehicle 202 on each of agents 204, 206, and 208. For example, agent discomfort predictions can be scalar values ​​between 0 and 1.

[0050] Vehicle 202 can generate a high agent discomfort prediction corresponding to agent 204 because vehicle 202 is in front of the incorporating agent 204. That is, through incorporation, vehicle 202 may impose discomfort on agent 204, for example, because of the proximity between vehicle 202 and agent 204, or because incorporation will require agent 204 to decelerate. For example, vehicle 202 can generate an agent discomfort prediction of 0.9 corresponding to agent 204.

[0051] Vehicle 202 can generate a moderate agent-uncomfortable prediction corresponding to agent 206 because merging into the left lane may also affect agent 206. For example, merging may require agent 204 to decelerate, which in turn will require agent 206 to decelerate. For example, vehicle 202 can generate an agent-uncomfortable prediction of 0.6 corresponding to agent 206.

[0052] Vehicle 202 can generate a low agent discomfort prediction corresponding to agent 208 because vehicle 202 does not impose any discomfort on agent 208 (who is in the right lane) by merging into the left lane. For example, vehicle 202 can generate an agent discomfort prediction of 0.1 corresponding to agent 208.

[0053] Figure 3This is a diagram of an example training system 300 for training an agent model. The agent model training system 300 is an example of a system implemented as a computer program on one or more computers at one or more locations, where the systems, components, and techniques described below are implemented.

[0054] An agent model can be any model configured to receive model inputs generated from sensor data captured by one or more sensors mounted on a vehicle in the environment, and to process the model inputs to generate model outputs characterizing one or more agents around the vehicle in the environment. In other words, the model output of the agent model is a prediction about one or more characteristics of the surrounding agents in the environment.

[0055] Specifically, the agent model is configured to receive agent feature data representing the agent, generated by agent feature extractor 320, for each of one or more surrounding agents in the environment. Agent feature extractor 320 is configured to receive sensor data captured by the vehicle's loading sensors and process the sensor data to generate agent feature data representing the surrounding agents, wherein the agent feature data is in a format that the agent model is configured to receive as input.

[0056] As a specific example, an agent model may include one or more of a recurrent neural network, a temporal convolutional neural network, or a boosting forest model. In some implementations, the agent model may use one or more eigenvalue smoothing techniques to reduce noise in the agent's feature data. For example, the agent model may use a low-pass filter to smooth temporal eigenvalues. In some implementations, the agent model may use feature calibration, such as applying a transformation to the agent's feature data, to ensure that the agent's feature data has a distribution comparable to that of the vehicle's feature data.

[0057] For example, the agent model could be an agent discomfort model, configured to receive agent feature data for each of one or more agents in the environment surrounding the vehicle, and process the agent feature data to generate agent discomfort predictions characterizing the level of discomfort imposed on the agents by the vehicle. For example, the agent discomfort model could be... Figure 1 The discomfort prediction system 130 is described.

[0058] As another example, the agent model could be an agent safety model, configured to receive agent feature data for each of one or more agents surrounding the vehicle in the environment, and process the agent feature data to generate an agent safety prediction characterizing the level of safety imposed on the agents by the vehicle. That is, the agent safety model generates a prediction of whether the vehicle results in an unsafe state or location for surrounding agents. For example, the agent safety prediction could be a scalar value between 0 and 1, where 0 corresponds to a prediction that the vehicle does not endanger surrounding agents at all, and 1 corresponds to a prediction that the vehicle seriously endangers surrounding agents.

[0059] As another example, the agent model could be an agent-progression model configured to receive agent feature data for each of one or more agents in the environment surrounding the vehicle, and to process the agent feature data to generate an agent-progression prediction characterizing the extent to which the vehicle causes the agent to deviate from its intended path. That is, the agent-progression model generates a prediction of whether the vehicle obstructs surrounding agents and causes them to move less efficiently or faster than expected. For example, the agent-progression prediction could be a scalar value between 0 and 1, where 0 corresponds to a prediction that the vehicle does not obstruct the agent's path at all, and 1 corresponds to a prediction that the vehicle severely obstructs the agent's path.

[0060] Although the following description refers to the case where the agent model is an unsuitable agent model, it should be understood that the following description can be applied to any appropriate type of agent model.

[0061] Since the discomfort level of the vehicle is directly observable, while the discomfort level of the surrounding agents is not, the agent model training system 300 trains the agent model to generate predictions corresponding to the surrounding agents by processing training examples corresponding to the vehicle itself. That is, the agent model training system uses training data representing the vehicle itself and training labels representing the discomfort level of the vehicle itself to train the agent model, where the training labels are generated through observations of the vehicle's discomfort level (e.g., using user feedback). The training system 300 treats the training data and training labels as representing the surrounding agents and trains the agent discomfort model to generate predictions about the surrounding agents.

[0062] The agent model training system 300 includes a training data storage 310, an agent feature extractor 320, and an agent model training engine 330.

[0063] The training data storage 310 includes training examples, each of which includes i) vehicle training data 312, which includes sensor data characterizing the vehicle captured by one or more sensors mounted on the same vehicle, and ii) vehicle training tags 314, which characterize the level of discomfort of the vehicle when the sensor data was collected.

[0064] The training data storage 310 provides vehicle training data 312 to the agent feature extractor 320, which processes the vehicle training data 312 to generate vehicle feature data 322 characterizing the vehicle. This vehicle feature data 322 is in a format configured for the agent model to receive as input. That is, during inference, the agent feature extractor 320 generates agent feature data characterizing the surrounding agents, and simultaneously during training, the agent feature extractor 320 generates vehicle feature data 322 characterizing the vehicle.

[0065] For example, if the vehicle feature data includes a top-down image of the environment centered on the vehicle, then during training, the agent feature extractor 320 can generate a top-down image centered on the vehicle. Then, during inference, the agent feature extractor 320 can generate agent feature data by transforming and / or cropping the top-down image so that it is centered on the surrounding agents.

[0066] In some implementations, the agent feature extractor 320 discards a portion of the vehicle training data 312 to generate vehicle feature data 322. Vehicles typically have more data characterizing themselves than data characterizing surrounding agents; that is, the vehicle training data 312 includes vehicle characteristics not included in the corresponding agent data to be provided to the agent feature extractor 320 at inference time. Because the agent feature extractor 320 is configured to generate vehicle feature data 322 as if it were generating agent feature data, the agent feature extractor 320 does not include in the vehicle feature data 322 any data characterizing the vehicle that does not correspond to the agent-characterizing data that the agent feature extractor 320 will have at inference time. Therefore, the agent feature extractor 320 can discard any data in the vehicle training data 312 that does not correspond to the agent-characterizing data that the agent feature extractor 320 will have access to at inference time.

[0067] The agent model training engine 330 obtains vehicle feature data 322 and vehicle training labels 314, and uses them to train the agent model. Specifically, the agent model training engine 330 processes the vehicle feature data 322 using the agent model to generate vehicle discomfort predictions characterizing the level of discomfort of the vehicles, and determines the error between the vehicle discomfort predictions and the vehicle training labels 314. The agent model training engine then updates the current parameters of the agent model using the determined error (e.g., using backpropagation). Thus, by processing training examples characterizing vehicles during training, the training system 300 can train the agent model to generate predictions characterizing the surrounding agents at inference time.

[0068] Figure 4 This is a diagram of an example training system 400 for training an agent model. The agent model training system 400 is an example of a system implemented as a computer program on one or more computers at one or more locations, where the systems, components, and techniques described below are implemented.

[0069] As referenced above Figure 3 The agent model can be any model configured to receive model input generated from sensor data captured by one or more sensors mounted on a vehicle in the environment, and to process the model input to generate model output characterizing one or more agents around the vehicle in the environment. Specifically, the agent model is configured to receive agent feature data characterizing the agent generated by agent feature extractor 420 for each of the one or more surrounding agents in the environment.

[0070] For example, the agent model can be an agent-adverse model, configured to receive agent feature data for each of one or more surrounding agents and process the agent feature data to generate an agent-adverse prediction. As another example, the agent model can be an agent-safe model, configured to receive agent feature data for each of one or more surrounding agents and process the agent feature data to generate an agent-safe prediction. As yet another example, the agent model can be an agent-forward model, configured to receive agent feature data for each of one or more surrounding agents and process the agent feature data to generate an agent-forward prediction.

[0071] Although the following description refers to the case where the agent model is an unsuitable agent model, it should be understood that the following description can be applied to any appropriate type of agent model.

[0072] The agent model training system 400 is first configured to train a vehicle model that processes vehicle feature data in the same format as the agent feature data and generates vehicle model output in the same format as the agent model output generated by the agent model. That is, the vehicle feature data and vehicle model output have the same format and describe the same characteristics as the agent feature data and agent model output, respectively. The agent model training system 400 can directly train the vehicle model using supervised training because the training system 400 has access to the ground-truth vehicle labels captured by the vehicle.

[0073] In some implementations, the vehicle model is larger than the agent model; for example, it has more trainable parameters. As a concrete example, the vehicle model can be a neural network with more neural network layers than the agent model. In some implementations, the vehicle model receives additional inputs besides the vehicle feature data; that is, the input to the vehicle model can be greater than the input to the agent model.

[0074] After training the vehicle model, the training system 400 uses the vehicle model to generate labels for training the agent model. That is, the training system 400 uses the trained vehicle model to process agent feature data representing the surrounding agents to generate a vehicle model output representing the surrounding agents; this vehicle model output is used as a baseline ground truth label when training the agent model.

[0075] The agent model training system 400 includes a training data storage 410, an agent feature extractor 420, a vehicle model training engine 430, a vehicle model running engine 440, and an agent model training engine 450.

[0076] The training data storage 410 includes training examples, each of which includes i) vehicle training data 412, which includes sensor data characterizing the vehicle captured by one or more sensors mounted on the vehicle, and ii) vehicle training tags 414, which characterize the level of discomfort of the vehicle when the sensor data was collected.

[0077] The training data storage 410 provides vehicle training data 412 to the agent feature extractor 420, which processes the vehicle training data 412 to generate vehicle feature data 422 characterizing the vehicle, and the vehicle feature data 422 is in a format that the vehicle model is configured to receive as input.

[0078] As referenced above Figure 3In some implementations, the agent feature extractor 420 discards a portion of the vehicle training data 412 to generate vehicle feature data 422. The vehicle training data 412 may include vehicle characteristics not included in the corresponding agent training data 416. Because the agent feature extractor 420 is configured to generate vehicle feature data 422 as if it were generating agent feature data, the agent feature extractor 420 does not include in the vehicle feature data 422 any data representing the vehicle that does not correspond to the data representing the agent available in the agent training data 416.

[0079] The vehicle model training engine 430 obtains vehicle feature data 422 and vehicle training labels 414, and uses them to train the vehicle model. Specifically, the vehicle model training engine 430 processes the vehicle feature data 422 using an agent model to generate vehicle discomfort predictions characterizing the predicted discomfort level of the vehicle, and determines the error between the vehicle discomfort predictions and the vehicle training labels 414. The vehicle model training engine 430 then updates the current parameters of the vehicle model using the determined error (e.g., using backpropagation).

[0080] At the end of the vehicle model training, the vehicle model training engine 430 provides the vehicle model training parameters 432 to the vehicle model running engine 440, which is configured to receive vehicle feature data or agent feature data and use the vehicle model to process the received feature data to generate vehicle model output.

[0081] The training data storage 410 also includes agent training data 416, which comprises sensor data characterizing the surrounding agents captured by one or more sensors mounted on the vehicle. In some implementations, vehicle training data 412 and agent training data 416 are identical; that is, for a given vehicle at a given point in time, vehicle training data 412 characterizing the vehicle and agent training data 4116 characterizing the surrounding agents in the environment are identical, for example, the set of all sensor data captured by the vehicle's mounted sensors at a given point in time.

[0082] The training data storage 410 provides agent training data 416 to an agent feature extractor, which processes the agent training data 416 to generate agent feature data 424 characterizing the surrounding agents, and the agent model is configured to receive it as input.

[0083] Agent feature extractor 420 provides agent feature data 424 to vehicle model execution engine 440, which processes agent feature data 424 (which characterizes surrounding agents) just as agent feature data 424 characterizes the vehicle, and generates vehicle model output characterizing the predicted level of ill-fitting of surrounding agents. Training system 400 determines this vehicle model output as agent training label 442, which will be used as a baseline ground truth level of ill-fitting when training the agent model.

[0084] The agent model training engine 450 obtains agent feature data 424 and agent training labels 442, and uses them to train the agent model. Specifically, the agent model training engine 450 processes the agent feature data 424 using the agent model to generate agent-adverse predictions characterizing the agent's level of adverseness, and determines the error between the agent-adverse predictions and the agent training labels 442. The agent model training engine 450 then updates the current parameters of the agent model using the determined error (e.g., using backpropagation).

[0085] Figure 5 This is a flowchart of an example process 500 for determining discomfort exerted by a vehicle on surrounding agents in an environment. For convenience, process 500 is described as being executed by a system of one or more computers located in one or more locations. For example, an discomfort prediction system appropriately programmed according to this specification (e.g., Figure 1 The discomfort prediction system 130 described in the text can perform 500 processes.

[0086] The system acquires sensor data characterizing the environment (step 502). The sensor data has been captured by one or more sensors mounted on a vehicle in the environment.

[0087] For each of one or more surrounding agents in the environment, the system processes network inputs generated from sensor data to generate an agent discomfort prediction (step 504). For example, the system may use a deep neural network to process the network inputs. The agent discomfort prediction characterizes the level of discomfort imposed on the agent by the vehicle. In some implementations, the network inputs are inputs to machine learning; for example, the network inputs may be learned concurrently with the training of the neural network.

[0088] The system combines individual agent discomfort predictions from surrounding agents to generate an aggregate discomfort score (step 506). For example, the system may determine the mean, median, minimum, or maximum of agent discomfort predictions to generate the aggregate discomfort score.

[0089] As another example, the system can use a learned function to process agent-related adverse predictions to generate an aggregated adverse score. For instance, the system can learn the function by simulating vehicle operation or by operating a vehicle in the real world. The system can make driving decisions based on the generated aggregated adverse score, determine the quality of the driving decisions, and update the learned function based on the determined quality. For example, if a gradient of the quality is available, the system can use backpropagation to update the learned function. As a concrete example, the system can use random forests or recurrent neural networks to process agent-related adverse predictions.

[0090] The system provides an aggregated discomfort score to the vehicle's path planning system (step 508). The path planning system can process the aggregated discomfort score and / or discomfort predictions for each individual agent to generate the vehicle's future path.

[0091] Figure 6 This is a flowchart of an example process 600 for training a neural network to predict discomfort inflicted on surrounding agents by a vehicle. For convenience, process 600 is described as being performed by a system of one or more computers located at one or more locations. For example, an agent model training system appropriately programmed according to this specification (e.g., Figure 3 The intelligent agent model training system 300 described in the text can perform 600 processes.

[0092] The system obtains training examples including sensor data captured by one or more sensors mounted on a specific vehicle (step 602).

[0093] The system uses a feature extractor to process the training examples to generate feature data characterizing a specific vehicle (step 604).

[0094] For example, a feature extractor can generate feature data using a suitable subset of sensor data, such as a subset of sensor data corresponding to a specific vehicle (relative to surrounding agents, the environment, etc.). That is, the subset of sensor data characterizes one or more specific characteristics of a particular vehicle. Importantly, the sensor data also includes data corresponding to each surrounding agent that includes the same specific characteristics. Therefore, the feature extractor can generate vehicle feature data and agent feature data in the same form. During training, the feature extractor generates vehicle feature data corresponding to a specific vehicle; during inference, the feature extractor can generate agent feature data corresponding to each surrounding agent.

[0095] The system obtains training labels characterizing the level of discomfort of a particular vehicle (step 606). For example, the training labels can be generated from user input provided by the user when capturing sensor data.

[0096] The system uses the neural network to process feature data based on the current values ​​of the network parameters to generate an discomfort prediction (step 608). The discomfort prediction forecasts the discomfort level of a specific vehicle.

[0097] The system determines the error between the generated ill-fitting prediction and the training label (step 610).

[0098] The system determines the update of the network parameters of the neural network based on the determined error (step 612).

[0099] Figure 7 This is a flowchart of an example process 700 for training a first neural network with multiple first network parameters to predict discomfort imposed on a surrounding agent by a vehicle. For convenience, process 700 will be described as being executed by a system of one or more computers located at one or more locations. For example, an agent model training system appropriately programmed according to this specification (e.g., Figure 4 The intelligent agent model training system 400 described in the text can perform processing 700.

[0100] The system obtains the second network parameters for training the second neural network (step 702). The second neural network is configured to process second network inputs generated from sensor data captured by one or more sensors mounted on a vehicle in the environment, and to generate a second network output characterizing the level of discomfort of the vehicle.

[0101] The system obtains training examples including sensor data captured by one or more sensors mounted on a specific vehicle (step 704).

[0102] The system uses a feature extractor to process the training examples to generate feature data characterizing a specific agent around a specific vehicle (step 706). In some implementations, the feature extractor is the same as the feature extractor that generates the second network input.

[0103] The system uses a second neural network to process the feature data to generate a second network output (step 708). The second network output characterizes the discomfort level of a particular agent and will be used as a training label corresponding to the feature data used to train the first neural network.

[0104] The system uses the first neural network to process feature data based on the current values ​​of the first network parameters to generate an unsuitable prediction (step 710).

[0105] The system determines the error between the generated unsuitable prediction and the second network output (step 712).

[0106] The system determines the update of the first network parameters based on the determined error (step 714).

[0107] Embodiments of the subject matter and functional operation described in this specification can be implemented in digital electronic circuits, tangibly embodied computer software or firmware, computer hardware, including the structures disclosed in this specification and their equivalents, or combinations thereof. Embodiments of the subject matter described in this specification can be implemented as one or more computer programs, i.e., one or more modules of computer program instructions encoded on a tangible, non-transitory storage medium, for execution by or control of the operation of a data processing apparatus. The computer storage medium can be a machine-readable storage device, a machine-readable storage substrate, a random or serial access memory device, or a combination thereof. Optionally or additionally, program instructions can be encoded on artificially generated propagation signals, such as machine-generated electrical, optical, or electromagnetic signals, generated to encode information for transmission to a suitable receiver device for execution by a data processing apparatus.

[0108] The term "data processing apparatus" refers to data processing hardware and includes various means, devices, and machines for processing data, such as programmable processors, computers, or multiple processors or computers. The apparatus may also be or further include off-the-shelf or custom-designed parallel processing subsystems, such as GPUs or other dedicated processing subsystems. The apparatus may also be or further include dedicated logic circuitry, such as FPGAs (Field-Programmable Gate Arrays) or ASICs (Application-Specific Integrated Circuits). In addition to hardware, the apparatus may optionally include code that creates an operating environment for computer programs, such as code constituting processor firmware, protocol stacks, database management systems, operating systems, or one or more combinations thereof.

[0109] A computer program (also referred to or described as a program, software, software application, application, module, software module, script, or code) can be written in any programming language, including compiled or interpreted languages, or declarative or procedural languages, and can be deployed in any form, including as a standalone program or as a module, component, subroutine, or other unit suitable for use in a computing environment. A program may, but does not necessarily, correspond to a file in a file system. A program may be stored as a portion of a file containing other programs or data, for example, as one or more scripts stored in a markup language document, as a single file dedicated to the program in question, or as multiple harmonizing files, for example, as a file storing one or more modules, subroutines, or portions of code. A computer program can be deployed to execute on a single computer, or located at a site or distributed across multiple sites and interconnected via a data communication network.

[0110] In this specification, the term "database" is used broadly to refer to any collection of data: the data does not need to be structured in any particular way, or not at all, and it can be stored on storage devices in one or more locations. Thus, for example, an indexed database may include multiple collections of data, each of which can be organized and accessed differently.

[0111] Similarly, in this specification, the term "engine" is used broadly to refer to a software-based system, subsystem, or process that is programmed to perform one or more specific functions. Typically, an engine will be implemented as one or more software modules or components, installed on one or more computers in one or more locations. In some cases, one or more computers will be dedicated to a particular engine; in other cases, multiple engines may be installed and run on the same one or more computers.

[0112] The processing and logic flows described in this specification can be executed by one or more programmable computers running one or more computer programs to perform functions by manipulating input data and generating output. The processing and logic flows can also be executed by dedicated logic circuitry (e.g., FPGA or ASIC) or by a combination of dedicated logic circuitry and one or more programmable computers.

[0113] A computer suitable for executing computer programs can be based on a general-purpose or special-purpose microprocessor, or both, or on any other type of central processing unit (CPU). Typically, the CPU receives instructions and data from read-only memory or random access memory, or both. The basic components of a computer are the CPU for executing or running instructions and one or more storage devices for storing instructions and data. The CPU and memory may be supplemented by or incorporated into special-purpose logic circuitry. Typically, a computer will also include, or be operatively coupled to, receiving data from or transferring data to one or more mass storage devices (e.g., magneto-optical, magneto-optical, or optical disc) for storing data, or both. However, a computer does not necessarily need to have such devices. Furthermore, a computer can be embedded in 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, to name a few.

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

[0115] To provide interaction with the user, embodiments of the subject matter described in this specification can be implemented on a computer having a display device (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor) for displaying information to the user, and a keyboard and pointing device (e.g., a mouse or trackball, or a sensitive display or other surface through which the user can provide input to the computer). Other types of devices can also be used to provide interaction with the user; for example, feedback provided to the user can be any form of sensory feedback, such as visual, auditory, or tactile feedback; and input from the user can be received in any form, including sound, speech, or tactile input. Additionally, the computer can interact with the user by sending and receiving documents from the device used by the user, for example, by sending a webpage to a web browser on the user's device in response to a request received from a web browser. Furthermore, the computer can interact with the user by sending text messages or other forms of messages to a personal device (e.g., a smartphone running a messaging application) and, conversely, receiving response messages from the user.

[0116] The data processing apparatus used to implement machine learning models may also include, for example, dedicated hardware accelerator units for handling the common and computationally intensive parts of machine learning training or production, namely inference and workloads.

[0117] 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.

[0118] Embodiments of the subject matter described in this specification can be implemented in computing systems that include backend components (e.g., as a data server), middleware components (e.g., an application server), or frontend components (e.g., a client computer with a graphical user interface, a web browser, or an application through which a user can interact with an implementation of the subject matter described in this specification), or any combination of one or more such backend, middleware, or frontend components. The components of the system can be interconnected via any form or medium of digital data communication (e.g., a communication network). Examples of communication networks include local area networks (LANs) and wide area networks (WANs), such as the Internet.

[0119] A computing system may include clients and servers. Clients and servers are typically geographically separated and usually interact via a communication network. The relationship between clients and servers occurs through computer programs running on separate computers that have a client-server relationship with each other. In some embodiments, the server transmits data (e.g., HTML pages) to a user device, for example, to display data to a user interacting with the device acting as a client and to receive user input from it. Data generated on the user device (e.g., the result of user interaction) can be received from the device on the server.

[0120] In addition to the embodiments described above, the following embodiments are also innovative:

[0121] Example 1 is a method comprising:

[0122] Obtain sensor data characterizing the environment, wherein the sensor data has been captured by one or more sensors mounted on a vehicle in the environment;

[0123] For each of one or more surrounding agents in the environment, a neural network is used to process the network input generated from sensor data to generate agent discomfort predictions that characterize the agent's level of discomfort.

[0124] Combining one or more agent discomfort predictions to generate an aggregate discomfort score; and

[0125] Provide aggregated unsuitability scores to the vehicle's path planning system in order to generate the vehicle's future path.

[0126] Example 2 is the method of Example 1, wherein the network input is a machine learning network input that is learned simultaneously with the training of the neural network.

[0127] Example 3 is a method of any of Examples 1 or 2, wherein combining one or more agent-adaptive predictions includes one or more of the following:

[0128] Determine a measure of the central tendency of an agent's inability to predict.

[0129] Determine the minimum value of the agent's unsuitable prediction.

[0130] Determine the maximum value of the agent's unsuitable prediction, or

[0131] Use learned functions to handle unsuitable predictions for each agent.

[0132] Example 4 is a method of any of Examples 1-3, wherein the network input for a specific surrounding agent includes a top-down image of the environment centered on the specific surrounding agent.

[0133] Example 5 is a method of any one of Examples 1-4, wherein the neural network has been trained using i) training sensor data captured by sensors mounted on one or more vehicles operating in the real world and ii) user input identifying the comfort level of individual vehicles at multiple time points during operation.

[0134] Example 6 is a method of any of Examples 1-5, wherein, for each surrounding agent:

[0135] The network input has already been generated by processing sensor data using a feature extractor;

[0136] The feature extractor generates feature data using an appropriate subset of the sensor data; and

[0137] A suitable subset of sensor data includes first data characterizing one or more specific properties of the surrounding intelligent agent.

[0138] Example 7 is a method of any of Examples 1-6, wherein the neural network has been trained using feature distillation with a second neural network, which is configured to process a second network input generated by sensor data captured by one or more sensors mounted on the vehicle, and generate a second network output characterizing the level of discomfort of the vehicle.

[0139] Example 8 is a method for training a first neural network having multiple first network parameters, configured to process first network inputs generated from sensor data captured by one or more sensors mounted on a vehicle in an environment, and to generate a first network output including agent discomfort prediction, wherein the agent discomfort prediction characterizes the level of discomfort of an agent around the vehicle in the environment, the method comprising:

[0140] A second network parameter is obtained through multiple training steps. The second neural network is configured to process second network inputs generated from sensor data captured by one or more sensors mounted on a vehicle in the environment, and to generate a second network output characterizing the level of discomfort of the vehicle.

[0141] Obtain training examples, which include sensor data captured by one or more sensors mounted on a specific vehicle in a specific environment;

[0142] Use a feature extractor to process training examples to generate feature data characterizing a specific agent around a specific vehicle in a specific environment;

[0143] A second neural network is used to process feature data to generate a second network output that characterizes the level of discomfort of a particular agent.

[0144] Based on the current values ​​of multiple first network parameters, the first neural network processes the feature data to generate an discomfort prediction characterizing the discomfort level of a particular agent.

[0145] Determine the error between the generated ill-fitting prediction and the second network output; and

[0146] The current values ​​of several first network parameters are updated based on the determined error.

[0147] Example 9 is the method of Example 8, wherein:

[0148] The feature extractor generates feature data using an appropriate subset of the sensor data;

[0149] A suitable subset of sensor data includes first data characterizing one or more specific properties of the vehicle; and

[0150] Sensor data includes second data that characterizes one or more specific properties of each surrounding agent in a particular environment.

[0151] Example 10 is a system comprising: one or more computers and one or more storage devices storing instructions operable when run by the one or more computers to cause the one or more computers to perform the methods of any of Examples 1 to 9.

[0152] Example 11 is a computer storage medium encoded with a computer program, the program including instructions that, when run by a data processing device, are operable to cause the data processing device to perform the method of any one of Examples 1 to 9.

[0153] Although this specification contains numerous specific implementation details, these details should not be construed as limiting any invention or the scope of the claims, but rather as descriptions of features relevant to specific embodiments of a particular invention. Certain features described herein in the context of separate embodiments may also be implemented in combination in a single embodiment. Conversely, multiple features described in the context of a single embodiment may also be implemented separately in multiple embodiments or in any suitable sub-combination. Furthermore, although features may be described above as functioning in certain combinations and even initially claimed in this way, in some cases, one or more features from the claimed combination may be removed, and the claimed combination may be directed to a sub-combination or a variation thereof.

[0154] Similarly, although operations are described in a specific order in the accompanying drawings, this should not be construed as requiring such operations to be performed in the specific order or sequence shown, or requiring all illustrated operations to achieve the desired result. In some cases, multitasking and parallel processing may be advantageous. Furthermore, the separation of various system modules and components in the above embodiments should not be construed as requiring such separation in all embodiments, and it should be understood that the described program components and systems can generally be integrated into a single software product or packaged into multiple software products.

[0155] Specific embodiments of the subject matter have been described. Other embodiments are within the scope of the following claims. For example, the actions listed in the claims can be performed in a different order and still achieve the desired result. As an example, the processes described in the figures do not necessarily require the specific order or sequence shown to achieve the desired result. In some cases, multitasking and parallel processing may be advantageous.

Claims

1. A method for controlling an autonomous vehicle, comprising: Obtain sensor data characterizing the environment, wherein the sensor data has been captured by one or more sensors mounted on a first vehicle in the environment, wherein the sensor data includes measurements of each of one or more surrounding vehicles in the environment that are different from the first vehicle; For each of one or more surrounding vehicles in the environment, a neural network deployed on the first vehicle processes the network input generated from sensor data to generate an agent discomfort prediction, which characterizes the level of discomfort that the first vehicle is causing to the drivers and passengers of the respective surrounding vehicles, wherein each respective surrounding vehicle is different from the first vehicle. Combine the discomfort predictions of one or more agents to generate an aggregate discomfort score; and Provide aggregated unsuitability scores to the path planning system of the first vehicle in order to generate the future path of the first vehicle.

2. The method according to claim 1, wherein, Network input is the machine learning network input that is learned simultaneously with the training of the neural network.

3. The method according to claim 1, wherein, Combining the one or more agent-adverse predictions includes one or more of the following: Determine a measure of the central tendency of an agent's inability to predict. Determine the minimum value of the agent's unsuitable prediction. Determine the maximum value of the agent's unsuitable prediction, or Use a learning function to handle unsuitable predictions for each agent.

4. The method according to claim 1, wherein, The network input for a specific surrounding agent includes a top-down image of the environment centered on the specific surrounding agent.

5. The method according to claim 1, wherein, The neural network has been trained using i) training sensor data captured by sensors mounted on one or more vehicles operating in the real world and ii) user input identifying the comfort level of individual vehicles at multiple time points during operation.

6. The method according to claim 1, wherein, For each surrounding agent: The network input has already been generated by processing sensor data using a feature extractor; The feature extractor generates feature data using an appropriate subset of the sensor data; as well as The appropriate subset of sensor data includes first data characterizing one or more specific properties of the surrounding intelligent agent.

7. The method according to claim 1, wherein, The neural network has been trained using feature distillation with a second neural network, which is configured to process second network inputs generated from sensor data captured by one or more sensors mounted on the first vehicle, and generate a second network output characterizing the level of discomfort of the first vehicle.

8. A system for controlling an autonomous vehicle, comprising: One or more computers and a storage device for storing one or more instructions, said instructions being operable when run by the one or more computers to cause the one or more computers to perform operations, said operations including: Obtain sensor data characterizing the environment, wherein the sensor data has been captured by one or more sensors mounted on a first vehicle in the environment, wherein the sensor data includes measurements of each of one or more surrounding vehicles in the environment that are different from the first vehicle; For each of one or more surrounding vehicles in the environment, a neural network deployed on the first vehicle processes the network input generated from sensor data to generate an agent discomfort prediction, which characterizes the level of discomfort that the first vehicle is causing to the drivers and passengers of the respective surrounding vehicles, wherein each respective surrounding vehicle is different from the first vehicle. Combine the discomfort predictions of one or more agents to generate an aggregate discomfort score; and Provide aggregated unsuitability scores to the path planning system of the first vehicle in order to generate the future path of the first vehicle.

9. The system according to claim 8, wherein, Network input is the machine learning network input that is learned simultaneously with the training of the neural network.

10. The system according to claim 8, wherein, Combining the one or more agent-adverse predictions includes one or more of the following: Determine a measure of the central tendency of an agent's inability to predict. Determine the minimum value of the agent's unsuitable prediction. Determine the maximum value of the agent's unsuitable prediction, or Use a learning function to handle unsuitable predictions for each agent.

11. The system according to claim 8, wherein, The network input for a specific surrounding agent includes a top-down image of the environment centered on the specific surrounding agent.

12. The system according to claim 8, wherein, The neural network has been trained using i) training sensor data captured by sensors mounted on one or more vehicles operating in the real world and ii) user input identifying the comfort level of individual vehicles at multiple time points during operation.

13. The system according to claim 8, wherein, For each surrounding agent: The network input has already been generated by processing sensor data using a feature extractor; The feature extractor generates feature data using an appropriate subset of the sensor data; as well as The appropriate subset of sensor data includes first data characterizing one or more specific properties of the surrounding intelligent agent.

14. The system according to claim 8, wherein, The neural network has been trained using feature distillation with a second neural network, which is configured to process second network inputs generated from sensor data captured by one or more sensors mounted on the first vehicle, and generate a second network output characterizing the level of discomfort of the first vehicle.

15. One or more non-transitory computer storage media encoded with computer program instructions, wherein when run by a plurality of computers, the computer program instructions cause the plurality of computers to perform operations, the operations including: Obtain sensor data characterizing the environment, wherein the sensor data has been captured by one or more sensors mounted on a first vehicle in the environment, wherein the sensor data includes measurements of each of one or more surrounding vehicles in the environment that are different from the first vehicle; For each of one or more surrounding vehicles in the environment, a neural network deployed on the first vehicle processes the network input generated from sensor data to generate an agent discomfort prediction, which characterizes the level of discomfort that the first vehicle is causing to the drivers and passengers of the respective surrounding vehicles, wherein each respective surrounding vehicle is different from the first vehicle. Combine the discomfort predictions of one or more agents to generate an aggregate discomfort score; and Provide aggregated unsuitability scores to the vehicle's path planning system in order to generate the future path of the first vehicle.

16. The non-transitory computer storage medium according to claim 15, wherein, Network input is the machine learning network input that is learned simultaneously with the training of the neural network.

17. The non-transitory computer storage medium according to claim 15, wherein, Combining the one or more agent-adverse predictions includes one or more of the following: Determine a measure of the central tendency of an agent's inability to predict. Determine the minimum value of the agent's unsuitable prediction. Determine the maximum value of the agent's unsuitable prediction, or Use a learning function to handle unsuitable predictions for each agent.

18. The non-transitory computer storage medium according to claim 15, wherein, The neural network has been trained using i) training sensor data captured by sensors mounted on one or more vehicles operating in the real world and ii) user input identifying the comfort level of individual vehicles at multiple time points during operation.

19. The non-transitory computer storage medium according to claim 15, wherein, For each surrounding agent: The network input has already been generated by processing sensor data using a feature extractor; The feature extractor generates feature data using an appropriate subset of the sensor data; as well as The appropriate subset of sensor data includes first data characterizing one or more specific properties of the surrounding intelligent agent.

20. The non-transitory computer storage medium according to claim 15, wherein, The neural network has been trained using feature distillation with a second neural network, which is configured to process second network inputs generated from sensor data captured by one or more sensors mounted on the first vehicle, and generate a second network output characterizing the level of discomfort of the first vehicle.

Images