Teadmiste formaliseerimine: erinevus redaktsioonide vahel
| 272. rida: | 272. rida: | ||
In the final part of the course we will start looking at uncertain reasoning: right now we will only try to do simple strict reasoning. | In the final part of the course we will start looking at uncertain reasoning: right now we will only try to do simple strict reasoning. | ||
We will have a look at potential tools for semantic parsing: | We will have a look at potential tools for semantic parsing, from simpler to more complex: | ||
* [https://github.com/wcmac/sippycup sippycup] | * [https://github.com/Kitt-AI/parsetron parsetron]: a really simple tool to build your own parser. | ||
* [https://github.com/mynlp/ccg2lambda ccg2lambda] | * [https://github.com/wcmac/sippycup sippycup]: has a detailed [https://nbviewer.jupyter.org/github/wcmac/sippycup/tree/master/ tutorial/course] attached, check the [https://nbviewer.jupyter.org/github/wcmac/sippycup/blob/master/sippycup-unit-0.ipynb first lab] | ||
* [https://github.com/mynlp/ccg2lambda ccg2lambda]: parses to classical logic strings, which are embedded in XML output. | |||
Other interesting things to look at: | Other interesting things to look at: | ||
Redaktsioon: 13. märts 2019, kell 10:42
 |
Name: Knowlege representation |
Time, place, result
Lectures: Wednesdays 12:00-13:30 room U06A-229
Practical work: Wednesdays 14:00-15:30, room ICT-121, ICT-122
Practical work will give 40% and exam 60% of points underlying the final grade.
The exam will consist of several small excercises.
The first practical work time on 30. January at 14:00 will be used as a secord conventional lecture of the day.
Some of the last lecture times at the end of the course may be used as additional seminars/labs.
Assumed background
You should have studied the course "Basics of AI and Machine Learning" or get acquinted with the logic and probabilities parts of the course yourself.
In particular, it is useful to read these course materials and exercises: logic AIMA book, wumpus world in AIMA book, uncertainty in AIMA book, probability models in AIMA book, prolog lab, bayes lab
Focus
The main focus of the course is on knowledge representation and reasoning (KR), on a spectrum from simple to very complex: representing and using knowledge in databases, sentences in natural language and commonsense knowledge.
The overall goal of the labwork to understand issues facing a task of building a natural language question answering system a la Watson and to see and experiment with existing parts of the solution.
The course contains the following blocks:
- Background and basics. Representing and using simple facts and rules.
- Knowledge conveyed by natural sentences: both statistical methods like word2vec and logic-based methods.
- General-knowledge databases: wikidata, wordnet, yago, conceptnet, nell, cyc.
- Reasoners and question answering systems.
- Context, time, location, events, causality.
- Different kinds and dimensions of uncertain knowledge.
- Indexes and search.
Check out this description of the whole KR area.
Books to use
- Recommended for NLP: Speech and Language Processing by Dan Jurafsky and James H. Martin. here is the 2nd edition and here the web page for the draft 3rd edition
- Ca half of the course themes are covered in this book with freely accessible pdf-s.
- The freely accesible pdf of the handbook if knowledge representation gives a detailed and thorough coverage of the subject; far more than necessary for the course.
Observe that a noticeable part of the course contents are not covered by these books: use the course materials and links to papers, standards and tutorials provided.
Practical work
There are three labs. They are all steps in a single project: build a simple natural-language question-answering system.
The labs have to be presented to the course teachers and all students present at labwork time.
The labs can be prepared alone or by teams of two people. The first lab task will be given on 6. February.
First, read the explanation of the overall task. The following labs are steps on the path to the end goal.
NB! You have to register for the lab like this:
First, go to
Search for: ITI8700
Log in with the "UNI ID".
Enroll on the course page found: Click "enrol me" button.
Second, go to http://gitlab.cs.ttu.ee and log in
Click on "Create a project"
Name of the project must be exactly that: iti8700-2019
Visibility level: private
Upload you code, presentation, examples etc you use for the presentation.
First lab
Deadline: 14. March (after this there will be a penalty).
If you manage to fullfill the task earlier, start doing the second lab.
Please read about the task for the first lab
Second lab
The task in the second lab is actually answering simple questions from the input text, using a small set of rules you write and a reasoner.
Please start by experimenting with a real prover: look and run Reasoner examples with gkc
We use the gkc prover for examples (instructions are in the Reasoner examples ... page above) but you could also try out an old classic prover Otter which actually works OK on windows even though it is really old.
Third lab
The third lab is optional and will simply give as many points as lab 1 or 2 towards the final result and the grade: practical work 60% and exam 40%.
The task in the third lab is the open-world scenario of answering questions based on wikipedia and using large downloaded rule sets a la yago, wordnet etc with a reasoner.
It is a plus to be able to give uncertain answers (likely, unlikely) and handle fuzzy properties like boy, girl, grownup, rich etc.
Lecture block 1: basics and representing simple facts.
Lectures 1 and 2: Overview of the course. Background and basics: SQL, logic, NLP
Lecture materials:
Lecture 2: RDF and RDFS (and OWL)
Lecture materials:
Lecture block 2: capturing meaning in natural language
Lecture 3: Intro to homework and NLP
Lecture materials:
- nlp and watson
- Jurafsky and Martin book: conversational agents
- start reading the Jurafsky and Martin book (see links above)
Lecture 4: vector representation of words
This lecture will be given by Priit Järv.
Lecture materials:
- First, listen to text vectorization episode from the linear digressions podcast.
- Second, listen to word2vec episode from the linear digressions podcast.
- Read the beginning (until you get tired ...) of the Vector Semantics chapter from the Jurafsky & Martin book.
Useful additional materials from (roughly) easier to more complex:
- word vectors: a short intro
- vector semantics part I presentation from the Jurafsky & Martin book for for chapter 6.
- vector representation: a short tutorial with code examples.
- word2vec tutorial from tensorflow
- vector semantics part II presentation from the Jurafsky & Martin book for chapter 6.
Probabilistic models:
Also interesting to read:
- Aetherial Symbols by the ultimate machine learning guru aka "godfather of machine learning" Geoffrey Hinton
- Autocomplete using Markov chains
Lecture block 3 and start of 4: large common-sense knowledge bases and reasoning
Lecture 5: First look into main large knowledge bases
We will have a look at the goals, main content and differences between:
- wordnet
- dbpedia
- yago
- babelnet
- conceptnet
- nell in wiki and a good paper. The nell website is currently down.
- cyc
Lecture 6: Big annotation systems and intro to rule reasoners
First, big annotation systems:
- Google structured data on the webpage.
- Facebook Open Graph markup on the webpage.
In connection, see also:
- schema.org: property markup vocabulary suggested by Google, Microsoft and others.
- json-ld: currently most popular rdf syntax (in json), also recommended by Google.
Second, intro to rule reasoners:
- Lecture material as ppt or as pdf
Additionally you may want to look at:
Lecture 7: rule reasoners
Please have a look and run the same experiments yourself with the gkc prover:
We use the gkc prover for examples (instructions are in the Reasoner examples ... page above) but you could also try out an old classic prover Otter which actually works OK on windows even though it is really old.
Lecture 8: starting with rule reasoners for natural language
We will start building a tiny question-answering tool, translating natural language to rule reasoner input.
Our first, very simple goal: translate the text "John is a father of Pete. Pete is a father of Mark. Who is the father of Pete?" to a rule reasoner input
father(john,pete). father(pete,mark). -father(X,pete) | ans(X).
then run the reasoner, fetch the ans(john) and give an answer "John is".
We will then proceed to gradually make questions and sentences more complex and add rules to be able to answer them.
In the final part of the course we will start looking at uncertain reasoning: right now we will only try to do simple strict reasoning.
We will have a look at potential tools for semantic parsing, from simpler to more complex:
- parsetron: a really simple tool to build your own parser.
- sippycup: has a detailed tutorial/course attached, check the first lab
- ccg2lambda: parses to classical logic strings, which are embedded in XML output.
Other interesting things to look at: