def cycle():
lerns = SupervisedDataSet(1024, 2)
do_R = input_image.analyse()
for i in range():
adress = "learning_data/folder"+n
data = do_R.transform_in_data(adress)
lerns.addSample((data), (1,0))
return lerns
def makeMnistDataSets(path):
"""Return a pair consisting of two datasets, the first being the training
and the second being the test dataset."""
test = SupervisedDataSet(28 * 28, 10)
test_image_file = os.path.join(path, 't10k-images-idx3-ubyte')
test_label_file = os.path.join(path, 't10k-labels-idx1-ubyte')
test_images = images(test_image_file)
test_labels = (flaggedArrayByIndex(l, 10) for l in labels(test_label_file))
for image, label in zip(test_images, test_labels):
test.addSample(image, label)
train = SupervisedDataSet(28 * 28, 10)
train_image_file = os.path.join(path, 'train-images-idx3-ubyte')
train_label_file = os.path.join(path, 'train-labels-idx1-ubyte')
train_images = images(train_image_file)
train_labels = (flaggedArrayByIndex(l, 10)
for l in labels(train_label_file))
for image, label in zip(train_images, train_labels):
train.addSample(image, label)
return train, test
class download_data_to_learn():
def __init__(self):
self.learnig_data_placement = os.path.dirname(os.path.realpath(__file__))+'/learnig_data/Folder'
self.all_files = []
self.imgs_arrays = [[],[],[],[]]
self.weights = SupervisedDataSet(1024, 2)
def Found_Learnig_Filles(self):
for i in range(4):
self.all_files.append(os.listdir(self.learnig_data_placement+str(i)))
def add_learning_information(self,resultat_nember=0):
img_adresse = self.all_files[resultat_nember]
for image_name in img_adresse:
img = self.binnarizing_img(self.learnig_data_placement+str(resultat_nember)+'/'+image_name)
self.imgs_arrays[resultat_nember].append(np.asarray(img))
for img_nember in range(len(self.all_files[resultat_nember])-1):
end_response = self.flatting_arrays(self.imgs_arrays[resultat_nember][img_nember].tolist())
self.weights.addSample((end_response), self.tranlater(resultat_nember))
def binnarizing_img(self, img_adresse):
file = Image.open(img_adresse)
img_convert = file.convert("L")
data = np.asarray(img_convert)
resultat = (data < 200) * 1
return resultat
def flatting_arrays(self, array):
flatten = lambda l: [item for sublist in l for item in sublist]
return flatten(array)
def tranlater(self, x):
binar_number = '{0:02b}'.format(x)
return [int(i) for i in list(binar_number)]
def cycle():
lerns = SupervisedDataSet(1024, 2)
do_R = lb.analyse()
for i in range(1, 104):
adress = "folder 1/" + str(i) + ".jpg"
data = do_R.transform_in_data(adress)
lerns.addSample((data), (1, 0))
for i in range(1, 106):
adress = "folder 2/" + str(i) + ".jpg"
data = do_R.transform_in_data(adress)
lerns.addSample((data), (0, 0))
for i in range(1, 75):
adress = "folder 3/" + str(i) + ".jpg"
data = do_R.transform_in_data(adress)
lerns.addSample((data), (0, 1))
for i in range(1, 66):
adress = "folder 4/" + str(i) + ".jpg"
data = do_R.transform_in_data(adress)
lerns.addSample((data), (1, 1))
return lerns
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
er = round(trainer.train(), 3)
while er > 0.112: #error esperado
er = round(trainer.train(), 3)
#print(er)
filename = "NNa{0}b{1}.pk1".format(2,3)
pickle.dump(net, open(filename,'wb'))
def preprocesamiento_img(img):
kernel = np.ones((3, 3), np.uint8)
hsv_img = cv.cvtColor(img, cv.COLOR_BGR2HSV)
from pybrain3.datasets import SupervisedDataSet
inputDataSet = SupervisedDataSet(35, 20) # Creating new DataSet
# A
inputDataSet.addSample(
(-1, 1, 1, 1, -1, 1, -1, -1, -1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, -1,
-1, -1, 1, 1, -1, -1, -1, 1, 1, -1, -1, -1, 1),
(1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
# B
inputDataSet.addSample(
(1, 1, 1, 1, -1, 1, -1, -1, -1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, -1, 1, -1,
-1, -1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, -1),
(0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
# C
inputDataSet.addSample(
(-1, 1, 1, 1, -1, 1, -1, -1, -1, 1, 1, -1, -1, -1, -1, 1, -1, -1, -1, -1,
1, -1, -1, -1, -1, 1, -1, -1, -1, 1, -1, 1, 1, 1, -1),
(0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
# D
inputDataSet.addSample(
(1, 1, 1, 1, -1, 1, -1, -1, -1, 1, 1, -1, -1, -1, 1, 1, -1, -1, -1, 1, 1,
-1, -1, -1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, -1),
(0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
# F
inputDataSet.addSample(
(1, 1, 1, 1, 1, 1, -1, -1, -1, -1, 1, -1, -1, -1, -1, 1, 1, 1, 1, -1, 1,
#!/usr/bin/python
from pybrain3.datasets import SupervisedDataSet
inputLettersDataSet = SupervisedDataSet(35, 1)
#A
inputLettersDataSet.addSample(
(-1, 1, 1, 1, -1, 1, -1, -1, -1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, -1,
-1, -1, 1, 1, -1, -1, -1, 1, 1, -1, -1, -1, 1), 1)
#B
inputLettersDataSet.addSample(
(1, 1, 1, 1, -1, 1, -1, -1, -1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, -1, 1, -1,
-1, -1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, -1), 1)
#C
inputLettersDataSet.addSample(
(-1, 1, 1, 1, -1, 1, -1, -1, -1, 1, 1, -1, -1, -1, -1, 1, -1, -1, -1, -1,
1, -1, -1, -1, -1, 1, -1, -1, -1, 1, -1, 1, 1, 1, -1), 1)
#D
inputLettersDataSet.addSample(
(1, 1, 1, 1, -1, 1, -1, -1, -1, 1, 1, -1, -1, -1, 1, 1, -1, -1, -1, 1, 1,
-1, -1, -1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, -1), 1)
#F
inputLettersDataSet.addSample(
(1, 1, 1, 1, 1, 1, -1, -1, -1, -1, 1, -1, -1, -1, -1, 1, 1, 1, 1, -1, 1,
-1, -1, -1, -1, 1, -1, -1, -1, -1, 1, -1, -1, -1, -1), 1)
[3.21061321e+02, 8.96041364e-01, 2.04813023e-04, 0.00000000e+00]
]
testFeaturesArray = np.array(testFeaturesArray, dtype=np.float64)
confusionMatrix = np.array(([[0, 0, 0], [0, 0, 0], [0, 0, 0]]), dtype=np.uint8)
height, width = trainFeaturesArray.shape
print(trainFeaturesArray[0, 0])
print((trainFeaturesArray[0, 0], trainFeaturesArray[0, 1],
trainFeaturesArray[0, 2]), (0))
print((0.8, 0.4), (0.7))
ds = SupervisedDataSet(2, 1)
for i in range(height):
if i < 25:
ds.addSample(
(float(trainFeaturesArray[i, 0]), float(trainFeaturesArray[i, 1])),
(0))
elif i >= 25 and i < 50:
ds.addSample(
(float(trainFeaturesArray[i, 0]), float(trainFeaturesArray[i, 1])),
(1))
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:
[403, 524, 47], [557, 772, 37]]
puntos = benigno
for i in range(0, 2):
if i == 1:
puntos = maligno
for j in range(1, Ninput[i]):
#print(str(i)+':'+str(j))
#image = cv2.imread("all-mias/mdb076.pgm")
image = cv2.imread('all-mias/' + str(i) + '/(' + str(j) + ').pgm', 0)
if image is None:
print("no se encontro")
else:
momentos = procesado(image, puntos[j - 1][0], puntos[j - 1][1],
puntos[j - 1][2])
#momentos = cal_momentos(img_procesada)
ds.addSample(momentos, output[i])
trainer = BackpropTrainer(net, ds)
er = round(trainer.train(), 3)
#print(er)
while er <= 0.113:
er = round(trainer.train(), 3)
print(er)
puntos = benigno
for i in range(17, 27):
img_test = cv2.imread(
'C:/Users/David VM/Downloads/all-mias/' + str(0) + '/(' + str(i) +
').pgm', 0)
carat = procesado(img_test, puntos[i - 1][0], puntos[i - 1][1],
if __name__ == '__main__':
from pylab import figure, show
# --- example on how to use the GP in 1 dimension
ds = SupervisedDataSet(1, 1)
gp = GaussianProcess(indim=1, start=-3, stop=3, step=0.05)
figure()
x = mgrid[-3:3:0.2]
y = 0.1 * x**2 + x + 1
z = sin(x) + 0.5 * cos(y)
ds.addSample(-2.5, -1)
ds.addSample(-1.0, 3)
gp.mean = 0
# new feature "autonoise" adds uncertainty to data depending on
# it's distance to other points in the dataset. not tested much yet.
# gp.autonoise = True
gp.trainOnDataset(ds)
gp.plotCurves(showSamples=True)
# you can also test the gp on single points, but this deletes the
# original testing grid. it can be restored with a call to _buildGrid()
print(gp.testOnArray(array([[0.4]])))
# --- example on how to use the GP in 2 dimensions
max_ = max(map(lambda t: len(authors[t]), authors))
max_len = max(
map(lambda t: max(map(lambda t1: t1[1], authors[t])), authors))
classes = [_ for _ in authors]
L = len(classes)
ds = SupervisedDataSet(33 * 33, L)
for author in authors:
for text in authors[author]:
arr = np.zeros(33 * 33)
for j in text[0]:
arr[int(j)] = text[0][j]
for _ in range(
math.ceil(max_ / len(authors[author]) * 10 *
(text[1] / max_len))):
arr2 = np.zeros(L)
arr2[classes.index(author)] = 1
ds.addSample(arr, arr2)
net = buildNetwork(33 * 33, 10, 10, L, bias=True)
trainer = RPropMinusTrainer(net, dataset=ds)
trainer.trainEpochs(100)
print(trainer.testOnData())
NetworkWriter.writeToFile(net, 'filename_2.xml')
s = 0
time3 = time.time()
print(time3 - time2)
#for inp, tar in ds:
# print(tar[0], net.activate(inp)[0]-tar[0])
#s+=(net.activate(inp)[0]-tar[0])**2
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) #valor_inicial, numero_parcela, valor_final ds.addSample((100, 1), (100)) ds.addSample((100, 2), (52.63)) ds.addSample((100, 3), (35.69)) ds.addSample((100, 4), (27.22)) ds.addSample((100, 5), (22.14)) 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)
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? "))
from pybrain3.datasets import SupervisedDataSet
daneWejsciowe = SupervisedDataSet(35, 20)
daneWejsciowe.addSample(
(-1, 1, 1, 1, -1, 1, -1, -1, -1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, 1, 1, -1,
-1, -1, 1, 1, -1, -1, -1, 1, 1, -1, -1, -1, 1),
(1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
daneWejsciowe.addSample(
(1, 1, 1, 1, -1, 1, -1, -1, -1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, -1, 1, -1,
-1, -1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, -1),
(0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
daneWejsciowe.addSample(
(-1, 1, 1, 1, -1, 1, -1, -1, -1, 1, 1, -1, -1, -1, -1, 1, -1, -1, -1, -1,
1, -1, -1, -1, -1, 1, -1, -1, -1, 1, -1, 1, 1, 1, -1),
(0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
daneWejsciowe.addSample(
(1, 1, 1, 1, -1, 1, -1, -1, -1, 1, 1, -1, -1, -1, 1, 1, -1, -1, -1, 1, 1,
-1, -1, -1, 1, 1, -1, -1, -1, 1, 1, 1, 1, 1, -1),
(0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
daneWejsciowe.addSample(
(1, 1, 1, 1, 1, 1, -1, -1, -1, -1, 1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, -1,
-1, -1, -1, 1, -1, -1, -1, -1, 1, 1, 1, 1, 1),
(0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
daneWejsciowe.addSample(
(1, 1, 1, 1, 1, 1, -1, -1, -1, -1, 1, -1, -1, -1, -1, 1, 1, 1, -1, -1, 1,
# 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])
from pybrain3.datasets import SupervisedDataSet
inputDataSet = SupervisedDataSet(35, 1) #Creating new DataSet
#A
inputDataSet.addSample(( #Adding first sample to dataset
-1, 1, 1, 1, -1,
1, -1, -1, -1, 1,
1, -1, -1, -1, 1,
1, 1, 1, 1, 1,
1, -1, -1, -1, 1,
1, -1, -1, -1, 1,
1, -1, -1, -1, 1
),
1)
#B
inputDataSet.addSample((
1, 1, 1, 1, -1,
1, -1, -1, -1, 1,
1, -1, -1, -1, 1,
1, 1, 1, 1, -1,
1, -1, -1, -1, 1,
1, -1, -1, -1, 1,
1, 1, 1, 1, -1
),
1)
#C
inputDataSet.addSample((
-1, 1, 1, 1, -1,
ds = SupervisedDataSet(2, 1)
#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:
print(time2 - time1)
max_ = max(map(lambda t: len(authors[t]), authors))
max_len = max(
map(lambda t: max(map(lambda t1: t1[1], authors[t])), authors))
classes = [_ for _ in authors]
L = len(classes)
for author in authors:
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):
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)
#print(error)
cv2.waitKey(3000)
#if cv2.waitKey(33) == ord("d"):
cv2.destroyAllWindows()
class NeuralNetwork:
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)
'''
self.__network = buildNetwork(2, 3, 1, outclass = SoftmaxLayer,
hiddenclass = SigmoidLayer, bias = False)
print(self.__network['in'])
print(self.__network['hidden0'])
print(self.__network['out'])
print(self.__network['bias'])
'''
def float_round(self, number, close_to):
"""import math
return math.isclose(float(number), close_to, abs_tol=0.45)"""
if float(number) >= 0.5:
return self._max_value == close_to
else:
return self._min_value == close_to
def __add_training_set(self, training_base):
# Adicionando os dados (Entrada), (Classe) para o treinamento
for index in range(0, self.__total_comments):
training_set_length = 2500 # int(self.__total_comments * 0.8)
if index < training_set_length:
array = []
# ********************** TROCAR PELO ARRAY DE ENTRADAS *******************
entry_array = training_base[index][0]
if training_base[index][1] >= 3.5:
comment_class = self._max_value
else:
comment_class = self._min_value
# print(entry_array, comment_class)
for key in entry_array:
# print (entry_array[key])
array.append(entry_array[key])
self.__base.addSample(array, comment_class)
# Imprimir a entrada e a classe supervisionada
# print(base['input'])
# print(base['target'])
def training_network(self, training_base, number_of_trainings=20):
print("Start Training")
self.__add_training_set(training_base)
training = BackpropTrainer(self.__network,
dataset=self.__base,
learningrate=0.01,
momentum=0.06)
# Fazer o treinamento number_of_trainings vezes e mostrar o erro
'''for count in range(0, number_of_trainings):
print("Training Number %d" % count + 1)
print("Error %s" % training.train())'''
# above, use training with validation
training.trainUntilConvergence(maxEpochs=number_of_trainings,
verbose=True,
validationProportion=0.25)
def test_network(self, test_base):
# self.__network = NetworkReader.readFrom('filename.xml')
test_base_length = len(test_base)
corrects = 0
errors = 0
# ******************* PASSAR OS COMENTÁRIOS PARA O TESTE *********************
for index in range(0, test_base_length):
array = []
# ********************** TROCAR PELO ARRAY DE ENTRADAS *******************
entry_array = test_base[index][0]
if test_base[index][1] >= 3.5:
comment_class = self._max_value
else:
comment_class = self._min_value
# print(entry_array, comment_class)
for key in entry_array:
array.append(entry_array[key])
try:
found = self.__network.activate(array)
if self.float_round(found, comment_class):
corrects += 1
else:
errors += 1
print(found, comment_class,
self.float_round(found, comment_class))
except (AssertionError, IndexError) as error:
print("Have an error message: %s" % error)
print("%f%%" % ((corrects * 100) / (errors + corrects)))
def save_network(self, location):
NetworkWriter.writeToFile(self.__network, location)
def load_network(self, location):
self.__network = NetworkReader.readFrom(location)