def __init__(self): """Konstruktor. frequencies to słownik {słowo : liczba} częstości występowania słów w języku polskim. """ self.frequencer = Frequencer() self.lemmatizer = Lemmatizer() self.garbage_words = self.generate_list_of_garbage_words() self.story_words = self.generate_list_of_story_words() self.corpus_dir = os.path.abspath('legends')
class QueryGenerator: """ Generuje zbiór zapytań na podstawie tekstu legendy. """ def __init__(self): """Konstruktor. frequencies to słownik {słowo : liczba} częstości występowania słów w języku polskim. """ self.frequencer = Frequencer() self.lemmatizer = Lemmatizer() self.garbage_words = self.generate_list_of_garbage_words() self.story_words = self.generate_list_of_story_words() self.corpus_dir = os.path.abspath('legends') def lemmatise(self, legend_toks_list): """ Sprowadza tekst legendy do postaci zlematyzowanej. legend_toks_list to lista tokenów legendy. """ #lems_dict = self.lemmatizer.get_lems(legend_toks_list) lems_dict = self.lemmatizer lemmatized = [] for token in legend_toks_list: tok_low = token.lower() lems_dict.znajdz(tok_low) ''' if lems_dict.has_key(tok_low): lemmatized.append(lems_dict[tok_low]) else: lemmatized.append(tok_low) ''' #lemmatized = lems_dict.get_lems() #return lemmatized return lems_dict.get_lems() def strip_garbage(self, lemmatized_legend_test): """ Usuwa z listy słów zlematyzowanych, słowa-śmieci, np. 'haha', 'hehe', 'historia', 'prawdziwa', czyli takie, które pojawiają się w co drugiej legendzie. """ return [ word for word in lemmatized_legend_test if not word in self.garbage_words] def toks(self, legend): """ Tokenizuje tekst legendy. """ # tokens = nltk.word_tokenize(legend) pattern = r'''(?x) ([A-Z]\.)+ | \w+ | \w+(-\w+)* | \$?\d+(\.\d+)?%? | [][.,;"'?():-_`]''' # return nltk.regexp_tokenize(legend, p3) p2 = r'(?x)\w+' p3 = r'\w+' re_word = re.compile(r'(\w+)', re.UNICODE) words = [] for word in re.findall(re_word, legend): words.append(word.lower()) return words def random_words(self, set_of_words, number_of_elements): """ Wyciąga number_of_elements elementów z set_of_words. """ num = number_of_elements if number_of_elements > len(set_of_words): num = len(set_of_words) return random.sample(set_of_words, num) def generate_queries(self, legend): """ Generuje zbiór list będących zapytaniami do wyszukiwarek. """ """ Podstawowy preprocessing """ # print "\nGenerowanie zapytania..." tokens = self.toks(legend) # print "\nTokens: " # print tokens lemmatized_legend_list = self.lemmatise(tokens) # print "\nLemmatized: " # print lemmatized_legend_list garbage_free = self.strip_garbage(lemmatized_legend_list) # print "\nGarbage free: " # print garbage_free """ Rzadkie słowa oraz słowa kluczowe """ rare_words = self.find_rare_words(garbage_free) # print "\nRare words: " # print rare_words keywords = self.keywords(lemmatized_legend_list, rare_words) # print "\nKeywords: " # print keywords """ Lista zapytań - list słów """ queries = [] """ Pierwsza lista to słowa kluczowe """ query1 = keywords queries.append(query1) """ Kolejne zapytania to kilka losowych elementów ze zbioru słów kluczowycy + kilka elementów typowo "legendowych", tj. "historia", "koleżanka" - wskazujących na to, że mamy do czynienia z historią. """ for i in range(9): story_words_num = random.randint(1, 3) query = self.random_words(self.story_words, story_words_num) keywords_words_num = random.randint(2, 5) k_words = self.random_words(keywords, keywords_words_num) for k in k_words: query.append(k) queries.append(query) return queries def find_rare_words(self, lemmatized_legend_list): """ Wyszukuje rzadkowystępujące (w j. polskim) słowa zawarte w liście słów lemmatized_legend_list. Zwraca listę rzadkich słów, w kolejności od najrzadszych. """ """ Uwzględni słowa o częstotliwości mniejszej niż rare_treshold. """ rare_treshold = 200 """ Znajdzie co najwyzej max_rares rzadkich słów. """ max_rares = 20 """ Mapowanie słów legendy do częstotliwości występowania w j. pl: """ freqs = self.frequencer.get_frequencies(lemmatized_legend_list) # print "\nfreqs: " # print freqs """ Sortowanie słów po częstotliwości ich występowania """ """ list of tuples sorted by the second element in each tuple. """ sorted_words = sorted(freqs.iteritems(), key=operator.itemgetter(1), reverse=True) """ Ostateczna lista rzadkich słów """ rares = [] for key in sorted_words: # print "key %s - %d" %(key[0], key[1]) if key[1] < rare_treshold: rares.append(key[0]) if len(rares) >= max_rares: break return rares def number_of_legends_in_corpus(self): """ Liczy legendy w korpusie. """ files = [ f for f in listdir(self.corpus_dir) if isfile(join(self.corpus_dir, f)) ] legends_num = 0 prefixes = set() for f in files: chunks = f.split('_'); if chunks[0] not in prefixes: prefixes.add(chunks[0]) legends_num = legends_num + 1 return legends_num def keywords(self, lemmatized_legend_text, legend_rare_words): """ Generuje zbiór słów kluczowych danej legendy. lemmatized_legend_text - lista zlematyzowanych, odśmiecionych (po przebiegu metody strip_garbage) "lemów. legend_rare_words - lista rzadkich słów występujących w legendzie (stworzona metodą find_rare_words). """ frequency_dist = nltk.FreqDist(lemmatized_legend_text) # print frequency_dist return {w for (w, freq) in frequency_dist.items() if freq > 2 and w in legend_rare_words} def generate_list_of_story_words(self): """ Generuje listę słów, które pojawiają się w wielu legendach, np. 'historia'. """ story_words = { u'historia', u'przyda', u'przydażać', u'przydarzać', u'przydarzyła', u'znajomy', u'kumpel', u'historia', u'prawdziwy', u'prawda', u'kolega', u'koleżanka', u'opowiedzieć' } return story_words def generate_list_of_garbage_words(self): """ Generuje słowa-śmieci, np. 'haha', 'hehe', 'historia', 'prawdziwa', czyli takie, które pojawiają się w co drugiej legendzie. """ garbage_words = { u'haha', u'hehe', u'bardzo', u'dużo', u'mieć', u'w', u'hehe', u'prawdziwy', } return garbage_words