La classe Matrix e il DenseLayer con Eigen
structmain.cpp
#include <iostream>
// Task 5: righe, colonne e dati di una matrice, tenuti insieme
struct CMatrix {
int rows;
int cols;
double* data; // rows*cols double, in ordine row-major
};
CMatrix cmat_alloc(int rows, int cols) {
CMatrix m;
m.rows = rows;
m.cols = cols;
m.data = new double[rows * cols];
return m;
}
void cmat_free(CMatrix& m) {
delete[] m.data;
m.data = nullptr; // delete[] su nullptr non fa nulla
m.rows = 0;
m.cols = 0;
}Il task. Task 5: una struct CMatrix con righe, colonne e un array di dati in ordine row-major, e le funzioni cmat_alloc, cmat_free, cmat_get e cmat_set (slide seguente).
Il task. Task 5: cmat_get e cmat_set; Task 6: layer_forward.
main.cpp
// elemento (i, j): la riga i occupa cols celle consecutive
double cmat_get(const CMatrix& m, int i, int j) {
return m.data[i * m.cols + j];
}
void cmat_set(CMatrix& m, int i, int j, double val) {
m.data[i * m.cols + j] = val;
}
// Task 6: z[j] = somma_i W(j, i) * x[i] + b[j], prodotto matrice-vettore
void layer_forward(const CMatrix& W, const double* x, const double* b, double* z) {
for (int j = 0; j < W.rows; ++j) {
double acc = 0.0;
for (int i = 0; i < W.cols; ++i) {
acc += cmat_get(W, j, i) * x[i];
}
z[j] = acc + b[j];
}
}Il task. Task 1: \(N\) da std::cin, due array con new double[N]. Task 2: input a \(1{,}0\), pesi a \(0{,}01\).
main.cpp
int main() {
// Task 1: N letto in esecuzione, due array sullo heap
int N;
std::cout << "Inserisci il numero di input del neurone (es. 784): ";
std::cin >> N;
if (N <= 0) {
std::cerr << "Errore: N deve essere maggiore di 0!" << std::endl;
return 1;
}
double* input = new double[N];
double* pesi = new double[N];
// Task 2: valori di prova
for (int i = 0; i < N; ++i) {
input[i] = 1.0;
pesi[i] = 0.01;
}Il task. Task 3: \(z = \sum_i w_i x_i + b\), con \(b = 0{,}5\). Task 4: un delete[] per ogni new[].
main.cpp
// Task 3: prodotto scalare piu' il bias
double b = 0.5;
double z = 0.0;
for (int i = 0; i < N; ++i) {
z += pesi[i] * input[i];
}
z += b;
std::cout << "Risultato del calcolo (Z): " << z << std::endl;
// Task 4: un delete[] per ogni new[]; senza, in un ciclo di addestramento
// la memoria persa crescerebbe a ogni passo
delete[] input;
delete[] pesi;mainIl task. Task 6: strato di \(M = 3\) neuroni; per \(N = 784\) stampa \(8{,}34\), \(16{,}18\) e \(24{,}02\).
main.cpp
// Task 5 e 6: uno strato di M neuroni
int M = 3;
CMatrix W = cmat_alloc(M, N); // M x N pesi
double* bias = new double[M];
double* x = new double[N];
double* z_out = new double[M];
for (int i = 0; i < N; ++i) {
x[i] = 1.0;
}
for (int j = 0; j < M; ++j) {
bias[j] = 0.5;
for (int i = 0; i < N; ++i) {
cmat_set(W, j, i, 0.01 * (j + 1));
}
}
layer_forward(W, x, bias, z_out);
for (int j = 0; j < M; ++j) {
std::cout << "z_out[" << j << "] = " << z_out[j] << std::endl;
}Il task. Task 7: due domande, su CMatrix W2 = W; e sulla lunghezza di x: sono i due problemi da cui partono le classi di oggi.
main.cpp
CMatrix W2 = W; copia i tre campi, puntatore incluso: le due struct puntano allo stesso blocco e il secondo cmat_free è un double free.x non c’è alcuna garanzia: un double* contiene solo un indirizzo.Oggi la CMatrix del Laboratorio 04 diventa una classe, e la rete ha il suo primo strato:
Matrix: la CMatrix scritta come classe, secondo il RAII (Lezione 09) e la Regola del Tre (Lezione 10). La copia di una Matrix copia i dati, non il puntatore: è la risposta alla prima domanda del Task 7.DenseLayer: uno strato di neuroni scritto con le matrici di Eigen, che conoscono le proprie dimensioni e le controllano nel prodotto: è la risposta alla seconda domanda.Nota
La rete userà Eigen, non Matrix. Eigen::MatrixXd fa ciò che fa Matrix (alloca, libera, copia) e in più calcola prodotti e somme di matrici in modo efficiente. Matrix è quindi un esercizio, e più avanti verrà tolta dal progetto. Gran parte del suo codice è già scritta nelle slide; le parti da scrivere sono indicate.
Si lavora sempre nel progetto basic_neural_plusplus del Laboratorio 01.
main.cpp in lab04_main.cpp, che non va compilato, poi svuotate main.cpp.main.cpp create quattro file vuoti: matrix.hpp, matrix.cpp, parametricLayer.hpp e parametricLayer.cpp. I nomi sono quelli dei file del framework, dove i layer con pesi si dicono parametrici.CMakeLists.txt la riga di basic_neural diventa:CMake compila i tre .cpp e li collega in un solo eseguibile (Lezione 08); gli header non si elencano. Le righe dell’AddressSanitizer del Laboratorio 04 restano. Si compila la prima volta alla fine del Task 4, con cmake --build build && ./build/basic_neural. Su macOS, per i leak, seguite la slide “L’AddressSanitizer su macOS” della Lezione 08.
CMakeLists.txtCMakeLists.txt
cmake_minimum_required(VERSION 3.15)
project(BasicNeuralPlusPlus)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
find_package(Eigen3 QUIET)
find_package(OpenCV REQUIRED)
message(STATUS "OpenCV ${OpenCV_VERSION} trovata")
# AddressSanitizer (Laboratorio 04)
add_compile_options(-fsanitize=address -g)
add_link_options(-fsanitize=address)
add_executable(basic_neural main.cpp matrix.cpp parametricLayer.cpp)
if(Eigen3_FOUND)
target_link_libraries(basic_neural Eigen3::Eigen)
else()
message(STATUS "Eigen non trovata: uso libs/eigen")
target_include_directories(basic_neural PRIVATE libs/eigen)
endif()
target_link_libraries(basic_neural ${OpenCV_LIBS})Il file atteso da oggi. Rispetto al Laboratorio 01 cambiano le righe 9–12: l’AddressSanitizer (Laboratorio 04) e i tre .cpp. task7 del Laboratorio 03 può restare, lab04_main.cpp no: ha un suo main.
CMatrix alla classe MatrixOgni operazione del Laboratorio 04 ha un posto nella classe:
| Laboratorio 04 | Classe Matrix |
|---|---|
CMatrix W = cmat_alloc(r, c); |
Matrix W(r, c); (costruttore) |
cmat_free(W); |
nessuna chiamata: il distruttore è automatico |
cmat_get(W, i, j) |
W.get(i, j) |
cmat_set(W, i, j, v); |
W.set(i, j, v); |
CMatrix W2 = W; (copia il puntatore) |
Matrix W2 = W; (costruttore di copia) |
W2 = W; (copia il puntatore) |
W2 = W; (operator=) |
I tre dati rows, cols e data diventano private: dall’esterno si usano solo i metodi, e nessuno può cambiare rows senza cambiare data.
MatrixScopo: dichiarare la classe, cioè i dati che contiene e i metodi che offre.
matrix.hpp
#ifndef MATRIX_HPP
#define MATRIX_HPP
class Matrix {
private:
int rows;
int cols;
double* data; // rows * cols, row-major
public:
Matrix(int r, int c);
~Matrix();
Matrix(const Matrix& altra);
Matrix& operator=(const Matrix& altra);
double get(int r, int c) const;
void set(int r, int c, double val);
int getRows() const;
int getCols() const;
};
#endifCopiate il codice in matrix.hpp: è completo.
get, getRows e getCols sono const (Lezione 09): leggono senza modificare.#ifndef, #define ed #endif sono la header guard (Lezione 08).Scopo: allocare la memoria nel costruttore e liberarla nel distruttore (RAII, Lezione 09).
matrix.cpp
#include "matrix.hpp"
#include <stdexcept> // invalid_argument, out_of_range
Matrix::Matrix(int r, int c) : rows(r), cols(c) {
if (r <= 0 || c <= 0) {
throw std::invalid_argument(
"Matrix: dimensioni non positive");
}
data = new double[rows * cols];
for (int i = 0; i < rows * cols; i++) {
data[i] = 0.0;
}
}
Matrix::~Matrix() {
delete[] data;
}Copiate il codice all’inizio di matrix.cpp.
cmat_alloc e azzera gli elementi. Con dimensioni non positive lancia un’eccezione (Lezione 10) e l’oggetto non viene creato.cmat_free ed è chiamato automaticamente.get e setCopiate in matrix.cpp, dopo il distruttore:
matrix.cpp
// elemento (r, c): la riga r comincia alla cella r * cols
double Matrix::get(int r, int c) const {
if (r < 0 || r >= rows || c < 0 || c >= cols) {
throw std::out_of_range("Matrix::get: indici fuori dai limiti");
}
return data[r * cols + c];
}
int Matrix::getRows() const { return rows; }
int Matrix::getCols() const { return cols; }Da scrivere: la definizione di set, il cui prototipo è in matrix.hpp. In matrix.cpp, come per get, la definizione comincia con void Matrix::set(int r, int c, double val). Il controllo degli indici è lo stesso di get, con il messaggio "Matrix::set: indici fuori dai limiti"; dopo il controllo, invece di restituire data[r * cols + c], gli assegna val. È il cmat_set del Laboratorio 04 con il controllo in più.
Scopo: applicare la Regola del Tre (Lezione 10), perché ogni copia di una Matrix abbia un blocco di memoria suo.
Copiate in fondo a matrix.cpp:
matrix.cpp
È il costruttore di copia della DynamicArray della Lezione 10, con rows * cols elementi invece di size_. Senza di esso il compilatore ne genera uno che copia il puntatore, e Matrix b = a; produrrebbe un double free alla fine del blocco.
Copiate in fondo a matrix.cpp:
matrix.cpp
Da completare: i passi b e c (Lezione 10).
delete[] il blocco a cui punta data.rows e cols quelli di altra, allocate con new un blocco di rows * cols double e copiatevi i valori con il ciclo for del costruttore di copia.È l’operator= di DynamicArray (Lezione 10) con rows * cols elementi. Senza il passo a, m = m libererebbe il blocco che sta per copiare.
MatrixScopo: verificare con un programma che Matrix funzioni come previsto.
main.cpp
#include <iostream>
#include <stdexcept>
#include "matrix.hpp"
void prova_matrix() {
// 1. set e get
Matrix a(2, 3); // 2 x 3, tutti a 0
a.set(0, 2, 5.0);
a.set(1, 0, 7.0);
std::cout << a.get(0, 2) << " " << a.get(1, 0) << " "
<< a.get(1, 1) << std::endl;
// 2. un indice sbagliato
try {
a.get(2, 0); // la riga 2 non esiste
std::cout << "nessuna eccezione" << std::endl;
} catch (const std::out_of_range& e) {
std::cout << "eccezione: " << e.what() << std::endl;
}Copiate il codice in main.cpp; la funzione continua nella slide seguente.
Il try e il catch sono quelli della Lezione 10: quando get lancia l’eccezione, il programma salta al catch e poi prosegue.
mainmain.cpp
// 3. la copia
Matrix b = a; // costruttore di copia
b.set(0, 2, 9.0);
std::cout << a.get(0, 2) << " " << b.get(0, 2) << std::endl;
// 4. l'assegnamento
Matrix c(4, 4);
c = a; // operator=
std::cout << c.getRows() << " " << c.getCols() << " "
<< c.get(1, 0) << std::endl;
}
int main() {
prova_matrix();
return 0;
}Matrix b = a; crea b come copia di a, quindi chiama il costruttore di copia; c = a; copia in un oggetto che esiste già, quindi chiama operator= (Lezione 10).
Ora compilate ed eseguite: l’output atteso è nella slide seguente.
5 7 0
eccezione: Matrix::get: indici fuori dai limiti
5 9
2 3 7
set e get funzionano; l’elemento \((1, 1)\), mai impostato, vale 0.get(2, 0) lancia l’eccezione, il catch la riceve e il programma prosegue. Se compare nessuna eccezione, in get manca il controllo degli indici.b è una copia indipendente: modificarla non cambia a. Con la copia generata dal compilatore la riga sarebbe 9 9, e alla fine del blocco ci sarebbe un double free.c aveva \(4 \times 4\) elementi; dopo c = a ha le dimensioni e i valori di a. Se la riga è 4 4 0, in operator= mancano i passi b e c.Dopo queste righe l’AddressSanitizer non deve stampare nulla: ogni blocco è stato liberato una e una sola volta.
Eigen::MatrixXd è la Eigen::MatrixXf della Lezione 02 con elementi double. Le operazioni che servono oggi:
| Codice | Significato |
|---|---|
Eigen::MatrixXd M; |
matrice di double, dimensioni decise in esecuzione |
Eigen::MatrixXd::Zero(r, c) |
matrice \(r \times c\) di zeri |
Eigen::MatrixXd::Random(r, c) |
matrice \(r \times c\) di valori casuali tra \(-1\) e \(1\) |
M(i, j) |
elemento \((i, j)\), in lettura e in scrittura |
M.rows(), M.cols() |
numero di righe e di colonne |
A * B, A + B |
prodotto e somma di matrici |
std::cout << M |
stampa la matrice, una riga di testo per riga |
#include <iostream>
#include <Eigen/Dense>
int main() {
Eigen::MatrixXd W = Eigen::MatrixXd::Zero(2, 3);
W(0, 0) = 1.0;
W(1, 2) = 2.0;
Eigen::MatrixXd x = Eigen::MatrixXd::Zero(3, 1);
x(0, 0) = 3.0;
x(2, 0) = 4.0;
Eigen::MatrixXd b = Eigen::MatrixXd::Zero(2, 1);
b(1, 0) = 0.5;
Eigen::MatrixXd z = W * x + b;
std::cout << "z: " << z.rows() << " x " << z.cols()
<< std::endl;
std::cout << z << std::endl;
return 0;
}Output:
z: 2 x 1
3
8.5
W è \(2 \times 3\), x è \(3 \times 1\) (un vettore colonna): z è \(2 \times 1\).W non sono quante le righe di x, Eigen interrompe il programma: invalid matrix product.DenseLayerScopo: dichiarare uno strato di neuroni che calcola \(z = W x + b\).
parametricLayer.hpp
#ifndef PARAMETRIC_LAYER_HPP
#define PARAMETRIC_LAYER_HPP
#include <Eigen/Dense>
class DenseLayer {
private:
Eigen::MatrixXd Wt; // W: Nn x Ni
Eigen::MatrixXd biases; // b: Nn x 1
public:
DenseLayer(int Nn, int Ni); // neuroni, ingressi
Eigen::MatrixXd forward(
const Eigen::MatrixXd& input);
const Eigen::MatrixXd& getWeights() const;
const Eigen::MatrixXd& getBiases() const;
};
#endifCopiate il codice in parametricLayer.hpp: è completo.
Wt, il nome del framework (Lezione 02), è la W del Laboratorio 04: una riga per neurone, una colonna per ingresso.getWeights restituisce un riferimento const: si leggono i pesi senza copiarli né modificarli.Eigen::MatrixXd li ha già, con copia profonda.DenseLayerScopo: scrivere con Eigen il layer_forward del Laboratorio 04.
Copiate in parametricLayer.cpp, creato vuoto nella slide «Il progetto»:
parametricLayer.cpp
#include "parametricLayer.hpp"
DenseLayer::DenseLayer(int Nn, int Ni) {
Wt = Eigen::MatrixXd::Random(Nn, Ni); // valori casuali tra -1 e 1
biases = Eigen::MatrixXd::Zero(Nn, 1); // bias nulli
}
Eigen::MatrixXd DenseLayer::forward(const Eigen::MatrixXd& input) {
// da scrivere: restituire W x + b, al posto della riga seguente
return input; // provvisorio, da sostituire
}
const Eigen::MatrixXd& DenseLayer::getWeights() const { return Wt; }
const Eigen::MatrixXd& DenseLayer::getBiases() const { return biases; }Da scrivere: il corpo di forward, una sola riga, al posto del return provvisorio: un return del prodotto di Wt per input, più biases. I due cicli annidati di layer_forward li esegue Eigen.
DenseLayerScopo: verificare le dimensioni di \(z\) e confrontare Eigen con il ciclo del Laboratorio 04.
main.cpp
void prova_dense_layer() {
// un'immagine MNIST: 784 pixel in colonna
Eigen::MatrixXd x = Eigen::MatrixXd::Random(784, 1);
// 128 neuroni, 784 ingressi
DenseLayer strato(128, 784);
Eigen::MatrixXd z = strato.forward(x);
std::cout << "z: " << z.rows() << " x " << z.cols()
<< std::endl;
// z(0,0) ricalcolato con il ciclo del Laboratorio 04
const Eigen::MatrixXd& W = strato.getWeights();
double acc = 0.0;
for (int i = 0; i < 784; i++) {
acc += W(0, i) * x(i, 0);
}
acc += strato.getBiases()(0, 0);
std::cout << z(0, 0) << " " << acc << std::endl;
}In main.cpp:
#include <Eigen/Dense> e #include "parametricLayer.hpp" dopo gli altri #include;prova_dense_layer dopo prova_matrix;main, dopo prova_matrix();, aggiungete prova_dense_layer();.Dopo le quattro righe del Task 4:
z: 128 x 1
<un numero> <lo stesso numero>
z ha una riga per neurone e una colonna.W è un riferimento const (Lezione 06) alla matrice restituita da getWeights: le dà un nome senza copiarla.x sono casuali.Provate poi l’ordine sbagliato, DenseLayer strato(784, 128);: W diventa \(784 \times 128\), il prodotto con un vettore di 784 righe non è definito e il programma si interrompe con un messaggio che contiene invalid matrix product. È la risposta alla seconda domanda del Laboratorio 04: Eigen controlla le dimensioni. Rimettete poi l’ordine giusto.
La soluzione verrà discussa all’inizio del prossimo laboratorio.