Пример #1
0
class NeuralNetworkLibrary:

    def create_neuron(self, numberOfInputs, activationFuncion):
        self._neuron = Neuron(int(numberOfInputs), str(activationFuncion))

    def set_neuron_inputs(self, val):
        value = ast.literal_eval(val)
        self._neuron.inputs = value
        assert self._neuron.inputs[:-1] == value, "Neuron's inputs was not set: "

    def randomize_neuron_weights(self):
        self._neuron.randomizeWeights()
        assert self._neuron.weights, "Weights were not initialized"

    def calculate_neuron_output(self):
        beforeOutput = self._neuron.output
        self._neuron.calcOutput()
        afterOutput = self._neuron.output
        assert beforeOutput is not afterOutput, "Neuron's aoutput was not updated"

    def update_neuron_weights(self):
        beforeWeights = self._neuron.weights
        self._neuron.updateWeights()
        afterWeights = self._neuron.weights
        assert beforeWeights is not afterWeights, "Weights were not updated"

    def initialize_network(self, data, target, numberOfNeurons, activationFunctions):
        self._network = Network(ast.literal_eval(data), ast.literal_eval(target), ast.literal_eval(numberOfNeurons),
                                ast.literal_eval(activationFunctions))

    def initialize_random_weights(self):
        self._network.initWeights()

    def are_weights_initialized(self):
        for layer in self._network.net:
            for neuron in layer:
                if not neuron.weights:
                    raise AssertionError("Network weights were not initialized")

    def train_until_error(self, error):
        self._network.train(error=eval(error))
        assert self._network.totalError <= eval(error), "Desired error was not achieved"

    def train_until_epoch(self, epoch):
        self._network.train(epochs=eval(epoch))
        assert self._network.learningEpochs == eval(epoch), "Desired error was not achieved"

    def run_network(self, inputs):
        self._network.run(ast.literal_eval(inputs))

    def is_net_output_within_deviation(self, target, permissibleDeviation):
        permDev = float(permissibleDeviation)
        targetSet = ast.literal_eval(target)
        for targetOutputs,netOutputs in zip(targetSet, self._network.netOutputs):
            for targetOutput,netOutput in zip(targetOutputs,netOutputs):
                assert targetOutput-permDev < netOutput < targetOutput+permDev, \
                    "Net output is : " + str(netOutput) + " but should be: " + str(targetOutput)
Пример #2
0
from src.network import Network

n = Network([[0,0],[0,1],[1,0],[1,1]], [[0],[1],[1],[0]], [10,5,1], ['sigmoid']*3)
n.initWeights()

n.train(error=pow(10, -5), epochs=pow(10, 3), eta=0.7, repeatSet=10, plot=True, plotInterval=5)

n.run([[0.1,0.1],[0.1,0.9],[1,0],[1,1]])