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

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

Запись от Konst2016 размещена 11.08.2021 в 15:54

Здравствуйте!Собираюсь написать как я обучал сеть (сверточную) на матрице из векторов word2vec пакета gensim.Писал в прошлых
статьях про обработку есстесственного языка.Там я использовал рекурентную сеть pybrain и представлял каждую статью(а их было 2 -
на англ. языке про вычесление и печатанье из википедии)как вектор(ведь окончательное реальное тестирование надо проводить на векторе)
среднего по рядам такой матрице.Ошибка там уменьшалась, но реально нейросеть не опознавала разницу между этими 2-мя векторами(функция evaluate() - 10%).
Подумал что сверточная нейросеть(numpy-CNN на github), что то сможет, она тоже не смогла это.Немного переделовал функции этого пакета.
Остались функции от предыдущих тестов.
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
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
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
На тестовые вопросы тоже неправильно отвечает, одно и то же.
'''
Размещено в Без категории
Показов 3186 Комментарии 1
Всего комментариев 1
Комментарии
  1. Старый комментарий
    Т.е. сигнал не проступил.
    Запись от Konst2016 размещена 15.08.2021 в 18:49 Konst2016 вне форума
 
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2021, vBulletin Solutions, Inc.