Laboratorio 07

La sigmoide e le ottimizzazioni del compilatore

Cristiano De Michele

Soluzione del Laboratorio 06, Task 4

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
Sequential::~Sequential() {
    for (Layer* l : layers) {
        delete l;              // il proprietario distrugge i layer
    }
}

void Sequential::add(Layer* layer) {
    layers.push_back(layer);   // da qui il proprietario è la rete
}

Il distruttore di Layer è virtuale: delete l esegue prima il distruttore di DenseLayer, poi quello di Layer.

Obiettivo di oggi

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:

  1. Matrix, l’esercizio del Laboratorio 05, esce dal progetto: da qui in avanti le matrici sono quelle di Eigen;
  2. si scrive SigmoidLayer, un layer senza pesi che applica la sigmoide a ogni elemento, e lo si mette dopo ogni DenseLayer;
  3. si misura il tempo di 10 000 forward della rete, prima senza e poi con le ottimizzazioni del compilatore della Lezione 14.

Come nel framework, SigmoidLayer sta in activation_layers.hpp e calcola la sigmoide con la stessa riga che scriverete nel Task 2.

Task 1: il progetto senza Matrix

Scopo: togliere Matrix dal progetto e preparare i file di SigmoidLayer.

  1. Nella cartella di main.cpp create due file vuoti: activation_layers.hpp e activation_layers.cpp.
  2. Nel CMakeLists.txt la riga di basic_neural diventa, senza matrix.cpp e con activation_layers.cpp (il file completo è nella slide seguente):
add_executable(basic_neural main.cpp parametricLayer.cpp sequential.cpp activation_layers.cpp)
  1. In main.cpp togliete #include "matrix.hpp", la funzione prova_matrix e la sua chiamata nel main.
  2. Compilate ed eseguite: restano le righe di 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.

Task 1 (segue): 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 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.

Task 2: la classe SigmoidLayer

Scopo: scrivere il primo layer senza pesi, che applica la sigmoide \(\sigma(z) = 1/(1+e^{-z})\) a ogni elemento dell’ingresso.

activation_layers.hpp
#ifndef ACTIVATION_LAYERS_HPP
#define ACTIVATION_LAYERS_HPP
#include "layer.hpp"

class SigmoidLayer : public Layer {
public:
    Eigen::MatrixXd forward(
        const Eigen::MatrixXd& input) override;
};
#endif
activation_layers.cpp
#include "activation_layers.hpp"

Eigen::MatrixXd SigmoidLayer::forward(
        const Eigen::MatrixXd& input) {
    Eigen::MatrixXd output = input;   // da completare
    return output;
}

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.

Task 2 (segue): elemento per elemento

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.

Task 3: la rete non lineare

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.

Task 3 (segue): il main e l’output

Nel main aggiungete la chiamata a prova_rete:

main.cpp
int main() {
    prova_dense_layer();
    prova_sequential();
    prova_rete();
    return 0;
}

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.

Task 4: misurare il tempo

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.

Task 4 (segue): la prima misura

  1. Nel CMakeLists.txt commentate con # le due righe dell’AddressSanitizer:
# add_compile_options(-fsanitize=address -g)
# add_link_options(-fsanitize=address)

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

  1. Aggiungete 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();.
  2. Compilate ed eseguite. L’ultima riga è 10000 forward: ... ms: annotate il tempo, è quello del codice senza ottimizzazioni.

Le righe dell’AddressSanitizer si possono riattivare quando si cercano errori di memoria.

Task 5: compilare con -O3

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

  1. Nel CMakeLists.txt la riga di CMAKE_CXX_FLAGS diventa:
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O3 -Wall")
  1. cmake --build build && ./build/basic_neural: CMake vede che il CMakeLists.txt è cambiato e ricompila tutti i file. Annotate il tempo.
  2. Ripetete con -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.

Il CMakeLists.txt finale

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

I tempi misurati

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.

Approfondimento: -march=native

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

  • l’eseguibile funziona solo su CPU con le stesse istruzioni;
  • su Apple Silicon il guadagno è piccolo o nullo (le istruzioni vettoriali NEON sono sempre attive); se il compilatore risponde unsupported argument 'native', l’opzione non c’è e -O3 basta;
  • su x86-64 Eigen 3.4 può stampare avvisi unused variable 'r' dai suoi header: non riguardano il vostro codice.

Approfondimento: dove va il tempo

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

Approfondimento: i due tempi

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.

Task da completare

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