Форум программистов, компьютерный форум, киберфорум
Konst2016
Войти
Регистрация
Восстановить пароль
Рейтинг: 1.00. Голосов: 1.

Скрипт.Обработка естесственного языка.Сеть обучается на 2х статьях википедии

Запись от Konst2016 размещена 02.08.2021 в 22:02

Здравствуйте!Написал код как 2-хслойная нейросеть обрабатывает матрицу, полученную от операции word2vec(пакет gensim)
, а это операция требует урлы статей из википедии про что такое вычисление и печатанье.Они даны в файле I.txt так:
https://en.wikipedia.org/wiki/Calculation
https://en.wikipedia.org/wiki/Printing
Сеть пока обучилась и показала оценку на тренировочных данных 100%.Она работала с сжатой матрицей.
Модели word2vec скрипт ложил в 'word2vec_model_save_folder/', а обученную сеть
в 'nn_model_trained_save_folder/'
Python
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
import bs4 as bs
import urllib.request
import nltk
from nltk.corpus import stopwords
from gensim.models import Word2Vec
import re
import os
import sys
from pybrain.structure import RecurrentNetwork, FullConnection, LinearLayer, SigmoidLayer, SoftmaxLayer
from pybrain.datasets import SupervisedDataSet
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.tools.customxml.networkwriter import NetworkWriter
import numpy as np
 
#--------------------------------------------------------------------------------------------
# Глобалы
#--------------------------------------------------------------------------------------------
vec_size=10 # размер вектора слова от word2vec обработки
input_articles_fname='I.txt' # файл с урлами статей из википедии
word2vec_model_save_folder='word2vec_model_save_folder/' # создаем папки на уровне скрипта
nn_model_trained_save_folder='nn_model_trained_save_folder/'
#---------------------------------------------------------------------------------------------
# /Глобалы
#---------------------------------------------------------------------------------------------
 
 
def get_2layed_recurrent_net(net_inputs:tuple)->RecurrentNetwork: # (10, 15, 1)
       assert len(net_inputs)==3, "nets inputs must be tuple with len 3"
       #Define network structure
       first_layer_ninputs=net_inputs[0]
       sec_layer_ninputs=net_inputs[1]
       third_layer_ninputs=net_inputs[2]
       network = RecurrentNetwork(name="Rec")
   
       inputLayer = LinearLayer(first_layer_ninputs, name="Input")
       hiddenLayer = SigmoidLayer(sec_layer_ninputs, name="Hidden")
       outputLayer = SoftmaxLayer(third_layer_ninputs, name="Output")
 
       network.addInputModule(inputLayer)
       network.addModule(hiddenLayer)
       network.addOutputModule(outputLayer)
 
       c1 = FullConnection(inputLayer, hiddenLayer, name="Input_to_Hidden")
       c2 = FullConnection(hiddenLayer, outputLayer, name="Hidden_to_Output")
       c3 = FullConnection(hiddenLayer, hiddenLayer, name="Recurrent_Connection")
 
       network.addConnection(c1)
       network.addRecurrentConnection(c3)
       network.addConnection(c2)
 
       network.sortModules()
       return network
 
 
def evaluate(net , X_test, Y_test):
        scores = []
        res_acc = 0
        rows = len(X_test)
        wi_y_test = len(Y_test[0])
        elem_of_out_nn = 0
        elem_answer = 0
        is_vecs_are_equal = False
        out_nn=None
        for row in range(rows):
            x_test = X_test[row]
            y_test = Y_test[row]
 
            out_nn = net.activate(x_test)
            for elem in range(wi_y_test):
                elem_of_out_nn = out_nn[elem]
                elem_answer = y_test[elem]
                if elem_of_out_nn > 0.5:
                    elem_of_out_nn = 1
                    # print("output vector elem -> ( %f ) " % 1, end=' ')
                    # print("expected vector elem -> ( %f )" %
                        #   elem_answer, end=' ')
                else:
                    elem_of_out_nn = 0
                    # print("output vector elem -> ( %f ) " % 0, end=' ')
                    # print("expected vector elem -> ( %f )" %
                        #   elem_answer, end=' ')
                if elem_of_out_nn == elem_answer:
                    is_vecs_are_equal = True
                else:
                    is_vecs_are_equal = False
                    break
            if is_vecs_are_equal:
                # print("-Vecs are equal-")
                scores.append(1)
            else:
                # print("-Vecs are not equal-")
                scores.append(0)
 
        res_acc = sum(scores) / rows * 100
 
        return res_acc
 
def write_word2vec_model2file(url_article:str, fname:str):
   scrapped_data = urllib.request.urlopen(url_article)
   article = scrapped_data .read()
 
   parsed_article = bs.BeautifulSoup(article,'lxml')
 
   paragraphs = parsed_article.find_all('p')
 
   article_text = ""
 
   for p in paragraphs:
      article_text += p.text
 
   # Cleaing the text
   processed_article = article_text.lower()
   processed_article = re.sub('[^a-zA-Z]', ' ', processed_article )
   processed_article = re.sub(r'\s+', ' ', processed_article)
 
   # Preparing the dataset
   all_sentences = nltk.sent_tokenize(processed_article)
 
   all_words = [nltk.word_tokenize(sent) for sent in all_sentences]
 
   # Removing Stop Words
 
   len_all_words=len(all_words)
   for i in range(len_all_words):
      all_words[i] = [w for w in all_words[i] if w not in stopwords.words('english')]
 
   word2vec = Word2Vec(all_words, min_count=0, vector_size=vec_size)
   word2vec.save(word2vec_model_save_folder+fname)
 
 
def process_nn_word2vec_matrix_and_save_nn2file(error_nn_2exit:float, nn_save_fname:str):
   word2vec_models_fnames:list=None    
   word2vec_models_fnames=os.listdir(word2vec_model_save_folder)
   len_word2vec_models_fnames=len(word2vec_models_fnames)    
   X=None
   X_tmp=[]
   Y=[]
   
   # Получаем матрицу X и Y из файлов word2vec модели
   # Обрабатываем все файлы
   for idx, word2vec_models_fname in enumerate(word2vec_models_fnames):     
      word2vec = Word2Vec.load(os.path.join(word2vec_model_save_folder, word2vec_models_fname))
      len_all_words=len(word2vec.wv)
      for row_count in range(len_all_words):
         row_vector=word2vec.wv.get_vector(list(word2vec.wv.key_to_index.keys())[row_count]) 
         X_tmp.append(row_vector)
      X_tmp=np.array(X_tmp)
 
      #-----------------------------------------------------------------------------------------
      # Предобработка (convergence matrix) сжимаем матрицу в рядах - нет переобучения, принимает
      #-----------------------------------------------------------------------------------------
      X_tmp-=np.mean(X_tmp, axis=0)
      X_tmp=np.dot(X_tmp.T, X_tmp)/X_tmp.shape[0] # квадратная
      #------------------------------------------------------------------------------------------
      # /Предобработка (convergence matrix) сжимаем матрицу в рядах - нет переобучения, принимает
      #------------------------------------------------------------------------------------------
      one_hot_encoded_list_target=[0]*len_word2vec_models_fnames
      
      one_hot_encoded_list_target[idx]=1
      print('%s article encoded as %s'%(word2vec_models_fname, one_hot_encoded_list_target))
      for row in range(vec_size):
            Y.append(one_hot_encoded_list_target)
      X_tmp=X_tmp.tolist()      
   X=X_tmp
   height_X=len(X)
 
   nn_nout=len_word2vec_models_fnames
   nn_nin=vec_size
   nn_nmiddle=int(nn_nin * 3/2)
      
   network = get_2layed_recurrent_net((nn_nin , nn_nmiddle, nn_nout))  
   #Add a data set
   ds = SupervisedDataSet(nn_nin, nn_nout)    
   for row in range(height_X):
      ds.addSample(X[row], Y[row]) 
 
 
   #Train the network
   trainer = BackpropTrainer(network, ds, momentum=0.99)
 
   max_error = error_nn_2exit #0.001 
   error= 1
   #Train
   while abs(error) >= max_error:
      error = trainer.train()
      print('err {0:.5f}'.format(error))
 
   print("Error: {0:.5f}".format(error))
   
   print(evaluate(network, X, Y))
 
   NetworkWriter.writeToFile(network, nn_model_trained_save_folder+nn_save_fname+'.xml')   
 
#---------------------------------------------------------
# Программа
#---------------------------------------------------------
 
urls_articles:list=None
with open(input_articles_fname, 'r') as f:
   urls_articles=f.readlines()
 
# сохраняем word2vec модели
for i in urls_articles:
  i=i.strip().rstrip('\n\r')
  url=i
  saved_model_fname=i.split('/')[-1]
  write_word2vec_model2file(url, saved_model_fname+'.model')
 
process_nn_word2vec_matrix_and_save_nn2file(0.001, 'articles_wiki')  
 
#---------------------------------------------------------
# /Программа
#---------------------------------------------------------
"""
Out:
Calculation.model article encoded as [1, 0]
Printing.model article encoded as [0, 1]
err 0.32456
err 0.00803
err 0.00000
Error: 0.00000
100.0
 
"""
Размещено в Без категории
Показов 1882 Комментарии 2
Всего комментариев 2
Комментарии
  1. Старый комментарий
    А что значит "сеть обучается"? Она что, способна на творчество? Всерьёз верите в существование искусственного интеллекта? Мозг не работает на классической логике. Даже в такой простой сфере, как математика бинарная логика даёт сбой.
    Запись от Ellipsoid размещена 03.08.2021 в 21:50 Ellipsoid вне форума
    Обновил(-а) Ellipsoid 03.08.2021 в 21:53
  2. Старый комментарий
    В данном примере я не смог проверить ее на обработке естесственного языка.А вообще она же может расспознавать картинки,
    внутри нее образуется как бы хэш каких то данных, способна классифицировать.Пока что результат что она формально обучается.
    Запись от Konst2016 размещена 03.08.2021 в 23:30 Konst2016 вне форума
 
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2021, vBulletin Solutions, Inc.