# -- Code Cell --
GAMMA = 0.9
CONVERGENCE_THRESHOLD = 1e-10
REWARD_GOAL  = 1.0
REWARD_STEP = -0.01
ACTIONS =[(-1,0), (0,1), (1,0), (0,-1)]

# -- Code Cell --
import numpy as np

# -- Code Cell --
grid_size = int(np.sqrt(len(df))) # 6
grid = df['type'].values.reshape((grid_size, grid_size))

# -- Code Cell --
def get_next_state(r,c,move):
    nr,nc = r+move[0], c+move[1]
    if 0<=nr<grid_size and 0 <= nc < grid_size and grid[nr,nc] != 1:
        return nr, nc
    return r,c

# -- Code Cell --
def get_next_state(r,c, move):
    nr,nc = r +move[0], c +move[0]
    if 0<=nr<grid_size and 0 <=nc<grid_size and grid[nr,nc] !=1:
        return nr,nc
    return r,c

# -- Code Cell --
def spec_to_image(spec):
    if spec.dim()==2:
        spec = spec.unsqueeze(0)
    spec = F.interpolate(spec.unsqueeze(0), resize=(224,224), mode='bilinear').squeeze(0)
    spec = spec.repeat(3,1,1)
    spec = normalize(spec)
    return spec

# -- Code Cell --


# -- Code Cell --


# -- Code Cell --


# -- Code Cell --
def get_next_state(r,c,move):
    nr, nc = r+ move[0], c+move[1]
    if 0<=nr<grid_size and 0<=nc<grid_size and grid[nr,nc]!=1:
        return nr,nc
    return r,c

# -- Code Cell --
V= np.zeros((grid_size, grid_size))
policy = np.zeros((grid_size, grid_size), dtype=int)

# -- Code Cell --
while True:
    delta =0
    new_V = V.copy()
    for r in range(grid_size):
        for c in range(grid_size):
            if grid[r,c] == 1 or 3:
                continue
            q_values = []
            for a in range(4):
                moves = [ACTIONS[a], ACTIONS[(a-1)%4, ACTIONS[(a+1)%4]]]
                probs = [0.8,0.1,0.1]
                q_a = 0
                for move, prob in zip(moves, probs):
                    nr, nc = get_next_state(r,c,move):
                    reward = REWARD_GOAL if grid[nr,nc] == 3 else REWARD_STEP
                    q_a += prob *(reward+GAMMA * V[nr,nc])
                q_values.append(q_a)
            best_q = max(q_values)
            delta = max(delta, abs(best_q - V[r,c]))
            new_V[r,c] = best_q

# -- Code Cell --
while True:
    delta = 0
    new_V= V.copy()
    for r in range(grid_size):
        for c in range(grid_size):
            if grid[r,c] == 3 or 1:
                continue
            q_values = 0
            for a in range(4):
                moves = [ACTIONS[a], ACTIONS[(a-1)%4], ACTIONS[(a+1)%4]]
                probs = [0.8, 0.1, 0.1]
                q_a =0
                for move, prob in zip(moves,probs):
                    nr,nc = get_next_state(r,c,move)
                    reward = REWARD_GOAL if grid[nr,nc] == 3 else REWARD_STEP
                    q_a += prob * (reward + GAMMA * V[nr,nc])
                q_values.append(q_a)
            best_q = max(q_values)
            delta = max(delta, abs(best_q-V[r,c]))
            new_V[r,c] = best_q

# -- Code Cell --
embeddings_index = {}
with open("pula") as f:
    for line in f:
        values = line.split()
        key= values[0]
        vector_values = np.asarray(values[1:], dtype='float32')
        embeddings_index[key] = vector_values
    

# -- Code Cell --
def get_embeddings(cuvinte, embeddings_index):
    vectors = [embeddings_index[word] for word in cuvinte if word in embeddings_index]
    if len(vectors) == 0:
        return np.zeros(200)
    return np.mean(vectors, axis=0)

# -- Code Cell --
embeddings_index = {}
with open("") as f:
    for line in f:
        values = line.split()
        key = values[0]
        vector = np.asarray(values[1:], dtype=np.float32)
        embeddings_index[key] = vector

# -- Code Cell --
def get_embeddings(tokens, embeddings_index):
    embeeddings = [embeddings_index[word] for word in tokens if word in embeddings_index.keys()]
    if len(embeeddings) == 0:
        return np.array(200)
    return np.mean(embeeddings, axis=0)

# -- Code Cell --
text = "Alasdas sdadsa sadsa caras"

# -- Code Cell --
from nltk.tokenize import word_tokenize
tokens =[]
tokens.append(word_tokenize(text))
tokens[0]

# -- Code Cell --
def descriminize(s):
    return tuple(np.digitize(s,b) for s,b in zip(states, self.bins))

# -- Code Cell --
def choose_action(self,state,action):
    if np.random.rand()<self.epsilon:
        return np.random.randint(self.n_actions)
    s = descriminize(state)
    return np.argmax(self.Q[s])

# -- Code Cell --
def update(self, state, next_state, action, reward):
    s=descriminize(state)
    next_s = descriminize(next_state)
    best_next = np.max(self.Q[next_s])
    self.Q[s][action] += self.alpha * (reward + self.gamma *best_next - self.Q[s][action])

# -- Code Cell --
def decay(self, alpha_decay=0.9999, epsilon_decay = 0.9995):
    self.epsilon = max(self.epsilon_min, self.epsilon*epsilon_decay)
    self.alpha = max(0.01, self.alpha * alpha_decay)

# -- Code Cell --
for ep in episodes:
    state,_ = env.reste()
    done = False
    while not done:
        action = agent.choose_action(state, env.action_space.n)
        next_state, rewrad, termianted, truncated, _ = env.step(action)
        done = termianted or truncated
        agent.update(state, next_state,action,reward)
        state = next_state

# -- Code Cell --
logs = []
for i in range(len(test)):
    row = test.iloc[i]
    custom_state = np.array([
        row['pos'],
        row['vel']
    ])
    state = custom_state.copy()
    env.reset()
    env.unwrapped.state = custom_state
    done=False
    while not done:
        action = agent.choose_action(state,env.action_space.n)
        next_state, rewrad, termianted, truncated, _ = env.step(action)
        done = termianted or truncated
        logs.append({
            "id":i,
            'action':action
        })
        state = next_state

# -- Code Cell --
import numpy as np
mask_labeled = ~np.isnan(y_train)
mask_unlabeles = np.isnan(y_train)
X_labeled = X_train[mask_labeled]
X_unlabeled=X_train[mask_unlabeles]
y_labeld = y_train[mask_labeled]
y_unlabeled=y_train[mask_unlabeles]
rf = RandomForestClassifier(class_weights = 'balanced')
rf.fit(X_labeled,y_labeld)
probs = rf.predict_proba(X_unlabeled)[:,1]
mask = (probs>0.95) | (probs<0.1)
X_pseudo = X_unlabeled[mask]
y_pseduo = (probs[mask]>0.5).astype(int)
X_aug = np.vstakc([X_labeled,X_pseudo])
y_aug = np.concatenate([y_labeld, y_pseduo])

# -- Code Cell --


# -- Markdown Cell --
# # FAST TEXT

# -- Code Cell --
from nltk.tokenize import word_tokenize
from nltk.corpus import stopwords
from nltk.stem import WordNetLemmatizer
stop_words = set(stopwords.words("english"))
lemmatizer= WordNetLemmatizer()
def peprocess_text(text):
    tokens = word_tokenize(text)
    tokens =[lemmatizer.lemmatize(w) for w in tokens if w not in stop_words]
    return " ".join(tokens)
def simple_tokenizer(text):
    return text.split()

# -- Code Cell --
stopwords = set(stopwords.words('english'))
lemmatizer = WordNetLemmatizer()
def preprocess_text(text):
    tokens = word_tokenize(text)
    tokens = [lemmatizer.lemmatize(w) for w in tokens if w not in stop_words]
    return " ".join(tokens)
def simple_tokenizer(text):
    return text.split()

# -- Code Cell --
stopwords = set(stopwords.words("english"))
lemmatizer =WordNetLemmatizer()
def pr(text):
    tokens = word_tokenize(text)
    tokens = [lemmatizer.lemmatize(w) for w in tokens if w not in stop_words]
    return " ".join(tokens)
def simple_tokenizer(text):
    return text.split()

# -- Code Cell --
train_text = train['comment_text'].apply(preprocess_text)
train_text = train_text.apply(simple_tokenizer)

# -- Code Cell --
from gensim.models import FastText
ft = FastText(sentences=pd.concat([train_text, test_text]), vector_szie = 300, window=5)

# -- Code Cell --
import torch
def get_embeddings(text):
    embeddings = []
    for x in text:
        if x in ft.wv:
            embeddings.append(ft.wv[x])
    return torch.tensor(embeddings)

# -- Code Cell --
import torch
def get_embeddings(text):
    embeddings = []
    for x in text:
        if x in ft.wv:
            embeddings.append(ft.wv[x])
    return torch.tensor(embeddings)

# -- Code Cell --
def get_embeddings(text):
    embeddings = []
    for x in text:
        if x in ft.wv:
            embeddings.append(ft.wv[x])
    return torch.tensor(embeddings)

# -- Code Cell --
train_embs = [get_embeddings(text) for text in train_text]

# -- Code Cell --
labels = torch.tensor(train[['toxic', 'severe_toxic','obsecne','insult']].values, dtype=torch.float32)