简单的多层神经网络实现

问题描述

前一段时间，我开始学习机器学习(在我学习的最后两年中).我已经读了很多书，并使用机器学习算法(神经网络除外)编写了很多代码，这超出了我的范围.我对这个主题非常感兴趣，但是我有一个很大的问题:我读过的所有书都有两个主要问题:

some time ago I have started my adventure with machine learning (during last 2 years of my studies). I have read a lot of books and written a lot of code with machine learning algorithms EXCEPT neural networks, which were out of my scope. I'm very interested in this topic, but I have a huge problem:All the books I have read have two main issues:

1. 包含数学方程式的色调.演讲后，我对它们非常熟悉，并且可以手工在纸上进行计算.
2. 包含嵌入在某些复杂上下文中的大型示例(例如，调查网店销售率)，并且要深入了解神经网络的实现，我必须编写大量代码来重现上下文.缺少什么-无需大量上下文和方程式的简单直接实现.

1. Contain tones of maths equations. After lecture I'm quite familiar with them and by hand, on the paper I can do the calculations.
2. Contain big examples embedded in some complicated context (for example investigating internet shop sales rates) and to get inside neural networks implementation, I have to write lot of code to reproduce the context.What is missing - SIMPLE straightforward implementation without a lot of context and equations.

您能告诉我我在哪里可以找到多层感知(神经网络)的简单实现吗?我不需要理论知识，也不需要上下文嵌入的示例.我更喜欢一些脚本语言来节省时间和精力-我以前的工作中有99％是用Python完成的.

Could you please advise me, where I can find SIMPLE implementation of multi layer perception (neural network) ? I don't need theoretical knowledge, and don want also context-embedded examples. I prefer some scripting languages to save time and effort - 99% of my previous works were done in Python.

以下是我以前读过的书清单(但没有找到我想要的书):

Here is the list of books I have read before (and not found what I wanted):

1. 机器学习在实践中
2. 编程集体智慧
3. 机器学习:算法视角
4. Java中的神经网络简介
5. C#中的神经网络简介

推荐答案

一个简单的实现

这是在Python中使用类的可读实现.此实现将效率与可理解性进行了权衡:

A simple implementation

Here is a readable implementation using classes in Python. This implementation trades efficiency for understandability:

    import math
    import random

    BIAS = -1

    """
    To view the structure of the Neural Network, type
    print network_name
    """

    class Neuron:
        def __init__(self, n_inputs ):
            self.n_inputs = n_inputs
            self.set_weights( [random.uniform(0,1) for x in range(0,n_inputs+1)] ) # +1 for bias weight

        def sum(self, inputs ):
            # Does not include the bias
            return sum(val*self.weights[i] for i,val in enumerate(inputs))

        def set_weights(self, weights ):
            self.weights = weights

        def __str__(self):
            return 'Weights: %s, Bias: %s' % ( str(self.weights[:-1]),str(self.weights[-1]) )

    class NeuronLayer:
        def __init__(self, n_neurons, n_inputs):
            self.n_neurons = n_neurons
            self.neurons = [Neuron( n_inputs ) for _ in range(0,self.n_neurons)]

        def __str__(self):
            return 'Layer:\n\t'+'\n\t'.join([str(neuron) for neuron in self.neurons])+''

    class NeuralNetwork:
        def __init__(self, n_inputs, n_outputs, n_neurons_to_hl, n_hidden_layers):
            self.n_inputs = n_inputs
            self.n_outputs = n_outputs
            self.n_hidden_layers = n_hidden_layers
            self.n_neurons_to_hl = n_neurons_to_hl

            # Do not touch
            self._create_network()
            self._n_weights = None
            # end

        def _create_network(self):
            if self.n_hidden_layers>0:
                # create the first layer
                self.layers = [NeuronLayer( self.n_neurons_to_hl,self.n_inputs )]

                # create hidden layers
                self.layers += [NeuronLayer( self.n_neurons_to_hl,self.n_neurons_to_hl ) for _ in range(0,self.n_hidden_layers)]

                # hidden-to-output layer
                self.layers += [NeuronLayer( self.n_outputs,self.n_neurons_to_hl )]
            else:
                # If we don't require hidden layers
                self.layers = [NeuronLayer( self.n_outputs,self.n_inputs )]

        def get_weights(self):
            weights = []

            for layer in self.layers:
                for neuron in layer.neurons:
                    weights += neuron.weights

            return weights

        @property
        def n_weights(self):
            if not self._n_weights:
                self._n_weights = 0
                for layer in self.layers:
                    for neuron in layer.neurons:
                        self._n_weights += neuron.n_inputs+1 # +1 for bias weight
            return self._n_weights

        def set_weights(self, weights ):
            assert len(weights)==self.n_weights, "Incorrect amount of weights."

            stop = 0
            for layer in self.layers:
                for neuron in layer.neurons:
                    start, stop = stop, stop+(neuron.n_inputs+1)
                    neuron.set_weights( weights[start:stop] )
            return self

        def update(self, inputs ):
            assert len(inputs)==self.n_inputs, "Incorrect amount of inputs."

            for layer in self.layers:
                outputs = []
                for neuron in layer.neurons:
                    tot = neuron.sum(inputs) + neuron.weights[-1]*BIAS
                    outputs.append( self.sigmoid(tot) )
                inputs = outputs
            return outputs

        def sigmoid(self, activation,response=1 ):
            # the activation function
            try:
                return 1/(1+math.e**(-activation/response))
            except OverflowError:
                return float("inf")

        def __str__(self):
            return '\n'.join([str(i+1)+' '+str(layer) for i,layer in enumerate(self.layers)])

更有效的实施(带有学习)

如果您正在寻找具有学习(反向传播)功能的神经网络的更有效示例，请查看我的神经网络Github存储库在这里.

这篇关于简单的多层神经网络实现的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！