신경 망(BP)알고리즘 Python 구현 및 응용

본 논문 의 사례 는 Python 이 신경 망 알고리즘 과 응용 을 실현 하 는 구체 적 인 코드 를 공유 하여 여러분 께 참고 하 시기 바 랍 니 다.구체 적 인 내용 은 다음 과 같 습 니 다.
우선 Python 으로 간단 한 신경 망 알고리즘 을 실현 합 니 다.

import numpy as np


#   tanh  
def tanh(x):
  return np.tanh(x)


# tanh     
def tan_deriv(x):
  return 1.0 - np.tanh(x) * np.tan(x)


# sigmoid  
def logistic(x):
  return 1 / (1 + np.exp(-x))


# sigmoid     
def logistic_derivative(x):
  return logistic(x) * (1 - logistic(x))


class NeuralNetwork:
  def __init__(self, layers, activation='tanh'):
    """
              
    :param layers:      
    :param activation:      （  tanh  ）
    :return:none
    """
    if activation == 'logistic':
      self.activation = logistic
      self.activation_deriv = logistic_derivative
    elif activation == 'tanh':
      self.activation = tanh
      self.activation_deriv = tan_deriv

    #     
    self.weights = []
    #      （  ）
    for i in range(1, len(layers) - 1):
      self.weights.append((2 * np.random.random((layers[i - 1] + 1, layers[i] + 1)) - 1) * 0.25)
      self.weights.append((2 * np.random.random((layers[i] + 1, layers[i + 1])) - 1) * 0.25)

  def fit(self, X, y, learning_rate=0.2, epochs=10000):
    """
          
    :param X:    （     ）
    :param y:     
    :param learning_rate:    （  0.2）
    :param epochs:     （      ，  10000）
    :return: none
    """
    #          
    X = np.atleast_2d(X)

    temp = np.ones([X.shape[0], X.shape[1] + 1])
    temp[:, 0: -1] = X
    X = temp
    y = np.array(y)

    for k in range(epochs):
      #     X   
      i = np.random.randint(X.shape[0])
      #                   
      a = [X[i]]
      #     
      for l in range(len(self.weights)):
        a.append(self.activation(np.dot(a[l], self.weights[l])))
      error = y[i] - a[-1]
      deltas = [error * self.activation_deriv(a[-1])]

      #     
      for l in range(len(a) - 2, 0, -1):
        deltas.append(deltas[-1].dot(self.weights[l].T) * self.activation_deriv(a[l]))
        deltas.reverse()
      for i in range(len(self.weights)):
        layer = np.atleast_2d(a[i])
        delta = np.atleast_2d(deltas[i])
        self.weights[i] += learning_rate * layer.T.dot(delta)

  def predict(self, x):
    x = np.array(x)
    temp = np.ones(x.shape[0] + 1)
    temp[0:-1] = x
    a = temp
    for l in range(0, len(self.weights)):
      a = self.activation(np.dot(a, self.weights[l]))
    return a

자신 이 정의 한 신경 망 알고리즘 을 사용 하여 간단 한 기능 을 실현 합 니 다.
 작은 사례:
X:                  Y
0 0                 0
0 1                 1
1 0                 1
1 1                 0

from NN.NeuralNetwork import NeuralNetwork
import numpy as np

nn = NeuralNetwork([2, 2, 1], 'tanh')
temp = [[0, 0], [0, 1], [1, 0], [1, 1]]
X = np.array(temp)
y = np.array([0, 1, 1, 0])
nn.fit(X, y)
for i in temp:
  print(i, nn.predict(i))

발견 결과 기본 메커니즘,무한 접근 0 또는 무한 접근 1 
두 번 째 예:그림 속 의 숫자 를 식별 합 니 다.
데이터 가 져 오기:

from sklearn.datasets import load_digits
import pylab as pl

digits = load_digits()
print(digits.data.shape)
pl.gray()
pl.matshow(digits.images[0])
pl.show()

관찰 하 다:크기:(1797,64)
숫자 0

다음 코드 는 그것들 을 식별 하 는 것 이다.

import numpy as np
from sklearn.datasets import load_digits
from sklearn.metrics import confusion_matrix, classification_report
from sklearn.preprocessing import LabelBinarizer
from NN.NeuralNetwork import NeuralNetwork
from sklearn.cross_validation import train_test_split

#      
digits = load_digits()
X = digits.data
y = digits.target
#     ，      0,1  ，           
X -= X.min()
X /= X.max()

#   ：
#    10   
#    64     8*8 ，64  
#      100
nn = NeuralNetwork([64, 100, 10], 'logistic')
#          
X_train, X_test, y_train, y_test = train_test_split(X, y)

#    sklearn         
labels_train = LabelBinarizer().fit_transform(y_train)
labels_test = LabelBinarizer().fit_transform(y_test)
print("start fitting")
#   3000 
nn.fit(X_train, labels_train, epochs=3000)
predictions = []
for i in range(X_test.shape[0]):
  o = nn.predict(X_test[i])
  # np.argmax:           
  predictions.append(np.argmax(o))

#         
print(confusion_matrix(y_test, predictions))
print(classification_report(y_test, predictions))

결과:
행렬 대각선 대 표 는 정확 한 수량 을 예측 하여 정확 한 확률 이 매우 많다 는 것 을 발견 하 였 다.

이 표 는 예측 의 정확 도 를 더욱 직관 적 으로 나타 낸다.
총 450 개 사례,성 공률 94%

이상 이 바로 본 고의 모든 내용 입 니 다.여러분 의 학습 에 도움 이 되 고 저 희 를 많이 응원 해 주 셨 으 면 좋 겠 습 니 다.