Problema con rete neurale BProp legge foto

[alien75]

Ho scritto questo con l'unica differenza che alla rete bisogna dare in pasto valori da 0 a 1 e non da 0 a 255 quindi ho aggiunto gray_image1 = gray_image1 / 255

Codice: Seleziona tutto

IMAGE1 = 'day_open.jpg'
IMAGE2 = 'day_closed.jpg'
IMAGE3 = 'night_open.jpg'
IMAGE4 = 'night_closed.jpg'

image1 = cv2.imread(IMAGE1)
image2 = cv2.imread(IMAGE2)
image3 = cv2.imread(IMAGE3)
image4 = cv2.imread(IMAGE4)


gray_image1 = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)
res1 = cv.resize(gray_image1,(100, 100), interpolation = cv.INTER_CUBIC)
gray_image2 = cv2.cvtColor(image2, cv2.COLOR_BGR2GRAY)
res2 = cv.resize(gray_image2,(100, 100), interpolation = cv.INTER_CUBIC)
gray_image3 = cv2.cvtColor(image3, cv2.COLOR_BGR2GRAY)
res3 = cv.resize(gray_image3,(100, 100), interpolation = cv.INTER_CUBIC)
gray_image4 = cv2.cvtColor(image4, cv2.COLOR_BGR2GRAY)
res4 = cv.resize(gray_image4,(100, 100), interpolation = cv.INTER_CUBIC)
gray_image1 = gray_image1 / 255
gray_image2 = gray_image2 / 255
gray_image3 = gray_image3 / 255
gray_image4 = gray_image4 / 255


X=np.array([gray_image1.reshape(10000),gray_image2.reshape(10000),gray_image3.reshape(10000),gray_image4.reshape(10000)])
y=np.array([[0,0],[0,1],[1,0],[1,1]])


print(X.shape)

nn = NeuralNetwork(input_size=10000, hidden_size=100, output_size=2)
print(f'training')
nn.train(X, y, epochs=700, learning_rate=0.8)

print("Predictions after training:")
print(f'  image1 {nn.feedforward(gray_image1.reshape(1,10000))}')
print(f'  image2 {nn.feedforward(gray_image2.reshape(1,10000))}')
print(f'  image3 {nn.feedforward(gray_image3.reshape(1,10000))}')
print(f'  image4 {nn.feedforward(gray_image4.reshape(1,10000))}')
print(f'  image5 {nn.feedforward(gray_image5.reshape(1,10000))}')


ottengo:

Codice: Seleziona tutto

Traceback (most recent call last):
  File "/home/fabio/Scrivania/backpropagation.py", line 83, in <module>
    X=np.array([gray_image1.reshape(10000),gray_image2.reshape(10000),gray_image3.reshape(10000),gray_image4.reshape(10000)])
ValueError: cannot reshape array of size 7200000 into shape (10000,)


[GioArca67]

Questo da me gira:

Codice: Seleziona tutto

import numpy as np
import cv2
import sys


class NeuralNetwork:
    def __init__(self, input_size, hidden_size, output_size):
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size

        self.weights_input_hidden = np.random.randn(self.input_size,self.hidden_size)*0.5
        self.weights_hidden_output = np.random.randn(self.hidden_size,self.output_size)*0.5

        self.bias_hidden = np.zeros((1, self.hidden_size))
        self.bias_output = np.zeros((1, self.output_size))
       
    def sigmoid(self, x):
        return 1 / (1 + np.exp(-x))

    def sigmoid_derivative(self, x):
        return x * (1 - x)

    def feedforward(self, X):
        self.hidden_activation = np.dot(X, self.weights_input_hidden) + self.bias_hidden
        self.hidden_output = self.sigmoid(self.hidden_activation)

        self.output_activation = np.dot(self.hidden_output, self.weights_hidden_output) + self.bias_output
        self.predicted_output = self.sigmoid(self.output_activation)
        return self.predicted_output

    def backward(self, X, y, learning_rate):
        output_error = y - self.predicted_output
        output_delta = output_error * self.sigmoid_derivative(self.predicted_output)

        hidden_error = np.dot(output_delta, self.weights_hidden_output.T)
        hidden_delta = hidden_error * self.sigmoid_derivative(self.hidden_output)
       
        self.weights_hidden_output += np.dot(self.hidden_output.T, output_delta) * learning_rate
        self.bias_output += np.sum(output_delta, axis=0, keepdims=True) * learning_rate
        self.weights_input_hidden += np.dot(X.T, hidden_delta) * learning_rate
        self.bias_hidden += np.sum(hidden_delta, axis=0, keepdims=True) * learning_rate

    def train(self, X, y, epochs, learning_rate):
        for epoch in range(epochs):
            output = self.feedforward(X)
            self.backward(X, y, learning_rate)
            if epoch % 100 == 0:
                loss = np.mean(np.square(y - output))
                print(f"Epoch {epoch}, Loss:{loss}")


img1name = 'girl.jpg'
img2name = 'girl2.jpg'
img3name = 'boy.jpg'
img4name = 'boy2.jpg'
img5name = 'man.jpg'

image1 = cv2.imread(img1name)
image2 = cv2.imread(img2name)
image3 = cv2.imread(img3name)
image4 = cv2.imread(img4name)
image5 = cv2.imread(img5name)


gray_image1 = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)
gray_image1 = cv2.resize(gray_image1,(100, 100), interpolation = cv2.INTER_CUBIC)
gray_image2 = cv2.cvtColor(image2, cv2.COLOR_BGR2GRAY)
gray_image2 = cv2.resize(gray_image2,(100, 100), interpolation = cv2.INTER_CUBIC)
gray_image3 = cv2.cvtColor(image3, cv2.COLOR_BGR2GRAY)
gray_image3 = cv2.resize(gray_image3,(100, 100), interpolation = cv2.INTER_CUBIC)
gray_image4 = cv2.cvtColor(image4, cv2.COLOR_BGR2GRAY)
gray_image4 = cv2.resize(gray_image4,(100, 100), interpolation = cv2.INTER_CUBIC)
gray_image5 = cv2.cvtColor(image5, cv2.COLOR_BGR2GRAY)
gray_image5 = cv2.resize(gray_image5,(100, 100), interpolation = cv2.INTER_CUBIC)


gray_image1 = gray_image1 / 255
gray_image2 = gray_image2 / 255
gray_image3 = gray_image3 / 255
gray_image4 = gray_image4 / 255
gray_image5 = gray_image5 / 255

X=np.array([gray_image1.reshape(10000),gray_image2.reshape(10000),gray_image3.reshape(10000),gray_image4.reshape(10000)])
y=np.array([[0,0],[0,1],[1,0],[1,1]])

print(X.shape)
print(f'Creating MLP')
nn = NeuralNetwork(input_size=10000, hidden_size=300, output_size=2)
print(f'training')
nn.train(X, y, epochs=1000, learning_rate=0.7)


print("Predictions after training:")
print(f'  image1 {nn.feedforward(gray_image1.reshape(1,10000))}')
print(f'  image2 {nn.feedforward(gray_image2.reshape(1,10000))}')
print(f'  image3 {nn.feedforward(gray_image3.reshape(1,10000))}')
print(f'  image4 {nn.feedforward(gray_image4.reshape(1,10000))}')
print(f'  image5 {nn.feedforward(gray_image5.reshape(1,10000))}')


risultato:

Codice: Seleziona tutto

python MLP3.py
(4, 10000)
Creating MLP
training
Epoch 0, Loss:0.3465247074046738
Epoch 100, Loss:0.2502056576196306
Epoch 200, Loss:0.25005571168586077
Epoch 300, Loss:0.2500328426315741
Epoch 400, Loss:0.25000863895033915
Epoch 500, Loss:0.00013282604517565123
Epoch 600, Loss:7.785192812715873e-05
Epoch 700, Loss:5.78842209816917e-05
Epoch 800, Loss:4.6946911163190634e-05
Epoch 900, Loss:3.980267472197344e-05
Predictions after training:
  image1 [[0.00388354 0.00757477]]
  image2 [[0.0076422  0.99202098]]
  image3 [[0.99147194 0.00304325]]
  image4 [[0.99999983 0.99924276]]
  image5 [[0.86041945 0.50702147]]



[alien75]

Perfetto funziona!!

risultato:

Codice: Seleziona tutto

(4, 10000)
training
Epoch 0, Loss:0.49628733856537344
Predictions after training:
  image1 [[3.90243453e-04 7.21565746e-07]]
  image2 [[1.62190833e-06 9.97980076e-01]]
  image3 [[9.99999447e-01 1.11494595e-04]]
  image4 [[0.99999999 0.99931057]]


[GioArca67]

Ottimo.

La cosa divertente ora è darle in pasto immagini non facenti parte il training set per vedere come si comporta.
Di fatto un MLP è un classificatore.

[alien75]

Sto facendo prove con immagini mai "viste in fase di apprendimento":
codice:

Codice: Seleziona tutto

import numpy as np
import cv2
import cv2 as cv
import sys


class NeuralNetwork:
    def __init__(self, input_size, hidden_size, output_size):
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size

        self.weights_input_hidden = np.random.randn(self.input_size, self.hidden_size)
        self.weights_hidden_output = np.random.randn(self.hidden_size, self.output_size)

        self.bias_hidden = np.zeros((1, self.hidden_size))
        self.bias_output = np.zeros((1, self.output_size))
       
    def sigmoid(self, x):
        return 1 / (1 + np.exp(-x))

    def sigmoid_derivative(self, x):
        return x * (1 - x)

    def feedforward(self, X):
        self.hidden_activation = np.dot(X, self.weights_input_hidden) + self.bias_hidden
        self.hidden_output = self.sigmoid(self.hidden_activation)

        self.output_activation = np.dot(self.hidden_output, self.weights_hidden_output) + self.bias_output
        self.predicted_output = self.sigmoid(self.output_activation)

        return self.predicted_output

    def backward(self, X, y, learning_rate):
        output_error = y - self.predicted_output
        output_delta = output_error * self.sigmoid_derivative(self.predicted_output)

        hidden_error = np.dot(output_delta, self.weights_hidden_output.T)
        hidden_delta = hidden_error * self.sigmoid_derivative(self.hidden_output)

        self.weights_hidden_output += np.dot(self.hidden_output.T, output_delta) * learning_rate
        self.bias_output += np.sum(output_delta, axis=0, keepdims=True) * learning_rate
        self.weights_input_hidden += np.dot(X.T, hidden_delta) * learning_rate
        self.bias_hidden += np.sum(hidden_delta, axis=0, keepdims=True) * learning_rate

    def train(self, X, y, epochs, learning_rate):
        for epoch in range(epochs):
            output = self.feedforward(X)
            self.backward(X, y, learning_rate)
            if epoch % 4000 == 0:
                loss = np.mean(np.square(y - output))
                print(f"Epoch {epoch}, Loss:{loss}")

IMAGE1 = 'day_open.jpg'
IMAGE2 = 'day_closed.jpg'
IMAGE3 = 'night_closed.jpg'
IMAGE4 = 'night_open.jpg'
IMAGE5 = 'day_closed.jpg'

image1 = cv2.imread(IMAGE1)
image2 = cv2.imread(IMAGE2)
image3 = cv2.imread(IMAGE3)
image4 = cv2.imread(IMAGE4)
image4 = cv2.imread(IMAGE5)

gray_image1 = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)
gray_image1 = cv2.resize(gray_image1,(100, 100), interpolation = cv2.INTER_CUBIC)
gray_image2 = cv2.cvtColor(image2, cv2.COLOR_BGR2GRAY)
gray_image2 = cv2.resize(gray_image2,(100, 100), interpolation = cv2.INTER_CUBIC)
gray_image3 = cv2.cvtColor(image3, cv2.COLOR_BGR2GRAY)
gray_image3 = cv2.resize(gray_image3,(100, 100), interpolation = cv2.INTER_CUBIC)
gray_image4 = cv2.cvtColor(image4, cv2.COLOR_BGR2GRAY)
gray_image4 = cv2.resize(gray_image4,(100, 100), interpolation = cv2.INTER_CUBIC)
gray_image5 = cv2.cvtColor(image4, cv2.COLOR_BGR2GRAY)
gray_image5 = cv2.resize(gray_image4,(100, 100), interpolation = cv2.INTER_CUBIC)
gray_image1 = gray_image1 / 255
gray_image2 = gray_image2 / 255
gray_image3 = gray_image3 / 255
gray_image4 = gray_image4 / 255
gray_image5 = gray_image5 / 255

X=np.array([gray_image1.reshape(10000),gray_image2.reshape(10000),gray_image3.reshape(10000),gray_image4.reshape(10000)])
y=np.array([[0,1],[0,0],[0,0],[0,1]])
print("output = ", y)

print(X.shape)

nn = NeuralNetwork(input_size=10000, hidden_size=300, output_size=2)
print(f'training')
nn.train(X, y, epochs=700, learning_rate=0.8)

print("Predictions after training:")
print(f'  image1 {nn.feedforward(gray_image1.reshape(1,10000))}')
print(f'  image2 {nn.feedforward(gray_image2.reshape(1,10000))}')
print(f'  image3 {nn.feedforward(gray_image3.reshape(1,10000))}')
print(f'  image4 {nn.feedforward(gray_image4.reshape(1,10000))}')
print(f'  image5 {nn.feedforward(gray_image5.reshape(1,10000))}')


risultati:

Codice: Seleziona tutto

utput =  [[0 1]
[0 0]
[0 0]
[0 1]]
(4, 10000)
training
Epoch 0, Loss:0.6077297865646656
Predictions after training:
  image1 [[2.19096642e-10 1.00000000e+00]]
  image2 [[4.47855458e-07 9.99934227e-01]]
  image3 [[5.11130835e-06 1.36975050e-04]]
  image4 [[4.47855458e-07 9.99934227e-01]]
  image5 [[4.47855458e-07 9.99934227e-01]]


Noto un'incongruenza massiccia tra i valori di output in fase di trainig ed i valori di output in fase di esecuzione, perché questo ?

[GioArca67]

y=np.array([[0,1],[0,0],[0,0],[0,1]])

??????

[alien75]

Ho cambiato gli output:

Codice: Seleziona tutto

output =  [[0 1]
[0 1]
[0 0]
[0 0]]
(4, 10000)
training
Epoch 0, Loss:0.389550199616187
Predictions after training:
  image1 [[1.78525902e-12 9.99999130e-01]]
  image2 [[3.50826873e-10 9.99999981e-01]]
  image3 [[3.79265982e-06 1.13144501e-03]]
  image4 [[3.79265982e-06 1.13144501e-03]]


I risultati ora corrispondono con quelli voluti:
Ecco il codice

Codice: Seleziona tutto

import numpy as np
import cv2
import cv2 as cv
import sys


class NeuralNetwork:
    def __init__(self, input_size, hidden_size, output_size):
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size

        self.weights_input_hidden = np.random.randn(self.input_size, self.hidden_size)
        self.weights_hidden_output = np.random.randn(self.hidden_size, self.output_size)

        self.bias_hidden = np.zeros((1, self.hidden_size))
        self.bias_output = np.zeros((1, self.output_size))
       
    def sigmoid(self, x):
        return 1 / (1 + np.exp(-x))

    def sigmoid_derivative(self, x):
        return x * (1 - x)

    def feedforward(self, X):
        self.hidden_activation = np.dot(X, self.weights_input_hidden) + self.bias_hidden
        self.hidden_output = self.sigmoid(self.hidden_activation)

        self.output_activation = np.dot(self.hidden_output, self.weights_hidden_output) + self.bias_output
        self.predicted_output = self.sigmoid(self.output_activation)

        return self.predicted_output

    def backward(self, X, y, learning_rate):
        output_error = y - self.predicted_output
        output_delta = output_error * self.sigmoid_derivative(self.predicted_output)

        hidden_error = np.dot(output_delta, self.weights_hidden_output.T)
        hidden_delta = hidden_error * self.sigmoid_derivative(self.hidden_output)

        self.weights_hidden_output += np.dot(self.hidden_output.T, output_delta) * learning_rate
        self.bias_output += np.sum(output_delta, axis=0, keepdims=True) * learning_rate
        self.weights_input_hidden += np.dot(X.T, hidden_delta) * learning_rate
        self.bias_hidden += np.sum(hidden_delta, axis=0, keepdims=True) * learning_rate

    def train(self, X, y, epochs, learning_rate):
        for epoch in range(epochs):
            output = self.feedforward(X)
            self.backward(X, y, learning_rate)
            if epoch % 4000 == 0:
                loss = np.mean(np.square(y - output))
                print(f"Epoch {epoch}, Loss:{loss}")

IMAGE1 = 'day_open.jpg'
IMAGE2 = 'night_open.jpg'
IMAGE3 = 'day_closed.jpg'
IMAGE4 = 'night_closed.jpg'
IMAGE5 = 'day_closed.jpg'

image1 = cv2.imread(IMAGE1)
image2 = cv2.imread(IMAGE2)
image3 = cv2.imread(IMAGE3)
image4 = cv2.imread(IMAGE4)
image4 = cv2.imread(IMAGE5)

gray_image1 = cv2.cvtColor(image1, cv2.COLOR_BGR2GRAY)
gray_image1 = cv2.resize(gray_image1,(100, 100), interpolation = cv2.INTER_CUBIC)
gray_image2 = cv2.cvtColor(image2, cv2.COLOR_BGR2GRAY)
gray_image2 = cv2.resize(gray_image2,(100, 100), interpolation = cv2.INTER_CUBIC)
gray_image3 = cv2.cvtColor(image3, cv2.COLOR_BGR2GRAY)
gray_image3 = cv2.resize(gray_image3,(100, 100), interpolation = cv2.INTER_CUBIC)
gray_image4 = cv2.cvtColor(image4, cv2.COLOR_BGR2GRAY)
gray_image4 = cv2.resize(gray_image4,(100, 100), interpolation = cv2.INTER_CUBIC)
gray_image5 = cv2.cvtColor(image4, cv2.COLOR_BGR2GRAY)
gray_image5 = cv2.resize(gray_image4,(100, 100), interpolation = cv2.INTER_CUBIC)
gray_image1 = gray_image1 / 255
gray_image2 = gray_image2 / 255
gray_image3 = gray_image3 / 255
gray_image4 = gray_image4 / 255
gray_image5 = gray_image5 / 255

X=np.array([gray_image1.reshape(10000),gray_image2.reshape(10000),gray_image3.reshape(10000),gray_image4.reshape(10000)])
y=np.array([[0,1],[0,1],[0,0],[0,0]])
print("output = ", y)

print(X.shape)

nn = NeuralNetwork(input_size=10000, hidden_size=300, output_size=2)
print(f'training')
nn.train(X, y, epochs=700, learning_rate=0.8)

print("Predictions after training:")
print(f'  image1 {nn.feedforward(gray_image1.reshape(1,10000))}')
print(f'  image2 {nn.feedforward(gray_image2.reshape(1,10000))}')
print(f'  image3 {nn.feedforward(gray_image3.reshape(1,10000))}')
print(f'  image4 {nn.feedforward(gray_image4.reshape(1,10000))}')
#print(f'  image5 {nn.feedforward(gray_image5.reshape(1,10000))}')