Presentation is loading. Please wait.

Presentation is loading. Please wait.

Programming for Linguists An Introduction to Python 13/12/2012.

Similar presentations


Presentation on theme: "Programming for Linguists An Introduction to Python 13/12/2012."— Presentation transcript:

1 Programming for Linguists An Introduction to Python 13/12/2012

2 Like a list, but more general In a list the index has to be an integer, e.g. words[4] In a dictionary the index can be almost any type A dictionary is like a mapping between 2 sets: keys and values Dictionaries

3 To create an empty list: list = [ ] To create an empty dictionary: dictionary = { } e.g. a dictionary containing English and Spanish words: >>>eng2sp = { } >>>eng2sp['one'] = 'uno’ >>>print eng2sp {'one': 'uno'}

4 In this case both the keys and the values are of the string type Like with lists, you can create dictionaries yourselves, e.g. eng2sp = {'one': 'uno', 'two': 'dos', 'three': 'tres'} print eng2sp Note: in general, the order of items in a dictionary is unpredictable

5 You can use the keys to look up the corresponding values, e.g. >>>print eng2sp['two'] The key ‘two’ always maps to the value ‘dos’ so the order of the items does not matter If the key is not in the dictionary you get an error message, e.g. >>>print eng2sp[‘ten’] KeyError: ‘ten’

6 The len( ) function returns the number of key-value pairs len(eng2sp) The in operator tells you whether something appears as a key in the dictionary >>>‘one’ in eng2sp True BUT >>>‘uno’ in eng2sp False

7 To see whether something appears as a value in a dictionary, you can use the values( ) function, which returns the values as a list, and then use the in operator, e.g. >>>‘uno’ in eng2sp.values( ) True Lists can be values, but never keys!

8 Default dictionary Try this: words = [‘een’, ‘twee’, ‘drie’] frequencyDict = { } for w in words: frequencyDict[w] += 1

9 Possible solution: for w in words: if w in frequencyDict: frequencyDict[w] += 1 else: frequencyDict[w] = 1

10 The easy solution: >>>from collections import defaultdict >>>frequencyDict = defaultdict(int) >>>for w in words: frequencyDict[w] += 1 you can use int, float, str,… in the defaultdict

11 Suppose you want to count the number of times each letter occurs in a string, you could: create 26 variables, traverse the string and, for each letter, add 1 to the corresponding counter create a dictionary with letters as keys and counters as the corresponding values A Dictionary as a Set of Counters

12 def frequencies(sent): freq_dict = defaultdict(int) for let in sent: freq_dict[let] += 1 return freq_dict dictA = frequencies(“abracadabra”) list_keys = dictA.keys( ) list_values = dictA.values( ) z_value = dictA[‘z’]

13 The first line of the function creates an empty default dictionary The for loop traverses the string Each time through the loop, we create a new key item with the initial value 1 If the letter is already in the dictionary we add 1 to its corresponding value

14 Write a function that counts the word frequencies in a sentence instead of the letter frequencies using a dictionary

15 def words(sent): word_freq = defaultdict(int) wordlist = sent.split( ) for word in wordlist: word_freq[word] += 1 return word_freq words(“this is is a a test sentence”)

16 Given a dictionary “word_freq” and a key “is”, finding the corresponding value: word_freq[“is”] This operation is called a lookup What if you know the value and want to look up the corresponding key? Dictionary Lookup

17 First you need to import itemgetter: from operator import itemgetter To go over each item in a dictionary you can use.iteritems( ) To sort the dictionary according to the values, you need to use key = itemgetter(1) To sort it decreasingly: reverse = True Sorting a Dictionary According to its Values

18 >>> from operator import itemgetter >>>def getValues(sent): w_fr = defaultdict(int) wordlist = sent.split( ) for word in wordlist: w_fr[word] += 1 byVals = sorted(w_fr.iteritems( ), key = itemgetter(1), reverse =True) return byVals >>>getValues(‘this is a a a sentence’)

19 Write a function that takes a sentence as an argument and returns all words that occur only once in the sentence.

20 def getHapax(sent): words = sent.split( ) freqs = defaultdict(int) for w in words: freqs[w] += 1 hapaxlist = [ ] for item in freqs: value = freqs[item] if value == 1: hapaxlist.append(item) return hapaxlist

21 Getting Started with NLTK In IDLE: import nltk nltk.download()

22 Searching Texts Start your script with importing all texts in NLTK: from nltk.book import * text1: Moby Dick by Herman Melville 1851 text2: Sense and Sensibility by Jane Austen 1811 text3: The Book of Genesis text4: Inaugural Address Corpus text5: Chat Corpus text6: Monty Python and the Holy Grail text7: Wall Street Journal text8: Personals Corpus text9: The Man Who Was Thursday by G. K. Chesterton 1908

23 Any time you want to find out about these texts, just enter their names at the Python prompt: >>> text1 A concordance view shows every occurrence of a given word, together with some context: e.g. “monstrous” in Moby Dick text1.concordance(“monstrous”)

24 Try looking up the context of “lol” in the chat corpus (text 5) If you have a corpus that contains texts that are spread over time, you can look up how some words are used differently over time: e.g. the Inaugural Address Corpus (dates back to 1789): words like “nation”, “terror”, “God”…

25 You can also examine what other words appear in a similar context, e.g. text1.similar(“monstrous”) common_contexts( ) allows you to examine the contexts that are shared by two or more words, e.g. text1.common_contexts([“very”, “monstrous”])

26 You can also determine the location of a word in the text This positional information can be displayed using a dispersion plot Each stripe represents an instance of a word, and each row represents the entire text, e.g. text4.dispersion_plot(["citizens", "democracy", "freedom", "duties", "America"])

27 Counting Tokens To count the number of tokens (words + punctuation marks), just use the len( ) function, e.g. len(text5) To count the number of unique tokens, you have to make a set, e.g. set(text5)

28 If you want them sorted alfabetically, try this: sorted(set(text5)) Note: in Python all capitalized words precede lowercase words (you can use.lower( ) first to avoid this)

29 Now you can calculate the lexical diversity of a text, e.g. the chat corpus (text5): tokens 6066 unique tokens or types The lexical diversity = nr of types/nr of tokens Use the Python functions to calculate the lexical diversity of text 5

30 len(set(text5))/float(len(text5))

31 Frequency Distributions To find n most frequent tokens: FreqDist( ), e.g. fdist = FreqDist(text1) fdist[“have”] 760 all_tokens = fdist.keys( ) all_tokens[:50] The function.keys( ) combined with the FreqDist( ) also gives you a list of all the unique tokens in the text

32 Frequency distributions can be informative, BUT the most frequent words usually are function words (the, of, and, …) What proportion of the text is taken up with such words? Cumulative frequency plot fdist.plot(50, cumulative=True)

33 If frequent tokens do not give enough information, what about infrequent tokens? Hapaxes= tokens which occur only once fdist.hapaxes( ) Without their context, you do not get much information either

34 Fine-grained Selection of Tokens Extract tokens of a certain minimum length: tokens = set(text1) long_tokens = [ ] for token in tokens: if len(token) >= 15: long_tokens.append(token) #OR shorter: long_tokens = list(token for token in tokens if len(token) >= 15)

35 BUT: very long words are often hapaxes You can also extract frequently occurring long words of a certain length: words = set(text1) fdist = FreqDist(text1) #short version freq_long_words = list(word for word in words if len(word) >= 7 and fdist[word] >= 7)

36 Collocations and Bigrams A collocation is a sequence of words that occur together unusually often, e.g. “red whine” is a collocation, “yellow whine” is not Collocations are essentially just frequent bigrams (word pairs), but you can find bigrams that occur more often than is to be expected based on the frequency of the individual words: text8.collocations( )

37 Some Functions for NLTK's Frequency Distributions fdist = FreqDist(samples) fdist[“word”]  frequency of “word” fdist.freq(“word”)  frequency of “word” fdist.N( )  total number of samples fdist.keys( )  the samples sorted in order of decreasing frequency for sample in fdist:  iterates over the samples in order of decreasing frequency

38 fdist.max( )  sample with the greatest count fdist.plot( )  graphical plot of the frequency distribution fdist.plot(cumulative=True)  cumulative plot of the frequency distribution fdist1 < fdist2  tests if the samples in fdist1 occur less frequently than in fdist2

39 Accessing Corpora NLTK also contains entire corpora, e.g.: Brown Corpus NPS Chat Gutenberg Corpus … A complete list can be found on _data/index.xml _data/index.xml

40 Each of these corpora contains dozens of individual texts To see which files are e.g. in the Gutenberg corpus in NLTK: nltk.corpus.gutenberg.fileids() Do not forget the dot notation nltk.corpus. This tells Python the location of the corpus

41 You can use the dot notation to work with a corpus from NLTK or you can import a corpus at the beginning of your script: from nltk.corpus import gutenberg After that you just have to use the name of the corpus and the dot notation before a function gutenberg.fileids( )

42 If you want to examine a particular text, e.g. Shakespeare’s Hamlet, you can use the.words( ) function Hamlet = gutenberg.words(“shakespeare- hamlet.txt”) Note that “shakespeare-hamlet.txt” is the file name that is to be found using the previous.fileids( ) function You can use some of the previously mentioned functions (corpus methods) on this text, e.g. fdist_hamlet = FreqDist(hamlet)

43 Some Corpus Methods in NLTK brown.raw( )  raw data from the corpus file(s) brown.categories( )  fileids( ) grouped per predefined categories brown.words( )  a list of words and punctuation tokens brown.sents( )  words( ) grouped into sentences

44 brown.tagged_words( )  a list of (word,tag) pairs brown.tagged_sents( )  tagged_words( ) grouped into sentences treebank.parsed_sents( )  a list of parse trees

45 def statistics(corpus): for fileid in corpus.fileids( ): nr_chars = len(corpus.raw(fileid)) nr_words = len(corpus.words(fileid)) nr_sents = len(corpus.sents(fileid)) nr_vocab = len(set([word.lower() for word in corpus.words(fileid)])) print fileid, “average word length: ”, nr_chars/nr_words, “average sentence length: ”, nr_words/nr_sents, “lexical diversity: ”, nr_words/nr_vocab

46 Some corpora contain several subcategories, e.g. the Brown Corpus contains “news”, “religion”,… You can optionally specify these particular categories or files from a corpus, e.g.: from nltk.corpus import brown brown.categories( ) brown.words(categories='news') brown.words(fileids=['cg22']) brown.sents(categories=['news', 'editorial', 'reviews'])

47 Some linguistic research: comparing genres in the Brown corpus in their usage of modal verbs from nltk.corpus import brown cfd = nltk.ConditionalFreqDist((genre, word) for genre in brown.categories( ) for word in brown.words(categories =genre)) #Do not press enter to type in the for #statements!

48 genres = ['news', 'religion', 'hobbies', 'science_fiction', 'romance', 'humor’] modal_verbs = ['can', 'could', 'may', 'might', 'must', 'will'] cfd.tabulate(conditions=genres, samples=modal_verbs)

49 can could may might must will news religion hobbies science_fiction romance humor A conditional frequency distribution is a collection of frequency distributions, each one for a different "condition” The condition is usually the category of the text (news, religion,…)

50 Loading Your Own Text or Corpus Make sure that the texts/files of your corpus are in plaintext format (convert them, do not just change the file extensions from e.g..docx to.txt) Make a map with the name of your corpus which contains all the text files

51 A text in Python: open your file f = open(“/Users/claudia/text1.txt”, “r”) read in the text text1 = f.read( )  reads the text entirely text1 = f.readlines( )  reads in all lines that end with \n and makes a list text1 = f.readline( )  reads in one line

52 Loading your own corpus in NLTK with no subcategories: import nltk from nltk.corpus import PlaintextCorpusReader loc = “/Users/claudia/my_corpus” #Mac loc = “ C:\Users\claudia\my_corpus” #Windows my_corpus = nltk.PlaintextCorpusReader(loc, “.*”)

53 Now you can use the corpus methods of NLTK on your own corpus, e.g. my_corpus.words( ) my_corpus.sents( ) …

54 Loading your own corpus in NLTK with subcategories: import nltk from nltk.corpus import CategorizedPlaintextCorpusReader loc=“/Users/claudia/my_corpus” #Mac loc=“C:\Users\claudia\my_corpus” #Windows 7 my_corpus = CategorizedPlaintextCorpusReader(loc, '(?!\.svn).*\.txt', cat_pattern= r'(cat1|cat2)/.*')

55 If your corpus is loaded correctly, you should get a list of all files in your corpus by using: my_corpus.fileids( ) For a corpus with subcategories, you can access the files in the subcategories by taking the name of the subcategory as an argument: my_corpus.fileids(categories = “cat1”) my_corpus.words(categories = “cat2”)

56 Writing Results to a File It is often useful to write output to files First you have to open/create a file for your output output_file = open(‘(path)/output.txt’,‘w’) output_file = open(‘(path)/output.txt’,‘a’) output_file.write(‘hallo’) output_file.close()

57 To download and install NLTK: Note: you need to have Python's NumPy and Matplotlib packages installed in order to produce the graphical plots See for installation instructionshttp://www.nltk.org/

58 Thank you


Download ppt "Programming for Linguists An Introduction to Python 13/12/2012."

Similar presentations


Ads by Google