Example #1
0
def read_weights_on_file(nome_arquivo_backup):
    with open(nome_arquivo_backup, 'r') as arquivo_backup:
        # print("leitura")
        camadas = []
        json_deserializacao = json.load(arquivo_backup)
        for indice_camada in range(len(json_deserializacao)):
            if (json_deserializacao[indice_camada]['tipo_camada'] == 'output'):
                # print(json_deserializacao[indice_camada]['total_neuronios'])
                # input()
                nova_camada = CamadaSaida(
                    json_deserializacao[indice_camada]['total_neuronios'])
            else:
                nova_camada = Camada(
                    json_deserializacao[indice_camada]['total_neuronios'])
            for neuronio in json_deserializacao[indice_camada]['neuronios']:
                novo_neuronio = Neuronio(neuronio['id'], [], 1,
                                         settings.momentum)
                for i in range(len(neuronio['entradas'])):
                    novo_neuronio.entradas.append(
                        Neuronio(neuronio['entradas'][i]['id'], [], 1,
                                 settings.momentum))
                    novo_neuronio.pesos.append(neuronio['entradas'][i]['peso'])
                nova_camada.neuronios.append(novo_neuronio)
            camadas.append(nova_camada)

        return camadas
Example #2
0
    def le_camada_entrada(self, nome_arquivo, quantas_entradas,
                          ultimo_id_neuronio, learning_rate, momentum):
        with open(nome_arquivo, 'r') as arquivo_leitura_entrada:
            quantos_leu = 0
            for linha in arquivo_leitura_entrada:
                linha_quebrada = linha.split(' ')
                for i in linha_quebrada[
                        0]:  # pega as ENTRADAS somente (desconsidera saída esperada AINDA)

                    n = Neuronio(
                        ultimo_id_neuronio, i, learning_rate,
                        momentum)  # passando peso -1 como teste apenas
                    n.entradas = [float(i)]
                    n.saida = float(
                        i)  # coloca entrada na saída para primeira camada
                    self.neuronios.append(n)
                    ultimo_id_neuronio += 1

                quantos_leu += 1
                if (quantos_leu == quantas_entradas):
                    self.exibe_neuronios()
                    break
            return ultimo_id_neuronio
class TestNeuronio(unittest.TestCase):
    def setUp(self):
        w = {"w0": 0, "w1": 0, "w2": 0}
        self.neuronio = Neuronio(**w)

    def test_neuronio(self):
        self.neuronio.w0 | should | equal_to(0)
        self.neuronio.w1 | should | equal_to(0)
        self.neuronio.w2 | should | equal_to(0)

    def test_treinamento_neuronio_4_padroes_operacao_e(self):
        aprendizagem = 1
        padroes = {
            "padrao_1": {"x1": 0, "x2": 0, "y": 0},
            "padrao_2": {"x1": 0, "x2": 1, "y": 0},
            "padrao_3": {"x1": 1, "x2": 0, "y": 0},
            "padrao_4": {"x1": 1, "x2": 1, "y": 1},
        }
        w_treinado = self.neuronio.treinar(taxa_de_aprendizagem=aprendizagem, padroes=padroes)
        w_treinado | should | equal_to({"w0": -2, "w1": 1, "w2": 0})
Example #4
0
    def getMSE(self):
        for entrada in self.entradas: # percorrendo as entradas
            for val in entrada:
                neuronio = Neuronio(val, self.pesos_h[0])
                self.h1 = neuronio.saida()

                neuronio = Neuronio(val, self.pesos_h[1])
                self.h2 = neuronio.saida()

                u1 = self.pesos_o[0][0] + self.h1[idx] * self.pesos_o[0][1] + self.h2[idx] * self.pesos_o[0][2]
                u2 = self.pesos_o[0][0] + self.h1[idx] * self.pesos_o[1][1] + self.h2[idx] * self.pesos_o[1][2]

                self.resultadoN1.insert(1 / (1 + pow(self.e, -u1)))
                self.resultadoN2.insert(1 / (1 + pow(self.e, -u2)))

                self.erroN1 = self.res_esperadoN1 - self.resultadoN1
                self.erro_quadratico += pow(self.erroN1, 2)

                self.erroN2 = self.res_esperadoN2 - self.resultadoN2
                self.erro_quadratico += pow(self.erroN2, 2)

            return (self.erro_quadratico/(self.entradas.size) * 2) * 100
Example #5
0
def inicialize_camada(camada, integer):
    for i in range(integer):
        camada.append(Neuronio())
    return camada
 def setUp(self):
     w = {"w0": 0, "w1": 0, "w2": 0}
     self.neuronio = Neuronio(**w)
Example #7
0
                taxa_aprendizagem, settings.momentum)

            quantos_neuronios_camada_escondida = settings.quantidade_neuronios_camada_escondida

            camada_escondida = Camada(quantos_neuronios_camada_escondida)

            quantos_neuronios_camada_saida = settings.quantidade_neuronios_camada_saida
            camada_saida = CamadaSaida(quantos_neuronios_camada_saida)

            camada_saida.le_saida_esperada(nome_arquivo_leitura, 1,
                                           linha_arquivo_treino)

            # LEITURA DA CAMADA ESCONDIDA
            for indice_neuronio_escondido in range(
                    quantos_neuronios_camada_escondida):
                neuronio_novo = Neuronio(settings.ultimo_id_neuronio, [],
                                         taxa_aprendizagem, settings.momentum)

                neuronio_novo.entradas = [
                    neuronio for neuronio in camada_entrada.neuronios
                ]
                neuronio_novo.pesos = [
                    camada_escondida.__gera_peso_aleatorio__()
                    for neuronio in camada_entrada.neuronios
                ]
                camada_escondida.neuronios.append(neuronio_novo)
                settings.ultimo_id_neuronio += 1
                # camada_escondida.neuronios.append(neuronio)

            # LEITURA DA CAMADA DE SAÍDA
            for _ in range(quantos_neuronios_camada_saida):
                neuronio_novo = Neuronio(settings.ultimo_id_neuronio, [],