Entity Seeking Queries and Semantic Dependency Trees
Queries for some searches may be entity seeking queries.
Someone may ask something like, “What is the hotel that looks like a sail.” That query may be looking for an entity that is the building, the Burj Al Arab Jumeirah.
Those entities may be identified in Semantic Dependency Trees, that answer the question in the query (example below)
Other queries are not entity seeking queries, and don’t look for answers about specific entities, such as “What is the weather today?” The answer to that query might respond to “The weather will be between 60-70 degrees Fahrenheit, and sunny today.”
Actions May Accompany Queries that Seek Entities
Google was granted a patent about answering entity seeking queries.
The process under the patent may perform particular actions for queries that seek one or more entities.
One action the system may perform involves:
- Identifying one or more types of entities that a query is seeking
- Determining whether the query is seeking one specific entity or potentially multiple entities
For example, the process may determine that a query of “What is the hotel that looks like a sail” is looking for a single entity that is a hotel.
In another example, the system may determine that a query “What restaurants nearby serve omelets” seeks potentially multiple entities that are restaurants.
An additional or alternative action the system may perform may include finding a most relevant entity or entities of the identified one or more types, and presenting what is identified to the user if sufficiently relevant to the query. For example, the system may identify that the Burj Al Arab Jumeirah is an entity that is a hotel and is sufficiently relevant to the terms “looks like a sail,” and, in response, audibly output synthesized speech of “Burj Al Arab Jumeirah.”
Additional Dialog about a Query to Concatenate an Entity Seeking Query
Yet another addition or alternative action may include initiating a dialog with the user for more details about the entities that are sought.
For example, the system may determine that a query is seeking a restaurant and there may be two entities that are restaurants are very relevant to the terms in the query and, in response, ask the searcher “Can you give me more details” and concatenate additional input from the user to the original query and re-execute the concatenated query.
Identifying SubQueries of Entity Seeking Queries
Another additional or alternative action may include identifying subqueries of a query which are entity-seeking, and using the above actions to answer the subquery, and then replacing the subqueries by their answers in the original query to obtain a partially resolved query which can be executed.
For example, the system may receive a query of “Call the hotel that looks like a sail,” determine that “the hotel that looks like a sail” is a subquery that seeks an entity, determine an answer to the subquery is “Burj Al Arab Jumeirah,” in response replace “the hotel that looks like a sail” in the query with “The Burj Al Arab Jumeirah” to obtain a partially resolved query of “Call the Burj Al Arab Jumeirah,” and then executes the partially resolved query.
Looking at Previous Queries
Another additional or alternative action may include identifying that a user is seeking entities and adapting how the system resolve queries accordingly.
For example, the system may determine that sixty percent of the previous five queries that a user searched for in the past two minutes sought entities and, in response, determine that a next query that a user provides is more likely an entity seeking query, and process the query accordingly.
An Advantage From Following this Process
An advantage may be more quickly resolving queries in a manner that satisfies a searcher.
For example, the system may be able to immediately provide an actual answer of “The Burj Al Arab Jumeirah” for the query “What hotel looks like a sail” where another system may instead provide a response of “no results found” or provide a response that is a search result listing for the query.
Another advantage may be that the process may be able to more efficiently identify an entity sought by a query. For example, it may determine an entity seeking query is looking for an entity of the type “hotel” and, in response, limit a search to only entities that are hotels instead of searching across multiple entities including entities that are not hotels.
Entities in Semantic Dependency Trees
This is an interesting approach to an entity seeking queries. Determining an entity type that may correspond to an entity sought by a query based on a term represented by a root of a dependency tree includes:
Determining the term represented by the root of the dependency tree represents a type of entity.
Determining an entity type that corresponds to an entity sought by the query based on a term represented by a root of the dependency tree includes:
Identifying a node in the tree that represents a term that represents a type of entity
Includes a direct child that represents a term that indicates an action to perform.
In response to determining that the root represents a term that represents and type of entity and includes a direct child that represents a term that indicates an action, identifying the root.
In some implementations, identifying a particular entity based on both the entity type and relevance of the entity to the terms in the query includes:
- Determining a relevance threshold based on the entity type
- Determining a relevance score of the particular entity based on the query satisfies the relevance threshold
- In response to determining the relevance score of the particular entity based on the query satisfies the relevance threshold, identifying the particular entity
This patent on Entity Seeking Queries can be found at:
Answering Entity-Seeking Queries
Inventors: Mugurel Ionut Andreica, Tatsiana Sakhar, Behshad Behzadi, Marcin M. Nowak-Przygodzki, and Adrian-Marius Dumitran
US Patent Application: 20190370326
Published: December 5, 2019
Filed: May 29, 2018
In some implementations, a query that includes a sequence of terms is obtained, the query is mapped, based on the sequence of the terms, to a dependency tree that represents dependencies among the terms in the query, an entity type that corresponds to an entity sought by the query is determined based on a term represented by a root of the dependency tree, a particular entity is identified based on both the entity type and relevance of the entity to the terms in the query, and a response to the query is provided based on the particular entity that is identified.
Mapping a Query to a Semantic Dependency Tree
A process that handles entity seeking queries
This process includes:
- A query mapper that maps a query including a sequence of terms to a semantic dependency tree
- An entity type identifier that may determine an entity type based on the semantic dependency tree
- An entity identifier that may receive the query
- The entity type that is determined
- Data from various data stores and identify an entity
- Subquery resolver that may partially resolve the query based on the entity that is identified
- Query responder that may provide a response to the query
An Example Semantic Dependency Tree
This is how a Semantic Dependency Tree may be constructed:
- A semantic dependency tree for a query may be a graph that includes nodes
- Each node represents one or more terms in a query
- Directed edges originating from a first node and ending at a second node may indicate that the one or more terms represented by the first node are modified by the one or more terms represented by the second node
- A node at which an edge ends may be considered a child of a node from which the edge originates
- A root of a semantic dependency tree may be a node representing one or more terms that do not modify other terms in a query and are modified by other terms in the query
- A semantic dependency tree may only include a single root
An Entity Type Identifier
An entity type identifier may determine an entity type that corresponds to an entity sought by the query based on a term represented by a root of the semantic dependency tree.
For example, the entity type identifier may determine an entity type of “Chinese restaurant” that corresponds to an sought by the query “Call the Chinese restaurant on Piccadilly Street 15” based on the term “Chinese restaurant” represented by the root of the semantic dependency tree.
In another example, the entity type identifier may determine an entity type of “song” for the query “play the theme song from the Titanic” based on the term “play” represented by the root of the semantic dependency tree for the query not representing an entity type and determining that the root has a child that represents the terms “the theme song” which does represent an entity type of “song.”
Entities from a Location History of a Searcher
The entity identifier may extract all the entities from a mobile location history of a searcher which have a type identified by the entity type identifier, such as hotels, restaurants, universities, etc. along with extracting features associated to each such entity such as the time intervals when the user visited the entity or was near the entity, or how often each entity was visited or the user was near the entity.
Entities from a Past Interaction History of a Searcher
In addition to that location history, the entity identifier may extract all the entities that the user was interested in their past interactions that have a type identified by the entity type identifier, such as:
- Movies that the user watched
- Songs that the user listened to
- Restaurants that the user looked up and showed interest in or booked
- Hotels that the user booked
Confidence in Relevance for Entity Seeing Queries
The patent also tells us that the entity identify may obtain a relevance score for each entity that reflects a confidence that the entity is sought to be the query.
The relevance score may be determined based on one or more of the features extracted from the data stores that led to the set of entities being identified, the additional features extracted for each entity in the set of entities, and the features extracted from the query.