| Student | Title | Type | Vision | Steps |
| Matthew Bilotti |
Machine Translation using a Jackendoff Substrate |
Idea, implementation, experiment |
If we are to develop robust, high-quality machine translation
techniques on a restricted domain such as spatial relations among
objects and motion of objects along paths, we will need to develop a
convenient interlingual representational substrate to which natural
language text can be parsed and from which natural language text can
be generated.
|
Present an Italian-language generator for Jackendoff
Lexical-Conceptual Structure capable of giving textual
descriptions of events in a simulated world;
interface the generator with an available English-language
Lexical-Conceptual Structure recognizer; and
demonstrate a minimal machine translation system.
|
| Ruggiero Cavallo |
Evaluating common assumptions of AI |
Idea, examination, analysis |
In the face of imperfect knowledge, scientists are often compelled to make
assumptions–regarding both the human mind and the external world–in order
to achieve progress. This might be viewed as a "necessary risk," but it's
a risk nonetheless, because false assumptions are unappealing to those who
loathe delusion, and/or can impede scientific progress. Thus, it's a good
idea to stop occasionally to make sure that our assumptions and opinions
are still both necessary and "optimal" given what we know.
|
My first step will be to choose and examine a small subset of the
prevailing opinions/assumptions in AI and their bases. For example, one
common assumption of AI researchers during the early years was that the
mundane tasks of everyday human life would be easy to model, and that
"smart" behaviors (e.g., playing chess) would be hardest to implement
artificially. This assumption has turned out wrong. I will try to select a
set of assumptions for evaluation that, if wrong, could potentially be
hindering AI research in making progress towards either of the following
two very related goals: first, building large-scale intelligent systems,
and second, understanding the workings of the human mind through
computational models. In most cases, assumptions are made because we cannot
currently come up with scientific "solutions" or "proofs." For this reason
and others, to properly evaluate the status quo, an important ingredient
will be the incorporation of work done in philosophy. In this regard the
project will also serve to explore the ways in which philosophy and
computer science (particularly AI) can enrich each other.
|
| Stefanie Chiou and Benjamin Ross |
Learning to Bid in Bridge Using Lexical Attraction |
Idea, implementation, experiment |
We plan to explore lexical attraction as a mechanism for learning tasks
other than language. In particular, we will examine the use lexical
attraction to learn how to bid in bridge. In doing so, we need to provide
some constraints on the lexical attraction model so that only legal bidding
behavior is allowed. For example, one such rule will be that all bids must
be greater than zero. This rule cannot be learned by the lexical
attraction model because it does not have any ability to generalize. To
see why, consider the case where the machine bids -1 points. If the
trainer then says that the machine loses the hand, the machine might
attempt to bid -2, or any other number of points. In the end, since there
is no bound on the set of natural numbers, the machine can choose any
number from negative infinity to positive infinity, and will never
generalize that the required number is between 0 and 9.
|
We will implement Yuret's lexical attraction system in Java along with the
rules for bidding in bridge. The system will be trained over a large
training set. After the training is completed, it be tested over a smaller
set to determine its accuracy in bidding on hands it has never seen before.
The accuracy will be treated as an indication of how well the system has
learned how to bid on bridge hands.
|
| Chris Crick |
Language Learning Through Gossip |
Implementation and experiment |
Kirby's language learners don't have much to talk about, and their
conversations are made completely at random. Real language develops
to talk about events in the real world. Two speakers witnessing an
event might want to discuss different aspects of the experience, or
even interpret the event differently. Watching an important event
motivates us to tell stories about it to people who weren't there, who
might then begin to spread increasingly inaccurate versions of the
truth. Humans interact through storytelling, rumormongering and
gossip; can a network of agents learn language under the same
conditions?
|
Reimplement Kirby's system, but with a more sophisticated event model.
Two agents might see the same event and try to communicate the same
idea to each other. Both agents might see an event, but their take on
it might not agree (one wants to say "The ball fell", the other "The
ball made a noise", for instance). Only one agent may have seen an
event, and it communcates what it saw to its neighbor. An agent may
not even have seen an event, but hears about it and wants to pass it
on to someone else (who may or may not have seen the event itself).
Analyze what kind of language emerges under these circumstances.
|
| Shaun Duffy |
Using Word Co-occurrence to Help Close the Knowledge Gap |
Idea, implementation, experiment |
What can Borchardt's "living book" system do if it does not have enough
information to provide an answer? I believe a powerful tool would be
one that searches through related topics for information that could be
of help. My vision is to essentially create a "related terms" algorithm
that uses word co-occurrence to determine what words are related to
other words.
|
I intend to construct a program that takes in a set of statements and
analyzes them in order to gauge the strength of relationships between
different words. Written in Java, my program should scan a corpus of
words, calculate a "closeness coefficient" from each word to every
other word, and then be prepared to generate a list of the most closely
related terms for any word the user chooses. These values will be kept
in a table for easy access and modification.
|
| Edward Faulkner |
Hiearchical Classification with Intermediate Complexity Features |
Idea, implementation, experiment |
The impressive capabilities of the human mind are closely tied to its
ability to manipulate visual information. In order to build systems with
human-like intelligence, we must study the human visual system and attempt
to duplicate it. An important human ability that continues to elude
computer systems is object recognition. Shimon Ullman claims that features
of intermediate complexity (IC) play a key role in object recognition. I
propose to extend Ullman's system to attempt hierarchical classification.
For example, instead of sorting a group of images into those which depict
cars and those that do not, I hope to further sort the car images into
station wagons, vans, and sedans.
|
I will reimplement Ullman's classification system using
Matlab, and run it multiple times over the same data, attempting to
classify various subsets. I plan to answer the following questions:
Is there a useful hierarchy of IC features? Does the optimal feature
size change as we move up and down the hiearchy? How high up the
hierarchy can visual classification go before classes become too
abstract for purely visual identification?
|
| Vikash Gilja |
Building Visual Routines from Semantics |
Project Proposal with Motivating Examples |
To build an efficient learner of visual and linguistic regularities, we
must explore the connection between these two modalities.
|
I have chosen to explore how a language based visuospatial
descriptions and a visual scene can provide the constraints necessary to
build a visual routine. Based on the work of Jackendoff, I assume that the
linguistic input can be transformed into lexical-conceptual semantics
(LCS). As a first step, I will develop and motivate a set of primitive
visual operations based upon the elements of LCS. Next, I plan to work out
example transformations from LCS to visual routines for specific visual
scenes. From there, I hope to develop a set of heuristics that correctly
produce such transformations, possibly based on bi-directional search and
near-miss learning. |
|
Jonathan Goler and Jesse Smithnosky
|
Identifying Objects using Thread Memory and a Vision Stub |
Project Proposal with Motivating Examples |
We are interested not only in how memory is stored, but also how
it is able to direct a line of reasoning to identify an observed object.
We plan to extend thread memory by including questions that the memory
system could ask the visual system. These questions should provide insight
when trying to resolve a single thread from a thread grouping. It is our
goal to create a working system that can identify simple objects with
inputs that could reasonably be generated by a computer vision system.
|
First we will create an implementation of thread memory. The system will
be trained with 100 hand-coded examples of threads that could be generated
from children's books. Next, we will define a set of questions that could
reasonably be asked of a computer vision system. Possibly examples include
"What color is the object?" and "Does the object possess bilateral
symmetry?" At each node we will find differences between threads and use
them to construct questions to ask of the visual input system. It is our
hope that this process will allow our system to correctly identify objects.
|
| Kaijen Hsiao |
Perception and Representation of Action |
Area Exam |
If we are ever to make a computer/robot that is able to learn by watching
(and possibly imitating) human actions, we must understand how to perceive,
understand, and represent actions.
|
Learn about current research in the perception and representation of action,
with an eye toward segmenting and determining the purpose/effects of human
movement in order to imitate the observed actions and apply them to new
situations.
|
| Anthony Kim |
Bootstrapping syntax with Kirby-learning in a physical world of trajectories |
Idea, implementation, experiment |
Kirby demonstrated that syntax can evolve with no prior linguistic
knowledge and no selection tendencies. I propose that learners can develop
a more complex syntax given a semantic domain of Jackendoff's LCS
structures. By communicating with a physical world of trajectories and
exchanging utterances, learners should develop a grammar that
has the expressive power of describing basic physical movements.
|
I will first study the latest work of Kirby to see how he may have
already chosen to extend his semantic domain. I will then implement a
"Kirby-like" simulation in Java which focuses on individuals learning a
syntax instead of the evolution of language; this simulation will use a
sequence of LCS structures and a sequence of utterances. Finally, I will
test the simulation to see how different kinds of trajectories can
influence the resulting syntax.
|
| Hans Lee |
Coupling vision and language through visual routines and linguistic cues |
Idea, implementation, experiment |
To develop a model of human visual attention and perception, we must
understand the premises on which they are based. I believe that one of the
keys to understanding visual attention and perception is the link between
language and all other i/o systems in the human body. When infants are
learning about their environment, the people around them repeat the names
of objects and actions many times to make them easy to recognize. Using
visual routines with linguistic cues and a proper representation would
allow for a more dynamic interaction and faster learning about the
environment surrounding visual systems.
|
First, Analyze Rao’s thesis and Gary Drescher’s Schemas to create an
initial design for a visual routine learning system. Second, formalize the
system and evaluate its strengths and weaknesses. Third, implement a
working visual routines system using a live camera that would allow hand
coded visual routines to be implemented. Finally, implement a learning
system for visual routines based on the knowledge learned from the first 3
stages. The first three parts will be completed by the presentation date.
The fourth stage, which is quite complex, will be started, and the work in
progress will be presented on the presentation day. A definable metric for
the success of this system will be its understanding of the objects around
it ( People, toys) and simple actions that it sees ( rolling, bouncing,
dropping).
|
| Karen Liu |
Learning and synthesizing socially appropriate conversational responses |
Idea, implementation, experiment |
To build robots/machines that will be able to develop long-term interactions with humans, we need
to design robots that can determine and synthesize appropriate social and natural responses through
actions and/or conversation. One problem that machines currently face is being able to construct
new conversational responses, in order to avoid repetitiveness in long-term interactions, given the
limited repertoire of responses that it currently knows.
|
Establish a taxonomy of "conversational types." Develop an algorithm that uses a similar idea to
Yuret's lexical attraction models to group different types of conversational speech (i.e. jokes,
greetings, backchannel utterances) and have positive and negative user feedback to
evaluate the groupings. Using these groupings of conversation, develop ways of blending the sentences
in the current repertoire of known speech or gaining new words (i.e. thesaurus, commonsense database)
to create new ways of responding within the same conversational type.
|
| Vikash K. Mansinghka |
2D Visual Perception by Combining Marr and Ullman |
Idea, implementation, experiment |
To understand visual perception, we must understand how to combine powerful
ideas (such as Marr's primal-sketch idea and Ullman's visual routines and
bidirectional search ideas) into powerful new theories that account for the
perception of, say, structure and motion. More generally, we must
concretely identify the perceptual problems such combinations are able to
solve.
|
Identify the precise ways in which Marr's ideas and Ullman's ideas
could be used to inform one another in the context of perception of
"flipbook-style" 2D line-drawing animations. Implement a Java vision
system structured according to these ideas which can consistently
match extracted primal-sketch-like representations from these
animations with learned models. Identify subsystems which perform
poorly (and what input conditions they are sensitive to) by analyzing
performance on a series of manually generated test cases.
|
| Alisa Marshall |
Improving Lexical Models of Language |
Idea, implementation, experiment |
Yuret's Lexical Model of Language doesn't display the best of accuracy even
under the best of circumstances. The best accuracy shown was 77.4%
when the
training and testing sets were the same. Words that can be used as both a
verb or a noun will cause errors as they can't be distinguished from
each other, therefor a sentense can be misparsed.
|
Using the annotated Penn Treebank corpus, reimplement Yuret's lexical
model. Test on words that have two distinct meanings and see how well it
performs. Then try to find patterns in the words that have distinct
meanings so that they can be pulled apart so that sentences containing the
less common meaning of the word may still be parsed correctly.
|
| Austin Casey McNurlen |
Primitive-Based Intelligence |
Idea, implementation, experiment |
To develop a description of human intelligence that can describe how humans
think about and solve any problem, especially analytical ones. The big
idea of the approach is complex thought is just clever combinations of
little knowledge nuggets called primitives.
|
Describe and formalize the approach and algorithm, and discuss how
the idea is based off of phenomenon observed in human problem solving.
Create a general architecture in Java that can take in primitives, and then
use them to solve problems based off of the primitives given to it. Create
several test primitive sets and questions for them in a couple of different
subject areas.
|
| Erik Nordlander |
Transition Space Representations for Legal Rights |
Idea, implementation, experiment |
Legal writing in contracts and other agreements can be some of the most the
complex prose for a layperson to understand, while at the same time can
seem clear to an informed reader. Most people desire to understand how
their rights will change as the result of agreeing to a particular
document. Most legal rights change in a way consistent with a Borchardt
representation. My goal is to present a clear transition diagram based
explanation of how a person’s rights will change because of a particular
legal document.
|
Create a transition-space inspired language for representing a specific set
of legal rights. Next, create a simple parser in Java that can recognize
key sentences that alter a person’s legal rights, given a particular
document. Moving through the document, it should be able to output the
representation at any point so that salient regions of text can be
identified, and if needed highlighted for the user.
|
| Jennifer Novosad, Deepali Garg |
Kirby's Language Evolution Program: Performance in a Varied Setting |
Idea, implementation, experiment |
If we are to understand how language develops as a learned behavior,
we must develop model learner communities and test these learners in
various environments. Kirby has shown how language develops when the
whole population forms a large group. We expect that the development
of language differs when the population is divided into groups with
only one member of each group participating as an inter-group
communicator. |
The success of this project requires the completion of
four big steps. First, we must develop a
comprehensive understanding of Kirby's work as
described in his paper entitled Language Evolution
without Natural Selection. Secondly, we must research
the methods Kirby uses. The third step is to compile
our understanding of Kirby's work and our research of
his methods and develop an Scheme implementation of his work.
The final step is to introduce the variation to test
the robustness of the program by varying the
parameters, and settings. |
| Leah Oats and Pius A. Uzamere II |
Using Artificial Intelligence to Improve the Results of Negotiation |
Idea, implementation, experiment |
Using a generalization of the McKelvey Chaos Theorem, it can be shown that
multi-party negotiations are chaotic and can lead to absurdly sub-optimal
results if no limitations are placed on the potential solutions that are
proposed by each party or the mediator, if any. Through the use of
artificial intelligence, computers can increase the likelihood of optimal
results.
|
Although we need to narrow down which of these steps we will focus on, we
have determined that the following are steps toward making our vision a
reality.
Parameterize issue space (that is, determine dimensions of arbitrary issues and be able to quantify and scale the axes).
Compute ordered pair for the ideal points of negotiating parties (that is, determine where a negotiator's beliefs fit into the issue space).
Compute indifference curves of negotiators (that is, given some proposal, what are the other proposals that are equivalently "good" according to some negotiator).
Compute ordered pair for arbitrary proposals that can come up in negotiation (where do they fit into the issue space).
|
| Dan Ramage | Teaching a Computer to Tell Jokes: A Computational Model of Humor of Looney Tunes |
Idea, implementation, experiment |
No computational model of human understanding can be considered complete
without a well developed model of humor, nor can a computer comprehend
interactions with human users unless it understands when they are joking.
To that end, I propose a computation model of several types of humor. In
particular, I want a computer to be able to tell jokes.
|
Establish a taxonomy of joke types. Select one to examine
(cartoon humor). Construct a computational model of the humor form (naive
physics violations as embodied in transition spaces). Construct a program
capable of transforming an appropriate situation into a joke. Evaluate the
jokes' funniness.
|
| John Rondoni |
Physical Activity Transition Detection with Borchardt's Transition Space Representation |
Idea, Implementation, Experiment |
For computer systems to understand people well enough to interact meaningfully with them at appropriate
times they must be aware not only of human physical activites, but the transistions between them.
Ideally, the computational mechanism responisble for this would be closely related to computer sysetms
ability to reason about and recognize physical behavior.
|
I will modify Borchardt's change characterizations to form a basis for the space of sensor features
applicable to detecting transitions in human physical activities, such as transitions between sitting,
standing, and walking. The features the system will reason about will be extracted from a Polar heart
rate monitor and a planar accelerometer attached to the subject's left thigh. I will implement and
test a program capable of leaning which subset of feature change characteristics are indicitive of
transitions in human physical activity. My hypothesis is that some small set of feature change
characteristics will be able to reliably identify such transistions.
|
| Gaylee Saliba |
Visual Routines Call for Better Representations |
Research Proposal with Motivating Examples |
If we are to understand how the brain uses patterns of visual attention
to learn visual routines, we need better representational apparatus to describe
such routines, for they capture physical events in the real world. |
Interlace Rao and Bordchart's models by building a Bordchart
Transition Space Representation that incorporates the primitive operations
found in Rao's model. Speculate on how well Bordchart’s language would work as
a representation for describing Rao’s visual routines, so as to enable the
modeling of visual events. The model will be demonstrated through a set of
examples drawn from the possible actions in the Blob World of the Bridge
Project. |
| J.D. Zamfirescu |
Matching Kirby with Human Language |
Idea, implementation, experiment |
In order to understand fully the implications of Kirby's hypothesis that
language may come from a simple system of observational learning, we must find
the limits of that system, that is, we must determine the degree to which
Kirby's hypothesis accounts for various aspects of
human language previously thought to be effects of the Universal Grammar.
Particular candidate aspects for study include fully recursive syntax, a larger
meaning space, non-guaranteed understanding of utterances, and the increased
presence of verbal noise.
|
I will begin by implementing Kirby's siulation (2001) in Java, keeping in mind
the ways in which I plan to expand it. I will implement a meaning space that
is not only sentence-wise recursive but also phrase-wise recursive (i.e.,
includes prepositional chains, etc.). I will also introduce noise into the
understanding routine, that is, I will not guarantee that the meaning is
passed correctly from the speaker to the listener. Finally, I will introduce
noise in the system by sometimes modifying the utterance a speaker produces
before the listener hears it.
Time permitting, I may also implement a parser, so that instead of simply
"knowing" the meaning of an utterance, the learner will have to interpret the
meaning before adding it to its ruleset or modifying its ruleset as appropriate.
|
