神经网络陷入0.75或.25丢失

Question

我正在做一个学校项目，遇到了以下问题。我已经在Python中编写了一个神经网络，该神经网络可以（应该）检测眼睛疾病（CNV，DME，Drusen和正常的眼睛）。为此，我在PC上有一个文件夹，其中包含受影响和未受影响的眼睛的图像（每类20.000）。当我开始训练网络时，损失将停留在.75或.25上。你能帮我吗？

我有以下代码：

    import numpy as np     # library om gemakkelijker matrixberekeningen te noteren
    import cv2             # library die de afbeeldingen verwerkt
    #import os              # library die de gebruiker in staat stelt om een afbeelding of tekst in te vullen
    import random          # library die gebruikt wordt om het netwerk in de beginfase op te bouwen
    import os.path
    training_map_path = "C:\\Users\\debruss\\Pictures\\trainingmap3\\"

class Neural_Network(object):
  #initialiseert de afmetingen van het netwerk
  def __init__(self):
    #parameters van netwerk
    self.inputSize = 40000        #90000
    self.hiddenSize1 = 3000       #1500  2160
    self.hiddenSize2 = 1500        #175
    self.outputSize = 4

    #gewichten van de connecties
    #aan het begin worden deze gewichten random gegenereerd
    self.W1 = np.random.randn(self.inputSize, self.hiddenSize1)
    self.W2 = np.random.randn(self.hiddenSize1, self.hiddenSize2)
    self.W3 = np.random.randn(self.hiddenSize2, self.outputSize)

  #Netwerkberekening naar rechts: er wordt dus een afbeelding geïndexeerd
  def forward (self, X):
    self.z = np.dot(X, self.W1)        #Matrixvermenigvuldiging 
    self.z2 = self.sigmoid(self.z)
    self.z3 = np.dot(self.z2, self.W2)    #Matrixvermenigvuldiging 
    self.z4 = self.sigmoid(self.z3)
    self.z5 = np.dot(self.z4, self.W3)    #Matrixvermenigvuldiging 
    O = self.sigmoid(self.z5)
    #print("Output van forward(X):")
    #print(O)
    return O

  #Netwerkberekening naar links: er wordt teruggerekend om het netwerk te verbeteren
  def backward(self, X, y, O):
    self.o_error = y - O
    #print("Error van het netwerk vergeleken met het goede antwoord:")
    #print(self.o_error)
    self.o_delta = self.o_error * self.sigmoidPrime(O)

    #print("o_delta:")
    #print(self.o_delta)

    self.z4_error = self.o_delta.dot(self.W3.T)
    self.z4_delta = self.z4_error * self.sigmoidPrime(self.z4)

    #print("z4_error:")
    #print(self.z4_delta)

    self.z2_error = self.z4_delta.dot(self.W2.T)
    self.z2_delta = self.z2_error * self.sigmoidPrime(self.z2)

    #print("z2_error:")
    #print(self.z2_delta)

    X = X.reshape(1, 40000)
    self.z2_delta = self.z2_delta.reshape(1, 3000)

    self.z2 = self.z2.reshape(1, 3000)
    self.z4_delta = self.z4_delta.reshape(1, 1500)

    self.z4 = self.z4.reshape(1, 1500)
    self.o_delta = self.o_delta.reshape(1, 4)

    self.W1 += X.T.dot(self.z2_delta)
    self.W2 += self.z2.T.dot(self.z4_delta)
    self.W3 += self.z4.T.dot(self.o_delta)

  #Training initieren
  def train(self, X, y):
    O = self.forward(X)
    #O = np.ravel(O)
    #O = O.reshape(-1)
    #print(O)
    self.backward(X, y, O)

  #sigmoid functie
  def sigmoid(self, s):
    return 1/(1+np.exp(-s))

  #afgeleide van de sigmoid functie: hiermee wordt bepaald of een neuron zijn informatie doorgeeft
  def sigmoidPrime(self, s):
    return s.transpose() * (1 - s)

def imgProcessor(pad):
  img = cv2.imread(pad, cv2.IMREAD_GRAYSCALE)
  img = np.matrix(cv2.resize(img, (200,200))) + 1

  def rowtorow(toProcess):
    return toProcess

  j = np.apply_along_axis(rowtorow, axis = 1, arr=img)
  j = np.ravel(j)
  j = j.reshape(1, 40000)       # j = j.reshape(1, 90000).ravel()
  j = np.ravel(j)
  #print("De afbeelding:")    
  print(j)
  return j

def imgPicker():
  loc = ''
  fi = random.randint(1,5)

  if (fi == 0):
    while 'CNV' not in loc:
      loc = random.choice(os.listdir(training_map_path))

  if (fi == 1):
    while 'DME' not in loc:
      loc = random.choice(os.listdir(training_map_path))

  if (fi == 2):
    while 'DRUSEN' not in loc:
      loc = random.choice(os.listdir(training_map_path))

  if (fi == 3):
    while 'NORMAL' not in loc:
      loc = random.choice(os.listdir(training_map_path))

  while os.path.isfile(loc) == False:
    loc = random.choice(os.listdir(training_map_path))
    #print(loc)
    #print(training_map_path + loc)
    if os.path.isfile(training_map_path + loc):
      break

  print(training_map_path + loc)
  return training_map_path + loc
  #print(y)# pad naar de te verwerken afbeelding

def correctAnswer(Za):
  if 'CNV' in Za:                                                        # er wordt bepaald bij welke categorie de afbeelding hoort
                                                                            # dit om het netwerk later te controleren (y is het antwoord).
    y = np.array(([1, 0, 0, 0]), dtype=int)
  if 'DME' in Za:
    y = np.array(([0, 1, 0, 0]), dtype=int)
  if 'DRUSEN' in Za:
    y = np.array(([0, 0, 1, 0]), dtype=int)
  if 'NORMAL' in Za:
    y = np.array(([0, 0, 0, 1]), dtype=int)
  #print("Het goede antwoord is:")
  #print(y)
  return y

NN = Neural_Network()

# LET OP! NIET ZOMAAR OP DE RUN-KNOP DRUKKEN!!! DIT KAN HET NETWERK DOEN VASTLOPEN
q = 100                         # KIES HOE VAAK HET NETWERK MOET REKENEN
for i in range(q):
  Z = imgPicker()
  X = imgProcessor(Z) * 255
  y = correctAnswer(Z)

  NN.train(X, y)
  if (i % 10 == 0):
    print("Loss at " + str(i) + ": " + str(np.mean(np.square(y - NN.forward(X).transpose()))))  #np.mean(np.square())

print("W1: ")
print(np.squeeze(np.asarray(NN.W1)))
print("W2: ")
print(np.squeeze(np.asarray(NN.W2)))
print("W3: ")
print(np.squeeze(np.asarray(NN.W3)))

谢谢！