La classe astratta Layer e la rete Sequential
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.
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
}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.
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:
Layer, base comune di tutti i layer, da cui deriva DenseLayer;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);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.
Si lavora nel progetto basic_neural_plusplus, come nel Laboratorio 05.
main.cpp create tre file vuoti: layer.hpp, sequential.hpp e sequential.cpp.CMakeLists.txt aggiungete sequential.cpp alla riga di basic_neural (il file completo è nella slide seguente):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.
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 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.
LayerScopo: dare a tutti i layer una classe base comune, come nella Lezione 12.
layer.hpp
Layer*.
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.
DenseLayer deriva da LayerScopo: 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;
};
#endifRispetto al Laboratorio 05 cambiano tre righe:
#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.
SequentialScopo: 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(); }
};
#endifCopiate il codice in sequential.hpp: è completo.
layers: i layer, come puntatori alla classe base (Lezione 12);= delete: copia vietata, slide seguente;add riceve un layer creato con new, di cui la rete diventa proprietaria;size(): il numero di layer.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:
= 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.
SequentialScopo: 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;
}forward è virtuale: viene eseguito quello del layer vero, oggi DenseLayer.
Copiate il codice in sequential.cpp e completate i due metodi:
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.
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.
Scopo: vedere che cosa succede se manca un pezzo. Poi rimettete il codice com’era.
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.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).prova_sequential aggiungete Sequential copia = rete; dopo Sequential rete;: la compilazione si ferma con use of deleted function 'Sequential::Sequential(const Sequential&)'.La soluzione verrà discussa all’inizio del prossimo laboratorio.