Problema errore lettura telecamera(OpenCV/Py)
Inviato: 1 apr 2025, 12:30Ho il seguente codice:
ed ottengo il seguente messaggio di errore:
perché mi da tale errore?
- 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 = 'DX1.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))}')
while True:
cap = cv.VideoCapture(0)
if not cap.isOpened():
print("Cannot open camera")
exit()
# Capture frame-by-frame
ret, frame = cap.read()
gray_image1 = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
gray_image1 = cv2.resize(gray_image1,(100, 100), interpolation =
cv2.INTER_CUBIC)
#cv.imshow("Display window", gray_image1)
#k = cv.waitKey(0)
gray_image1 = gray_image1 / 255
print("Predictions after training:")
print(f' image1 {nn.feedforward(gray_image1.reshape(1,10000))}')
ed ottengo il seguente messaggio di errore:
- 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
caricamento who
Predictions after training:
image1 [[1.27132098e-03 9.94429034e-01 1.29911218e-06 1.00000000e+00]]
image2 [[1.48849602e-06 3.20656101e-06 1.35191542e-03 9.99999999e-01]]
image3 [[2.48041896e-08 9.99999952e-01 3.40170904e-07 1.00000000e+00]]
image4 [[2.94269280e-05 5.07023377e-10 3.94733197e-04 9.99999994e-01]]
image5 [[4.27285717e-04 9.98542453e-01 9.99999901e-01 9.99994018e-01]]
image6 [[1.75611959e-03 9.99998415e-01 6.93325269e-04 9.99992124e-01]]
image7 [[8.60520542e-01 9.99900309e-01 2.20303752e-06 9.99999999e-01]]
Predictions after training:
image1 [[0.92460133 0.14056893 0.2178598 0.98757831]]
[ WARN:0@1.894] global cap_v4l.cpp:913 open VIDEOIO(V4L2:/dev/video0): can't open camera by index
[ERROR:0@1.894] global obsensor_uvc_stream_channel.cpp:158 getStreamChannelGroup Camera index out of range
Cannot open camera
perché mi da tale errore?
