Problema mancanza messaggio di errore di tofile()

[GioArca67]

Ma se invece di usare tofile() e fromfile() usassi save() e load()?

P. S.
Programmazione orientata agli oggetti,... Un mistero misterioso...

P. P. S.
Non vuole essere offensivo... Però un rafforzamento sul tema ci vorrebbe.
La tua rete neurale è un oggetto il quale è composto da uno stato (delle informazioni che sono salvate al suo interno), e l'abilità di compiere determinate azioni (i metodi), che puoi anche vedere come l'interfaccia col mondo, e che deve essere l'unico modo col quale il mondo esterno si relaziona con l'oggetto. Per cui è vietato l'accesso diretto allo stato dell'oggetto, stato che viene reso accessibile solo tramite azioni messe a disposizione all'oggetto.
Nel tuo caso self.weights_input_hidden è un elemento dello stato e train() un'abilità dell'oggetto.
Ora tu hai una nuova esigenza: salvare e ripristinare parte dello stato (in effetti sarebbe meglio salvare tutto lo stato perché ad es. se domani volessi esaminare immagini 150*180 col tuo programma sei fregato, devi riscriverlo); allora devi chiedere all'oggetto di saper fare due cose nuove: salvarsi in un file e ricaricarsi da un file (ovviamente sei sempre tu che implementi 'sti metodi).
Ma è il punto di vista che cambia: non è il programma che usa l' oggetto a darsi da fare (quindi il da farsi non lo scrivi nel programma), bensì è l'oggetto, che sa come esso stesso è costruito al suo interno, che si preoccupa di fare ciò che gli viene chiesto (train, feedforward, save, ecc. sono metodi dell'oggetto e sono scritti nel blocco di definizione dell'oggetto)

[xyz]

Codice: Seleziona tutto

ValueError: shapes (1,10000) and (3000000,) not aligned: 10000 (dim 1) != 3000000 (dim 0)


Qui l'errore è chiaro, stati facendo una operazione tra matrici con dimensioni non congrue

[alien75]

Ho modificato cosi:

Codice: Seleziona tutto

import numpy as np
import cv2
import cv2 as cv
import sys
import os
from tempfile import TemporaryFile

outfile = TemporaryFile()

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_open.jpg'
IMAGE4 = 'night_closed.jpg'
IMAGE5 = 'DX.jpg'
IMAGE6 = 'SX.jpg'
IMAGE7 = 'day_open.jpg'

image1 = cv2.imread(IMAGE1)
image2 = cv2.imread(IMAGE2)
image3 = cv2.imread(IMAGE3)
image4 = cv2.imread(IMAGE4)
image5 = cv2.imread(IMAGE5)
image6 = cv2.imread(IMAGE6)
image7 = cv2.imread(IMAGE7)

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_image6 = cv2.cvtColor(image6, cv2.COLOR_BGR2GRAY)
gray_image6 = cv2.resize(gray_image6,(100, 100), interpolation = cv2.INTER_CUBIC)
gray_image7 = cv2.cvtColor(image7, cv2.COLOR_BGR2GRAY)
gray_image7 = cv2.resize(gray_image7,(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
gray_image6 = gray_image6 / 255
gray_image7 = gray_image7 / 255

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



nn = NeuralNetwork(input_size=10000, hidden_size=300, output_size=4)
if os.path.exists("wih.txt"):
    #caricamento pesi tra ingresso e strato di hidden
    print(f'caricamento wih')
    open('wih.txt', 'r')
    nn.weights_input_hidden = np.load("wih.txt")
else:
    print(f'training')
    nn.train(X, y, epochs=700, learning_rate=0.8)
    #salvataggio pesi tra ingresso e strato hidden
    open('wih.txt', 'w') 
    wih = nn.weights_input_hidden
    np.save(outfile, wih)


if os.path.exists("who.txt"):
    #caricamento pesi tra strato di hidden ed uscita
    print(f'caricamento who')
    open('who.txt', 'r')
    nn.weights_hidden_output = np.load("who.txt")
else:
    print(f'training')
    nn.train(X, y, epochs=700, learning_rate=0.8)
    #salvataggio pesi tra strato hidden e uscita   
    open('who.txt', 'w')
    who = nn.weights_hidden_output 
    np.save(outfile, who)

   

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))}')
print(f'  image6 {nn.feedforward(gray_image6.reshape(1,10000))}')
print(f'  image7 {nn.feedforward(gray_image7.reshape(1,10000))}')


ed ottengo:

Codice: Seleziona tutto

output =  [[0 1 0 0]
[0 0 0 0]
[0 1 0 0]
[0 0 0 0]
[0 1 1 0]
[0 1 0 1]]
caricamento wih
Traceback (most recent call last):
  File "/home/fabio/Scrivania/BP.py", line 108, in <module>
    nn.weights_input_hidden = np.load("wih.txt")
  File "/usr/local/lib/python3.10/dist-packages/numpy/lib/_npyio_impl.py", line 460, in load
    raise EOFError("No data left in file")
EOFError: No data left in file


mi dice che non ci sono dati nei file salvati, perché?
Immagino sia perche i dati dei pesi li puo' utilizzare solo l'oggetto internamente e non esternamente, giusto?
Se creassi due array dei pesi esterni alla classe ?
Che ne dite?

[GioArca67]

Non riesco a farlo eseguire, ma togli gli open()

[GioArca67]

Che bruttura...
Comunque

togli all'inizio

Codice: Seleziona tutto

from tempfile import TemporaryFile

outfile = TemporaryFile()

dopo print output

Codice: Seleziona tutto

WIH_FN="wih.npy"
WHO_FN="who.npy"

nn = NeuralNetwork(input_size=10000, hidden_size=300, output_size=4)
if os.path.exists(WIH_FN):
    #caricamento pesi tra ingresso e strato di hidden
    print(f'caricamento wih da {WIH_FN}')
    nn.weights_input_hidden = np.load(WIH_FN)
else:
    print(f'training')
    nn.train(X, y, epochs=700, learning_rate=0.8)
    #salvataggio pesi tra ingresso e strato hidden
    wih = nn.weights_input_hidden
    np.save(WIH_FN, wih)


if os.path.exists(WHO_FN):
    #caricamento pesi tra strato di hidden ed uscita
    print(f'caricamento who da {WHO_FN}')
    nn.weights_hidden_output = np.load(WHO_FN)
else:
    print(f'training')
    nn.train(X, y, epochs=700, learning_rate=0.8)
    #salvataggio pesi tra strato hidden e uscita   
    who = nn.weights_hidden_output
    np.save(WHO_FN, who)

poi prosegue con il print("Predictions after training:")

ma perché due test differenti? la "memoria" della rete è composta dall'accoppiata wih e who: basta che ne manchi uno che devi fare il training
Inoltre per come hai organizzato fa il training 2 volte

[alien75]

Risolto:

Codice: Seleziona tutto

import numpy as np
import cv2
import cv2 as cv
import sys
import os
from tempfile import TemporaryFile

outfile = TemporaryFile()

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_open.jpg'
IMAGE4 = 'night_closed.jpg'
IMAGE5 = 'DX.jpg'
IMAGE6 = 'SX.jpg'
IMAGE7 = 'day_open.jpg'

image1 = cv2.imread(IMAGE1)
image2 = cv2.imread(IMAGE2)
image3 = cv2.imread(IMAGE3)
image4 = cv2.imread(IMAGE4)
image5 = cv2.imread(IMAGE5)
image6 = cv2.imread(IMAGE6)
image7 = cv2.imread(IMAGE7)

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_image6 = cv2.cvtColor(image6, cv2.COLOR_BGR2GRAY)
gray_image6 = cv2.resize(gray_image6,(100, 100), interpolation = cv2.INTER_CUBIC)
gray_image7 = cv2.cvtColor(image7, cv2.COLOR_BGR2GRAY)
gray_image7 = cv2.resize(gray_image7,(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
gray_image6 = gray_image6 / 255
gray_image7 = gray_image7 / 255

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

WIH="wih.npy"
WHO="who.npy"

nn = NeuralNetwork(input_size=10000, hidden_size=300, output_size=4)
if os.path.exists(WIH) and os.path.exists(WHO):
    #caricamento pesi tra ingresso e strato di hidden
    print(f'caricamento wih')
    nn.weights_input_hidden = np.load(WIH)
    #caricamento pesi tra strato di hidden ed uscita
    print(f'caricamento who')
    nn.weights_hidden_output = np.load(WHO)
else:
   print(f'training')
   nn.train(X, y, epochs=700, learning_rate=0.8)
   #salvataggio pesi tra ingresso e strato hidden
   wih = nn.weights_input_hidden
   np.save(WIH, wih)
   #salvataggio pesi tra strato hidden e uscita   
   who = nn.weights_hidden_output
   np.save(WHO, who)
   

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))}')
print(f'  image6 {nn.feedforward(gray_image6.reshape(1,10000))}')
print(f'  image7 {nn.feedforward(gray_image7.reshape(1,10000))}')


Ora funziona.

[GioArca67]

Bravo!