Laboratorio 05

La classe Matrix e il DenseLayer con Eigen

Cristiano De Michele

Soluzione del Laboratorio 04, Task 5: la struct

main.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).

Soluzione del Laboratorio 04, Task 5 e 6: accesso e strato

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];
    }
}

Soluzione del Laboratorio 04, Task 1 e 2

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;
    }

Soluzione del Laboratorio 04, Task 3 e 4

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;

Soluzione del Laboratorio 04, Task 6: lo strato nel main

Il 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;
    }

Soluzione del Laboratorio 04, Task 7

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
    // Task 7: CMatrix W2 = W; copierebbe il puntatore, non i dati:
    // due cmat_free sullo stesso blocco sarebbero un double free
    cmat_free(W);
    delete[] bias;
    delete[] x;
    delete[] z_out;
    return 0;
}
  1. CMatrix W2 = W; copia i tre campi, puntatore incluso: le due struct puntano allo stesso blocco e il secondo cmat_free è un double free.
  2. Sulla lunghezza di x non c’è alcuna garanzia: un double* contiene solo un indirizzo.

Obiettivo di oggi

Oggi la CMatrix del Laboratorio 04 diventa una classe, e la rete ha il suo primo strato:

  1. 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.
  2. 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.

Il progetto

Si lavora sempre nel progetto basic_neural_plusplus del Laboratorio 01.

  1. Copiate main.cpp in lab04_main.cpp, che non va compilato, poi svuotate main.cpp.
  2. Accanto a 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.
  3. Nel CMakeLists.txt la riga di basic_neural diventa:
add_executable(basic_neural main.cpp matrix.cpp parametricLayer.cpp)

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.

Il progetto: il CMakeLists.txt

CMakeLists.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.

Dalla CMatrix alla classe Matrix

Ogni 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.

Task 1: l’interfaccia di Matrix

Scopo: 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;
};

#endif

Copiate il codice in matrix.hpp: è completo.

  • Le prime quattro funzioni pubbliche sono il costruttore e i tre membri della Regola del Tre.
  • get, getRows e getCols sono const (Lezione 09): leggono senza modificare.
  • #ifndef, #define ed #endif sono la header guard (Lezione 08).

Task 2: costruttore e distruttore

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.

  • Il costruttore fa il lavoro di cmat_alloc e azzera gli elementi. Con dimensioni non positive lancia un’eccezione (Lezione 10) e l’oggetto non viene creato.
  • Il distruttore fa il lavoro di cmat_free ed è chiamato automaticamente.

Task 2 (segue): get e set

Copiate 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ù.

Task 3: il costruttore di copia

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
// un blocco nuovo, con gli stessi valori di altra
Matrix::Matrix(const Matrix& altra)
    : rows(altra.rows), cols(altra.cols),
      data(new double[altra.rows * altra.cols]) {
    for (int i = 0; i < rows * cols; i++) {
        data[i] = altra.data[i];
    }
}

È 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.

Task 3 (segue): l’assegnamento

Copiate in fondo a matrix.cpp:

matrix.cpp
Matrix& Matrix::operator=(const Matrix& altra) {
    if (this == &altra) return *this;  // a. auto-assegnamento: m = m
    // b. liberare il vecchio blocco
    // c. copiare rows e cols, allocare un blocco nuovo e copiarvi i valori
    return *this;                      // d. restituire l'oggetto stesso
}

Da completare: i passi b e c (Lezione 10).

  • Al posto del commento b: liberate con delete[] il blocco a cui punta data.
  • Al posto del commento c: assegnate a 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.

Task 4: la prova di Matrix

Scopo: 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.

Task 4 (segue): la copia e il main

main.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.

Task 4 (segue): cosa deve stampare

5 7 0
eccezione: Matrix::get: indici fuori dai limiti
5 9
2 3 7
  1. set e get funzionano; l’elemento \((1, 1)\), mai impostato, vale 0.
  2. 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.
  3. 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.
  4. 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.

Le matrici di Eigen

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

Un esempio con Eigen

#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\).
  • \(z_0 = 1 \cdot 3 = 3\), \(z_1 = 2 \cdot 4 + 0{,}5 = 8{,}5\).
  • Se le colonne di W non sono quante le righe di x, Eigen interrompe il programma: invalid matrix product.

Task 5: l’interfaccia di DenseLayer

Scopo: 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;
};

#endif

Copiate 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.
  • Distruttore e copia non si scrivono: Eigen::MatrixXd li ha già, con copia profonda.

Task 6: i metodi di DenseLayer

Scopo: 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.

Task 7: la prova di DenseLayer

Scopo: 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:

  1. aggiungete #include <Eigen/Dense> e #include "parametricLayer.hpp" dopo gli altri #include;
  2. copiate prova_dense_layer dopo prova_matrix;
  3. nel main, dopo prova_matrix();, aggiungete prova_dense_layer();.

Task 7 (segue): cosa deve stampare

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.
  • I due numeri coincidono: il prodotto di Eigen e il ciclo calcolano la stessa somma. Il valore cambia da un sistema all’altro, perché i pesi e 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.

Task da completare

La soluzione verrà discussa all’inizio del prossimo laboratorio.