Laboratorio 06

La classe astratta Layer e la rete Sequential

Cristiano De Michele

Soluzione del Laboratorio 05, Task 2

Il task. Nei Task 1–3 la CMatrix del Laboratorio 04 diventava la classe Matrix, con il RAII e la Regola del Tre; il codice era quasi tutto nelle slide. Nel Task 2 andava scritto set, con lo stesso controllo degli indici di get.

matrix.cpp
void Matrix::set(int r, int c, double val) {
    if (r < 0 || r >= rows || c < 0 || c >= cols) {
        throw std::out_of_range("Matrix::set: indici fuori dai limiti");
    }
    data[r * cols + c] = val;
}

Soluzione del Laboratorio 05, Task 3

Il task. Completare l’operatore di assegnamento con i passi b e c della Lezione 10. La prova del Task 4 stampa 5 7 0, l’eccezione di get, 5 9 e 2 3 7.

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

Soluzione del Laboratorio 05, Task 6

Il task. Nei Task 5 e 6 DenseLayer(int Nn, int Ni) usava le matrici di Eigen; andava scritto il corpo di forward, in una riga. La prova del Task 7 stampa z: 128 x 1 e lo stesso valore calcolato da Eigen e dal ciclo.

parametricLayer.cpp
Eigen::MatrixXd DenseLayer::forward(const Eigen::MatrixXd& input) {
    return Wt * input + biases;
}

Obiettivo di oggi

Oggi la rete prende forma: una classe Sequential che contiene una sequenza di layer e li applica uno dopo l’altro. Si usano gli strumenti della Lezione 12:

  1. la classe astratta Layer, base comune di tutti i layer, da cui deriva DenseLayer;
  2. un std::vector<Layer*> che tiene i layer della rete; Sequential ne è il proprietario e li distrugge nel suo distruttore (Lezione 09: ogni new ha un proprietario);
  3. il distruttore virtuale, perché i layer si distruggono attraverso un Layer*.

Una rete non si copia: la copia di Sequential si vieta, con = delete.

È lo schema del framework: la classe base Layer, da cui derivano tutti i layer, e Sequential, che li possiede.

Il progetto

Si lavora nel progetto basic_neural_plusplus, come nel Laboratorio 05.

  1. Nella cartella di main.cpp create tre file vuoti: layer.hpp, sequential.hpp e sequential.cpp.
  2. Nel CMakeLists.txt aggiungete sequential.cpp alla riga di basic_neural (il file completo è nella slide seguente):
add_executable(basic_neural main.cpp matrix.cpp parametricLayer.cpp sequential.cpp)
  1. main.cpp resta quello del Laboratorio 05: nel Task 5 si aggiunge una terza funzione di prova, prova_sequential.

A ogni modifica, dalla cartella del progetto: cmake --build build && ./build/basic_neural. Le righe dell’AddressSanitizer restano attive; 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 sequential.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 del Laboratorio 05: cambia solo la riga 12, con sequential.cpp.

Task 1: la classe astratta Layer

Scopo: dare a tutti i layer una classe base comune, come nella Lezione 12.

layer.hpp
#ifndef LAYER_HPP
#define LAYER_HPP

#include <Eigen/Dense>

class Layer {
public:
1    virtual ~Layer() {}
    virtual Eigen::MatrixXd forward(
2        const Eigen::MatrixXd& input) = 0;
};

#endif
1
Distruttore virtuale: la rete distrugge i layer attraverso un Layer*.
2
Metodo virtuale puro: Layer è astratta, e ogni layer deve scrivere il suo forward.

Copiate il codice in layer.hpp: è completo.

forward ha la stessa firma del forward di DenseLayer del Laboratorio 05: riceve l’ingresso, un vettore colonna, e restituisce l’uscita.

È la classe base Layer del framework, che oltre a forward ha anche backward e get_type.

Task 2: DenseLayer deriva da Layer

Scopo: fare di DenseLayer un Layer, per poterlo mettere nella rete.

parametricLayer.hpp
#ifndef PARAMETRIC_LAYER_HPP
#define PARAMETRIC_LAYER_HPP
#include "layer.hpp"

class DenseLayer : public Layer {
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) override;
    const Eigen::MatrixXd& getWeights() const;
    const Eigen::MatrixXd& getBiases() const;
};
#endif

Rispetto al Laboratorio 05 cambiano tre righe:

  • l’#include: ora layer.hpp, che include Eigen;
  • : public Layer dopo il nome della classe;
  • override alla fine di forward.

parametricLayer.cpp e l’output del Laboratorio 05 non cambiano.

Task 3: l’header di Sequential

Scopo: dichiarare la rete, una sequenza di layer di cui la rete è proprietaria.

sequential.hpp
#ifndef SEQUENTIAL_HPP
#define SEQUENTIAL_HPP
#include <vector>
#include "layer.hpp"

class Sequential {
private:
    std::vector<Layer*> layers;
public:
    Sequential() {}
    ~Sequential();
    Sequential(const Sequential&) = delete;
    Sequential& operator=(const Sequential&) = delete;
    void add(Layer* layer);
    Eigen::MatrixXd forward(const Eigen::MatrixXd& input);
    int size() const { return layers.size(); }
};
#endif

Copiate il codice in sequential.hpp: è completo.

  • layers: i layer, come puntatori alla classe base (Lezione 12);
  • il distruttore distrugge i layer;
  • = delete: copia vietata, slide seguente;
  • add riceve un layer creato con new, di cui la rete diventa proprietaria;
  • size(): il numero di layer.

Task 3 (segue): la copia vietata

Sequential distrugge i suoi layer nel distruttore. La copia generata dal compilatore copierebbe il vettore, cioè gli indirizzi: due reti con gli stessi layer, e alla fine ogni layer distrutto due volte, il double free della Lezione 10.

Copiare davvero i layer richiederebbe di sapere di che tipo è ciascuno, DenseLayer o altro: il framework non copia mai una rete. Per questo la copia si vieta:

Sequential(const Sequential&) = delete;
Sequential& operator=(const Sequential&) = delete;

= delete dopo una dichiarazione elimina quella funzione: copiare o assegnare un Sequential diventa un errore di compilazione, invece di un double free in esecuzione. La Regola del Tre è rispettata: il distruttore è scritto, la copia e l’assegnamento sono vietati.

= delete si riprende più avanti, per altre classi che non si devono copiare.

Task 4: i metodi di Sequential

Scopo: scrivere i metodi della rete: il proprietario dei layer li distrugge.

sequential.cpp
#include "sequential.hpp"

Sequential::~Sequential() {
    // da scrivere: un for sugli elementi di layers
    // che distrugge ogni layer
}

void Sequential::add(Layer* layer) {
    // da scrivere: aggiungere layer in fondo al vettore
}

Eigen::MatrixXd Sequential::forward(
        const Eigen::MatrixXd& input) {
    Eigen::MatrixXd corrente = input;
    for (Layer* l : layers) {
1        corrente = l->forward(corrente);
    }
    return corrente;
}
1
forward è virtuale: viene eseguito quello del layer vero, oggi DenseLayer.

Copiate il codice in sequential.cpp e completate i due metodi:

  • il distruttore è un for sugli elementi, come nella Lezione 12, con delete per ogni layer;
  • add è una riga: push_back.

forward è dato: l’uscita di ogni layer è l’ingresso del successivo; l’uscita dell’ultimo è l’uscita della rete.

Task 5: la prova

Scopo: verificare che la rete applichi i layer in sequenza e che li distrugga.

main.cpp
// Task 5: una rete di due layer, 784 -> 128 -> 10
void prova_sequential() {
    Eigen::MatrixXd x = Eigen::MatrixXd::Random(784, 1);
    Sequential rete;
    rete.add(new DenseLayer(128, 784));
    rete.add(new DenseLayer(10, 128));
    Eigen::MatrixXd z = rete.forward(x);
    std::cout << "layer: " << rete.size() << ", z: "
              << z.rows() << " x " << z.cols() << std::endl;
}

int main() {
    prova_matrix();
    prova_dense_layer();
    prova_sequential();
    return 0;
}

In main.cpp aggiungete #include "sequential.hpp", la funzione prova_sequential dopo prova_dense_layer e la sua chiamata nel main.

DenseLayer(128, 784): 128 neuroni e 784 ingressi.

Output atteso, dopo quello del Laboratorio 05:

layer: 2, z: 10 x 1

L’AddressSanitizer non deve stampare nulla.

Task 5 (segue): tre esperimenti

Scopo: vedere che cosa succede se manca un pezzo. Poi rimettete il codice com’era.

  1. Distruttore non virtuale (Lezione 12). Togliete virtual dal distruttore di Layer: g++ avvisa (deleting object of abstract class type 'Layer' which has non-virtual destructor will cause undefined behavior) e l’AddressSanitizer ferma il programma con new-delete-type-mismatch: delete l esegue solo il distruttore di Layer. Con clang su macOS: trace trap.
  2. Il proprietario non distrugge. Nel distruttore di Sequential commentate delete l;. Su Linux l’AddressSanitizer segnala 814336 byte(s) leaked in 6 allocation(s): i due DenseLayer e le loro quattro matrici (i pesi del primo layer: 802 816 byte).
  3. La copia. In prova_sequential aggiungete Sequential copia = rete; dopo Sequential rete;: la compilazione si ferma con use of deleted function 'Sequential::Sequential(const Sequential&)'.

Task da completare

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