Bodymedia, Inc.

Google Inc.

X Development LLC

David Andre

John Michael Stivoric

Eric Teller

Jonathan Farringdon

Christopher D Pacione

Suresh Vishnubhatla

Raymond Pelletier

Scott A Safier

Rishabh Singh

Scott Klaus Boehmke

Christopher D Kasabach

Rebecca Radkoff

Nisarg Vyas

Artem Goncharuk

James A Gasbarro

John A Monocello, Iii

James Hanlon

Gregory T Kovacs

Bin Ni

Thomas Peter Hunt

Manzil Zaheer

Ryan Butterfoss

Owen Lewis

Hanjun Dai

Karen Roter Davis

Jayendra Parmar

Grace Taixi Brentano

Karen E Davis

Erich Karl Nachbar

Mark Handel

Lam Thanh Nguyen

Salil Vijaykumar Pradhan

Salil Pradhan

Falak Shah

Donna Wolf

Steve Menke

Eric Hsiung

Neal Spruce

Steve Shassberger

Dhara Kotecha

Scott Safier

This specification is generally directed to techniques for creating reduced-dimensionality embeddings (e.g., embedding layers of neural networks) with dimensions that are interpretable by and/or are meaningful to humans. In various implementations, a datum may sampled from a document. A dimensionality reduction process may be performed based on the sampled datum to generate a semantically-interpretable embedding having a number of individually-interpretable dimensions. The dimensionality reduction process may include: analyzing the sampled datum according to a number of distinct semantic queries to determine respective numeric solutions. The number of distinct semantic queries may correspond to the number of individually-interpretable dimensions. Each numeric solution may offer an inconclusive clue about the sampled datum. The dimensionality reduction process may also include populating the dimensions of the semantically-interpretable embedding with respective numeric solutions.

Interpretable embeddings

Disclosed implementations relate to automating semantically-similar computing tasks across multiple contexts. In various implementations, an initial natural language input and a first plurality of actions performed using a first computer application may be used to generate a first task embedding and a first action embedding in action embedding space. An association between the first task embedding and first action embedding may be stored. Later, subsequent natural language input may be used to generate a second task embedding that is then matched to the first task embedding. Based on the stored association, the first action embedding may be identified and processed using a selected domain model to select actions to be performed using a second computer application. The selected domain model may be trained to translate between an action space of the second computer application and the action embedding space.

Automating semantically-related computing tasks across contexts

This specification is generally directed to techniques for robust natural language (NL) based control of computer applications. In many implementations, the NL control is at least selectively interactive in that the user feedback input is solicited, and received, in resolving action(s), resolving action set(s), generating domain specific knowledge, and/or in providing feedback on implemented action set(s). The user feedback input can be utilized in further training of machine learning model(s) utilized in the NL based control of the computer applications.

Robust natural language based control of computer applications

This specification is generally directed to techniques for generating interfacing source code between computing components based on natural language input. In various implementations, a natural language input that requests generation of interfacing source code to logically couple a first computing component with a second computing component may be processed to generate an interface request semantic embedding. The interface request semantic embedding may be processed based on one or more domain models associated with the first and second computing components to generate a pool(s) of candidate code snippets for logically coupling with first and second computing components. A plurality of candidate instances of interfacing source code may be generated between the first and second computing components. Each candidate software interface may include a different permutation of candidate code snippets from the pool(s) of candidate code snippets.

Generating interfacing source code

Implementations are described herein for aggregating information responsive to a query from multiple different data feed services using machine learning. In various implementations, NLP may be performed on a natural language input comprising a query for information to generate a data feed-agnostic aggregator embedding (FAAE). A plurality of data feed services may be selected, each having its own data feed service action space that includes actions that are performable to access data via the data feed service. The FAAE may be processed based on domain-specific machine learning models corresponding to the selected data feed services. Each domain-specific machine learning model may translate between a respective data feed service action space and a data feed-agnostic semantic embedding space. Using these models, action(s) may be selected from the data feed service action spaces and performed to aggregate, from the plurality of data feed services, data that is responsive to the query.

Aggregating information from different data feed services

Using a natural language (NL) latent presentation in the automated conversion of source code from a base programming language (e.g., C++) to a target programming language (e.g., Python). A base-to-NL model can be used to generate an NL latent representation by processing a base source code snippet in the base programming language. Further, an NL-to-target model can be used to generate a target source code snippet in the target programming language (that is functionally equivalent to the base source code snippet), by processing the NL latent representation. In some implementations, output(s) from the NL-to-target model indicate canonical representation(s) of variables, and in generating the target source code snippet, technique(s) are used to match those canonical representation(s) to variable(s) of the base source code snippet. In some implementations, multiple candidate target source code snippets are generated, and a subset (e.g., one) is selected based on evaluation(s).

Using natural language latent representation in automated conversion of source code from base programming language to target programming language

The technology enables locating asset tracking tags based on a ramped sequence of signals from one or more beacon tracking tags. The sequence includes at least one minimum power signal and at least one maximum power signal. Each signal in the sequence has a tag identifier and an initial signal strength value. Each beacon signal in the ramped sequence is associated with the time at which that beacon signal was received by a reader. Each beacon signal is also associated with a received signal strength at reception. A location of the beacon tracking tag is estimated according to the signals in the sequence based on the difference between the initial and received signal strengths. A position of the reader device is identified based on the beacon tag's location. An asset tracking tag location is identified based on the reader's location and packets received by the reader from the asset tag.

Power ramping of beacon signals to enhance location accuracy

Training and/or utilization of machine learning model(s) (e.g., neural network model(s)) in automatically generating test case(s) for source code. Techniques disclosed herein can be utilized in generating test case(s) for unit test testing (or other white-box testing) and/or for functional testing (or other black-box testing). In some implementations, the machine learning model(s) can be trained on source code, unit test pairs. In some additional or alternative implementations, reinforcement learning techniques can be utilized to check for correctness of base source code, target source code pairs (e.g., by matching program execution of different branches).

Training and/or using machine learning model(s) for automatic generation of test case(s) for source code

Techniques are described herein for translating source code in one programming language to source code in another programming language using machine learning. A method includes: receiving first source code in a first higher-level programming language; processing the first source code, or an intermediate representation thereof, using a sequence-to-sequence neural network model to generate a sequence of outputs, each including a probability distribution; generating second source code in a second higher-level programming language by, for each output in the sequence of outputs: determining a highest probability in the probability distribution associated with the output; in response to the highest probability exceeding a first threshold, generating a predicted portion of the second source code based on a token that corresponds to the highest probability; and in response to the highest probability not exceeding the first threshold, generating a placeholder; and outputting the second source code.

Annotations for developers

Implementations are directed to improving network anti-fragility. In some aspects, a method includes receiving parameter data from a network of nodes, the parameter data comprising attributes, policies, and action spaces for each node in the network of nodes; configuring one or more interruptive events on one or more nodes included in the network of nodes; determining a first action of each node in the network of nodes in response to the one or more interruptive events; determining a first performance metric, for each node, that corresponds to the first action, wherein the first performance matric is determined based on at least a first reward value associated with the first action; continuously updating the first action in an iterative process to obtain a final action, wherein a performance metric corresponding to the final action satisfies a performance threshold, and transmitting the final action for each node to the network of nodes.

Anti-fragile network

Implementations are described herein for using machine learning to perform various tasks related to migrating source code based on relatively few ('few shots') demonstrations. In various implementations, an autoregressive language model may be conditioned based on demonstration tuple(s). In some implementations, a demonstration tuple may include a pre-migration version of a first source code snippet and a post-migration version of the first source code snippet. In other implementations, demonstration tuples may include other data, such as intermediate forms (e.g., natural language descriptions or pseudocode), input-output pairs demonstrating intended behavior, etc. The autoregressive language model may be trained on corpora of source code and natural language documentation on the subject of computer programming. A pre-migration version of a source code file may be processed based on the conditioned autoregressive language model, and a post-migration version may be generated based on output generated based on the conditioned autoregressive model.

Conditioning autoregressive language model to improve code migration

Training and/or utilization of a neural decompiler that can be used to generate, from a lower-level compiled representation, a target source code snippet in a target programming language. In some implementations, the lower-level compiled representation is generated by compiling a base source code snippet that is in a base programming language, thereby enabling translation of the base programming language (e.g., C++) to a target programming language (e.g., Python). In some of those implementations, output(s) from the neural decompiler indicate canonical representation(s) of variables. Technique(s) can be used to match those canonical representation(s) to variable(s) of the base source code snippet. In some implementations, multiple candidate target source code snippets are generated using the neural decompiler, and a subset (e.g., one) is selected based on evaluation(s).

Training and/or using neural network model to generate target source code from lower-level representation

Growing community of inventors

Pittsburgh, PA, United States of America

David Andre