challenging-america-word-gap-prediction/run.py

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), 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]}")
        elif search_for_word in left_context_search_for_word_not_complete:
            print(f"{left_context} {' '.join(search_for_word.split('_'))} {trigrams_not_complete['_'.join([left_context, search_for_word])]/bigrams_not_complete[search_for_word]}")
        else:
            print(f"??? {' '.join(search_for_word.split('_'))}")

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