Analiza sentimentelor de către NacimNacim2 - OpenClassrooms

O intrebare ? Nu vă faceți griji, vă vom ajuta !

#coding: utf-8
import panda ca pd
import numpy ca np
importați xml.etree.ElementTree ca ET
din colecții import Counter
importați matplotlib.pyplot ca plt
torță de import
din torch.utils.data import DataLoader, TensorDataset
import torță.nn ca nn

def get_list (cale):
copac = ET.parse (cale)
root = tree.getroot ()
text_list = []
listă_opiniilor = []
pentru examinare în root.findall („Recenzie”):
text_string = "

pentru trimis în review.findall ("./ propoziții/propoziție"):
text_string = text_string + " + sent.find ("text"). text
text_string = text_string.lower ()
text_string = text_string.strip ()
text_list.append (text_string + ("\ n"))

pentru opinie în review.findall („./ Opinions/Opinion”):
if (opinion.get ("category") == "LAPTOP # GENERAL"):
opinion_dict = opinion.get ("polaritate")
# opinion_inner_list.append (opinion_dict)
opinion_list.append (opinion_dict)
returnează text_list, opinion_list

recenzii, etichete = get_list (path_train)

#test_text_list, test_opinion_list = get_list (path_test)
print ('train_text_list', recenzii)
imprimare ()
print („listă_opiniilor_trenului”, etichete)

linie = []
din punctuația importului șirului
all_text = ".join ([c pentru c în recenzii dacă c nu este în punctuație]) # punctuație clară
print (all_text)

reviews_split = all_text.split ('\ n')
print ('numărul de recenzii:', len (reviews_split))
all_text2 = ".join (reviews_split)
cuvinte = all_text2.split ()

count_words = Counter (cuvinte)
#numărați frecvența cuvintelor #
total_words = len (cuvinte)
print (total_words) #nbr total de cuvinte
sorted_words = count_words.most_common (total_words)
print (count_words) # și scrieți frecvența cuvintelor
vocab_to_int =
print (vocab_to_int)
# creați lista care include listele de discuții sub formă de numere întregi #
reviews_int = []
pentru examinare în reviews_split:
r = [vocab_to_int [w] pentru w în review.split ()]
reviews_int.append (r)
print (review_int)
print ("langueuuur rev_int", len (reviews_int))

# codifica etichete #

encoded_labels = [1 if label == 'positive' else 0 if label == 'negative'else 2 if label ==' conflict 'else 3 for label in labels] #encode the labels
encoded_labels = np.array (encoded_labels)

# analizează datele #
reviews_len = [len (x) pentru x în reviews_int]
pd.Series (reviews_len) .hist ()
plt.show ()
pd.Series (reviews_len) .describe ()
# scapă de valorile scurte și lungi #
print ("the labels11111", len (encoded_labels))
reviews_int = [reviews_int [i] pentru i, l în enumerate (reviews_len) dacă l> 0]
encoded_labels = [encoded_labels [i] pentru i, l în enumerate (reviews_len) dacă l> 0 și i seq_length:
new = review [0: seq_length]

lungime_seq = 395
caracteristici = pad_features (reviews_int, seq_length)
print (caracteristici)
len_feat = len (caracteristici)
print ("len feat", len_feat)
split_frac = 0,8

#training data

train_x = caracteristici [0: int (split_frac * len_feat)] # recenziile
print ("train_x", train_x)
train_y = encoded_labels [0: int (split_frac * len_feat)] # etichetele
print ("train_y", train_y)
print ("review_split", len (reviews_split))
print ("languer rev", len (reviews_int))

# date rămase
restant_x = caracteristici [int (split_frac * len_feat):]
y_ restant = etichete_codate [int (split_frac * len_feat):]
print (len (restant_x))
print (len (restant_y))

# date de validare
valid_x = restant_x [0: int (len (restant_x) * 0,5)]
valid_y = restant_y [0: int (len (restant_y) * 0,5)]
print ('len (valid_x)', len (valid_x))
print ('len (valid_y)', len (valid_y))
# date de testare
test_x = restant_x [int (len (restant_x) * 0,5):]
test_y = restant_y [int (len (restant_y) * 0,5):]
print ('len (test_x)', len (test_x))
print ('len (test_y)', len (test_y))

train_data = TensorDataset (torch.tensor (np.asarray (train_x)), torch.tensor (np.asarray (train_y)))
valid_data = TensorDataset (torch.tensor (np.asarray (valid_x)), torch.tensor (np.asarray (valid_y)))
test_data = TensorDataset (torch.tensor (np.asarray (test_x)), torch.tensor (np.asarray (test_y)))

# dataloaders
batch_size = 20 #număr de probe procesate înainte de actualizarea modelului

train_loader = DataLoader (train_data, shuffle = True, batch_size = batch_size, drop_last = True)
valid_loader = DataLoader (valid_data, shuffle = True, batch_size = batch_size, drop_last = True)
test_loader = DataLoader (test_data, shuffle = True, batch_size = batch_size, drop_last = True)

dataiter = iter (train_loader) # acces la datele de încorporare
sample_x, sample_y = dataiter.next ()
print ('Dimensiune de intrare eșantion:', sample_x.size ()) # batch_size, seq_length
print ('Eșantion de intrare: \ n', eșantion_x)
imprimare ()
print ('Dimensiune etichetă eșantion:', sample_y.size ()) # batch_size
print („Exemplu de etichetă: \ n”, sample_y)
train_on_gpu = torch.device ("cpu") # Training pe CPU
clasa SentimentLSTM (nn.Module):
" "
Modelul RNN care va fi utilizat pentru efectuarea analizei sentimentelor.
" "

def __init __ (self, vocab_size, output_size, embedding_dim, hidden_dim, n_layers, drop_prob = 0.5): # constructorul pentru a defini diferitele straturi pe care le vom avea
" "
Inițializați modelul configurând straturile.
" "

---