Сверточная нейросеть для опознованее 2-х статей википедии.Как обычно не справилась:)

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
from pybrain.tools.customxml.networkreader import NetworkReader
import numpy as np
 
 
from tqdm import tqdm
import argparse
import pickle
 
from CNN.utils import initializeFilter, initializeWeight
from CNN.utils import convolution, maxpool
from CNN.forward import softmax
 
 
from CNN.network import conv
 
import numpy as np
import pickle
from tqdm import tqdm
 
# --------------------------------------------------------------------------------------------
# Глобалы
# --------------------------------------------------------------------------------------------
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'
nepochs_word2vec=10
seed_word2vec=42
min_count_word2vec=0
fname_2test_nn1='test_article_calculation.txt'
fname_2test_nn2='test_article_printing.txt'
fname_saved_nn='articles_wiki.xml'
'''
 Сверточная нейро-сеть Numpy-CNN
 f - размер квадратного фильтра
 s - stride - шаг фильтра
'''
num_classes=2
batch_size_cnn=1
kvadr_img_size=vec_size
img_channel=1
first_conv_layer_channel=img_channel
num_epochs_cnn=10
l_r_cnn=0.07
f_first_conv_layer=2
num_first_conv_filters=4
f_sec_conv_layer=2
f_third_maxpool_layer=2
num_sec_filters=num_first_conv_filters
s_first_conv_layer=1
s_sec_conv_layer=1
s_third_maxpool_layer=2
# Полносвязные слои
matrix_3D_after_first_conv_kvadr_size=int((kvadr_img_size - f_first_conv_layer)/s_first_conv_layer)+1 # 9
print('matrix_3D_after_first_conv_kvadr_size', matrix_3D_after_first_conv_kvadr_size)
matrix_3D_after_sec_conv_kvadr_size=int((matrix_3D_after_first_conv_kvadr_size - f_sec_conv_layer)/s_sec_conv_layer)+1 # 8
print('matrix_3D_after_sec_conv_kvadr_size', matrix_3D_after_sec_conv_kvadr_size)
matrix_3D_after_third_maxpool_kvadr_size=int((matrix_3D_after_sec_conv_kvadr_size - f_third_maxpool_layer)/s_third_maxpool_layer)+1 # 4
print('matrix_3D_after_third_maxpool_kvadr_size', matrix_3D_after_third_maxpool_kvadr_size)
w4_width=matrix_3D_after_third_maxpool_kvadr_size ** 2 * num_first_conv_filters
print('w4_width', w4_width)
w4_height=int(3/2 * w4_width)
w4=(w4_height, w4_width)
print('w4', w4)
w5=(num_classes, w4_height)
print('w5', w5)
fname_saved_cnn='params.pkl'
'''
 /Сверточная нейро-сеть Numpy-CNN
 f - размер квадратного фильтра
 s - stride - шаг фильтра
'''
# ---------------------------------------------------------------------------------------------
# /Глобалы
# ---------------------------------------------------------------------------------------------
 
def evaluate(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
 
    params, cost = pickle.load(open(fname_saved_cnn, 'rb'))
    [f1, f2, w3, w4, b1, b2, b3, b4] = params
    for row in range(rows):
        x_test = X_test[row]
        y_test = Y_test[row]
 
        x_test=x_test.reshape(1, kvadr_img_size, kvadr_img_size) 
        out_nn = predict(x_test, f1, f2, w3, w4, b1, b2, b3, b4)
        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
                
            else:
                elem_of_out_nn = 0
               
            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 get_2layed_recurrent_net(net_inputs: tuple) -> RecurrentNetwork:  # ex (10, 15, 2)
    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 process_article_tokenize(article_text:str):
  # 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]  # Получаем 2D матрицу
                        if w not in stopwords.words('english')]  
    return all_words
 
def create_word2vec_obj(all_words):
  word2vec=Word2Vec(all_words, min_count=min_count_word2vec, vector_size=vec_size, epochs=nepochs_word2vec, seed=seed_word2vec)
  return word2vec
  
 
def get_word2vec_model(url_article):
    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 
    all_words=process_article_tokenize(article_text)
    word2vec = create_word2vec_obj(all_words)
    return word2vec
 
 
def process_cnn_word2vec_matrix_and_save_nn2file(): 
    word2vec_models_fnames: list = None
    word2vec_models_fnames = os.listdir(word2vec_model_save_folder)
    len_word2vec_models_fnames = len(word2vec_models_fnames)
    X = []
    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)
        X_inner_2D = []
        for row in range(len_all_words):
            row_vector = word2vec.wv.get_vector(list(word2vec.wv.key_to_index.keys())[row])
            X_inner_2D.append(row_vector)
        X_inner_2D = np.array(X_inner_2D, dtype=object)
        X_inner_2D-=np.mean(X_inner_2D) 
        X_inner_2D=np.dot(X_inner_2D.T, X_inner_2D)/X_inner_2D.shape[0] # квадратизируем матрицу
        X_inner_2D_to1D=X_inner_2D.reshape(X_inner_2D.shape[0] ** 2)  # для целей Numpu-CNN
        print('X_inner_2D_to1D shape', X_inner_2D_to1D.shape)
 
        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))
        Y.append(one_hot_encoded_list_target)
        X.append(X_inner_2D_to1D)
    
    train(X, Y, num_epochs=num_epochs_cnn, img_dim=kvadr_img_size, w4_=w4, w5_=w5, f=f_first_conv_layer, num_filt1=num_first_conv_filters, num_filt2=num_sec_filters, batch_size=batch_size_cnn, save_path=fname_saved_cnn)
 
    print(evaluate(X, Y)) 
 
# Переопределим функцию train() пакета Numpy-CNN
def train(X, Y, num_classes = 2, lr = l_r_cnn, beta1 = 0.95, beta2 = 0.99, img_dim =10, img_depth = 1, f = 5, num_filt1 = 4, num_filt2 = 4, w4_=(128, 800), w5_=(10, 128), batch_size = 12, num_epochs = 2, save_path = 'params.pkl'):
    X, Y=np.array(X), np.array(Y)
    # training data
    train_data = np.hstack((X,Y))
 
    np.random.shuffle(train_data)
 
    ## Initializing all the parameters
    f1, f2, w3, w4 = (num_filt1 ,img_depth,f,f), (num_filt2 ,num_filt1,f,f), w4_, w5_
    f1 = initializeFilter(f1)
    f2 = initializeFilter(f2)
    w3 = initializeWeight(w3)
    w4 = initializeWeight(w4)
 
    b1 = np.zeros((f1.shape[0],1))
    b2 = np.zeros((f2.shape[0],1))
    b3 = np.zeros((w3.shape[0],1))
    b4 = np.zeros((w4.shape[0],1))
 
    params = [f1, f2, w3, w4, b1, b2, b3, b4]
 
    cost = []
 
    print("LR:"+str(lr)+", Batch Size:"+str(batch_size))
 
    X_height=train_data.shape[0] 
    # Итерация проход по матрице обучающего набора
    for epoch in range(num_epochs):
        np.random.shuffle(train_data)
        # срез, выделение группы рядов
        batches = [train_data[k:k + batch_size] for k in range(0, X_height, batch_size)]
 
        t = tqdm(batches)
        for x, batch in enumerate(t):
            params, cost = adamGD(batch, num_classes, lr, img_dim, img_depth, beta1, beta2, params, cost)
            t.set_description("Cost: %.2f" % (cost[-1]))
            
    to_save = [params, cost]
    
    with open(save_path, 'wb') as file:
        pickle.dump(to_save, file)
        
    return cost
 
# Переопределим функцию adamGD() пакета Numpy-CNN
def adamGD(batch, num_classes, lr, dim, n_c, beta1, beta2, params, cost):
    '''
    update the parameters through Adam gradient descnet.
    '''
    [f1, f2, w3, w4, b1, b2, b3, b4] = params
    
    X = batch[:,0:-num_classes] # get batch inputs
    X = X.reshape(len(batch), n_c, dim, dim)
    Y = batch[:,-num_classes:] # get batch labels
    
    cost_ = 0
    batch_size = len(batch)
    
    # initialize gradients and momentum,RMS params
    df1 = np.zeros(f1.shape)
    df2 = np.zeros(f2.shape)
    dw3 = np.zeros(w3.shape)
    dw4 = np.zeros(w4.shape)
    db1 = np.zeros(b1.shape)
    db2 = np.zeros(b2.shape)
    db3 = np.zeros(b3.shape)
    db4 = np.zeros(b4.shape)
    
    v1 = np.zeros(f1.shape)
    v2 = np.zeros(f2.shape)
    v3 = np.zeros(w3.shape)
    v4 = np.zeros(w4.shape)
    bv1 = np.zeros(b1.shape)
    bv2 = np.zeros(b2.shape)
    bv3 = np.zeros(b3.shape)
    bv4 = np.zeros(b4.shape)
    
    s1 = np.zeros(f1.shape)
    s2 = np.zeros(f2.shape)
    s3 = np.zeros(w3.shape)
    s4 = np.zeros(w4.shape)
    bs1 = np.zeros(b1.shape)
    bs2 = np.zeros(b2.shape)
    bs3 = np.zeros(b3.shape)
    bs4 = np.zeros(b4.shape)
    
    for i in range(batch_size):
        
        x = X[i]
        y=Y[i].reshape(num_classes, 1)
        
        # Collect Gradients for training example
        grads, loss = conv(x, y, params, conv_s=s_first_conv_layer, pool_f=f_third_maxpool_layer, pool_s=s_third_maxpool_layer)
        [df1_, df2_, dw3_, dw4_, db1_, db2_, db3_, db4_] = grads
        
        df1+=df1_
        db1+=db1_
        df2+=df2_
        db2+=db2_
        dw3=dw3 + dw3_
        db3=db3 + db3_
        dw4=dw4 + dw4_
        db4=db4 + db4_
 
        cost_+= loss
 
    # Parameter Update  
        
    v1 = beta1*v1 + (1-beta1)*df1/batch_size # momentum update
    s1 = beta2*s1 + (1-beta2)*(df1/batch_size)**2 # RMSProp update
    f1 =f1 - lr * v1/np.sqrt(s1+1e-7) # combine momentum and RMSProp to perform update with Adam
    
    bv1 = beta1*bv1 + (1-beta1)*db1/batch_size
    bs1 = beta2*bs1 + (1-beta2)*(db1/batch_size)**2
    b1 = b1 - lr * bv1/np.sqrt(bs1+1e-7)
   
    v2 = beta1*v2 + (1-beta1)*df2/batch_size
    s2 = beta2*s2 + (1-beta2)*(df2/batch_size)**2
    f2 = f2 - lr * v2/np.sqrt(s2+1e-7)
                       
    bv2 = beta1*bv2 + (1-beta1) * db2/batch_size
    bs2 = beta2*bs2 + (1-beta2)*(db2/batch_size)**2
    b2 = b2 - lr * bv2/np.sqrt(bs2+1e-7)
    
    v3 = beta1*v3 + (1-beta1) * dw3/batch_size
    s3 = beta2*s3 + (1-beta2)*(dw3/batch_size)**2
    s3=s3.astype(float)
    w3 =w3 - lr * v3/np.sqrt(s3+1e-7)
    
    bv3 = beta1*bv3 + (1-beta1) * db3/batch_size
    bs3 = beta2*bs3 + (1-beta2)*(db3/batch_size)**2
    bs3=bs3.astype(float)
    b3 =b3 - lr * bv3/np.sqrt(bs3+1e-7)
    
    v4 = beta1*v4 + (1-beta1) * dw4/batch_size
    s4 = beta2*s4 + (1-beta2)*(dw4/batch_size)**2
    s4=s4.astype(float)
    w4=w4 - lr * v4 / np.sqrt(s4+1e-7)
    
    bv4 = beta1*bv4 + (1-beta1)*db4/batch_size
    bs4 = beta2*bs4 + (1-beta2)*(db4/batch_size)**2
    bs4=bs4.astype(float)
    b4 = b4 - lr * bv4 / np.sqrt(bs4+1e-7)
    
 
    cost_ = cost_/batch_size
    cost.append(cost_)
 
    params = [f1, f2, w3, w4, b1, b2, b3, b4]
    
    return params, cost
 
# Переопределим функцию predict пакета nunpy-CNN
def predict(image, f1, f2, w3, w4, b1, b2, b3, b4, conv_s = s_first_conv_layer, pool_f = f_third_maxpool_layer, pool_s = s_third_maxpool_layer):
    '''
    Make predictions with trained filters/weights. 
    '''
    conv1 = convolution(image, f1, b1, conv_s) # convolution operation
    conv1[conv1<=0] = 0 #relu activation
    
    conv2 = convolution(conv1, f2, b2, conv_s) # second convolution operation
    conv2[conv2<=0] = 0 # pass through ReLU non-linearity
    
    pooled = maxpool(conv2, pool_f, pool_s) # maxpooling operation
    (nf2, dim2, _) = pooled.shape
    fc = pooled.reshape((nf2 * dim2 * dim2, 1)) # flatten pooled layer
    
    z = w3.dot(fc) + b3 # first dense layer
    z[z<=0] = 0 # pass through ReLU non-linearity
    
    out = w4.dot(z) + b4 # second dense layer
    probs = softmax(out) # predict class probabilities with the softmax activation function
    
    return probs       
 
 
# ---------------------------------------------------------
# Программа - это может быть обучение и/или тестирование
# ---------------------------------------------------------
 
# Обучение
def save_word2vec_models_and_process_nn_save_nn():
    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]+'.model'
        word2vec=get_word2vec_model(url)
        word2vec.save(os.path.join(word2vec_model_save_folder,saved_model_fname))
 
    process_cnn_word2vec_matrix_and_save_nn2file()
 
 
# Тестирование
def test_nn(fname_2test_nn):
  article=""
  with open(fname_2test_nn, 'r', encoding='utf-8') as f:
      article=f.read()
  params, cost = pickle.load(open(fname_saved_cnn, 'rb'))
  [f1, f2, w3, w4, b1, b2, b3, b4] = params
  all_words=process_article_tokenize(article)
  word2vec=create_word2vec_obj(all_words) 
  X=[]
  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.append(row_vector)
  X=np.array(X)
  X-=np.mean(X) 
  X=np.dot(X.T, X)/X.shape[0] # квадратная 
  X=X.reshape(1, kvadr_img_size, kvadr_img_size)
  res = predict(X, f1, f2, w3, w4, b1, b2, b3, b4)
  
  res=res.tolist()
  print('res', res)
 
save_word2vec_models_and_process_nn_save_nn()
test_nn(fname_2test_nn1)
 
 
 
# ---------------------------------------------------------
# /Программа - это может быть обучеие и/или тестирование
# ---------------------------------------------------------
'''
Out:
 
matrix_3D_after_first_conv_kvadr_size 9
matrix_3D_after_sec_conv_kvadr_size 8
matrix_3D_after_third_maxpool_kvadr_size 4
w4_width 64
w4 (96, 64)
w5 (2, 96)
X_inner_2D_to1D shape (100,)
Calculation.model article encoded as [1, 0]
X_inner_2D_to1D shape (100,)
Printing.model article encoded as [0, 1]
LR:0.07, Batch Size:1
Cost: 0.73: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████| 2/2 [00:00<00:00, 14.39it/s]
Cost: 0.76: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████| 2/2 [00:00<00:00, 13.61it/s]
Cost: 0.75: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████| 2/2 [00:00<00:00, 14.71it/s]
Cost: 0.73: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████| 2/2 [00:00<00:00, 14.08it/s]
Cost: 0.73: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████| 2/2 [00:00<00:00, 12.90it/s]
Cost: 0.73: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████| 2/2 [00:00<00:00, 14.93it/s]
Cost: 0.73: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████| 2/2 [00:00<00:00, 13.33it/s]
Cost: 0.73: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████| 2/2 [00:00<00:00, 13.51it/s]
Cost: 0.73: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████| 2/2 [00:00<00:00, 14.93it/s]
Cost: 0.73: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████| 2/2 [00:00<00:00, 11.76it/s]
50.0
На тестовые вопросы тоже неправильно отвечает, одно и то же.
'''