U.S. patent application number 15/375641 was filed with the patent office on 2017-10-12 for boolean-query composer.
The applicant listed for this patent is Quid, Inc.. Invention is credited to Oriana Jeannette Love, Mary Kate Lowe, Alex Marrs, Ruggero Altair Tacchi.
Application Number | 20170293676 15/375641 |
Document ID | / |
Family ID | 57794612 |
Filed Date | 2017-10-12 |
United States Patent
Application |
20170293676 |
Kind Code |
A1 |
Lowe; Mary Kate ; et
al. |
October 12, 2017 |
BOOLEAN-QUERY COMPOSER
Abstract
Provided is a process of refining Boolean queries, the process
including: obtaining a query; searching a corpus of documents based
on the query; selecting narrowing terms that pertain to respective
subsets of the responsive documents; selecting broadening terms
related to the query; instructing the user's computing device to
present a graphical user interface comprising: graphical
representations of the narrowing terms; graphical representations
of the broadening terms; and one or more user inputs by which the
user refines the query by adding a selected narrowing term or a
selected broadening term; obtaining a user selection of a
broadening term or a narrowing term; forming a refined query based
on the user selection; searching at least part of the corpus based
on the refined query to identify refined responsive documents; and
instructing the user's computing device to present an updated
graphical user interface with information about the refined
responsive documents.
Inventors: |
Lowe; Mary Kate; (San
Francisco, CA) ; Tacchi; Ruggero Altair; (San
Francisco, CA) ; Marrs; Alex; (San Francisco, CA)
; Love; Oriana Jeannette; (Alameda, CA) |
|
Applicant: |
Name |
City |
State |
Country |
Type |
Quid, Inc. |
San Francisco |
CA |
US |
|
|
Family ID: |
57794612 |
Appl. No.: |
15/375641 |
Filed: |
December 12, 2016 |
Related U.S. Patent Documents
|
|
|
|
|
|
Application
Number |
Filing Date |
Patent Number |
|
|
15092938 |
Apr 7, 2016 |
9552412 |
|
|
15375641 |
|
|
|
|
Current U.S.
Class: |
1/1 |
Current CPC
Class: |
G06F 16/93 20190101;
G06F 16/3341 20190101; G06F 16/338 20190101; G06F 16/245 20190101;
G06F 16/3325 20190101 |
International
Class: |
G06F 17/30 20060101
G06F017/30 |
Claims
1. A method, comprising: causing, with one or more processors, a
computing device to display a user interface with a result of a
first Boolean query applied to a data set, wherein: the user
interface represents subsets of the result as concurrently
displayed graphical regions; each of the graphical regions
representing a respective subset of query results has a visual
attribute determined based on a respective statistic of the
respective subset; the user interface includes a user-selectable
input by which the first Boolean query is changed, at least in
part, without the user typing additional query terms; receiving,
with one or more processors, a user selection entered via the
user-selectable input, the user selection indicating a term to be
added to the first Boolean query; based on the user selection, with
one or more processors, forming a second Boolean query; applying,
with one or more processors, the second Boolean query to the data
set to produce a result of the second Boolean query; and causing,
with one or more processors, the computing device to display the
result of the second Boolean query.
2. The method of claim 1, wherein: the data set includes one or
more corpora of unstructured text documents, the one or more
corpora including more than 50,000 natural language text documents;
causing the computing device to display the user interface
comprises: receiving the first Boolean query from the user
computing device; recursively decomposing the first Boolean query
to form an abstract syntax tree representation of the first Boolean
query; accessing a plurality of previously formed indices based on
terms parsed from the first Boolean query to identify documents
including the terms; determining the subsets based on a semantic
analysis of the one or more corpora; determining respective
statistics of the subsets; determining dimensions in display space
of the user interface based on the respective statistics; sending
instructions to render the user interface over a network from a
computational linguistics system to a browser executing on the
computing device, wherein the user interface is presented within
the browser and is formed, at least in part, by invoking WebGL
commands to enlist a graphical processing unit of the computing
device in rendering at least part of the user interface; the user
interface includes means for depicting a space-filling layout;
causing the computing device to display the result of the second
Boolean query comprises: sending instructions to the computing
device to update the user interface by inserting or removing
components of a document object model of the user interface in
memory.
3. The method of claim 1, wherein forming the second Boolean query
comprises: selecting a Boolean operator based on whether the term
is a broadening term or a narrowing term; determining a position in
the first Boolean query to add the term based on steps for
determining an order of operations; and forming an abstract syntax
tree representation of the second Boolean query based on both the
selected Boolean operator and the determined position.
4. The method of claim 1, wherein: the user interface provides a
dynamically adjustable visual guide to edit Boolean queries the
user.
5. The method of claim 1, wherein: the user interface provides a
plurality of candidate query terms that are user selectable without
typing the candidate query terms, wherein the user interface
graphically distinguishes between presented candidate query terms
that are broadening terms and candidate query terms that are
narrowing terms.
6. The method of claim 1, wherein: causing the computing device to
display the result of the second Boolean query comprises causing
portions of the graphical user interfaces to be constructed
dynamically with client-side scripts executed by the computing
device.
7. The method of claim 1, wherein: applying the second Boolean
query comprises interrogating structured data associated with
unstructured text documents among the data set.
8. The method of claim 1, wherein causing the computing device to
display the result of the second Boolean query comprises: causing
the computing device to display a synthesis of responsive
documents.
9. The method of claim 1, wherein causing the computing device to
display the result of the second Boolean query comprises: steps for
presenting search results.
10. The method of claim 1, wherein causing a computing device to
display a user interface with a result of a first Boolean query
comprises: causing the computing device to display a proportional
shape graph.
11. The method of claim 1, wherein causing a computing device to
display a user interface with a result of a first Boolean query
comprises: iteratively and alternatively subdividing available
space in a region of the display based on the statistics and
selecting rectangle sizes based on whether an aspect ratio of a
candidate rectangle satisfies a threshold.
12. The method of claim 1, wherein the user interface comprises
user selectable filters based on metadata of the data set.
13. The method of claim 1, wherein the user interface comprises a
query editing input having means for indicating status of query
terms.
14. The method of claim 1, wherein the user interface comprises a
plurality of user selectable candidate query terms, the candidate
query terms being selected based on a topic to which the candidate
terms pertain.
15. The method of claim 1, wherein terms in different regions of
the interface, with different visual attributes, appearing
concurrently, are selectable by the user to add query elements and
Boolean operators associated with those query elements.
16. The method of claim 1, wherein: the term is a negative
disjunctive term selected from among a plurality of candidate query
terms determined by means for distributional semantic analysis
using means for compressing sparse matrices and means for
performing matrix operations.
17. The method of claim 1, wherein: the term is a positive
disjunctive term selected by the user clicking on a corresponding
area of the user interface and invoking a corresponding event
handler executed in a browser of the computing device, the positive
disjunctive term being selected from among a plurality of positive
disjunctive terms determined based on means for latent semantic
analysis.
18. The method of claim 1, wherein: forming the second Boolean
query comprises steps for refactoring a Boolean query and steps for
validating a Boolean query.
19. The method of claim 1, wherein: receiving a user selection
comprises receiving both a user selected positive conjunctive term
and a user selected negative conjunctive term; the second Boolean
query includes both the positive conjunctive term and the negative
conjunctive term; and the user interface is caused to be updated to
display text of the second Boolean query.
20. A tangible, non-transitory, machine-readable medium storing
instructions that when executed by one or more processors
effectuate operations comprising: causing, with one or more
processors, a computing device to display a user interface with a
result of a first Boolean query applied to a data set, wherein: the
display represents subsets of the result as concurrently displayed
graphical regions; each of the graphical regions representing a
respective subset of query results has a visual attribute
determined based on a respective statistic of the respective
subset; the user interface includes a user-selectable input by
which the first Boolean query is changed without the user typing
additional query terms; receiving, with one or more processors, a
user selection entered via the user-selectable input, the user
selection indicating a term to be added to the first Boolean query;
based on the user selection, with one or more processors, forming a
second Boolean query; applying, with one or more processors, the
second Boolean query to the data set to produce a result of the
second Boolean query; and causing, with one or more processors, the
computing device to display the result of the second Boolean query.
Description
CROSS-REFERENCE TO RELATED APPLICATIONS
[0001] The present patent is a continuation of U.S. patent
application Ser. No. 15/092,938, filed 07 Apr. 2016, having the
same title, the entire content of which is hereby incorporated by
reference.
BACKGROUND
[0002] 1. Field
[0003] The present invention relates generally to computational
linguistics and, more specifically, to techniques for composing and
refining Boolean queries on data sets related to computational
linguistics.
[0004] 2. Description of the Related Art
[0005] Often people wish to draw inferences based on information
contained in, and distributed among, relatively large collections
of documents, e.g., substantially more documents than they have
time to read or the cognitive capacity to analyze. Certain types of
inferences implicate relationships between those documents. For
example, it may be useful to organize documents by the subject
matter described in the documents, sentiments expressed in the
documents, or topics addressed in the documents. In many cases,
useful insights can be derived from such organization, for example,
discovering taxonomies, ontologies, relationships, or trends that
emerge from the analysis. Examples might include organizing
restaurants based on restaurant reviews, organizing companies based
on content in company websites, organizing current events or public
figures based on new stories, and organizing movies based on
dialogue.
[0006] One family of techniques for making such inferences is
computational linguistic analysis of text, such as unstructured
text, within the documents of a corpus, e.g., with natural language
processing techniques, like those based on distributional
semantics. Computers are often used to perform semantic similarity
analyses within corpora to gauge document pair-wise similarity of
the documents according to various metrics, or pair-wise measures
of relationships between entities, topics, terms, or sentiments
discussed in the documents, which may be crafted to yield results
like those described above. Through the sophisticated use of
computers, inferences that would otherwise be impractical are
potentially attainable, even on relatively large collections of
documents.
[0007] In many cases, the collections of documents are relatively
large, for example, more than 100 documents, and in many cases more
than 10,000 documents, making it difficult for users to effectively
explore the results of analyses. One powerful tool for
interrogating such a corpus, or an analysis of such a corpus, is a
Boolean query.
[0008] Boolean queries are used in a variety of contexts, including
to express queries for relational databases and queries for
searching natural language in unstructured documents. This query
format has the advantage of being relatively expressive and
precise. Very complex queries can be expressed as combinations of
query elements (like keywords or database field values or ranges)
and Boolean operators (like "and," "or," and "not"). For these
reasons, Boolean queries are often favored by developers of
software systems.
[0009] Many users, however, struggle to properly formulate Boolean
queries. Non-technical users are often not trained in formal logic
and find Boolean queries to be nonintuitive and frustrating.
Compounding this problem, typical use cases for Boolean queries
involve iterative query formulation, by which a user submits a
query, reviews the results, and then refines their query, in an
iterative process until they reach the search results that they
desire. Thus, to use this powerful technique, the user formulates
multiple queries, adjusting the queries at the margin, a process
that can be particularly nonintuitive for less sophisticated
users.
SUMMARY
[0010] The following is a non-exhaustive listing of some aspects of
the present techniques. These and other aspects are described in
the following disclosure.
[0011] Some aspects include a process of refining Boolean queries,
the process including: obtaining a query provided by a user via a
user's computing device; searching a corpus of documents based on
the query to identify responsive documents, the corpus having more
than 2,000 documents; selecting narrowing terms that pertain to
respective subsets of the responsive documents; selecting
broadening terms related to the query; instructing the user's
computing device to present a graphical user interface comprising:
graphical representations of the narrowing terms; graphical
representations of the broadening terms; and one or more user
inputs by which the user refines the query by adding a selected
narrowing term or a selected broadening term; obtaining a user
selection of a broadening term or a narrowing term; forming a
refined query based on the user selection; searching at least part
of the corpus based on the refined query to identify refined
responsive documents; and instructing the user's computing device
to present an updated graphical user interface with information
about the refined responsive documents.
[0012] Some aspects include a tangible, non-transitory,
machine-readable medium storing instructions that when executed by
a data processing apparatus cause the data processing apparatus to
perform operations including the above-mentioned process.
[0013] Some aspects include a system, including: one or more
processors; and memory storing instructions that when executed by
the processors cause the processors to effectuate operations of the
above-mentioned process.
BRIEF DESCRIPTION OF THE DRAWINGS
[0014] The above-mentioned aspects and other aspects of the present
techniques will be better understood when the present application
is read in view of the following figures in which like numbers
indicate similar or identical elements:
[0015] FIG. 1 is a flow chart of an example of a process for
refining a Boolean query;
[0016] FIG. 2 is a user interface corresponding to a query result
step of FIG. 1;
[0017] FIG. 3 is another portion of the user interface
corresponding to a query result step of FIG. 1;
[0018] FIG. 4 is a user interface corresponding to a query result
exploration consistent with the process of FIG. 1;
[0019] FIG. 5 is a user interface corresponding to a query
modification step of FIG. 1;
[0020] FIG. 6 is another user interface corresponding to a query
modification step of FIG. 1;
[0021] FIG. 7 is another user interface corresponding to a query
modification step of FIG. 1;
[0022] FIG. 8 is another user interface corresponding to a query
modification step of FIG. 1;
[0023] FIG. 9 is another user interface corresponding to a query
modification of FIG. 1;
[0024] FIG. 10 is a block diagram of the logical architecture of a
system configured to perform the process of FIG. 1; and
[0025] FIG. 11 is a block diagram of an example of a computer
system by which the above-techniques may be implemented.
[0026] While the invention is susceptible to various modifications
and alternative forms, specific embodiments thereof are shown by
way of example in the drawings and will herein be described in
detail. The drawings may not be to scale. It should be understood,
however, that the drawings and detailed description thereto are not
intended to limit the invention to the particular form disclosed,
but to the contrary, the intention is to cover all modifications,
equivalents, and alternatives falling within the spirit and scope
of the present invention as defined by the appended claims.
DETAILED DESCRIPTION OF CERTAIN EMBODIMENTS
[0027] To mitigate the problems described herein, the inventors had
to both invent solutions and, in some cases just as importantly,
recognize problems overlooked (or not yet foreseen) by others at
the intersection of the fields of computational linguistics and
human-computer interaction. Indeed, the inventors wish to emphasize
the difficulty of recognizing those problems that are nascent and
will become much more apparent in the future should trends in
industry continue as the inventors expect. Further, because
multiple problems are addressed, it should be understood that some
embodiments are problem-specific, and not all embodiments address
every problem with traditional systems described herein or provide
every benefit described herein. That said, improvements that solve
various permutations of these problems are described below.
[0028] Some of the above-mentioned problems with traditional
techniques for forming Boolean queries may be mitigated by the
techniques described herein. Some embodiments may allow users to
iterate relatively seamlessly on their Boolean queries by providing
an intuitive, dynamically adjusted visual guide to the user. Some
embodiments may provide candidate query terms for a user to
consider adding to their query, and some embodiments may
graphically distinguish between terms suitable for broadening the
query (e.g., with an "or" Boolean operator) and terms suitable for
narrowing the query (e.g., with an "and" or "and not" Boolean
operator). Further, some embodiments may embed these tools in a
larger graphical user interface with filters that are combinable
with the queries and snippets of text and statistics that allow the
user to quickly visually parse whether a query requires refinement
to reach their desired results. In some embodiments, portions of
these graphical user interfaces are constructed dynamically with
client-side scripts to reduce round-trip exchanges with remote
servers and provide a relatively low-latency responsive graphical
user interface. That said, not all embodiments provide all of these
benefits, as several inventions are described, and the different
inventions are independently useful.
[0029] Some of the present techniques may relieve users of a
cognitive burden, by composing queries. But this does not mean that
the present techniques are performing a mental process. Rather
specific computational steps are described that produce a result
that some more sophisticated users are able to produce with their
mind, but the invention is in the means, not the ends. The
computational steps by which this is implemented are not mental
processes. Even sophisticated users do not compose queries with
mental steps that match those described herein, .e.g., broadening
and narrowing terms are selected and presented based on larger
collections of data than any human being could process in their
mind, and the graphical user interfaces that are generated have no
analog in the mental process of users. Accordingly, the present
techniques should not be confused with abstract ideas relating to
mental processes.
[0030] FIG. 1 is a flow chart depicting an example of a process 10
for refining a Boolean query in accordance with some of the present
techniques. In some embodiments, the process 10 may be stored on a
tangible, non-transitory, machine-readable media such that when the
instructions are executed by a data processing apparatus, like that
described below with reference to FIG. 11, the operations of
process 10 are effectuated. In some embodiments, the process 10 may
be performed by a component of a computational linguistics system
described below with reference to FIG. 10, e.g., executing on the
computer system described with reference to FIG. 11. Examples of
the process 10 may yield graphical user interfaces presented on a
user device like those described below with reference to FIGS. 2
through 9. In some embodiments, an instance of the process 10 may
be executed server-side for each session with an individual remote
user interfacing with the server via a client computing device, for
example, over the Internet. Thus, in some cases, a relatively large
number of instances of the process 10 may be ongoing concurrently,
for instance, more than 100 or more than 1000 instances operating
concurrently, each instance serving a different user session.
[0031] In some embodiments, the process 10 may begin with obtaining
a query. In some embodiments, the query may be entered by a user
entering text into a text input box of a webpage in their web
browser. An example of such a graphical user interface is
illustrated in the graphical user interface 32 of FIG. 2, which may
be displayed upon rendering code sent to a user device. In this
example, the graphical user interface includes a text input box 34
into which the user types query elements, like keywords. In some
embodiments, the text input box may be hidden (e.g., completely,
for instance by not sending code that causes the input to be
displayed), and the graphical components displayed may initially
represent the entire document corpus, e.g., with the types of
results shown in FIGS. 3 and 4. In this example, a Boolean query
may still be generated on the backend server, but not exposed to
users.
[0032] In this example, the user interface 32 further includes
query completion suggestions 36. In some embodiments, the query
completion suggestions 36 may be obtained by sending partially
completed queries to a remote server system (e.g., by a client-side
event handler executing in JavaScript.TM. receiving a character
entered event), which may then select candidate responsive query
suggestions and ranked those suggestions. The responsive
suggestions may be sent back to the client device, for example,
before the user types a subsequent character or before the user
finishes entering their query, and candidate suggestions consistent
with the currently entered query (which may have acquired
additional characters) are presented in ranked order. In some
cases, the candidate suggestions are refined as additional
characters are entered to eliminate candidates that have a
different prefix from the currently entered characters. In some
embodiments, a user may select, e.g. click on, touch, or arrow down
to, one of the suggestions and complete the query.
[0033] In this example, the query input interface 32 includes a
corpus identifier 38. In some embodiments, the corpus identifier
can be selected by the user, and the remote server system (e.g.,
like that described with reference to FIG. 10) may send identifiers
of a plurality of different corpora among which the user can select
to search within the corresponding bodies of documents. Examples of
different corpora are described below with reference to FIG. 10,
which describes a computational linguistics system operative to
ingest documents, preprocess the documents to facilitate search,
and label the documents with various metadata to facilitate
exploration of the corpora.
[0034] As illustrated in FIG. 1, the process 10 may further include
searching a corpus of documents based on the query, as indicated by
Block 14. In commercially relevant use cases, the corpus of
documents is expected to be a relatively large collection of
unstructured natural language text documents. A variety of examples
are described below. In some embodiments, the corpus may include
more than 1000, more than 2000, more than 5000, or more than 50,000
natural language text documents having a median length of greater
than, for example, 500 words. Or embodiments are also consistent
with shorter documents, like micro-blog posts of less than or equal
to 140 characters. In some embodiments, the corpus of documents may
be documents related in some sense, for example, from the same
source or category of sources. In some cases, each document may be
associated with metadata, like an author, title, the publication
date, a version, and the like, and Boolean queries may be
supplemented by filtering according to the metadata.
[0035] That said, some of the present techniques are not limited to
corpa of unstructured text. Some of the Boolean query refinement
techniques are expected to be useful for interrogating other data
sets, or for interrogating structured data associated with
unstructured text documents. For instance, various metadata
elements of the corpora may serve as the related suggested
broadening categories or the refining categories described herein.
For example, a data set of college basketball statistics may have
text bios of players and associated player attributes, like date of
birth. One metadata attribute may be date of birth. Some
embodiments may present broadening and refining categories based on
date of birth.
[0036] In some embodiments, searching the corpus of documents may
be expedited by preprocessing the documents. For example, in some
embodiments, an index of the documents according to keyword (e.g.,
with an n-gram serving as the index keys, which are each paired
with a set of document identifiers in which the n-gram is present)
may be formed in advance of obtaining the query. In some
embodiments, the index identifies the number of times each word
appearing in the corpus appears in each document. For instance, an
index key corresponding to the word "wearable" may have values
corresponding to unique document identifiers of every document in
which the term "wearable" occurs and the number of occurrences in
that document for ranking purposes.
[0037] In some embodiments, a multi-term query may be serviced by
identifying each index entry in which a term (e.g., an n-gram of
two words, three words, or the like) in the query serves as a key
and then combining the responsive documents according to Boolean
operators between the keywords. For example, a Boolean operator in
the conjunctive form, "and," between two keywords may cause the
system to identify index values (i.e., document identifiers)
associated in the index with the keywords on either side of the
operator. Embodiments may then determine which document identifiers
appear in both lists to identify results. Similarly, a Boolean
operator in the disjunctive form, "or," may cause the system to
append index values associated with each of the keywords on either
side of the operator. In some embodiments, duplicate index values
may be condensed into a single representative entry. In some
embodiments, the responsive entries may be ranked, for example,
based on the number of times that the keywords appear in the
documents, or based on both the number of times the keywords appear
in the documents and the context in which those keywords appear,
for example, in association with other terms related to those
keywords (e.g., having a greater than a threshold co-occurrence
rate).
[0038] In some embodiments, many (and in some cases, most) queries
are expected to return relatively large collections of documents.
This is the intended use case of some embodiments, which is
distinct from many online search engines designed to return the
most relevant document. In view of this distinction, some
embodiments of process the results and provide graphical user
interfaces that facilitate insights on collections of responsive
documents, rather than merely directing the user to individual
documents. In many cases, users are more interested in what an
entire field has to say about a particular topic, rather than
finding, for instance, the most relevant individual document about
some topic. Many traditional search engines are not well-suited for
this type of analysis, as it is common for search engines to
emphasize individual responsive documents rather than attempt to
provide some synthesis of the collection of responsive documents.
In contrast, some embodiments consistent with the present
techniques may both help the user find the needle in the haystack,
as well as develop an understanding of the haystack itself.
[0039] To this end, some embodiments may present search results in
graphical user interfaces like those illustrated in FIGS. 3 and 4,
or in the force directed graph representations described below in
some cases, presenting graphical user interfaces may be performed
by sending instructions to a client device that cause the client
device to prepare and render a display (e.g., a graphical, haptic,
or audible stimulus). In some embodiments, the instructions are
conveyed in the hypertext transport layer protocol, for example, as
a web pages encoded in hypertext markup language, cascading style
sheets, JavaScript.TM., and various serialized data formats, like
JavaScript object notation.
[0040] In some embodiments, some or a substantial portion of the
logic of the graphical user interface may be executed on the client
device to facilitate relatively responsive graphical user
interfaces. For example, graphical user interfaces may be updated
by inserting or removing components of a document object model in
memory of a browser rather than re-composing an entire webpage on
the server and sending the entire webpage with the updated view to
the client device to be re-rendered. In some embodiments, both data
being displayed and data potentially relevant to the current view
(but not immediately displayed) may be sent as JSON objects, and
the graphical user interface may be updated client-side without
requesting additional data by referencing cached data and updating
the document object model. Embodiments are also consistent with
applying these techniques to virtual document object models and
with special-purpose, non-web browser applications, like native
applications executing on mobile devices. Or, some embodiments may
favor simpler client -sized code, and compose updated views
substantially entirely server-side.
[0041] In the graphical user interface 40 of FIG. 3, information
about responsive search results is displayed. In this example,
375,000 documents are identified as responsive to the query. Some
embodiments determine various statistics about these documents to
characterize the search results for the user in a meaningful way
that provides insight about the responsive collection of documents.
In this example, the statistics are presented in a faceted view
with several user selectable facets 42. Each facet, in this
example, corresponds to a category of items about which statistics
are calculated. Examples of such items are described below and may
include document topic, author, company, entities mentioned,
sentiment, and the like. In some embodiments, the statistics
include the number of documents to which the respective item
pertains, the strength of pertinence of the respective item to the
documents, and weighted combinations thereof. Some embodiments may
calculate an item score, and the graphical user interface may be
prepared to provide a visual indication of the item score.
[0042] In this example item scores are graphically represented in a
proportional shape graph 44. A variety of different types of
space-filling layouts, like proportional shape graphs, may be used.
Examples include Voroni diagrams, bubble charts, or a tree map like
the tree map illustrated in FIG. 3. In this example, the graph 44
includes a region 46 corresponding to documents about personal
wearable technology and another region 48 corresponding to
monitoring wearable technology. In some embodiments, a dimension of
these regions may be indicative of statistics about the documents
pertaining to that attribute. In some embodiments, the dimensions
area, and the area corresponds to the statistics. In some
embodiments, the dimension is length or radius, and the length or
radius corresponds to the statistic's value. The correspondence can
be linear or, particularly when a relatively wide range of values
is experiences, nonlinear, for example, logarithmic. In some
embodiments, other visual attributes may represent the statistics,
for example, attributes that afford visual weight, like color,
saturation, transparency, drop shadows, fonts, and the like.
[0043] In some embodiments, the graph 44 may be composed with a
tiling algorithm that selects the dimensions of the shapes based on
the statistics of the documents. For example, a size and aspect
ratio for the graph 44 may be obtained by querying the attributes
of a window object in the browser and subtracting space for other
components of the graphical user interface. These dimensions may be
input, along with the statistics into a tiling algorithm, like a
tree map algorithm, such as the binary tree algorithm, the mixed
tree map algorithm, the ordered tree map algorithm, the slice and
dice tree map algorithm, the squarified tree map algorithm, the
strip tree map algorithm, and the like.
[0044] In some embodiments partitioning a plane according to a
relatively large set of statistics can be a computationally complex
task that scales poorly as the number of values increase. A variety
of iterative techniques may be used to make the problem tractable.
For example, some embodiments may iteratively and alternatively
subdivide the available space with the values corresponding to
statistics and select rectangle sizes based on whether the aspect
ratio of the candidate rectangle satisfies a threshold.
[0045] In some embodiments, the graphical user interface 40 further
includes a region 50 with user selectable filters. In some
embodiments, user selectable filters may further limit the Boolean
query, for example, based on metadata of the documents. Examples
include publication date ranges, geographic proximity to a
reference location, topic categories, document source categories,
or a country associated with the document.
[0046] Of particular note, in some embodiments, the graphical user
interface includes a query editing input 52. In some embodiments,
the query editing input includes a graphical element 54
representing the currently submitted query. In some embodiments,
the visual attributes of the graphical element 54 indicate this
status. Examples of such graphical elements include color, font,
transparency, saturation, vibratory movement, drop shadow, and the
like. In some embodiments, the graphical element includes text
corresponding to the text of the query element and an input 56 by
which the query element may be removed from the query upon user
selection. In some embodiments, the query editing input further
includes a query submit input 58 that causes the corresponding
query to be sent to a server and executed. In some embodiments, the
various inputs may each be associated with an event handler
executing in JavaScript that effectuates the corresponding actions
in response to a specified event, like a user click, touch, hover,
or the like.
[0047] FIG. 4 is another view of the graphical user interface 40
showing a response of the graphical user interface 40 to a user
selection of one of the items in region 44, in this case topic 46.
Upon selecting a topic, in some embodiments, the server may send
information, or data cached in the browser may be retrieved, to
present a summary of the item in region 60. In this example, region
60 includes representative articles and snippets 62 of those
articles. In this example, 95,000 articles correspond to the item.
Representative articles may be selected, for instance, randomly, or
based on the strength of a score by which the articles, or
documents, were assigned to the item. Further information about the
topic is presented in a time series 64 which may be a graph having
bins corresponding to time ranges, like one week or one month, and
heights corresponding to document counts of the documents in
respective bins, for instance, published during those time bins,
like in a time-series histogram. Some embodiments may further
include statistics like a percentage of the documents that are
unique to that item or that are unique to that topic (without
pertaining to other topics) to assist with query refinement.
[0048] The query that yields of the results shown in FIGS. 3 and 4
may be modified with steps shown in the process 10 of FIG. 1. As
shown in FIG. 1, in some embodiments, before search results are
presented, some embodiments may select narrowing terms that pertain
to respective subsets of the responsive documents, as indicated by
Block 16. Examples of narrowing terms are the items shown in region
44 and selectable through faceted inputs 42 in FIGS. 3 and 4. In
some embodiments, the narrowing terms are topics, entities
mentioned, keywords, or metadata attributes of the documents in the
corpa (or other data set), and the like. The terms are narrowing
because they only pertain to a subset of the documents and when
selected are used to identify a subset of the documents. A
narrowing term may also pertain to documents outside of the search
results, but the term does not become broadening merely in virtue
of this fact. Rather, it is the combination of the term pertaining
to a subset of the documents, and the term being used to identify
that subset that makes the term a narrowing term.
[0049] Narrowing terms (which may be, e.g., n-grams, qualitative
metadata attributes, and quantitative metadata attributes) may be
identified with a variety of techniques. In some embodiments,
narrowing terms are keywords appearing in the documents. Examples
of potentially relevant keywords may be obtained with various
techniques, for example, responsive to term frequency inverse
document frequency exceeding a threshold, with named entity
recognition algorithms, topic extraction algorithms, and the like,
being executed on the responsive documents. In some embodiments,
documents may be preprocessed with these algorithms and associated
with results to expedite operations at query time.
[0050] Some embodiments may also select broadening terms related to
the query, as indicated by Block 18 of FIG. 1. In some embodiments,
broadening terms may be selected based on some semantic
relationship to the search results. Examples include terms having a
high co-occurrence with search terms (e.g., greater than a
threshold amount or frequency). Other examples include terms having
a high co-occurrence with terms co-occurring with the search terms
above a threshold. Again, broadening terms may appear in the
documents and serve both as a narrowing term and a broadening term
and be presented in two locations on the user interface, once in an
area for broadening terms and once in an area for narrowing terms.
A term serves as a broadening term if it is presented as a
candidate to expand the search results beyond the current
responsive documents, rather than searching exclusively within the
responsive documents. In some embodiments, different criteria may
be used to select broadening terms that are used to select
narrowing terms, as user intent often varies between these
interactions.
[0051] Terms (e.g., words or n-grams) appearing in region 44 may
serve as narrowing terms, and the list of related terms in region
66 may serve as the broadening terms. Thus, terms in different
regions of the interface, with different visual attributes,
appearing concurrently, may be selected by the user to add query
elements and Boolean operators associated with those query
elements, as described in greater detail below. The addition may be
in the proper syntax for a Boolean query, in some cases adding
parenthetical operators needed to effectuate user intent. This is
expected to facilitate more adept editing of Boolean queries, even
by less experienced users, and is expected to save keystrokes for
more advanced users. The cognitive load of identifying query
elements is expected to be reduced for the user by presenting
likely candidate options. And the cognitive load of selecting an
appropriate Boolean operator and syntax for those query elements is
further reduced by automatically applying those Boolean operators
upon selection of the candidates by a user and, in some
embodiments, by automatically generating correct syntax, like
appropriately applied parentheses and accounting for order of
operations of Boolean operators.
[0052] As illustrated in FIG. 1, next, some embodiments may
determine whether a narrowing term is selected, as indicated by
Block 22 and, if not, whether a broadening term is selected, as
indicated by Block 24. The selection may be by the user among the
presented candidate narrowing terms and broadening terms in the
graphical user interfaces described with reference to FIGS. 3 and
4. Selection may be accomplished with a variety of techniques,
including clicking, touching, hovering, and navigating through a
selection menu. As illustrated, upon a user selecting a narrowing
term, some embodiments may add in "and" operator to the existing
Boolean query as indicated by Block 26. In some embodiments, a
negative conjunctive query element may be added instead of a
positive conjunctive query element. The addition may include adding
both a query element corresponding to the term and the Boolean
operator in the appropriate syntax. Similarly, upon the broadening
term being selected, some embodiments may add an "or" term to the
Boolean query, as indicated by Block 28. Again, both positive and
negative disjunctive query terms may be added, and the addition may
be in the appropriate syntax for a Boolean expression. Some
embodiments may maintain a record of cursor position in the Boolean
query, and elements may be added based on the cursor position,
which may be a relevant parameter for more complex queries, e.g.,
to adjust within a parenthetical set of operators.
[0053] Next, some embodiments may determine whether more terms are
selected, as indicated by Block 30. If more terms are to be
selected, embodiments repeat steps 22, 24, 26, or 28, in some cases
iteratively until the user has fully compose the query or refine
query. In some embodiments, the user may delete query elements as
well during this process. Alternatively, upon determining that the
user is done selecting query terms, embodiments may return to block
14 and research the corpus of documents to compose new search
results and update the graphical user interfaces accordingly. In
some embodiments, a user may iterate through the process 10 through
multiple loops, refining their query until they reach their desired
result.
[0054] Query composition and refinement in the context of graphical
user interface 40 is shown in greater detail in FIGS. 5 through 9.
These interfaces may be presented as a user iterates through steps
22, 24, 26, or 28 in FIG. 1.
[0055] As shown in FIG. 5, a user may select a term for positive or
negative addition in conjunctive form with a menu. FIG. 6 shoes the
result of selecting the negative conjunctive option. Each of the
illustrated items in the treemap may produce a similar menu upon
selection. The corresponding area in the treemap is expected to
provide an intuitive indication of the likely magnitude of the
effect of the query adjustment on search results.
[0056] In some embodiments, as shown in FIG. 5, selecting item 68
(in this case, the term "space") reveals a menu 70 for adding
conjunctive terms, both positive and negative. In this example,
selection of the trashcan icon causes a negative conjunctive
Boolean operator to be associated with the item, and selection of
the "+" causes a positive conjunctive Boolean operator to be
associated with the item.
[0057] FIG. 6 shows a modified query 72 after selection of the
negative conjunctive Boolean option in menu 70. As illustrated, a
Boolean operator 74 and the item 76 have been added to the query.
In some embodiments, a user may submit this refine query (e.g., by
selecting the magnifying glass icon) and receive different results
or further edit the query (e.g., by selecting more terms or by
typing in more terms).
[0058] In some embodiments, the different components of the Boolean
query may be graphically represented in a way that indicates their
functionality. For example, Boolean operators may be represented
with a different color, font, visual weight, or the like from that
used to represent the terms upon which the Boolean operators
operate, and each Boolean operatory type (e.g., "and," "or," and
"not") may be represented the same way with a distinct set of
visual attributes from the other types to make it easy to visually
parse the query.
[0059] FIG. 7 illustrates selection of item 46 to reveal another
instance of the same menu, and FIG. 8 illustrates a resulting
further refinement to the query of FIG. 6 with an additional
Boolean operator of the conjunctive positive form 78 and additional
term 80 selected in the interaction of FIG. 7. In FIG. 7, the user
may select the "+" sign to add the term "personal" as a narrowing
term associated with conjunctive operator "and" in FIG. 8.
[0060] A similar technique may be used to add disjunctive query
components, as illustrated in FIG. 9. Selected broadening term 82
includes a "+" input in an associated menu that when selected by
the user causes the corresponding broadening term to be added in
association with a disjunctive Boolean operator, "or." Embodiments
are consistent with both positive and negative disjunctive Boolean
operators.
[0061] In some embodiments, users may struggle with the order of
operation of Boolean operators. For instance, the query "apples AND
oranges OR bananas" yields a different result from "oranges OR
bananas AND apples," because the operator "AND" is evaluated before
the operator "OR" by convention. Parenthesis or brackets are
typically used to express a different order of operations from the
default. Some embodiments may be operative to insert parenthesis
for the user to specify an order operations. A variety of
techniques may be used to determine user intent and the
corresponding correct syntax. For instance, some embodiments may
determine whether the addition is intended to be a broadening or
narrowing refinement based on whether the user selected a term in
the treemap or the list of related terms above in the graphical
interfaces of FIGS. 3-9. Based on this choice, and the context of
the current query, ambiguity as to order of operation may be
resolved with by selecting the option that broadens or narrows.
[0062] In some cases, the desired order of operations may be
inferred from the order in which selections of narrowing and
broadening terms are received. For example, in response to
broadening term selection being followed by a narrowing term
selection, some embodiments may place the existing query in
parentheses before applying the narrowing term. Conversely, in
response to a narrowing term being followed by a broadening term
selection, some embodiments may place the existing query in
parentheses before applying the broadening term. For example, the
existing query may be "`wearable technology` AND phone," and the
user may click on the broadening term "fitness." In some
embodiments, the resulting query is "(wearable technology' AND
phone) OR fitness." Or in another example, the existing query may
be "`wearable technology` AND phone," and the user may click on the
narrowing term "sensor." In some embodiments, the resulting query
is "((wearable technology' AND phone) OR fitness) AND sensor." As a
result, some embodiments may apply parenthesis more liberally than
is required, as some parenthesis may be redundant to the implicit
order of operations of the Boolean operators, but the results are
expected to conform the user's intent. Some embodiments may
recursively decompose the query into an abstract syntax tree and
remove each set of parentheses that do not affect the structure of
the abstract syntax tree due to the parenthesis being redundant to
the implicit order of operations of the Boolean operators, or some
embodiments may leave the parenthesis in place to favor simpler
operation.
[0063] Some embodiments may use additional user inputs for
specifying order of operations, e.g., in some embodiments, a user
may hold down a shift key while selecting multiple narrowing or
broadening terms to indicate a desire to place the terms in
parenthesis. Or a user may drag and drop terms into an area of the
query input between parentheses to indicate a desire to add those
terms to that portion of the query. Or some embodiments may include
an input by which a user designates a query result as a "corpus,"
and the query process may begin again on this newly defined corpus,
effectively imposing an order of operations in which the previous
query is, in effect, performed before new queries.
[0064] In some embodiments, the refined query (e.g., shown in FIG.
8) may be composed entirely without a user typing a single key
after entering the initial query, thereby facilitating relatively
fast modifications to queries with relatively low cognitive load
being placed on the user. Further, graphically representing the
Boolean query components with visual attributes that indicate their
functionality and distinguish different Boolean operators is
expected to help train users on how to compose Boolean queries. And
representing narrowing or broadening terms with graphical
attributes (e.g., area, font-size, color, saturation, transparency,
location, drop shadow, vibratory movement, or the like) that
indicate the effect of adding the term to a modified query (e.g., a
large area tile in the treemap indicates a large number of
documents will remain after a positive conjunctive addition or be
removed by a negative conjunctive addition) is expected to reduce
the number of refinements needed to make a query responsive to the
user's intent.
[0065] Having reached a satisfactory query with the interfaces of
FIGS. 2-9, next, some embodiments of the process 10 in FIG. 1 may
present search results and further query-adjustment interfaces with
narrowing and broadening terms, as indicated in block 20. Examples
of the presented interface are described with reference to FIGS. 3
and 4.
[0066] FIG. 10 illustrates, in block diagram form, the logical
architecture of an example of a computing environment 800 in which
the above-described techniques may be implemented. In some
embodiments, environment 800 includes a computational linguistics
system 802, the Internet 804, document sources 806, and a plurality
of user devices 808, such as personal computers, laptops, or mobile
devices having the features of the below-described computer
systems. Representative devices are shown, but it should be
understood that substantially more devices and instances may be
used in commercial embodiments, e.g., more than 100, or more than
1,000 user devices, and more than 10, or more than 100 document
sources.
[0067] In this example, subscribing users may submit queries to the
system 802 (which may be geographically remote) via a web browser
executing on user devices 808 and exchanges over the Internet 804.
In some embodiments, users may submit queries to view (or otherwise
interrogate, e.g., search) trends, entity relationships, sentiment
relationships, term relationships, or document relationships (e.g.,
graphs of such relationships) determined by the computational
linguistics system 802 based on unstructured plain text documents.
These documents, in some cases, may be retrieved (e.g., downloaded)
from content hosted by third party document sources 806, in some
cases as batch downloads in advance of queries.
[0068] In some embodiments, the computational linguistics system
802 may include a query composer 810 to perform the above-described
techniques, a web server 812, an application-program interface
(API) server 814, a document-ingest module 816, a corpora
repository 818, a natural-language processing module 820, a graph
repository 822, a data visualization module 824, a user-account
repository 825, and a controller 826. The controller 826 may
coordinate the described operations of the other modules. In some
cases, prior to granting access, the controller 826 may confirm a
user's credentials against a user account in the repository 825 for
security purposes and to verify whether a user account is current,
e.g., a subscription fee has been paid.
[0069] In some embodiments, the query composer 810 includes a
narrowing term selector 840, a broadening term selector 842, a
query compiler 844, and a query validator 846. In some embodiments,
the narrowing term selector may perform the steps described above
to select narrowing terms, and the broadening term selector 842 may
perform the steps described above to select broadening terms. In
some embodiments, the query compiler 844 may be operative to add
the refinements to the Boolean query, as described above with
reference to Blocks 26 and 28. In some embodiments, the user may
compose invalid or unnecessarily complex Boolean queries. To assist
the users, some embodiments may include a query validator 46. In
some embodiments, the query validator 46 may analyze the query to
identify, for example, logical inconsistencies guaranteed to
provide zero search results, for example, requesting both X and not
X. Further, in some embodiments, the query validator a 46 may be
operative to simplify Boolean expressions with Boolean algebra, for
example, by factoring parentheticals and consolidating redundant
terms. In some embodiments, the simplified Boolean expression may
be presented to the user for further refinements.
[0070] In some embodiments, system 802 may include a web server 812
and an application-program interface (API) server 814. These
servers may listen to corresponding network ports, maintain session
state for various sessions with user devices 808, advance requests
and posted data to controller 826, and send responsive data to user
devices 808. In some cases, responses may be in the form of web
pages, like serialized bodies of markup language, cascading style
sheets, and JavaScript.TM. instructions used by web browsers to
render content, like inputs for making requests or data
visualizations of query responses. In some embodiments, the API
server 814 may be operative to send structured responsive data,
like XML or JSON formatted responses to queries and receive
machine-generated requests. In some embodiments, the servers may be
blocking servers, or the servers may use various techniques to
process multiple requests concurrently, e.g., with various
asynchronous programming techniques, like by tracking and
implementing deferreds or promises.
[0071] In some embodiments, the document-ingest module 816 may
obtain collections of documents and store those documents in
corpora repository 818, which may have analyzed corpora of
unstructured plain text documents used to generate the presently
described graphs. In some embodiments, the documents may be
obtained from different document sources 806, such as remote,
third-party repositories of documents, like web servers.
[0072] In some embodiments, retrieved and stored corpora are
collections of unstructured text documents. In some embodiments,
the unstructured text may be included within structured portions of
other documents, for example, rendered text within markup
instructions in a webpage, or unstructured text embedded in a
serialized data format, like paragraphs within an extensible markup
language document or JavaScript.TM. object notation document. This
surrounding structure notwithstanding, in some embodiments, at
least some, and in some cases most or only, the text analyzed in
constructing graph topologies is unstructured text, like human
readable plain text in prose form with markup instructions and
scripting language instructions removed. For instance, an automated
web browser, like Selenium.TM., may be executed to retrieve web
pages, execute scripts to and render markup language construct a
document object model of the webpages, and parse visible text from
the web pages that is retrievable from ".text" attribute of a DOM
object containing the text. Removing the computer-readable portion
is expected to cause documents to be grouped according to their
content intended to be read by humans, rather than according to the
programming library or practices invoked by a developer. Or some
embodiments may leave this markup language and scripting
instructions in place to analyzed documents according to their mode
of construction or to weight terms according to their visual weight
when rendered or annotate terms according to their context. In some
embodiments, the text may be encoded as Unicode or ASCII text.
[0073] In some cases, an analyzed corpus may be relatively large,
for example, more than 100 documents, more than 1,000 documents, or
more than 10,000 documents, and connections indicating semantic
similarity between the documents (or entities, sentiments, terms,
or the like, as described below) may be relatively numerous, e.g.,
more than 5 connections on average between documents, like more
than 50, more than 500, or between each unique pair of documents.
In some embodiments, each of the documents may also include a
substantial amount of text, for instance, more than 100 words, more
than 500 words, or more than 2,000 words.
[0074] In some embodiments, an analyzed corpus used to construct a
graph may be relatively large. For expected use cases of the
present inventions, the corpus is larger than would be economically
feasible for humans to manually perform the process 10 in
reasonable amounts of time, and computers are required to implement
the process 10 in commercially relevant intended applications. For
example, the corpus may include more than 50 documents, like more
than 500, or more than 5,000 documents. Further, in some
embodiments, the documents within the corpus may be relatively
long, for example, having a median length of more than 50 words,
like more than 500 or more than 5,000 words, depending upon the use
case.
[0075] The necessity of computer implementation, even for
relatively small corpora, can arise from the number of documents,
the length of documents, or the semantic pairwise
interrelationships between the documents, which can give rise to
data structures that can grow factorially with each additional
document depending upon how aggressively semantic links between
documents are pruned. Due to this scaling effect, each additional
document in some applications can impose substantial additional
computational and memory burdens, and increasing the number of
documents even by a small amount can be a nontrivial problem,
particularly without the benefit of some of the techniques
described herein to expedite computer processing of the analysis
and conserve limited memory within a computer system.
[0076] In some embodiments, the documents within the corpus may be
related in some fashion, for example, all from the same source or
related to a category of topics, entities, sentiments, or the like.
Examples of corpora include academic literature, like scientific
literature, medical literature, economic literature,
psychological-research literature, and the like, for instance, from
a given journal, university, country, or academic. Other examples
include webpages, for example, from businesses, like the 500
highest ranking business entity websites responsive to a given
query, businesses within a given region, business in a given
industry, businesses at a given state of development (like emerging
businesses), or combinations thereof, like startups in Silicon
Valley targeting the shipping industry to give one example. Other
examples of corpora include documents hosted in government
databases, like the full text patent database hosted by the United
States Patent Office, regulatory filings with the Securities and
Exchange Commission hosted in the Edgar database, court filings
within the Pacer database, Federal Communication Commission
filings, United States Food and Drug Administration filings, and
the like. Another example of corpora includes various bodies of
journalism, like catalogs of newspapers, magazines, and the like.
Relevant corpora also include social media posts, for example,
microblog posts, blog posts, posts within social networks, and the
like, as well as resumes, job postings, and product manuals. Some
embodiments may operate on corpa of unrelated documents, such as
any corpus containing metadata that could be represented as
discrete data points or ranges.
[0077] In some cases, the corpus is obtained by processing non-text
documents, for example, by performing optical character recognition
on image-formatted documents or by submitting photographs to image
recognition and description algorithms that return a prose
description of photographs. In some cases, the corpus may be
obtained without metadata indicating the semantic relationships
between documents within the corpus, and these relationships may be
discerned, for example, with software provided by Quid of San
Francisco California, or by performing latent semantic analysis or
other distributional semantic techniques to construct the graphs
described herein. In some cases, the analysis may be performed by
an unsupervised machine learning technique, or some embodiments may
train supervised machine learning models (e.g., with stochastic
gradient descent) based on a training set, like text data having
manually-labeled features. Unsupervised methods are expected to be
less expensive and more broadly applicable, as the cost and
complexity of feature engineering may be reduced relative to
supervised techniques, which is not to suggest that at least some
embodiments are not also consistent with supervised learning.
[0078] In some embodiments, the natural-language processing module
820 may analyze these corpora and store resulting graphs in the
graph repository 822, e.g., at query time or in advance, depending
on acceptable latency and resources available, or in some cases
partially in advance. In some cases, graphs like those described
above may be obtained by subjecting a corpus to various types of
distributional semantic analysis, e.g., statistical similarities
measures like latent semantic analysis, random indexing, normalized
Google.TM. distance, Best path Length On a Semantic Self-Organizing
Map, Vector Generation of an Explicitly-defined Multidimensional
Semantic Space, or other techniques by which the distribution of
terms in documents is represented as relatively high-dimensional
vectors, and semantic similarity is measured by according to
similarity of the vectors, for instance, cosine similarity or
Minkowski distance. The analysis technique used by some embodiments
may be selected based on the type of relationships to be measured,
e.g., between entities or terms, versus between larger units of
language, like documents or paragraphs. In some cases, a corpus may
be analyzed multiple ways, yielding graphs of relationships between
entities mentioned in the documents as well as graphs of
relationships between the documents.
[0079] Graphs need not be labeled as a "graph" in program code to
constitute a graph. Other constructs may be used to the same ends
and still constitute a graph. It is enough that the arrangement of
information (e.g., in program state, storage, or both) contain the
attributes of the presently described graphs to constitute a graph
having edges and nodes. For example, in an object-oriented
programming environment, documents may be mapped to "document"
objects, and those objects may have an attribute of a list of
semantically similar documents each of which corresponds to a
different "document" object and has a similar list referencing
other documents, regardless of whether this arrangement is referred
to as a "graph" in code.
[0080] In some embodiments, to measure relationships between
documents (or other larger language units, like paragraphs), each
document may be represented by a feature vector in which each value
of the vector indicates the presence, number of occurrences, or
frequency of an n-gram in the document. N-grams are sequences of
one or more terms, e.g., "the" is an example of an n-gram where
n=1, "the quick" is another n-gram where n=2, and "the quick brown
fox jumped" is another where n=5. In some cases, relatively
uninformative terms, like stop words ("the," "a," and "an" being
common examples), or terms detected with term-frequency inverse
document frequency (TF-IDF) scoring may be omitted.
[0081] To calculate TF-IDF for a given n-gram, some embodiments may
count the number of times the n-gram occurs within a given document
and the number of other n-grams in the document before calculating
a frequency with which the term occurs within the document. Some
embodiments may also count the number of times the n-gram occurs in
a larger collection of documents, such as the analyzed corpus of a
sampling thereof, as well as the total number of terms in the
larger collection of documents to calculate another frequency with
which the term appears in the larger collection of documents. The
two resulting frequencies may be compared, for instance, dividing
one frequency by the other, to determine the TF-IDF score.
[0082] Position of a value in the feature vector may correspond to
one n-gram, e.g., the first position of a vector may correspond to
the n-gram "jumped over," and documents containing this sequence of
terms have a feature vector with value in the first position
indicating that this term is present. Documents many be analyzed as
a whole, or at higher resolution. For instance, in some
embodiments, each document may be partitioned into paragraphs, and
then, a feature vector may be constructed for each paragraph, with
values of the vector corresponding to the presence of n-grams
within the respective paragraph. Vectors need not be labeled as
"vectors" in program code to constitute vectors, e.g., ordered
lists may constitute a vector in some cases.
[0083] Because the universe of n-grams a document could contain is
relatively large, and documents tend to use a relatively small
portion of these n-grams, feature vectors tend to be relatively
high-dimensional and sparse, having a value of zero for most
values. To mitigate the burden of high-dimensionality, in some
cases, feature vectors may be subjected by some embodiments to
various types of dimensional reduction, like indexing, random
indexing, or singular value decomposition.
[0084] In some cases, a corpus may be represented by arranging the
feature vectors into a term-document matrix. For instance, each row
or column may correspond to a document, and the values along the
row or column may be the feature vector of that document. Thus,
rows may represent documents, and columns n-gams, or vice
versa.
[0085] Or in some embodiments, a document or corpus may be
represented as a co-occurrence matrix, where both rows and columns
represent n-grams, and values indicate the presence, number, or
frequency of instances in which corresponding n-grams occur within
a threshold distance of one another in the text. In some
embodiments, co-occurrence matrices for documents may be appended
to one another to represent a corpus in a higher-dimensional
matrix, e.g., in a three dimensional corpus matrix, with each
two-dimensional co-occurrence matrix corresponding to a document.
Such matrices may be reduced in dimension with a number of
techniques, including random indexing. Matrices need not be labeled
as a "matrix" in program code to constitute a matrix, e.g., an
ordered list of ordered lists may constitute a matrix.
[0086] In some cases, a variety of types of relationships may be
processed with some embodiments. For instance, semantic similarity
or relatedness of entitles mentioned in documents, sentiments
expressed in documents, or terminology in documents may be
determined with computational natural language processing of
unstructured plain text corpora. In some embodiments, a
corresponding graph may be constructed, with documents, paragraphs,
entities, sentiments, or terms as nodes, and weighted edges
indicating relationships, like similarity, relatedness,
species-genus relationships, synonym relationships, possession
relationships, relationships in which one node acts on another
node, relationships in which one node is an attribute of another,
and the like. In some cases, the edges may be weighted and
directed, e.g., where the relationship applies in one direction and
can vary in magnitude or certainty.
[0087] Analyses of such matrices may entail operations like
insertion, multiplication, and addition. As noted above, in some
embodiments, matrix operations may be prohibitively slow or memory
intensive for a larger datasets. A number of techniques may be used
to expedite these operations and reduce memory consumption. In some
embodiments, to expedite operations, matrix operations may be
performed in a single instance of a computer system, for example,
within a single memory address space of a single operating system,
and in some cases, by holding some or all of the matrix data in
program state concurrently to avoid disk access or network access
latency penalties. Or, some embodiments may distribute operations
on additional computing systems, which is not to imply that any
other feature described herein may not also be omitted. In some
embodiments, the computer system may be configured with a
relatively large amount of random access memory and on-chip cash
memory to these ends.
[0088] In some cases, some of the sparse-matrices described above
may consume a relatively large amount of memory using some
traditional techniques. To conserve memory, some embodiments may
compress the sparse matrices, for example, by decomposing a matrix
into vectors, and translating the vectors into an index indicating
which vector scalars have a nonzero value and corresponding
indications of those values. Some embodiments may compress such
vectors with run-length coding of values of those values that are
zero. Some examples may compress sparse matrices as a dictionary of
key, a list of lists, a coordinate list, a compressed sparse row,
or a compressed sparse column. In some cases, such matrices, or
portions of sparse matrices, may be expanded for some vector
operations and then re-compressed after and before, respectively,
the sparse matrices, or portions thereof, are moved upward in a
memory hierarchy towards a processor.
[0089] Various encodings may be selected to improve the functioning
of a computer system. In some cases, values of matrices, like
weights, may be normalized, for example, ranging between zero and
one or as eight, 16, or 32 bit binary values having a number of
digits selected in view of an operating system, register size,
memory bust size, and other hardware constraints of a computer
system upon which the above processes are to be run to expedite
operations and conserve memory.
[0090] Some embodiments may determine document similarity based on
latent semantic analysis of unstructured text in the documents. For
instance, some embodiments may create a term document matrix of the
documents. Then, the term-document matrix may be transformed with
singular value decomposition (SVD) to map documents to concepts
expressed by the terms. Documents having similar concepts may be
deemed similar, e.g., based on similarity of concept vectors for
the documents yielded by SVD. In some cases, terms appearing with
more than a threshold frequency in the documents may be determined
and weighted according to TF-IDF. In some cases, the resulting
weighted term document matrix may be decomposed by determining two
vectors, that when multiplied, approximate the matrix. In some
embodiments, error between the approximation and the matrix may be
determined, and the error may be decomposed by determining two more
vectors that when multiplied approximate the matrix of errors. This
process may be repeated until an aggregate error is determined to
be smaller than a threshold. A threshold number (e.g., the second
and third) of the resulting vectors may correspond to dimensions in
a concept space, where the concepts that emerge correspond to
co-occurrence of terms in documents indicated by clusters in the
space. Documents may be clustered according to their corresponding
vectors in the concept space, or similarity of documents may be
determined by some embodiments by comparing their respective
vectors in this space, e.g., based on cosine similarity or other
measures.
[0091] In some cases, high dimensional sparse vectors may be
reduced in dimension with random indexing. For instance, document
text may be represented in a co-occurrence matrix, where rows
represent n-grams, columns represent adjacent n-grams (like within
a threshold number of words in the text), or vice versa, and values
represent presence, number, or frequency of instances in which
corresponding terms are determined to be adjacent one another in
the text. In some cases, to reduce memory consumption of sparse
vectors in such a semantic similarity analysis, a co-occurrence
matrix may be created by representing adjacent n-grams as vectors
that are smaller (e.g., substantially smaller) than the number of
potential adjacent n-grams and are made generally distinguishable
from one another by randomly (e.g., pseudo-randomly) assigning
values, like 0, +1, or -1. As adjacent n-grams are encountered
during parsing, corresponding rows or columns of n-grams in the
co-occurrence matrix may be updated by summing current values of
the row or column with corresponding values of the adjacent n-gram
vector. Similarity of n-grams (and corresponding entities) may be
determined based on similarity of resulting vectors in the
co-occurrence matrix, e.g., based on cosine similarity.
[0092] In some cases, similarity (or other relationships) between
larger language units may be determined. For instance, in some
cases, a feature vectors may be determined for documents in a
corpus. Some embodiments may execute a density-based clustering
algorithm, like DBSCAN, to establish groups corresponding to the
resulting clusters and exclude outliers. To cluster according to
vectors, some embodiments may iterate through each of the vectors
reflected in the records and designate a vector as a core location
in vector space if at least a threshold number of the other vectors
in the records are within a threshold distance in vector space.
Some embodiments may then iterate through each of the vectors and
create a graph of reachable vectors, where nodes on the graph are
identified in response to non-core corresponding vectors being
within a threshold distance of a core vector in the graph, and in
response to core vector in the graph being reachable by other core
vectors in the graph, where to vectors are reachable from one
another if there is a path from one vector to the other vector
where every link and the path is a core vector and is it within a
threshold distance of one another. The set of nodes in each
resulting graph, in some embodiments, may be designated as a
cluster, and points excluded from the graphs may be designated as
outliers that do not correspond to clusters.
[0093] In some cases, when performing these operations, movements
within a memory hierarchy of a computer system (e.g., from storage,
to dynamic random access memory, to L3 cache, to L2 cache, to
processor registers) may be relatively slow, and memory space may
be particularly limited higher in the hierarchy, closer to the
processor. For example, access to data stored in registers of a
processor, such as a CPU or graphics processing unit, may be
relatively fast, while the amount of available storage may be
relatively low. Level 2 and level 3 cache, respectively, may offer
trade-offs of increasing magnitude, exchanging slower access times
for greater storage space. Similarly, dynamic random access memory
may offer even greater storage, though access times may be several
orders of magnitude slower than the registers or cache memory, and
persistent system storage, such as a hard disk or solid-state
drive) may extend this trade-off even further. In some embodiments,
matrices may be large enough that during operation substantial
portions of the matrix, for example, most of the matrix, cannot fit
into the higher levels of a memory hierarchy, and portions of the
matrix may be swapped in and out of the higher levels of memory
hierarchy during operations on those portions. As a result, in some
embodiments, movement of data between levels of the memory
hierarchy may account for a substantial portion of the computing
resources, e.g., time and memory, consumed by a matrix operation.
As some use cases reach relatively large scales, this consumption
of computing resources may become prohibitive.
[0094] In some embodiments a blocking algorithm may be executed
during certain matrix operations, for example, when multiplying two
dense matrices or a dense matrix by a sparse matrix, to improve the
functioning of the computer system and reduce the amount of time
spent shifting data back and forth between levels of a memory
hierarchy. In some embodiments, upon initiating a matrix
multiplication, one or both of the matrices may be subdivided into
blocks (e.g., tiles), each having a plurality of contiguous values
within the respective matrix within a plurality of a sequence of
rows and columns, for instance, those values that are both in the
first 8 columns and in the first 8 rows might constitute one tile.
In some embodiments, tile size may be selected based on the amount
of available memory at various levels of a memory hierarchy, such
that a given tile can fit within a targeted level of the hierarchy,
like the level 2 or level 3 cache. Next, some embodiments may
iterate through the tiles, loading the tiles into a higher level of
the memory hierarchy, and then performing operations with that
tile. In some embodiments, a given tile, after being loaded into
the higher level the memory hierarchy, may be applied to update
each implicated value of a product matrix. In some cases, the
values of the product matrix may be initially set to zero, and then
those values may accumulate updates as tiles are loaded and
processed, until all of the tiles have been processed, and the
final value of the resultant matrix is known. In some cases,
updating a given value may include summing an existing value with
one or more products of values within a tile that has been loaded
into the higher level of the memory hierarchy. References to higher
and lower levels of memory hierarchy, rather than specific levels,
are intended to indicate the applicability of this approach to
different levels of the hierarchy, for example, the higher and
lower levels may be level 2 cache and dynamic random access memory
respectively or level 2 cache and level 3 cache respectively. In
some cases, multiple levels of tiling may be performed, e.g., a
tile loaded into cache may be sub-divided into register-sized
sub-tiles. In some cases, some of the techniques for accelerating
matrix or vector operations or conserving memory may be implemented
by invoking appropriate sequences of commands in a basic linear
algebra subroutine library, like level 1, 2, or 3 commands.
[0095] In some embodiments, the data visualization module 824 may
be operative to prepare data visualizations for display on user
devices, e.g., visualizations of the graphs described herein. In
some cases, such visualizations may include physics-based
arrangements of nodes within a display, like a force-directed
layout. In some cases, graph generation and visualization
preparation takes place on system 802, and resulting interactive
visualizations run (e.g., entirely) in a web browser of a user
device. In some cases, this entails displaying and manipulating
thousands of vertices and edges in an environment on user devices
not known for speed. At the same time, in some use cases, users
desire a relatively large amount of data on display, while keeping
a responsive frame rate. To increase frame rate, some embodiments
may use various techniques to optimize the network visualization
and make the computer system run faster, including invoking WebGL
commands to enlist a user's GPU in rendering a web page and
pre-processing.
[0096] Graphs of real-world information are often relatively
intricate. In some embodiments, visualizations may support
real-time (e.g., in this context, with less than 500 ms latency)
interactions with relatively large numbers of interactive objects,
e.g., more than 500, like more than 1,000, and in some cases as
many as 20,000 interactive objects with near zero latency. In some
embodiments, this speed is accomplished by pre-processing physics
models of graph layouts with a graphical processing units (GPUs) of
the system 802, to reduce the computational burden on less powerful
CPUs executing browsers on user devices. In some cases, displays
may be relatively high dimensional, e.g., various visual
attributes, like line weight, icon size, color, transparency, drop
shadow offsets, or properties of physical models, like inertia,
friction, attractive forces, repulsive forces, momentum, frequency
of oscillation, and the like, may be mapped to different dimensions
like those discussed above, e.g., similarity, relatedness,
sentiment, and the like. Connections tend to be more relatively
complicated and irregular, and embodiments often do not determine
the visual shape of the graph ahead of time. Indeed, graph
isomorphism provides for a relatively large number of visual
arrangements of otherwise identical graphs, but many arrangements
are relatively un-informative and difficult to visually parse to a
human user consuming the resultant data.
[0097] To visualize graph relations, some embodiments of module 824
may arrange vertices (also referred to as nodes) and edges using a
physics simulation that mimics the stretching of spider webs. Some
spider-web-inspired representations may model interactions between
each pair of vertices as a Coulomb-like repulsion and an additional
Hooke-like attraction in the presence of an edge between the pair.
A relatively weak gravitation-like force may be modeled to prevent
separate components and isolated vertices from venturing too far
from the network's center of mass. Thus, some embodiments may use
this physics-based network layout. In some cases, the parameters
and initial conditions of the physics based model may be determined
by module 824, and instructions for executing the model and
adjusting the model based on user input may be sent to the user
device, e.g., in the form of JavaScript.TM. instructions that
model, for instance, a user selecting and dragging a node as a
force applied to the physics model. Embodiments are expected to
appear relatively natural, and the hierarchy of a network's
structure is expected to be readily apparent; both small and large
network structures are exposed, which is expect to allow users to
study relationships between groups of vertices on different
scales.
[0098] Running a physics simulation in a user's browser can easily
exceed the available computing resources, as the simulation can be
inherently resource-intensive for larger, highly connected data
sets. To mitigate this issue, some embodiments may exploit
phenomena expected to arise as the size of the data scales. It is
expected that, in some embodiments, the number of time steps
consumed to achieve equilibrium starting with a random
configuration of vertices scales linearly with the number of
vertices. That is undesirable for presentation purposes (though
some embodiments are consistent with this approach, particularly
for smaller data sets). To mitigate this, some embodiments may
arrange for initial conditions of the simulation so the equilibrium
is attained faster.
[0099] To select initial conditions of the physics-based animation
of this n-body system, some embodiments may perform a gradient
descent optimization. Some embodiments may compute the gradient of
the modeled system's energy (e.g., based on the forces affecting
nodes), integrate that to compute momentum, and move the particles
in the simulation representing nodes accordingly. Initial
conditions of the gradient descent may be selected strategically in
some cases to mitigate the effects of local minima in what is
expected to be a relatively rough energy landscape (though
embodiments are also consistent with random selection of initial
conditions, like with a stochastic gradient descent). For instance,
some embodiments may seed the simulation with a vertex
configuration that is in the vicinity of the final destination. To
this end, some embodiments may execute a discretized version of the
problem and search through all vertex configurations on a 2D
grid.
[0100] This process is still of combinatorial complexity, however,
and may be generally too expensive for some larger graphs. To
mitigate this issue further some embodiments may simplify the
search space to one dimension with space filling curves, like a
z-curve or Hilbert curve that cover a 2D region of space with a
one-dimensional curve. Such space-filling curves may be constructed
via an iterative process, whereby at each step of the iteration the
curve is refined at ever-finer scales. By ceasing iterations at a
finite step, some embodiments may obtain a curve with just enough
points to accommodate the data at issue. Further benefits, in some
embodiments may arise from the property of some space filling
curves: the 2D distance between any pair of vertices is
well-approximated by (the square root of) the distance along the
curve. In this scenario, in some embodiments, the problem of
finding an approximate 2D layout is equivalent to finding an
energy-optimal linear ordering of vertices, which some embodiments
may use to implement less computationally intensive heuristics,
circumventing the initial combinatorial complexity. That said, not
all embodiments provide this benefit, as the various inventions
described herein are independently useful.
[0101] FIG. 11 is a diagram that illustrates an exemplary computing
system 1000 in accordance with embodiments of the present
technique. Various portions of systems and methods described
herein, may include or be executed on one or more computer systems
similar to computing system 1000. Further, processes and modules
described herein may be executed by one or more processing systems
similar to that of computing system 1000.
[0102] Computing system 1000 may include one or more processors
(e.g., processors 1010a-1010n) coupled to system memory 1020, an
input/output I/O device interface 1030, and a network interface
1040 via an input/output (I/O) interface 1050. A processor may
include a single processor or a plurality of processors (e.g.,
distributed processors). A processor may be any suitable processor
capable of executing or otherwise performing instructions. A
processor may include a central processing unit (CPU) that carries
out program instructions to perform the arithmetical, logical, and
input/output operations of computing system 1000. A processor may
execute code (e.g., processor firmware, a protocol stack, a
database management system, an operating system, or a combination
thereof) that creates an execution environment for program
instructions. A processor may include a programmable processor. A
processor may include general or special purpose microprocessors. A
processor may receive instructions and data from a memory (e.g.,
system memory 1020). Computing system 1000 may be a uni-processor
system including one processor (e.g., processor 1010a), or a
multi-processor system including any number of suitable processors
(e.g., 1010a-1010n). Multiple processors may be employed to provide
for parallel or sequential execution of one or more portions of the
techniques described herein. Processes, such as logic flows,
described herein may be performed by one or more programmable
processors executing one or more computer programs to perform
functions by operating on input data and generating corresponding
output. Processes described herein may be performed by, and
apparatus can also be implemented as, special purpose logic
circuitry, e.g., an FPGA (field programmable gate array) or an ASIC
(application specific integrated circuit). Computing system 1000
may include a plurality of computing devices (e.g., distributed
computer systems) to implement various processing functions.
[0103] I/O device interface 1030 may provide an interface for
connection of one or more I/O devices 1060 to computer system 1000.
I/O devices may include devices that receive input (e.g., from a
user) or output information (e.g., to a user). I/O devices 1060 may
include, for example, graphical user interface presented on
displays (e.g., a cathode ray tube (CRT) or liquid crystal display
(LCD) monitor), pointing devices (e.g., a computer mouse or
trackball), keyboards, keypads, touchpads, scanning devices, voice
recognition devices, gesture recognition devices, printers, audio
speakers, microphones, cameras, or the like. I/O devices 1060 may
be connected to computer system 1000 through a wired or wireless
connection. I/O devices 1060 may be connected to computer system
1000 from a remote location. I/O devices 1060 located on remote
computer system, for example, may be connected to computer system
1000 via a network and network interface 1040.
[0104] Network interface 1040 may include a network adapter that
provides for connection of computer system 1000 to a network.
Network interface may 1040 may facilitate data exchange between
computer system 1000 and other devices connected to the network.
Network interface 1040 may support wired or wireless communication.
The network may include an electronic communication network, such
as the Internet, a local area network (LAN), a wide area network
(WAN), a cellular communications network, or the like.
[0105] System memory 1020 may be configured to store program
instructions 1100 or data 1110. Program instructions 1100 may be
executable by a processor (e.g., one or more of processors
1010a-1010n) to implement one or more embodiments of the present
techniques. Instructions 1100 may include modules of computer
program instructions for implementing one or more techniques
described herein with regard to various processing modules. Program
instructions may include a computer program (which in certain forms
is known as a program, software, software application, script, or
code). A computer program may be written in a programming language,
including compiled or interpreted languages, or declarative or
procedural languages. A computer program may include a unit
suitable for use in a computing environment, including as a
stand-alone program, a module, a component, or a subroutine. A
computer program may or may not correspond to a file in a file
system. A program may be stored in a portion of a file that holds
other programs or data (e.g., one or more scripts stored in a
markup language document), in a single file dedicated to the
program in question, or in multiple coordinated files (e.g., files
that store one or more modules, sub programs, or portions of code).
A computer program may be deployed to be executed on one or more
computer processors located locally at one site or distributed
across multiple remote sites and interconnected by a communication
network.
[0106] System memory 1020 may include a tangible program carrier
having program instructions stored thereon. A tangible program
carrier may include a non-transitory computer readable storage
medium. A non-transitory computer readable storage medium may
include a machine readable storage device, a machine readable
storage substrate, a memory device, or any combination thereof.
Non-transitory computer readable storage medium may include
non-volatile memory (e.g., flash memory, ROM, PROM, EPROM, EEPROM
memory), volatile memory (e.g., random access memory (RAM), static
random access memory (SRAM), synchronous dynamic RAM (SDRAM)), bulk
storage memory (e.g., CD-ROM and/or DVD-ROM, hard-drives), or the
like. System memory 1020 may include a non-transitory computer
readable storage medium that may have program instructions stored
thereon that are executable by a computer processor (e.g., one or
more of processors 1010a-1010n) to cause the subject matter and the
functional operations described herein. A memory (e.g., system
memory 1020) may include a single memory device and/or a plurality
of memory devices (e.g., distributed memory devices). Instructions
or other program code to provide the functionality described herein
may be stored on a tangible, non-transitory computer readable
media. In some cases, the entire set of instructions may be stored
concurrently on the media, or in some cases, different parts of the
instructions may be stored on the same media at different times,
e.g., a copy may be created by writing program code to a
first-in-first-out buffer in a network interface, where some of the
instructions are pushed out of the buffer before other portions of
the instructions are written to the buffer, with all of the
instructions residing in memory on the buffer, just not all at the
same time.
[0107] I/O interface 1050 may be configured to coordinate I/O
traffic between processors 1010a-1010n, system memory 1020, network
interface 1040, I/O devices 1060, and/or other peripheral devices.
I/O interface 1050 may perform protocol, timing, or other data
transformations to convert data signals from one component (e.g.,
system memory 1020) into a format suitable for use by another
component (e.g., processors 1010a-1010n). I/O interface 1050 may
include support for devices attached through various types of
peripheral buses, such as a variant of the Peripheral Component
Interconnect (PCI) bus standard or the Universal Serial Bus (USB)
standard.
[0108] Embodiments of the techniques described herein may be
implemented using a single instance of computer system 1000 or
multiple computer systems 1000 configured to host different
portions or instances of embodiments. Multiple computer systems
1000 may provide for parallel or sequential processing/execution of
one or more portions of the techniques described herein.
[0109] Those skilled in the art will appreciate that computer
system 1000 is merely illustrative and is not intended to limit the
scope of the techniques described herein. Computer system 1000 may
include any combination of devices or software that may perform or
otherwise provide for the performance of the techniques described
herein. For example, computer system 1000 may include or be a
combination of a cloud-computing system, a data center, a server
rack, a server, a virtual server, a desktop computer, a laptop
computer, a tablet computer, a server device, a client device, a
mobile telephone, a personal digital assistant (PDA), a mobile
audio or video player, a game console, a vehicle-mounted computer,
or a Global Positioning System (GPS), or the like. Computer system
1000 may also be connected to other devices that are not
illustrated, or may operate as a stand-alone system. In addition,
the functionality provided by the illustrated components may in
some embodiments be combined in fewer components or distributed in
additional components. Similarly, in some embodiments, the
functionality of some of the illustrated components may not be
provided or other additional functionality may be available.
[0110] Those skilled in the art will also appreciate that while
various items are illustrated as being stored in memory or on
storage while being used, these items or portions of them may be
transferred between memory and other storage devices for purposes
of memory management and data integrity. Alternatively, in other
embodiments some or all of the software components may execute in
memory on another device and communicate with the illustrated
computer system via inter-computer communication. Some or all of
the system components or data structures may also be stored (e.g.,
as instructions or structured data) on a computer-accessible medium
or a portable article to be read by an appropriate drive, various
examples of which are described above. In some embodiments,
instructions stored on a computer-accessible medium separate from
computer system 1000 may be transmitted to computer system 1000 via
transmission media or signals such as electrical, electromagnetic,
or digital signals, conveyed via a communication medium such as a
network or a wireless link. Various embodiments may further include
receiving, sending, or storing instructions or data implemented in
accordance with the foregoing description upon a
computer-accessible medium. Accordingly, the present invention may
be practiced with other computer system configurations.
[0111] In block diagrams, illustrated components are depicted as
discrete functional blocks, but embodiments are not limited to
systems in which the functionality described herein is organized as
illustrated. The functionality provided by each of the components
may be provided by software or hardware modules that are
differently organized than is presently depicted, for example such
software or hardware may be intermingled, conjoined, replicated,
broken up, distributed (e.g. within a data center or
geographically), or otherwise differently organized. The
functionality described herein may be provided by one or more
processors of one or more computers executing code stored on a
tangible, non-transitory, machine readable medium. In some cases,
third party content delivery networks may host some or all of the
information conveyed over networks, in which case, to the extent
information (e.g., content) is said to be supplied or otherwise
provided, the information may provided by sending instructions to
retrieve that information from a content delivery network.
[0112] The reader should appreciate that the present application
describes several inventions. Rather than separating those
inventions into multiple isolated patent applications, applicants
have grouped these inventions into a single document because their
related subject matter lends itself to economies in the application
process. But the distinct advantages and aspects of such inventions
should not be conflated. In some cases, embodiments address all of
the deficiencies noted herein, but it should be understood that the
inventions are independently useful, and some embodiments address
only a subset of such problems or offer other, unmentioned benefits
that will be apparent to those of skill in the art reviewing the
present disclosure. Due to costs constraints, some inventions
disclosed herein may not be presently claimed and may be claimed in
later filings, such as continuation applications or by amending the
present claims. Similarly, due to space constraints, neither the
Abstract nor the Summary of the Invention sections of the present
document should be taken as containing a comprehensive listing of
all such inventions or all aspects of such inventions.
[0113] It should be understood that the description and the
drawings are not intended to limit the invention to the particular
form disclosed, but to the contrary, the intention is to cover all
modifications, equivalents, and alternatives falling within the
spirit and scope of the present invention as defined by the
appended claims. Further modifications and alternative embodiments
of various aspects of the invention will be apparent to those
skilled in the art in view of this description. Accordingly, this
description and the drawings are to be construed as illustrative
only and are for the purpose of teaching those skilled in the art
the general manner of carrying out the invention. It is to be
understood that the forms of the invention shown and described
herein are to be taken as examples of embodiments. Elements and
materials may be substituted for those illustrated and described
herein, parts and processes may be reversed or omitted, and certain
features of the invention may be utilized independently, all as
would be apparent to one skilled in the art after having the
benefit of this description of the invention. Changes may be made
in the elements described herein without departing from the spirit
and scope of the invention as described in the following claims.
Headings used herein are for organizational purposes only and are
not meant to be used to limit the scope of the description.
[0114] As used throughout this application, the word "may" is used
in a permissive sense (i.e., meaning having the potential to),
rather than the mandatory sense (i.e., meaning must). The words
"include", "including", and "includes" and the like mean including,
but not limited to. As used throughout this application, the
singular forms "a," "an," and "the" include plural referents unless
the content explicitly indicates otherwise. Thus, for example,
reference to "an element" or "a element" includes a combination of
two or more elements, notwithstanding use of other terms and
phrases for one or more elements, such as "one or more." The term
"or" is, unless indicated otherwise, non-exclusive, i.e.,
encompassing both "and" and "or." Terms describing conditional
relationships, e.g., "in response to X, Y," "upon X, Y,", "if X,
Y," "when X, Y," and the like, encompass causal relationships in
which the antecedent is a necessary causal condition, the
antecedent is a sufficient causal condition, or the antecedent is a
contributory causal condition of the consequent, e.g., "state X
occurs upon condition Y obtaining" is generic to "X occurs solely
upon Y" and "X occurs upon Y and Z." Such conditional relationships
are not limited to consequences that instantly follow the
antecedent obtaining, as some consequences may be delayed, and in
conditional statements, antecedents are connected to their
consequents, e.g., the antecedent is relevant to the likelihood of
the consequent occurring. Statements in which a plurality of
attributes or functions are mapped to a plurality of objects (e.g.,
one or more processors performing steps A, B, C, and D) encompasses
both all such attributes or functions being mapped to all such
objects and subsets of the attributes or functions being mapped to
subsets of the attributes or functions (e.g., both all processors
each performing steps A-D, and a case in which processor 1 performs
step A, processor 2 performs step B and part of step C, and
processor 3 performs part of step C and step D), unless otherwise
indicated. Further, unless otherwise indicated, statements that one
value or action is "based on" another condition or value encompass
both instances in which the condition or value is the sole factor
and instances in which the condition or value is one factor among a
plurality of factors. Unless otherwise indicated, statements that
"each" instance of some collection have some property should not be
read to exclude cases where some otherwise identical or similar
members of a larger collection do not have the property, i.e., each
does not necessarily mean each and every. Limitations as to
sequence of recited steps should not be read into the claims unless
explicitly specified, e.g., with explicit language like "after
performing X, performing Y," in contrast to statements that might
be improperly argued to imply sequence limitations, like
"performing X on items, performing Y on the X'ed items," used for
purposes of making claims more readable rather than specifying
sequence. Unless specifically stated otherwise, as apparent from
the discussion, it is appreciated that throughout this
specification discussions utilizing terms such as "processing,"
"computing," "calculating," "determining" or the like refer to
actions or processes of a specific apparatus, such as a special
purpose computer or a similar special purpose electronic
processing/computing device.
[0115] The present techniques will be better understood with
reference to the following enumerated embodiments:
1. A method of refining Boolean queries, the method comprising:
obtaining, with one or more processors, a query provided by a user
via a user's computing device; searching, with one or more
processors, a corpus of documents based on the query to identify
responsive documents, the corpus having more than 2,000 documents;
selecting, with one or more processors, narrowing terms that
pertain to respective subsets of the responsive documents;
selecting, with one or more processors, broadening terms related to
the query; instructing, with one or more processors, the user's
computing device to present a graphical user interface comprising:
graphical representations of the narrowing terms; graphical
representations of the broadening terms; and one or more user
inputs by which the user refines the query by adding a selected
narrowing term or a selected broadening term; obtaining, with one
or more processors, a user selection of a broadening term or a
narrowing term; forming, with one or more processors, a refined
query based on the user selection; searching, with one or more
processors, at least part of the corpus based on the refined query
to identify refined responsive documents; and instructing, with one
or more processors, the user's computing device to present an
updated graphical user interface with information about the refined
responsive documents. 2. The method of embodiment 1, wherein the
graphical user interface comprises: a plurality of graphical
regions, each graphical region corresponding to one of the
narrowing terms, wherein a spatial dimension of each graphical
region is selected based on an amount of the responsive documents
responsive to a refined query including the respective term as a
conjunctive addition to the query. 3. The method of embodiment 2,
wherein the spatial dimensions are assigned by performing steps for
partitioning a plane. 4. The method of embodiment 1, wherein the
graphical user interface comprises: a plurality of graphical
regions, each graphical region corresponding to one of the
narrowing terms, wherein a visual weight or size of each graphical
region is selected based on an amount of the responsive documents
responsive to a refined query including the respective term as a
conjunctive addition to the query. 5. The method of any of
embodiments 1-4, wherein the graphical user interface comprises: a
positive conjunctive input selector for each narrowing term; and a
negative conjunctive input selector for each narrowing term. 6. The
method of any of embodiments 1-5, wherein the graphical user
interface comprises: a positive disjunctive input selector for each
broadening term; and a negative disjunctive input selector for each
broadening term. 7. The method of any of embodiments 1-6, wherein
forming a refined query comprises: refactoring a Boolean query
combining a plurality of narrowing terms and a plurality of
broadening terms to shorten the Boolean query. 8. The method of any
of embodiments 1-7, wherein the graphical user interface comprises:
a query entry input having graphical regions representing query
constituent components and user-selectable inputs for each of the
components by which the respective component is removed from the
query. 9. The method of embodiment 8, wherein: the graphical
regions each have a respective non-textual visual attribute
indicative of whether the respective graphical region corresponds
to a positive conjunctive query element, a negative conjunctive
query element, an positive disjunctive query element, or a negative
disjunctive query element, and the graphical regions are added to
the graphical user interface by inserting a specification for the
graphical regions into a document object model for the graphical
user interface with scripting code executed within a web browser
responsive to one or more event handlers mapped to inputs by which
the user requests the addition of the corresponding query elements.
10. The method of any of embodiments 1-9, wherein the narrowing
terms are selected by performing steps for selecting narrowing
terms. 11. The method of any of embodiments 1-10, wherein the
broadening terms are selected by performing steps for selecting
broadening terms. 12. The method of any of embodiments 1-11,
comprising: after selecting the broadening terms pre-processing
candidate search results for a refined query based on one of the
broadening terms before the one of the broadening terms is selected
by the user.
[0116] 13. The method of any of embodiments 1-12, comprising:
iteratively presenting query results and broadening terms and
narrowing terms corresponding to those query results each time the
user selects one or more broadening or narrowing terms through at
least three iterations.
14. The method of any of embodiments 1-13, comprising: iteratively
presenting query results and broadening terms and narrowing terms
corresponding to those query results each time the user selects and
submits one or more broadening or narrowing terms. 15. The method
of any of embodiments 1-14, wherein the graphical user interface
comprises: means for selecting among a plurality of filters for the
search results, wherein the refined responsive documents both
satisfy a user-selected filter and the refined query. 16. The
method of any of embodiments 1-15, wherein a plurality of
categories of narrowing terms are selected, and wherein the
graphical user interfaces comprises a plurality of inputs for
faceted selection of the narrowing terms by category. 17. The
method of any of embodiments 1-16, comprising: receiving a user
selection of a narrowing term; and before the narrowing term is
added to the refined query, causing the user device to present at
least part of a plurality of documents to which the selected
narrowing term pertains. 18. The method of embodiment 17,
comprising: presenting a time-series graphical representation of
amounts of documents to which the selected narrowing term applies.
19. The method of any of embodiments 1-18, comprising: receiving
another user selection of another term after forming the refined
query; and in response to receiving the other user selection,
embedding the refined query in parentheses and then forming another
refined query with the other term outside of the parenthesis. 20.
The method of any of embodiments 1-19, comprising: before obtaining
the query, obtaining the corpus, the corpus comprising more than
5000 documents; for each document in the corpus, with one or more
processers: determining a respective n-gram vector, each n-gram
vector comprising a plurality of values each indicating presence of
a respective n-gram in text of the respective document, wherein the
n-gram vectors indicate at least 500 values and correspond to at
least some n-grams including three words; and determining scores
indicating an amount of semantic similarity relative to the other
documents in the analyzed corpus based on angles between the n-gram
vector of the respective document and n-gram vectors of the other
documents in the analyzed corpus; wherein presenting information
about the refined responsive documents comprises presenting a
force-directed graph of the responsive documents wherein at least
one parameter of a physics model of the force directed graph
corresponds to scores indicating the amount of semantic similarity.
21. A system, comprising: one or more processors; and memory
storing instructions that when executed by the processors cause the
processors to effectuate operations comprising those of any of
embodiments 1-20. 22. A tangible, non-transitory, machine readable
medium storing instructions that when executed by processors cause
the processors to effectuate operations comprising those of any of
embodiments 1-20.
* * * * *