187 lines
11 KiB
Python
187 lines
11 KiB
Python
from encodings import search_function
|
|
import lzma
|
|
from re import L
|
|
import regex as re
|
|
import string
|
|
import queue
|
|
# text = lzma.open('train/in.tsv.xz').read()
|
|
def read_file(file):
|
|
for line in file:
|
|
yield re.sub(' +|\t', ' ', line.replace("\\n"," ").replace("\n","").translate(str.maketrans('','', string.punctuation))).split(" ")
|
|
|
|
def get_words(file):
|
|
for words in read_file(file):
|
|
yield from words
|
|
|
|
def set_bigram_count(first_word, second_word, bigrams):
|
|
if f"{first_word}_{second_word}" not in bigrams:
|
|
bigrams[f"{first_word}_{second_word}"] = 1
|
|
else:
|
|
bigrams[f"{first_word}_{second_word}"] += 1
|
|
|
|
def set_trigram_count(first_word, second_word, third_word, trigrams):
|
|
if f"{first_word}_{second_word}_{third_word}" not in trigrams:
|
|
trigrams[f"{first_word}_{second_word}_{third_word}"] = 1
|
|
else:
|
|
trigrams[f"{first_word}_{second_word}_{third_word}"] += 1
|
|
|
|
def load_train():
|
|
trigrams = {}
|
|
bigrams = {}
|
|
with lzma.open('train/in.tsv.xz', mode='rt') as file:
|
|
wordNo = 1
|
|
word_bi_last = ""
|
|
words = ["", "", ""]
|
|
for i_, word in enumerate(get_words(file)):
|
|
word = word.lower()
|
|
if len(word_bi_last) > 0:
|
|
set_bigram_count(word_bi_last, word, bigrams)
|
|
if i_ == 1:
|
|
words[0]=word_bi_last
|
|
words[1]=word
|
|
elif i_ == 2:
|
|
words[2]=word
|
|
set_trigram_count(words[0], words[1], words[2], trigrams)
|
|
elif i_ > 2:
|
|
words[0]=words[1]
|
|
words[1]=words[2]
|
|
words[2]=word
|
|
set_trigram_count(words[0], words[1], words[2], trigrams)
|
|
word_bi_last = word
|
|
|
|
def predict(search_for_words):
|
|
trigrams_complete = {} # Tablica trigramów szukanych słów które wystąpiły w tekście z dokładnie tymi samymi szukanymi słowami w tej samej kolejności
|
|
bigrams_complete = {} # Tablica bigramów szukanych słów które wystąpiły w tekście z dokładnie tymi samymi szukanymi słowami w tej samej kolejności
|
|
# bigrams_not_complete = {}
|
|
# trigrams_not_complete = {}
|
|
# search_for_words_complete = [] # Tablica szukanych słów które wystąpiły w tekście z dokładnie tymi samymi szukanymi słowami w tej samej kolejności
|
|
# Szukanie bigramów i trigramów które zawierają szukaną lukę dla słowa z tablicy search_for_words.
|
|
# Jeżeli kolejność słów się zgadza liczona jest ilość wystąpień takich bigramów i trigramów z tymi słowami.
|
|
# Przy czym dla trigramów sprawdzane są tylk odwa ostatnie słowa bo to logiczne. I potem sprawdzane jest który trigram dla danych słów najczęściej występuje.
|
|
# I to pierwsze słowo z tego trigramu dla tych danych dwóch słów jest tym słowem szukanym (leftcontext).
|
|
# bigramy i trigramy zapisywane są w dict jako jeden cały string a słowa odzielone są _ (podłogą).
|
|
with lzma.open('train/in.tsv.xz', mode='rt') as file:
|
|
wordNo = 1
|
|
word_bi_last = ""
|
|
words = ["", "", ""]
|
|
for i_, word in enumerate(get_words(file)): # lecimy po kolei słowo po słowie. Słow ma usunięte wszelkie interpunkcja
|
|
word = word.lower() # normalizowanie na małe znaki
|
|
if not word:
|
|
continue
|
|
if len(word_bi_last) > 0: # Mamy już pierwsze słow zbuforowane (szczególnie potrzebne dla pierwszego przebiegu) możemy więc zapisać
|
|
for search_for_word in search_for_words:
|
|
search_for_word_s = search_for_word.split("_")
|
|
if search_for_word_s[0] == word_bi_last and search_for_word_s[1] == word: # Jeżeli szukane słowa tworzą bigram występujący w tekście trenującym to zwiększamy liczbę jego wystąpień
|
|
set_bigram_count(word_bi_last, word, bigrams_complete)
|
|
# elif search_for_word_s[0] == word_bi_last:
|
|
# set_bigram_count(word_bi_last, word, bigrams_not_complete)
|
|
if i_ == 1: # If potrzebny aby zbuforować min 3 wyrazy dla trigramu w początkowej fazie przebiegu pętli.
|
|
words[0]=word_bi_last
|
|
words[1]=word
|
|
elif i_ == 2: # są już zbuforowane 3 słowa więc można zacząć zliczać trigramy tylko w początkowej fazie przebiegu pętli.
|
|
words[2]=word # To jest to 3 słowo
|
|
for search_for_word in search_for_words:
|
|
search_for_word = search_for_word.split("_")
|
|
if search_for_word[0] == words[1] and search_for_word[1] == words[2]: # Jeżeli szukane słowa należą do przedostatniego i ostatniego słowa trigramu to jest zwiększana liczba wystąpień tego trigramu.
|
|
set_trigram_count(words[0], words[1], words[2], trigrams_complete)
|
|
# elif search_for_word[0] == words[1]:
|
|
# set_trigram_count(words[0], words[1], words[2], trigrams_not_complete)
|
|
elif i_ > 2: # Jest to już ponad 2 przebieg pętli więc możemy rotować wyrazy jak w kolecje. Dla trigramów.
|
|
words[0]=words[1]
|
|
words[1]=words[2]
|
|
words[2]=word
|
|
for search_for_word in search_for_words:
|
|
search_for_word = search_for_word.split("_")
|
|
if search_for_word[0] == words[1] and search_for_word[1] == words[2]:
|
|
set_trigram_count(words[0], words[1], words[2], trigrams_complete)
|
|
# elif search_for_word[0] == words[1]:
|
|
# set_trigram_count(words[0], words[1], words[2], trigrams_not_complete)
|
|
word_bi_last = word
|
|
|
|
if i_ == 500000:
|
|
break
|
|
|
|
print(len(search_for_words))
|
|
print(len(bigrams_complete))
|
|
print(len(trigrams_complete))
|
|
# print(len(bigrams_complete), len(bigrams_not_complete), len(bigrams_complete)+len(bigrams_not_complete))
|
|
# print(len(trigrams_complete), len(trigrams_not_complete), len(trigrams_complete)+len(trigrams_not_complete))
|
|
# Szukanie trigramu który najczęściej wystąpił dla każdych dokadnie tych samych co szukanych danych dwóch słów z tablicy serch_for_word.
|
|
# Dotyczy dkoładnie pasujących bigramów z szukanymi słowami
|
|
left_context_search_for_word = {}
|
|
for bigram_complete in bigrams_complete:
|
|
max_count = 0
|
|
for trigram in trigrams_complete:
|
|
if bigram_complete == '_'.join(trigram.split("_")[1:3]) and trigrams_complete[trigram] > max_count:
|
|
max_count = trigrams_complete[trigram]
|
|
left_context = trigram.split("_")[0]
|
|
left_context_search_for_word[bigram_complete] = left_context
|
|
|
|
# # Szukanie trigramu który najczęściej wystąpił dla pierwszego szukanego słowa z szukanych słów z tablicy serch_for_word.
|
|
# # To w przypadku gdyby szukane słowa w ogóle nie znalazły swojego dopasowania w zbiorze train to wtedy dostaną jakieś tam prawdopodobieństwo dla tego pierwszego słow z szukanych słów.
|
|
# left_context_search_for_word_not_complete = {}
|
|
# for bigram_not_complete in bigrams_not_complete:
|
|
# max_count = 0
|
|
# for trigram in trigrams_not_complete:
|
|
# if bigram_not_complete == '_'.join(trigram.split("_")[1:3]) and trigrams_not_complete[trigram] > max_count:
|
|
# max_count = trigrams_not_complete[trigram]
|
|
# left_context = trigram.split("_")[0]
|
|
# left_context_search_for_word_not_complete[bigram_not_complete] = left_context
|
|
|
|
for search_for_word in search_for_words:
|
|
if search_for_word in left_context_search_for_word:
|
|
left_context = left_context_search_for_word[search_for_word]
|
|
print(f"{left_context} {' '.join(search_for_word.split('_'))} {trigrams_complete['_'.join([left_context, search_for_word])]/bigrams_complete[search_for_word]}")
|
|
|
|
def load_dev():
|
|
# Ładowanie zbioru testującego
|
|
# Luka została oznaczona jako znak tabulacji (\t)
|
|
search_for_words = []
|
|
with lzma.open('dev-0/in.tsv.xz', mode='rt') as file:
|
|
index = 0
|
|
second_word = ""
|
|
third_word = ""
|
|
was_tab = False
|
|
word_index_watch = 0
|
|
for line in file:
|
|
# Wczytanie linijiki i dzielenie jej na słowa, w przypadku napotkania luki (znaku \t) dodanie spacji aby oznaczyć jako słowo. Czyszczenie słów z różnych dziwnych znaków.
|
|
for word in line.replace("\\n"," ").replace("\n","").translate(str.maketrans('','', string.punctuation)).replace("\t", " \t ").split(" "):
|
|
word = word.lower()
|
|
if not word: # omijamy pusty znak wynikający z podziału przez spacje, dokońca nie wiem dlaczego się pojawia raczej nie powienien.
|
|
continue
|
|
# Napotkał lukę czyli kolejne dwa wyrazy będą brane jako bigramy i na tych bigramach (zmienna search_for_words) będzie dokonywana predykcja.
|
|
if word == '\t':
|
|
was_tab = True
|
|
word_index_watch = 0
|
|
second_word = ""
|
|
third_word = ""
|
|
elif was_tab: # Wystąpiła wcześniej luka (szukane pierwsze słowo) czyli zapisujemy słowo jako drugie słowo z bigramu, przeskakujemy iterację i potem zapisujemy trzecie słowo jeżeli w między czasie nie wystąpi jakaś luka inaczej zaczynamy proces od nowa.
|
|
if not second_word: # Sprawdzamy czy już drugie słowo nie zostało zbuforowane, jeżeli tak to oznacza, że teraz czekamy na trzecie słowo
|
|
second_word = word # Buforujemy drugie słowo
|
|
elif word_index_watch == 1: # Kolejna iteracja czyli jest to trzecie słowo z bigramu to zapisujemy szukany bigram
|
|
third_word = word
|
|
search_for_words.append(f"{second_word}_{third_word}")
|
|
was_tab = False # Oznaczamy, że dla tej luki mamy już bigram
|
|
else: # Jeżeli przekroczymy indeks słów to szkuamy kolejnej luki i resetujemy zmienne. W sumie do końca nie wiem czy to jest potrzebne
|
|
was_tab = False
|
|
second_word = ""
|
|
third_word = ""
|
|
|
|
word_index_watch += 1
|
|
|
|
# print(line)
|
|
index += 1
|
|
if index == 100:
|
|
break
|
|
print(search_for_words)
|
|
return search_for_words
|
|
|
|
if __name__ == "__main__":
|
|
# load_train()
|
|
predict(load_dev())
|
|
# with lzma.open('train/in.tsv.xz', mode='rt') as file:
|
|
# index = 0
|
|
# for _ in get_words(file):
|
|
# index += 1
|
|
# print(index) # 141820215
|
|
|