La sigmoide e le ottimizzazioni del compilatore
Il task. Nei Task 3 e 4 la rete Sequential diventava proprietaria dei suoi layer, in un std::vector<Layer*>, con la copia vietata da = delete. Da completare c’erano il distruttore, un for con delete l;, e add, un push_back. La prova del Task 5 stampa layer: 2, z: 10 x 1.
sequential.cpp
Il distruttore di Layer è virtuale: delete l esegue prima il distruttore di DenseLayer, poi quello di Layer.
Due strati lineari uno dopo l’altro equivalgono a un solo strato lineare: è il collasso della slide “Piegare lo spazio” della Lezione 02. Perché la rete non collassi serve una funzione di attivazione non lineare dopo ogni DenseLayer.
Oggi:
Matrix, l’esercizio del Laboratorio 05, esce dal progetto: da qui in avanti le matrici sono quelle di Eigen;SigmoidLayer, un layer senza pesi che applica la sigmoide a ogni elemento, e lo si mette dopo ogni DenseLayer;Come nel framework, SigmoidLayer sta in activation_layers.hpp e calcola la sigmoide con la stessa riga che scriverete nel Task 2.
MatrixScopo: togliere Matrix dal progetto e preparare i file di SigmoidLayer.
main.cpp create due file vuoti: activation_layers.hpp e activation_layers.cpp.CMakeLists.txt la riga di basic_neural diventa, senza matrix.cpp e con activation_layers.cpp (il file completo è nella slide seguente):main.cpp togliete #include "matrix.hpp", la funzione prova_matrix e la sua chiamata nel main.prova_dense_layer e di prova_sequential (z: 128 x 1, i due numeri uguali, layer: 2, z: 10 x 1).matrix.hpp e matrix.cpp possono restare nella cartella: non vengono più compilati.
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 parametricLayer.cpp sequential.cpp activation_layers.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 06: cambia solo la riga 12.
SigmoidLayerScopo: scrivere il primo layer senza pesi, che applica la sigmoide \(\sigma(z) = 1/(1+e^{-z})\) a ogni elemento dell’ingresso.
activation_layers.hpp
Copiate i due file.
SigmoidLayer non ha attributi: niente pesi né bias, quindi niente costruttore né distruttore da scrivere.
Con output = input il programma compila già, ma forward restituisce l’ingresso invariato: la riga segnata va completata, come nella slide seguente.
Da scrivere: nella riga segnata, al posto di input, la sigmoide di ogni elemento di input. È la riga del Laboratorio 01, 1.0f / (1.0f + (-z.array()).exp()), con input al posto di z e 1.0 al posto di 1.0f, perché qui gli elementi sono double.
Come nel Laboratorio 01, input.array() tratta la matrice come una tabella di numeri: il segno -, exp(), la somma con 1.0 e la divisione di 1.0 agiscono su ogni elemento. Il risultato è un array di Eigen; assegnato a output, una Eigen::MatrixXd, diventa una matrice con le dimensioni di input.
Senza .array(), per una matrice exp() è l’esponenziale di matrice, \(e^{M} = \sum_k M^k/k!\), e la compilazione si ferma con un errore che contiene MatrixExponentialReturnValue.
Scopo: mettere una sigmoide dopo ogni DenseLayer e verificare che le uscite della rete stiano fra 0 e 1.
main.cpp
// Task 3: 784 -> 128 -> 10, sigmoide dopo ogni DenseLayer
void costruisci_rete(Sequential& rete) {
rete.add(new DenseLayer(128, 784));
rete.add(new SigmoidLayer());
rete.add(new DenseLayer(10, 128));
rete.add(new SigmoidLayer());
}
void prova_rete() {
Eigen::MatrixXd x = Eigen::MatrixXd::Random(784, 1);
Sequential rete;
costruisci_rete(rete);
Eigen::MatrixXd y = rete.forward(x);
std::cout << "y: " << y.rows() << " x " << y.cols()
<< ", min " << y.minCoeff()
<< ", max " << y.maxCoeff() << std::endl;
}Aggiungete le due funzioni a main.cpp, dopo prova_sequential e prima del main, e in cima #include "activation_layers.hpp".
La rete passa per riferimento: la copia di Sequential è vietata (Laboratorio 06).
minCoeff() e maxCoeff(): il più piccolo e il più grande elemento di y.
main e l’outputNel main aggiungete la chiamata a prova_rete:
Compilate ed eseguite: dopo le righe del Task 1 compare una riga come questa, ottenuta su Linux con g++:
y: 10 x 1, min 2.67228e-05, max 0.996831
Su altri sistemi i numeri cambiano, perché cambiano i valori casuali di Random. In ogni caso il minimo deve essere maggiore di 0 e il massimo minore di 1: lo garantisce la sigmoide dopo l’ultimo DenseLayer.
Molti valori sono vicini a 0 o a 1: con 784 ingressi e pesi fra −1 e 1, \(z\) è grande in modulo, e lì la sigmoide è quasi costante.
Scopo: misurare la durata di 10 000 forward della rete, con il cronometro della Lezione 14.
main.cpp
// Task 4: il tempo di n forward della rete
void misura_tempo() {
Eigen::MatrixXd x = Eigen::MatrixXd::Random(784, 1);
Sequential rete;
costruisci_rete(rete);
int n = 10000; // una sola forward e' troppo breve da misurare
auto inizio = std::chrono::high_resolution_clock::now();
for (int i = 0; i < n; i++) {
rete.forward(x);
}
auto fine = std::chrono::high_resolution_clock::now();
auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
fine - inizio).count();
std::cout << n << " forward: " << ms << " ms" << std::endl;
}auto, now() e duration_cast sono quelli della Lezione 14.
CMakeLists.txt commentate con # le due righe dell’AddressSanitizer:L’AddressSanitizer controlla ogni accesso alla memoria e rallenta il programma: con le due righe attive la stessa misura dura circa 4 volte di più.
misura_tempo a main.cpp, dopo prova_rete e prima del main, e in cima #include <chrono>. Nel main, dopo prova_rete();, aggiungete la chiamata misura_tempo();.10000 forward: ... ms: annotate il tempo, è quello del codice senza ottimizzazioni.Le righe dell’AddressSanitizer si possono riattivare quando si cercano errori di memoria.
-O3Scopo: misurare quanto cambia il tempo con le opzioni -O della Lezione 14.
Il CMakeLists.txt non chiede ottimizzazioni: il compilatore usa -O0, e il tempo del Task 4 è quello del codice non ottimizzato.
CMakeLists.txt la riga di CMAKE_CXX_FLAGS diventa:cmake --build build && ./build/basic_neural: CMake vede che il CMakeLists.txt è cambiato e ricompila tutti i file. Annotate il tempo.-O1 e con -O2 al posto di -O3; alla fine rimettete -O3.Con i quattro tempi annotati (-O0, -O1, -O2, -O3) confrontate i rapporti con quelli della slide seguente.
CMakeLists.txt finaleCMakeLists.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} -O3 -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 parametricLayer.cpp sequential.cpp activation_layers.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})Rispetto al Task 1: riga 5 con -O3, righe 10 e 11 commentate (Task 4). Il Laboratorio 08 parte da qui.
La stessa rete, 10 000 forward, su un computer Linux x86-64 con g++ 13 ed Eigen 3.4 (mediana di 5 esecuzioni):
| Opzione | Tempo | Rispetto a -O0 |
|---|---|---|
-O0 |
10 250 ms | 1× |
-O1 |
273 ms | 38× |
-O2 |
257 ms | 40× |
-O3 |
243 ms | 42× |
Quasi tutto il guadagno arriva con -O1. Eigen è scritta con molte funzioni piccole; da -O1 il compilatore sostituisce le chiamate con il corpo delle funzioni (inlining, come il getter della Lezione 14) e ne ottiene cicli semplici. Con -O1 -fno-inline, cioè senza inlining, il tempo torna a 5 070 ms.
Sul vostro computer i tempi saranno diversi: confrontate i rapporti.
-march=nativeIl framework compila con -O3 -march=native: -march=native permette al compilatore di usare tutte le istruzioni della CPU su cui compila.
Su x86-64, senza questa opzione, si usano solo le istruzioni vettoriali SSE2, che elaborano 2 double per volta; con -march=native anche AVX (4 double) o AVX-512 (8), se la CPU le ha. Sulla stessa rete: -O3 243 ms, -O3 -march=native 105 ms.
Per provarlo: -O3 -march=native -Wall nella riga di CMAKE_CXX_FLAGS. Avvertenze:
unsupported argument 'native', l’opzione non c’è e -O3 basta;unused variable 'r' dai suoi header: non riguardano il vostro codice.Scopo: misurare separatamente un DenseLayer e un SigmoidLayer, per sapere quale parte della rete conviene ottimizzare.
main.cpp
// Approfondimento: il tempo di n forward di un solo layer
void tempo_layer(const std::string& nome, Layer* l,
const Eigen::MatrixXd& x) {
int n = 10000;
auto inizio = std::chrono::high_resolution_clock::now();
for (int i = 0; i < n; i++) {
l->forward(x);
}
auto fine = std::chrono::high_resolution_clock::now();
auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(
fine - inizio).count();
std::cout << nome << ": " << ms << " ms" << std::endl;
}
void dove_va_il_tempo() {
DenseLayer denso(128, 784);
SigmoidLayer sigmoide;
tempo_layer("DenseLayer", &denso, Eigen::MatrixXd::Random(784, 1));
tempo_layer("SigmoidLayer", &sigmoide, Eigen::MatrixXd::Random(128, 1));
}Aggiungete le due funzioni a main.cpp, dopo misura_tempo e prima del main, e in cima #include <string>. Nel main, dopo misura_tempo();, aggiungete la chiamata dove_va_il_tempo();. tempo_layer riceve un Layer*: misura un layer qualsiasi, e l->forward esegue il forward del layer vero (Lezione 12).
Confrontate i due tempi fra loro e con quello della rete nel Task 4. Sul computer della slide “I tempi misurati”:
| Opzione | DenseLayer(128, 784) |
SigmoidLayer, 128 valori |
|---|---|---|
-O0 |
9 800 ms | 220 ms |
-O3 |
220 ms | 11 ms |
Il DenseLayer fa circa 100 000 moltiplicazioni e somme (128 × 784), la sigmoide 128 esponenziali: il tempo della rete è quasi tutto nei prodotti, e riscrivere la sigmoide non lo cambierebbe. Prima di ottimizzare, si misura dove va il tempo.
La soluzione verrà discussa all’inizio del prossimo laboratorio.