natural language processing (9)

No coherent meaning without simulation. In the Bubble Lexicon graph, different and possibly conflicting meanings can attach to each word-concept node; therefore, words hardly have any coherent meaning in the static view. We suggest that when human minds think about what a word or phrase means, meaning is always evaluated in some context. Similarly, a word only becomes coherently meaningful in a bubble lexicon as a result of simulation (graph traversal) via spreading activation (edges are weighted, though Fig. 1 does not show the weights) from the origin node, toward some destination. This helps to exclude meaning attachments which are irrelevant in the current context, to hammer down a more coherent meaning.

Saurus produces interesting results for larger bodies of text as well. In a speech made in Sept. 2005, U.S. Senator John Kerry criticized the government's response to Hurricane Katrina's devastation of New Orleans: "The incompetence of Katrina's response is not reserved to a hurricane. There's an enormous gap between American's daily expectations and government's daily performance." Had the speechwriter used Saurus to modify the tone with the guide phrase "violent hate", Senator Kerry might have spoken: "The incompetence of Katrina's reaction is not reserved to a hurricane. There's a heinous breach between American's daily prospects and management's daily execution."

Write a program to generate 10000 random numbers between 0 and 99 inclusive. You should count how many of times each number is generated and write these counts out to the screen.

Pane and Myers conducted studies asking non-programming fifth-grade users to write descriptions of a Pac-Mac game (in another study, college students were given a spreadsheet programming task). The participants also drew sketches of the game so they could make deictic references. Pane and Myers then analyzed the descriptions to discover what underlying abstract programming models were implied by the users' natural language descriptions. They then used this analysis in the design of the HANDS programming language. HANDS uses a direct-manipulation, demonstrational interface. While still a formal programming language, it hopefully embodies a programming model that is closer to users' "natural" understanding of the programming process before they are "corrupted" by being taught a conventional programming language. They learned several important principles, such as that users rarely referred to loops explicitly, and preferred event-driven paradigms.

This paper describes the design and implementation of "langutils," a high-performance natural language toolkit for Common Lisp. We introduce the techniques of real-world NLP and explore tradeoffs in the representation and implementation of tokenization, part-of-speech tagging, and parsing. The paper concludes with a discussion of the use of the toolkit in two natural language applications.language techniques to identify specific kinds of information within larger texts.

Perhaps one reason for the absence of explicit looping in natural language is that there already exists basic linguistic constructions that imply a class of procedure which reasons about sets using relational descriptions (e.g. "sweet drinks" as a subset of "drinks"); these set-theoretic constructions seem to supplant the need to narrate looping constructions explicitly. For example, consider the following utterance and the procedure it implies (expressed in Python): The bartender makes a random sweet drink from the menu. bartender.make(random.choice(filter(lambda drink: "sweet" in drink.properties, menu.drinks)))

As a person types a story into Metafor, the system continuously updates a side-by-side "visualization" of the person"s narrative as scaffolding code. This code may not be directly executable, but it is meant to help a person reify her thoughts. We believe that Metafor is a novel system which can accomplish at least two main goals: 1) assist novice programmers in developing intuitions about programming; and 2) facilitate intermediate programmers with a brainstorming and "outlining" tool, ahead of "writing."

Natural language is also generic enough to use the same syntax to declare and compute variables, a manner similar to generic functions of the Common LISP Object System (e.g. "Pacman eats yellow dots" can depending on what"s known, declare that dots are yellow, or apply "eat" only to the subset of dots which are yellow). Unlike in most programming languages, the economic and goal-driven nature of story understanding causes evaluation of natural language expressions to almost always be lazy. For example, it may be sufficient to acknowledge that a procedure for generating the "shortest path" exists without actually specifying one.

Whereas ontology and metadata systems are bloating with semantic relation diversity, a semantic fabric is homogenous in its relation type (they are all affinity scores) and its method of reasoning (spreading activation). Because a semantic fabric represents just one semantic dimension, it can do it exhaustively and yield a very high-resolution resource for making semantic measurements along that dimension. Semantic fabrics re-introduce continuity into an increasingly symbolic and discretized semantic universe, begging us to heed that old adage, "do one thing, and do it well."