def create(user, category_id, network_hr=None, dataset_hr=None, network_dy=None, dataset_dy=None): res = CategoryAdvisor() res.user = user res.category_id = category_id if network_hr is None: res.bprnetw_hr = buildNetwork(CategoryAdvisor.OBSERVE_LENGTH, 20, CategoryAdvisor.PREDICT_LENGTH, outclass=LinearLayer, bias=True, recurrent=True) else: res.bprnetw_hr = network_hr if dataset_hr is None: res.dataset_hr = SupervisedDataSet(CategoryAdvisor.OBSERVE_LENGTH, CategoryAdvisor.PREDICT_LENGTH) else: res.dataset_hr = dataset_hr if network_dy is None: res.bprnetw_dy = buildNetwork(CategoryAdvisor.OBSERVE_LENGTH, 20, CategoryAdvisor.PREDICT_LENGTH, outclass=LinearLayer, bias=True, recurrent=True) else: res.bprnetw_dy = network_dy if dataset_dy is None: res.dataset_dy = SupervisedDataSet(CategoryAdvisor.OBSERVE_LENGTH, CategoryAdvisor.PREDICT_LENGTH) else: res.dataset_dy = dataset_dy return res
def buildDecomposableNetwork():
""" three hidden neurons, with 2 in- and 2 outconnections each. """
n = buildNetwork(2, 3, 2, bias=False)
ndc = NeuronDecomposableNetwork.convertNormalNetwork(n)
# set all the weights to 1
ndc._setParameters(ones(12))
return ndc
def setupNN(self, trainer=RPropMinusTrainer, hidden=None, **trnargs):
""" Constructs a 3-layer FNN for regression. Optional arguments are passed on to the Trainer class. """
if hidden is not None:
self.hidden = hidden
logging.info("Constructing FNN with following config:")
FNN = buildNetwork(self.DS.indim, self.hidden, self.DS.outdim)
logging.info(str(FNN) + "\n Hidden units:\n " + str(self.hidden))
logging.info("Training FNN with following special arguments:")
logging.info(str(trnargs))
self.Trainer = trainer(FNN, dataset=self.DS, **trnargs)
def trainingNetwork(self, words_classes_vector_list, number_epoch=1000):
"""
Метод преобразования слова в векторную форму.
"""
self.words_classes_vector_list = words_classes_vector_list
# Параметры нейронной сети
num_input_neuron = 25
num_output_neuron = len(words_classes_vector_list[0])
num_hidden_neuron = int((num_input_neuron + num_output_neuron) * 2 / 3)
#print("\n Основные параметры нейронной сети:")
#print(str(num_input_neuron) + " " + str(num_output_neuron) + " " + str(num_hidden_neuron))
_bias = False
_hiddenclass = SoftmaxLayer
_outclass = LinearLayer
_nb_classes = num_output_neuron
num_epoch = number_epoch
# Создание нейронной сети и датасетов
self.net = buildNetwork(num_input_neuron,
num_hidden_neuron,
num_output_neuron,
bias=_bias,
hiddenclass=_hiddenclass,
outclass=_outclass)
norgate = ClassificationDataSet(num_input_neuron,
num_output_neuron,
nb_classes=_nb_classes)
nortrain = ClassificationDataSet(num_input_neuron,
num_output_neuron,
nb_classes=_nb_classes)
# Заполнение нейронной сети
#print("\n Данные для обучения: ")
for elem in words_classes_vector_list[1]:
word = elem[0]
_class = elem[1]
#print(str(elem[2]) + " " + str(elem[0]) + " " + str(_class))
norgate.addSample(tuple(word), tuple(_class))
nortrain.addSample(tuple(word), tuple(_class))
# Обучение нейронной сети
trainer = BackpropTrainer(
self.net, norgate
) # , verbose=True, batchlearning=False, momentum= 0.1, learningrate= 0.01, weightdecay= 0.01, lrdecay=1.0
trnerr, valerr = trainer.trainUntilConvergence(dataset=nortrain,
maxEpochs=num_epoch,
verbose=False)
return (trnerr, valerr)
"""
def buildRecurrentNetwork():
N = buildNetwork(1,
1,
1,
recurrent=True,
bias=False,
hiddenclass=LinearLayer,
outputbias=False)
h = N['hidden0']
N.addRecurrentConnection(FullConnection(h, h))
N.sortModules()
N.name = 'RecurrentNetwork'
return N
def buildNestedNetwork():
""" build a nested network. """
N = FeedForwardNetwork('outer')
a = LinearLayer(1, name='a')
b = LinearLayer(2, name='b')
c = buildNetwork(2, 3, 1)
c.name = 'inner'
N.addInputModule(a)
N.addModule(c)
N.addOutputModule(b)
N.addConnection(FullConnection(a, b))
N.addConnection(FullConnection(b, c))
N.sortModules()
return N
def setupNN(self, trainer=RPropMinusTrainer, hidden=None, **trnargs):
""" Setup FNN and trainer for classification. """
self._convertAllDataToOneOfMany()
if hidden is not None:
self.hidden = hidden
FNN = buildNetwork(self.DS.indim,
self.hidden,
self.DS.outdim,
outclass=SoftmaxLayer)
logging.info("Constructing classification FNN with following config:")
logging.info(str(FNN) + "\n Hidden units:\n " + str(self.hidden))
logging.info("Trainer received the following special arguments:")
logging.info(str(trnargs))
self.Trainer = trainer(FNN, dataset=self.DS, **trnargs)
def trainClasifier(self, training_set):
dataSet = self.__createDataset(training_set)
mpl_conf = self.configuration_map['mlp_classifier_config']
self.__net = buildNetwork(
dataSet.indim, mpl_conf['hidden_nodes'], dataSet.outdim,
bias = mpl_conf['biasArg'] ,recurrent = mpl_conf['recurrentArg'] ,
hiddenclass = mpl_conf['hiddenclassArg'] , outclass = mpl_conf['outclassArg'])
self.__trainer = BackpropTrainer(
self.__net, dataSet, learningrate = mpl_conf['learningRateArg'],
momentum = mpl_conf['momentumArg'],verbose = mpl_conf['verbose'])
self.__trainer.trainUntilConvergence(continueEpochs=12, maxEpochs = mpl_conf['epochs'])
def __init__(self, unique_words, total_comments, hidden=400):
self._max_value = 0.9
self._min_value = 0.1
self.__unique_words = unique_words
self.__total_comments = total_comments
self.__conversion_rate = 0.5
print("Total de Comentários: ", self.__total_comments)
print("Total de Palavras Únicas: ", len(self.__unique_words))
unique_words_length = len(self.__unique_words)
# Construcao da rede com quantPalavrasUnicas na entradas, 1000 camadas ocultas e 1 saida
self.__network = buildNetwork(unique_words_length, hidden, 1)
# Base de dados com quantPalavrasUnicas atributos prevzisores e uma clase
self.__base = SupervisedDataSet(unique_words_length, 1)
'''
def buildMixedNestedNetwork():
""" build a nested network with the inner one being a ffn and the outer one being recurrent. """
N = RecurrentNetwork('outer')
a = LinearLayer(1, name='a')
b = LinearLayer(2, name='b')
c = buildNetwork(2, 3, 1)
c.name = 'inner'
N.addInputModule(a)
N.addModule(c)
N.addOutputModule(b)
N.addConnection(FullConnection(a, b))
N.addConnection(FullConnection(b, c))
N.addRecurrentConnection(FullConnection(c, c))
N.sortModules()
return N
def setupRNN(self, trainer=BackpropTrainer, hidden=None, **trnargs):
""" Setup an LSTM RNN and trainer for sequence classification. """
if hidden is not None:
self.hidden = hidden
self._convertAllDataToOneOfMany()
RNN = buildNetwork(self.DS.indim,
self.hidden,
self.DS.outdim,
hiddenclass=LSTMLayer,
outclass=SoftmaxLayer)
logging.info("Constructing classification RNN with following config:")
logging.info(str(RNN) + "\n Hidden units:\n " + str(self.hidden))
logging.info("Trainer received the following special arguments:")
logging.info(str(trnargs))
self.Trainer = trainer(RNN, dataset=self.DS, **trnargs)
from pybrain3.supervised.trainers import BackpropTrainer
import pickle
from sklearn.metrics import confusion_matrix
import matplotlib.pyplot as plt
#lectura de los datos con las caracteteristicas de cada imagen
data = []
archivo = 'caracteristicas con lata.csv'
datos = pd.read_csv(archivo, header=0)
data2 = []
archivo2 = 'caracteristicas sin lata.csv'
datos2 = pd.read_csv(archivo2, header=0)
#configuracion de la red neuronal (caracteristicas, capas de la red, salidas)
net = buildNetwork(7, 40, 2, bias=True)
ds = SupervisedDataSet(7, 2)
#lecctura de cada dato de la imagen
for j in range(0,len(datos)):
data.clear()
data2.clear()
for i in range(0,7):
data.append(datos.iloc[j,i])
data2.append(datos2.iloc[j,i])
#print('paso: ', data)
ds.addSample((data), (1,)) #asignacion de caracteristicas y etiqueta
ds.addSample((data2), (0,))
#print('paso: ', j)
#print(ds)
trainer = BackpropTrainer(net, ds) #entrenamiento de la red mediante la comparacion del error esperado
else:
ds.addSample(
(float(trainFeaturesArray[i, 0]), float(trainFeaturesArray[i, 1])),
(2))
# for i in range(height):
# if i < 25:
# ds.addSample((float(trainFeaturesArray[i, 0]), float(trainFeaturesArray[i, 1]), float(trainFeaturesArray[i, 2])), (0))
# elif i >= 25 and i < 50:
# ds.addSample((float(trainFeaturesArray[i, 0]), float(trainFeaturesArray[i, 1]), float(trainFeaturesArray[i, 2])), (1))
# else:
# ds.addSample((float(trainFeaturesArray[i, 0]), float(trainFeaturesArray[i, 1]), float(trainFeaturesArray[i, 2])), (2))
# ds.addSample((0.8, 0.4), (0.7))
# ds.addSample((0.5, 0.7), (0.5))
# ds.addSample((1.0, 0.8), (0.95))
nn = buildNetwork(2, 4, 1, bias=True)
# trainer = BackpropTrainer(nn, ds)
trainer = BackpropTrainer(nn, dataset=ds)
for j in range(750):
trainer.train()
for k in range(height):
if k < 25:
flag = 0
elif k > 25 and k < 51:
flag = 1
else:
flag = 2
prevision = nn.activate((testFeaturesArray[k, 0], testFeaturesArray[k,
def __init__(self, dimState, numActions, name=None):
Module.__init__(self, dimState, 1, name)
self.network = buildNetwork(dimState + numActions,
dimState + numActions, 1)
self.numActions = numActions
# cv2.imshow("imagen libre", dilatado)
# cv2.waitKey()
# cv2.destroyAllWindows()
momentos = []
momentos = cal_momentos(dila)
momentos.append(area)
momentos.append(perimetro)
momentos.append(circularidad)
momentos.append(media)
momentos.append(des_stand)
#print(momentos)
return momentos
net = buildNetwork(29, 5, 1, bias=True)
ds = SupervisedDataSet(29, 1)
veredicto = ""
output = [[0], [1]]
Ninput = [21, 21]
puntos = []
benigno = [[535, 425, 197], [522, 280, 69], [477, 133, 30], [525, 425, 33],
[471, 458, 40], [667, 365, 31], [595, 864, 68], [547, 573, 48],
[653, 477, 49], [493, 125, 49], [674, 443, 79], [322, 676, 43],
[388, 742, 66], [546, 463, 33], [462, 406, 44], [432, 149, 20],
[492, 473, 131], [544, 194, 38], [680, 494, 20], [612, 297, 34],
[714, 340, 23], [357, 365, 50], [600, 621, 111], [492, 434, 87],
[191, 549, 23], [523, 551, 48], [252, 788, 52], [347, 636, 26],
[669, 543, 49], [351, 661, 62]]
maligno = [[538, 681, 29], [338, 314, 56], [318, 359, 27], [266, 517, 28],
import pandas as pd
from pybrain3.datasets.supervised import SupervisedDataSet
from pybrain3.structure.modules.tanhlayer import TanhLayer
from pybrain3.supervised.trainers.backprop import BackpropTrainer
from pybrain3.tools.shortcuts import buildNetwork
from sklearn.model_selection import train_test_split
p = pd.read_csv(
'D:\pycharm_project\\fingerprint\Road_test_data_lte\my_test\single_cell_test_data\p3.csv'
)
p.fillna(value=0, inplace=True)
pX = p[['servingrsrp', 'rsrp0', 'rsrp1', 'rsrp2', 'rsrp3', 'rsrp4', 'rsrp5']]
py = p[['longitude', 'latitude']]
pX_train, pX_test, py_train, py_test = train_test_split(pX, py, test_size=0.1)
# 构建训练与测试数据集
training = SupervisedDataSet(pX_train.shape[1], 2)
for i in range(pX_train.shape[0]):
training.addSample(pX_train.iloc[i], py_train.iloc[i])
testing = SupervisedDataSet(pX_test.shape[1], 2)
for i in range(pX_test.shape[0]):
testing.addSample(pX_test.iloc[i], py_test.iloc[i])
# 构建人工神经外网络
net = buildNetwork(pX_train.shape[1], 4, 2, hiddenclass=TanhLayer, bias=True)
trainer = BackpropTrainer(net, training, learningrate=0.01)
trainer.trainEpochs(epochs=100)
predictions = net.activateOnDataset(dataset=testing)
y_predict = pd.DataFrame(predictions, columns=['longitude', 'latitude'])
print(y_predict)
# Redes Neurais utilizando Pybrain
from pybrain3.datasets import SupervisedDataSet
from pybrain3.tools.shortcuts import buildNetwork
from pybrain3.supervised import BackpropTrainer
# dimensões dos vetores de entrada e do objetivo
dataset = SupervisedDataSet(2, 1)
dataset.addSample([1, 1], [0])
dataset.addSample([1, 0], [1])
dataset.addSample([0, 1], [1])
dataset.addSample([0, 0], [0])
network = buildNetwork(dataset.indim, 4, dataset.outdim, bias=True)
trainer = BackpropTrainer(network, dataset, learningrate=0.01, momentum=0.99)
'''
for epoch in range(1000):
trainer.train()
'''
trainer.trainEpochs(1000)
'''
treinar até a convergência: trainer.trainUntilConvergence
'''
test_data = SupervisedDataSet(2, 1)
test_data.addSample([1, 1], [0])
test_data.addSample([1, 0], [1])
test_data.addSample([0, 1], [1])
ds.addSample((100, 6), (18.76))
ds.addSample((100, 7), (16.35))
ds.addSample((100, 8), (14.54))
ds.addSample((100, 9), (13.14))
ds.addSample((100, 10), (12.02))
ds.addSample((100, 11), (11.10))
ds.addSample((100, 12), (10.34))
'''
ds.addSample((200, 12), (20.68))
ds.addSample((6518.78, 1), (6518.78))
ds.addSample((6518.78, 3), (2326.33))
ds.addSample((6518.78, 5), (1443.38))
ds.addSample((6518.78, 8), (947.93))
ds.addSample((6518.78, 9), (856.47))
ds.addSample((6518.78, 10), (783.43))
ds.addSample((6518.78, 11), (723.79))
ds.addSample((6518.78, 12), (674.19))'''
nn = buildNetwork(2, 4, 1)
trainer = BackpropTrainer(nn, ds)
for i in range(20000):
print(trainer.train())
while True:
valor_inicial = float(input('Valor inicial: '))
numero_parcela = int(input('Quantidade parcelas '))
x = nn.activate((valor_inicial, numero_parcela))
print(f'Corresponde ao valor {x[0]:.2f}')
xlist2 = [0.2, 10]
xlist100 = list(range(12, 112))
xa1 = array(xlist1)
xa2 = array(xlist2)
xa100 = array(xlist100)
pc1 = ParameterContainer(1)
pc2 = ParameterContainer(2)
pc100 = ParameterContainer(100)
pc1._setParameters(xa1)
pc2._setParameters(xa2)
pc100._setParameters(xa100)
# for the task object, we need a module
nnet = buildNetwork(task.outdim, 2, task.indim)
# a mimimalistic Evolvable subclass that is not (like usual) a ParameterContainer
class SimpleEvo(Evolvable):
def __init__(self, x):
self.x = x
def mutate(self):
self.x += random() - 0.3
def copy(self):
return SimpleEvo(self.x)
def randomize(self):
self.x = 10 * random() - 2
data = SupervisedDataSet(33 * 33 * 33, L)
for text in authors[author]:
arr = np.zeros(33 * 33 * 33, dtype='int8')
for j in text[0]:
arr[int(j)] = text[0][j]
arr2 = np.zeros(L, dtype='int8')
arr2[classes.index(author)] = 1
data.addSample(arr, arr2)
del arr, arr2
print('!')
data.saveToFile('cashes/data_3_' + str(author) + '.mod')
del data
print(author, 'constructed')
print('data constructed')
del authors
net = buildNetwork(33 * 33 * 33, 10, 10, L, bias=True)
trainer = RPropMinusTrainer(net)
print('training started')
for i in range(20):
for author in authors:
data = SupervisedDataSet.loadFromFile('cashes/data_3_' +
str(author) + '.mod')
for j in range(5):
e = trainer.trainOnDataset(data)
print(i, author, j, 'time:', time.time() - time2, e)
del data
print(trainer.testOnData())
NetworkWriter.writeToFile(net, 'filename_3.xml')
s = 0
time3 = time.time()
print(time3 - time2)
#!/usr/local/bin/python3
from pybrain3.tools.shortcuts import buildNetwork
from pybrain3.datasets import *
from pybrain3.supervised.trainers import BackpropTrainer
from math import *
import time
test_func = lambda x, k: 0.5 + k * sin(2 * 3.1415 * x / 64)
start_time = time.time()
if __name__ == "__main__":
print(test_func(3, 5.54))
net = buildNetwork(3, 3, 1, bias=True)
ds = SupervisedDataSet(3, 1)
for x in range(10):
for k in range(10):
ds.addSample((x, test_func(x, k)), k)
train = BackpropTrainer(net, learningrate=0.01, momentum=0.05)
train.trainOnDataset(ds, 1000)
train.testOnData()
print(net.activate((3, 2)))
# print(test_func(90, 1))
print('Время выполнения: %s сек' % (time.time() - start_time))
from pybrain3.tools.shortcuts import buildNetwork # Para criar a rede neural
from pybrain3.datasets import SupervisedDataSet # Datasets/Conjunto de dados
from pybrain3.supervised.trainers import BackpropTrainer # Algoritmo para treinamento
datasets = SupervisedDataSet(2, 1) # Entradas e saídas
datasets.addSample(
(0.8, 0.4), 0.7
) # Quantidade de horas dormidas e quantidade de horas estudadas tendo tirado a nota
datasets.addSample((0.5, 0.7), 0.5)
datasets.addSample((0.1, 0.7), 0.95)
rede_neural = buildNetwork(
2, 4, 1, bias=True
) # Passada arquitetura da rede (2 neuronios na camada de entrada +
# 4 neuronio na camada oculta + 1 neuronio na camada de saída)
trainer = BackpropTrainer(rede_neural, datasets) # Treinador
for i in range(2000): # Treinando a rede neural 2000 vezes
print(trainer.train())
while True:
dormiu = float(input('Dormiu quanto tempo? '))
estudou = float(input('Estudou quanto tempo? '))
z = rede_neural.activate((dormiu, estudou))[0] * 10
print(f'Precisão da nota: {z}')
from pybrain3.tools.shortcuts import buildNetwork
from pybrain3.datasets import SupervisedDataSet
from pybrain3.supervised.trainers import BackpropTrainer
ds = SupervisedDataSet(2, 1)
ds.addSample((0.8, 0.4), (0.7))
ds.addSample((0.5, 0.7), (0.5))
ds.addSample((1.0, 0.8), (0.95))
#Utilizando "bias" para o algoritmo treinar mais rápido
nn = buildNetwork(2, 16, 1, bias=True)
#treinando o algoritmo
trainer = BackpropTrainer(nn, ds)
#analisando a evolução do algoritmo
for i in range(2000):
print(trainer.train())
#com o buildNetwork utilizando 4 neurônios, temos 0.013496550372475475 de margem de erro
#com o buildNetwork utilizando 16 neurônios, temos 0.0009338957668739359 de margem de erro
#teste 1 com 512 neurônios: 1.6434602192104412e-32 de margem de erro
#teste 2 com 512 neurônios: 1.3702349577667055e-30 de margem de erro
#irei utilizar neste algoritmo apenas 16 neurônios
#alguns testes por curiosidade
while True:
sleep = float(input("How many hours did you sleep? "))
study = float(input("How many hours did you study? "))
#aqui vai a nossa base de aprendizado
base = (
#8 horas dormidas, 2 horas estudadas, 7.1 de nota na prova
((8, 2), (7.1,)),
((10, 1), (2.3,)),
((7.5, 3), (8.0,)),
((3.5, 10), (2.5)),
)
#aqui aplicamos os numeros usados como base de aprendizado acima
for example in base:
ds.addSample(example[0], example[1])
#aqui criamos a rede neural com a base de aprendizado anterior
nn = buildNetwork(2, 4, 1) # 2=neurónios, 4=camadas ocultas, 1 = uma saida
#aqui definimos o treinador, informamos a rede neural e a base de aprendizado
trainer = BackpropTrainer(nn, ds)
#aqui vamos treinar a rede neural, quanto maior de treinamentos, menores serão as chances de erros
for i in range(10000):#melhorar a base de aprendizado é infinitamente mais eficiente que deixar esse numero alto
print(trainer.train())
#aqui vamos perguntar ao usuário o tempo dormindo e horas estudadas e vamos prever a nota dele
while True:
horas_dormidas = float(input('O aluno vai dormir quantas horas? '))
horas_estudadas = float(input('O aluno vai estudar quantas horas? '))
nota = nn.activate((horas_dormidas, horas_estudadas))
print(f'O aluno vai tirar aproxiamadamente {nota[0]:.2f} pontos na prova')
train_data, part_data = dataset.splitWithProportion(0.6)
print('Quantidade para treino %d' % len(train_data))
#dividindo os dados para teste e validação
test_data, val_data = part_data.splitWithProportion(0.5)
print('Quantidade para teste %d' % len(test_data))
print('Quantidade para validação %d' % len(val_data))
# In[19]:
from pybrain3.tools.shortcuts import buildNetwork
from pybrain3.supervised.trainers import BackpropTrainer
net = buildNetwork(dataset.indim, 3, dataset.outdim)
trainer = BackpropTrainer(net, dataset=train_data, learningrate=0.01, momentum=0.1, verbose=True)
train_errors, val_errors = trainer.trainUntilConvergence(dataset=train_data, maxEpochs=100)
# In[20]:
import matplotlib.pyplot as plt
get_ipython().run_line_magic('matplotlib', 'inline')
plt.plot(train_errors, 'b', val_errors, 'r')
plt.show()
trainer.totalepochs
suavidad = 1 - (1 / (1 + (desv_estandar**2)))
print(suavidad)
oblicuidad = 0
for i in range(0, len(hist)):
oblicuidad = oblicuidad + ((hist[i] - media)**3)
oblicuidad = oblicuidad / (len(hist) * (desv_estandar**3))
print(oblicuidad)
# areaInteres = regionInteres(img_limpia)
# momentos=moments(areaInteres)
#print(momentos)
#-----------------------------Entrenamiento------------------------------
net = buildNetwork(
4, 10, 1,
bias=True) #Red neuronal. Num. Entradas,Capas ocultas, y salidas
ds = SupervisedDataSet(4, 1)
if j == 1:
print("normales")
ds.addSample((media, desv_estandar, suavidad, oblicuidad), (0, ))
if j == 2:
print("tumor")
ds.addSample((media, desv_estandar, suavidad, oblicuidad), (1, ))
trainer = BackpropTrainer(net, ds)
error = round(trainer.train(), 7)
while error > 0.15: #Minimo error soportado
error = round(trainer.train(), 7)
# Первый аргумент -- количество признаков np.shape(X)[1], второй аргумент -- количество меток классов len(np.unique(y_train)))
ds_train.setField('input', X_train) # Инициализация объектов
ds_train.setField('target', y_train[:, np.newaxis]
) # Инициализация ответов; np.newaxis создает вектор-столбец
ds_train._convertToOneOfMany() # Бинаризация вектора ответов
# Контрольная часть
ds_test = ClassificationDataSet(np.shape(X)[1],
nb_classes=len(np.unique(y_train)))
ds_test.setField('input', X_test)
ds_test.setField('target', y_test[:, np.newaxis])
ds_test._convertToOneOfMany()
np.random.seed(0)
# Построение сети прямого распространения (Feedforward network)
net = buildNetwork(ds_train.indim,
HIDDEN_NEURONS_NUM,
ds_train.outdim,
outclass=SoftmaxLayer)
# ds.indim -- количество нейронов входного слоя, равне количеству признаков
# ds.outdim -- количество нейронов выходного слоя, равное количеству меток классов
# SoftmaxLayer -- функция активации, пригодная для решения задачи многоклассовой классификации
init_params = np.random.random(
(len(net.params)
)) # Инициализируем веса сети для получения воспроизводимого результата
net._setParameters(init_params)
# Модуль настройки параметров pybrain использует модуль random; зафиксируем seed для получения воспроизводимого результата
np.random.seed(0)
trainer = BackpropTrainer(
net, dataset=ds_train) # Инициализируем модуль оптимизации
err_train, err_val = trainer.trainUntilConvergence(maxEpochs=MAX_EPOCHS)
