Programmazione Scientifica++: Lezione 14

Funzioni friend, ottimizzazione (-O3) e libreria Eigen

Cristiano De Michele

Argomenti di oggi

  • Le funzioni friend: una funzione, non un metodo, a cui una classe permette di leggere i suoi membri private
  • Le opzioni -O del compilatore, e come misurare il tempo con <chrono>
  • Le librerie esterne: come il compilatore trova gli header di Eigen, l’opzione -I
  • Il batching: elaborare più immagini insieme
  • Gli argomenti da riga di comando: main(int argc, char* argv[]), e la conversione da testo a numero della Lezione 11
  • Due esercizi: i numeri complessi con friend, e un programma che legge gli iperparametri da riga di comando

Gli argomenti di oggi nel framework

  • Funzioni friend. Quando la rete aggiorna i pesi si scrive W -= lr * grad;: a sinistra di * c’è un numero, a destra una matrice di Eigen. Eigen lo permette con una funzione operator* che le sue classi dichiarano friend.
  • Le opzioni -O. Il framework si compila con -O3, e durante l’addestramento si misura con <chrono> la durata di ogni epoca.
  • Eigen. Gli header di Eigen il compilatore li trova perché CMake gli passa la loro cartella, con l’opzione -I o con la sua variante -isystem.
  • Argomenti da riga di comando. Un programma del framework misura l’accuratezza della rete al variare delle epoche e legge il learning rate dalla riga di comando: per provarne un altro non si ricompila.

La cartella della lezione

Come nelle lezioni precedenti, gli esempi si compilano durante la lezione, in una cartella a parte.

CMakeLists.txt
cmake_minimum_required(VERSION 3.15)
project(Lezione14)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
find_package(Eigen3 QUIET)
# AddressSanitizer (Lezione 08): oggi spento
# add_compile_options(-fsanitize=address -g)
# add_link_options(-fsanitize=address)
# qui una riga add_executable per esempio
  1. Create la cartella LEZIONE_14, fuori da basic_neural_plusplus, e apritela in VS Code.
  2. Createvi il CMakeLists.txt qui a sinistra, poi cmake -B build.

Novità: la riga 6, per Eigen; le righe 8 e 9 commentate, perché l’AddressSanitizer rallenta i programmi e oggi misureremo tempi.

Un eseguibile per esempio

Sopra ogni esempio c’è il nome del suo file. Quando lo incontrate, create il file, copiatevi il codice e aggiungete al CMakeLists.txt la sua riga:

add_executable(stampa stampa.cpp)
add_executable(esercizio_complesso esercizio_complesso.cpp)    # esercizio
add_executable(prodotto prodotto.cpp)
add_executable(somma somma.cpp)
add_executable(prodotto_eigen prodotto_eigen.cpp)
target_link_libraries(prodotto_eigen Eigen3::Eigen)
add_executable(batching batching.cpp)
target_link_libraries(batching Eigen3::Eigen)
add_executable(argomenti argomenti.cpp)
add_executable(parametri parametri.cpp)
add_executable(esercizio_iperparametri esercizio_iperparametri.cpp)    # esercizio

Poi, dalla cartella LEZIONE_14, compilate ed eseguite solo quell’esempio:

cmake -B build && cmake --build build --target stampa && ./build/stampa

Le righe target_link_libraries servono agli esempi con Eigen: le spiegheremo con l’opzione -I. I messaggi citati sono quelli di g++ su Linux; con clang (macOS) il testo cambia, il significato no.

Ripasso: scalare per vettore

Nella Lezione 10 5.0 * v1 non compilava. v1 * 5.0 diventa v1.operator*(5.0), un metodo dell’operando di sinistra; in 5.0 * v1 a sinistra c’è un double, che non ha metodi.

La soluzione è stata una funzione, non un metodo, scritta fuori dalla classe, in fondo a Vettore2D.cpp:

Vettore2D operator*(double s, const Vettore2D& v) {
    return v * s;
}
  • 5.0 * v1 diventa operator*(5.0, v1): la funzione riceve i due operandi, nell’ordine in cui compaiono.
  • Il corpo usa il metodo operator*(double) della classe, v * s, e non ha bisogno di leggere x_ e y_, che sono private.

Oggi il caso che resta: una funzione che deve leggere i membri private di una classe.

Stampare un oggetto con <<

Per stampare un Vettore2D vorremmo scrivere std::cout << v. Come 5.0 * v1, diventa operator<<(std::cout, v): a sinistra c’è std::cout, un oggetto della classe std::ostream della libreria standard, a cui non possiamo aggiungere metodi. Serve una funzione:

std::ostream& operator<<(std::ostream& os, const Vettore2D& v);
  • os è lo stream su cui scrivere, qui std::cout; si passa per reference, perché uno stream non si copia.
  • Restituisce os, per poter scrivere std::cout << v << "\n": prima std::cout << v, che restituisce std::cout, poi std::cout << "\n".
  • Così funziona std::cout << M del Laboratorio 05: Eigen definisce una funzione operator<< per le sue matrici.

Qui, a differenza di 5.0 * v1, il corpo deve leggere x_ e y_, private: il Vettore2D della prossima slide non ha getter (quello della Lezione 10 sì).

Le funzioni friend

stampa.cpp
#include <iostream>

class Vettore2D {
private:
    double x_, y_;
public:
    Vettore2D(double x, double y) : x_(x), y_(y) {}
    friend std::ostream& operator<<(std::ostream& os,
                                    const Vettore2D& v);
};

std::ostream& operator<<(std::ostream& os, const Vettore2D& v) {
    os << "(" << v.x_ << ", " << v.y_ << ")";
    return os;
}

int main() {
    Vettore2D v(3.0, 4.0);
    std::cout << "v = " << v << "\n";
    return 0;
}
  • Righe 8-9: la classe dichiara friend la funzione operator<<, che così può leggere i membri private.
  • La funzione resta una funzione: senza Vettore2D:: (riga 12) e senza this.
  • L’accesso lo concede la classe: una funzione non può dichiararsi friend da sola.

Output: v = (3, 4)

Provate: le funzioni friend

In stampa.cpp, un esperimento alla volta:

  1. Togliete le righe 8-9. Cosa succede?
    'double Vettore2D::x_' is private within this context, e lo stesso per y_: senza friend la funzione non può leggere gli attributi private.
  2. Rimettete le righe e togliete solo la parola friend. Cosa succede?
    'std::ostream& Vettore2D::operator<<(std::ostream&, const Vettore2D&)' must have exactly one argument, più gli errori su x_ e y_. Senza friend la dichiarazione è quella di un metodo, che ha come operando di sinistra l’oggetto stesso e riceve un solo parametro.
  3. Rimettete friend e spostate le righe 8-9 subito dopo la riga 5, nella parte private. Cosa cambia?
    Niente: una dichiarazione friend vale nella parte public come nella parte private.

Provate: friend o static?

Anche un metodo static (Lezione 13), come una funzione friend, non ha this. In stampa.cpp, con le righe 8-9 al loro posto, scrivete static al posto di friend. Cosa succede?

'static std::ostream& Vettore2D::operator<<(std::ostream&, const Vettore2D&)' must be either a non-static member function or a non-member function, più gli errori su x_ e y_.

La differenza: un metodo static è un membro della classe, si chiama con Vettore2D:: e non può fare da operatore come <<; una funzione friend è una funzione esterna, a cui la classe concede l’accesso ai membri private.

Funzione friend o getter?

Con due getter pubblici, getX() e getY() come nel Vettore2D della Lezione 10, operator<< non avrebbe bisogno di friend. Sono due scelte corrette:

  • i getter rendono leggibili gli attributi da qualunque parte del programma;
  • friend dà l’accesso a una sola funzione, scelta dalla classe: per il resto del programma gli attributi restano inaccessibili.

Si sceglie friend quando gli attributi non devono essere letti dall’esterno, ma un operatore come << ne ha bisogno.

La velocità non è un criterio. Quando il compilatore ottimizza, un getter di una riga viene espanso dove è chiamato (inlining: la chiamata è sostituita dal corpo della funzione, Lezione 08), e il codice macchina è lo stesso dell’accesso diretto.

Una classe può dichiarare friend anche un’altra classe: con friend class Rete; tutti i metodi di Rete leggono i membri private.

Esercizio: i numeri complessi

Scopo: scrivere due funzioni friend: l’operatore << per la stampa e il prodotto di un numero per un complesso.

In esercizio_complesso.cpp (slide seguente) la classe Complesso ha due attributi private, re_ e im_, e nessun getter.

  1. Nella classe dichiarate friend le funzioni
    std::ostream& operator<<(std::ostream& os, const Complesso& z) e
    Complesso operator*(double s, const Complesso& z).
  2. Dopo la classe definitele: operator<< scrive z nella forma (1.5 + i*2); operator* restituisce il Complesso con parti s * re_ e s * im_.
  3. Nel main scommentate le due stampe.

Output atteso, su tre righe: |z| = 2.5, z = (1.5 + i*2), 2 * z = (3 + i*4).

cmake -B build && cmake --build build --target esercizio_complesso && ./build/esercizio_complesso

Complessi: il file da completare

esercizio_complesso.cpp
#include <cmath>
#include <iostream>

class Complesso {
private:
    double re_, im_;
public:
    Complesso(double re, double im) : re_(re), im_(im) {}
    double modulo() const { return std::sqrt(re_ * re_ + im_ * im_); }
    // da completare: le dichiarazioni friend di operator<< e operator*
};

// da completare: operator<<, che scrive z nella forma (re + i*im)
// da completare: operator*, che restituisce il Complesso z per s

int main() {
    Complesso z(1.5, 2.0);
    std::cout << "|z| = " << z.modulo() << "\n";
    // std::cout << "z = " << z << "\n";             // da scommentare
    // std::cout << "2 * z = " << 2.0 * z << "\n";   // da scommentare
    return 0;
}

Compila così com’è e stampa |z| = 2.5. operator* è quella della Lezione 10, che ora legge direttamente re_ e im_.

Soluzione dell’esercizio sui complessi

esercizio_complesso.cpp
#include <cmath>
#include <iostream>

class Complesso {
private:
    double re_, im_;
public:
    Complesso(double re, double im) : re_(re), im_(im) {}
    double modulo() const { return std::sqrt(re_ * re_ + im_ * im_); }
    friend std::ostream& operator<<(std::ostream& os,
                                    const Complesso& z);
    friend Complesso operator*(double s, const Complesso& z);
};

std::ostream& operator<<(std::ostream& os, const Complesso& z) {
    os << "(" << z.re_ << " + i*" << z.im_ << ")";
    return os;
}

Complesso operator*(double s, const Complesso& z) {
    return Complesso(s * z.re_, s * z.im_);
}

Righe 10-12: le due dichiarazioni friend. Senza, le righe 16 e 21 non compilano: 'double Complesso::re_' is private within this context.

z.re_ e z.im_ sono private: li possono leggere solo i metodi e le funzioni dichiarate friend.

Soluzione: il main

esercizio_complesso.cpp

int main() {
    Complesso z(1.5, 2.0);
    std::cout << "|z| = " << z.modulo() << "\n";
    std::cout << "z = " << z << "\n";
    std::cout << "2 * z = " << 2.0 * z << "\n";
    return 0;
}

Output:

|z| = 2.5
z = (1.5 + i*2)
2 * z = (3 + i*4)

Riga 28: 2.0 * z diventa operator*(2.0, z) e restituisce un nuovo Complesso, che << stampa.

Le opzioni -O del compilatore

Senza opzioni di ottimizzazione, come con il nostro CMakeLists.txt, il compilatore traduce un’istruzione alla volta: è il livello -O0, il default. Il codice macchina segue il sorgente riga per riga, e le variabili si leggono e si scrivono in memoria a ogni uso.

Con -O1, -O2 e -O3 il compilatore trasforma il programma per renderlo più veloce, senza cambiarne il risultato. Per esempio:

  • inlining: la chiamata di una funzione breve è sostituita dal suo corpo;
  • le variabili usate spesso restano nei registri della CPU;
  • vettorizzazione: un ciclo usa le istruzioni SIMD della Lezione 02, su più numeri per istruzione;
  • i cicli vengono riscritti: srotolati, scambiati, spezzati.

Con CMake: -O2 -Wall al posto di -Wall nella riga di CMAKE_CXX_FLAGS.

Quale livello scegliere

-O0: nessuna ottimizzazione, il default. Il codice macchina segue il sorgente: è il livello adatto mentre si scrive e si corregge il programma.

-O1, -O2: le ottimizzazioni principali; -O2 è il livello più usato. Con g++ 13 (quello di Ubuntu 24.04) su x86-64 comprende già la vettorizzazione e lo srotolamento dei cicli piccoli.

-O3: 13 trasformazioni in più rispetto a -O2, per lo più sui cicli: scambio dei cicli annidati, spezzamento, unroll-and-jam. Non sempre è più veloce di -O2: va misurato. Il framework usa -O3.

Nota

La compilazione rallenta poco: un file con Eigen si compila in 1,5 s a -O0 e in 2,0 s a -O3. A -O3 il codice macchina non segue più il sorgente e un debugger salta fra le righe: per questo si sviluppa a -O0. Ottimizzando, però, -Wall trova più errori (Lezione 07), e un errore che compare solo a -O3 è quasi sempre un comportamento indefinito (per esempio un indice fuori dall’array): si cerca con un sanitizer (Lezione 08).

Un prodotto di matrici

prodotto.cpp
#include <chrono>
#include <iostream>

const int N = 500;
double A[N][N], B[N][N], C[N][N];  // globali, come in C

void prodotto() {                  // C = A B
    for (int i = 0; i < N; i++) {
        for (int k = 0; k < N; k++) {
            double a = A[i][k];
            for (int j = 0; j < N; j++) {
                C[i][j] += a * B[k][j];
            }
        }
    }
}

Un esempio da misurare: \(C = AB\) con matrici \(500 \times 500\), \(C_{ij} = \sum_k A_{ik} B_{kj}\): \(1{,}25 \cdot 10^8\) moltiplicazioni e altrettante somme.

I cicli sono nell’ordine i, k, j: quello interno scorre righe di B e di C, contigue in memoria, e ogni C[i][j] si somma per conto suo.

Le matrici, 2 MB l’una, sono globali, quindi partono da 0: come variabili locali occuperebbero 6 MB degli 8 MB dello stack (Lezione 08).

Misurare il tempo: <chrono>

prodotto.cpp

int main() {
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            A[i][j] = 0.001 * (i + j);
            B[i][j] = 0.001 * (i - j);
        }
    }
    auto inizio = std::chrono::high_resolution_clock::now();
    prodotto();
    auto fine = std::chrono::high_resolution_clock::now();
    auto ms = std::chrono::duration_cast<
        std::chrono::milliseconds>(fine - inizio).count();
    std::cout << "C[1][2] = " << C[1][2] << "\n";
    std::cout << "tempo: " << ms << " ms\n";
    return 0;
}
  • now(), da <chrono>: l’istante attuale; fine - inizio: la durata.
  • duration_cast: la durata in millisecondi (microseconds per i µs); count(): il numero.
  • auto: il tipo, qui std::chrono::time_point<...>, lo deduce il compilatore dal valore iniziale; si riprende nella Lezione 18.

Output, a -O0:

C[1][2] = 41.416
tempo: 320 ms

Provate: le opzioni -O

  1. Compilate ed eseguite prodotto così com’è, a -O0, e annotate il tempo.
  2. Nel CMakeLists.txt, alla riga 5, scrivete -O1 -Wall al posto di -Wall; ricompilate ed eseguite. Poi con -O2 e con -O3. Cambia il risultato?
  3. Tornate a -O0, scommentate le righe 8 e 9 (AddressSanitizer) e rimisurate. Alla fine ricommentatele e lasciate -O3.

Su un computer Linux x86-64, con g++ 13 (mediana di 7 esecuzioni):

-O0 -O1 -O2 -O3 -O0 con AddressSanitizer
prodotto 320 ms 75 ms 50 ms 40 ms 420 ms

Il risultato, C[1][2] = 41.416, è lo stesso: cambia solo il tempo. Il guadagno maggiore arriva con -O1; -O2 e -O3 vettorizzano anche il ciclo interno. Su un MacBook Pro M3 Max, con il clang di Apple: 158 ms a -O0, 34 ms a -O3. Sul vostro computer i tempi saranno diversi: confrontate i rapporti.

Provate: l’ordine nel prodotto

A -O3, riscrivete prodotto() con l’ordine i, j, k della formula: cosa succede al tempo?

for (int i = 0; i < N; i++)
    for (int j = 0; j < N; j++) {
        double s = 0.0;
        for (int k = 0; k < N; k++) s += A[i][k] * B[k][j];
        C[i][j] = s;
    }

Stesso risultato, ma più lento: da 40 a 65 ms con g++ 13, da 34 a 135 ms sull’M3 Max. Il motivo è la somma su s: ogni passo usa il risultato del precedente, quindi il compilatore non può vettorizzare il ciclo interno.

Provate: l’ordine nel sommare M

somma.cpp
#include <chrono>
#include <iostream>

const int N = 4000;
double M[N][N];                    // 128 MB, globale

int main() {
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            M[i][j] = 0.001 * (i + j);
    auto inizio = std::chrono::high_resolution_clock::now();
    double s = 0.0;
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            s += M[i][j];
    auto fine = std::chrono::high_resolution_clock::now();
    auto ms = std::chrono::duration_cast<
        std::chrono::milliseconds>(fine - inizio).count();
    std::cout << "somma = " << s << "\n";
    std::cout << "tempo: " << ms << " ms\n";
    return 0;
}

Come in C, M è memorizzata per righe (row-major): una riga è contigua, mentre M[i][j] e M[i+1][j] distano 32 000 byte.

  1. A -O3, eseguite somma e annotate il tempo.
  2. Scambiate le righe 13 e 14, per leggere M per colonne: cosa succede al tempo?

Stessa somma, ma da 19 a 165 ms con g++ 13, da 10 a 59 ms sull’M3 Max.

L’ordine dei cicli e la cache

La CPU tiene i dati letti di recente nella cache, una piccola memoria veloce al suo interno, e ce li porta dalla memoria principale a blocchi contigui, per esempio di 64 byte, cioè 8 double:

  • per righe (l’indice di colonna cresce nel ciclo interno) gli 8 numeri di un blocco servono uno dopo l’altro, e intanto la CPU porta già il blocco successivo;
  • per colonne (l’indice di riga cresce nel ciclo interno) ogni lettura cade in un blocco diverso, 32 000 byte più in là, e la CPU aspetta la memoria.

Se la matrice sta tutta nella cache, l’ordine conta poco: con N = 500, 2 MB come in prodotto, i due ordini impiegano lo stesso tempo. Per questo nel prodotto leggere B per colonne pesava poco: a rallentarlo era la somma su s.

Eigen memorizza le matrici per colonne (column-major): lì vale il contrario.

La regola: nel ciclo interno, elementi contigui e somme indipendenti, come nell’ordine i, k, j.

Ripasso: Eigen e i suoi header

Eigen è header-only (Laboratorio 01, Lezione 08): basta che il compilatore trovi i suoi header. Con #include <Eigen/Dense> il preprocessore (Lezione 04) cerca Eigen/Dense nelle cartelle di sistema, come /usr/include, ma Eigen sta in /usr/include/eigen3 (Ubuntu) o /opt/homebrew/include/eigen3 (macOS). L’opzione -I aggiunge una cartella a quelle in cui cercare, prima di quelle di sistema:

g++ -I/usr/include/eigen3 -O3 -Wall prodotto_eigen.cpp -o prodotto_eigen

In un progetto CMake l’opzione la aggiunge CMake:

  • target_link_libraries(... Eigen3::Eigen) aggiunge -isystem /usr/include/eigen3: come -I, ma di norma non si stampano gli avvisi dentro quegli header;
  • per Eigen copiata a mano (Laboratorio 01), target_include_directories(... PRIVATE ...) con il percorso di libs/eigen aggiunge -I.

Lo stesso prodotto con Eigen

prodotto_eigen.cpp
#include <chrono>
#include <iostream>
#include <Eigen/Dense>

int main() {
    const int N = 500;
    Eigen::MatrixXd A(N, N), B(N, N);
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            A(i, j) = 0.001 * (i + j);
            B(i, j) = 0.001 * (i - j);
        }
    }
    auto inizio = std::chrono::high_resolution_clock::now();
    Eigen::MatrixXd C = A * B;
    auto fine = std::chrono::high_resolution_clock::now();
    auto ms = std::chrono::duration_cast<
        std::chrono::milliseconds>(fine - inizio).count();
    std::cout << "C(1,2) = " << C(1, 2) << "\n";
    std::cout << "tempo: " << ms << " ms\n";
    return 0;
}

Le stesse matrici di prodotto.cpp, con le operazioni di Eigen del Laboratorio 05: A(i, j) e A * B.

Output, a -O3:

C(1,2) = 41.416
tempo: 20 ms

Stesso risultato, in 20 ms invece di 40, e senza pensare all’ordine dei cicli: ci pensa Eigen, che sfrutta la cache e le istruzioni SIMD.

Provate: i comandi di CMake

  1. Commentate target_link_libraries(prodotto_eigen Eigen3::Eigen) e ricompilate con cmake --build build --target prodotto_eigen --verbose, che stampa i comandi eseguiti da CMake. Cosa succede?
  2. Rimettete la riga e ricompilate con lo stesso comando. Dove sono le opzioni?
  1. fatal error: Eigen/Dense: No such file or directory: nel comando di compilazione manca -isystem, e il preprocessore non trova l’header.
  2. Le due righe che contano, accorciate:
/usr/bin/c++ -isystem /usr/include/eigen3 -O3 -Wall -std=gnu++17 ... -c .../prodotto_eigen.cpp
/usr/bin/c++ -O3 -Wall CMakeFiles/prodotto_eigen.dir/prodotto_eigen.cpp.o -o prodotto_eigen

La prima compila (-c), la seconda fa il linking (Lezione 08); c++ è il compilatore C++ di sistema, su Ubuntu g++. -isystem viene da Eigen3::Eigen, -O3 -Wall da CMAKE_CXX_FLAGS, -std=gnu++17 da CMAKE_CXX_STANDARD.

Provate: Eigen a -O0

Alla riga 5 del CMakeLists.txt tornate a -Wall, cioè a -O0, e rieseguite prodotto_eigen. Quanto ci mette?

Circa 920 ms, più del ciclo scritto a mano a -O0 (320 ms), e 45 volte più che a -O3 (20 ms).

Eigen è fatta di molte funzioni piccole, che senza inlining restano chiamate. Con Eigen le opzioni -O sono indispensabili: rimettete -O3.

Il batching

Le formule della backpropagation (Lezione 03) elaborano un’immagine alla volta, un vettore colonna \(\mathbf{x}\): predizione, errore, aggiornamento dei pesi. È lo stochastic gradient descent (SGD), e il framework fa così.

Per ogni immagine il prodotto \(\mathbf{W}\mathbf{x}\) di un DenseLayer(128, 784) legge tutta la matrice dei pesi, \(128 \times 784 \approx 100\,000\) numeri, e usa ogni peso per una sola moltiplicazione e una somma.

Come per la somma per colonne, se i pesi non stanno nella cache a ogni immagine vanno riletti dalla memoria principale, e la CPU passa più tempo ad aspettare i dati che a calcolare.

Si possono elaborare 64 immagini insieme?

Matrici invece di vettori

Il batching sostituisce il vettore colonna \(\mathbf{x}\) (784 pixel \(\times\) 1 immagine) con una matrice \(\mathbf{X}\) (784 pixel \(\times\) 64 immagini), un’immagine per colonna.

Le equazioni restano le stesse, \(\mathbf{Z} = \mathbf{W} \mathbf{X} + \mathbf{B}\), dove \(\mathbf{B}\) ha in ogni colonna lo stesso \(\mathbf{b}\).

Con 64 immagini insieme ogni peso letto serve per 64 prodotti invece che per uno: stesse letture, 64 volte più calcoli. Nel prodotto di due matrici Eigen sfrutta questo riuso, e usa meglio le istruzioni SIMD.

Nota

Nel nostro framework il batch ha una sola colonna: aggiorniamo i pesi dopo ogni immagine, come fa Rashid nel libro. È lo stochastic gradient descent puro, e su MNIST basta per superare il 90% in tre epoche. Scriveremo comunque tutto in forma matriciale, così il passaggio al mini-batch resta aperto: cosa cambia nell’aggiornamento dei pesi è uno degli spunti per i progetti finali.

Il batching in un esempio

batching.cpp
#include <chrono>
#include <iostream>
#include <Eigen/Dense>

int main() {
    int neuroni = 128;          // come in DenseLayer(128, 784)
    int n = 1000;               // ripetizioni
    Eigen::MatrixXd W = Eigen::MatrixXd::Random(neuroni, 784);
    Eigen::MatrixXd x = Eigen::MatrixXd::Random(784, 1);   // 1 immagine
    Eigen::MatrixXd X = Eigen::MatrixXd::Random(784, 64);  // 64 immagini
    Eigen::MatrixXd z, Z;
    auto t0 = std::chrono::high_resolution_clock::now();
    for (int r = 0; r < 64 * n; r++) { z = W * x; }   // una alla volta
    auto t1 = std::chrono::high_resolution_clock::now();
    for (int r = 0; r < n; r++) { Z = W * X; }        // 64 insieme
    auto t2 = std::chrono::high_resolution_clock::now();
    std::cout << "una alla volta: " << std::chrono::duration_cast<
        std::chrono::milliseconds>(t1 - t0).count() << " ms\n";
    std::cout << "64 insieme: " << std::chrono::duration_cast<
        std::chrono::milliseconds>(t2 - t1).count() << " ms\n";
    return 0;
}

Gli stessi prodotti, \(64\,000\) immagini, nei due modi: righe 13 e 15. Il bias non c’è: non cambia il confronto.

Provate: il batching

  1. Eseguite batching, con -O3. Quale dei due modi è più veloce?
  2. Alle righe 6 e 7 scrivete neuroni = 1000 e n = 100: i pesi passano da 0,8 MB a 6,3 MB. Cosa cambia?

Su un computer Linux x86-64, con g++ 13 ed Eigen 3.4, a -O3 (mediana di 5 esecuzioni):

pesi una alla volta 64 insieme
\(128 \times 784\), 0,8 MB, \(n = 1000\) 1000 ms 1000 ms
\(1000 \times 784\), 6,3 MB, \(n = 100\) 1330 ms 740 ms

Con 1000 neuroni i pesi non stanno nella cache vicina al core (qui 2 MB) e il batch quasi dimezza il tempo; con 128 ci stanno, e qui non si guadagna. Su un Mac M3 si guadagna circa 2 volte anche con 128: il processore calcola così in fretta che conta anche il riuso dei pesi già nella cache. Misurate sul vostro computer.

Argomenti da riga di comando

Per provare learning rate diversi, con lr scritto nel main si deve modificare il codice e ricompilare ogni volta. Conviene passare i valori quando si lancia il programma: ./build/parametri 100 0.01. Come in C, il main li riceve se ha due parametri:

argomenti.cpp
#include <iostream>

int main(int argc, char* argv[]) {
    std::cout << "argc = " << argc << "\n";
    for (int i = 0; i < argc; i++) {
        std::cout << "argv[" << i << "] = " << argv[i] << "\n";
    }
    return 0;
}
  • argc (argument count): il numero di parole della riga di comando, separate da spazi, compreso il nome del programma.
  • argv (argument vector): un array di argc stringhe del C (char*).

./build/argomenti 100 0.01 stampa:

argc = 3
argv[0] = ./build/argomenti
argv[1] = 100
argv[2] = 0.01

argv[0] è il nome del programma: gli argomenti veri sono da argv[1] in poi.

Provate: argc e argv

  1. ./build/argomenti 100 "learning rate". Quanto vale argc?
    argc = 3, e argv[2] = learning rate: le virgolette tengono insieme le due parole in un solo argomento.
  2. ./build/argomenti, senza argomenti. Cosa stampa?
    argc = 1 e argv[0] = ./build/argomenti: c’è solo il nome del programma. argv[1] non è un argomento: lo standard garantisce che argv[argc] sia un puntatore nullo.

Ripasso: da testo a numero

argv[1] è il testo "100", non il numero 100. Si converte come i campi del CSV di MNIST nella Lezione 11: std::stoi in int, std::stod in double.

parametri.cpp
#include <iostream>
#include <string>

int main(int argc, char* argv[]) {
1    if (argc < 3) {
        std::cerr << "Uso: " << argv[0]
                  << " <epoche> <learning_rate>\n";
2        return 1;
    }
    int epoche = std::stoi(argv[1]);
    double lr = std::stod(argv[2]);
    std::cout << "epoche: " << epoche << ", lr: " << lr << "\n";
    std::cout << "doppio delle epoche: " << 2 * epoche << "\n";
    return 0;
}
1
Prima di leggere argv[1] e argv[2] si controlla che ci siano.
2
1, non -1: la shell tiene gli 8 bit bassi del valore restituito, e -1 le arriva come 255.

./build/parametri 100 0.01 stampa:

epoche: 100, lr: 0.01
doppio delle epoche: 200

In C si usano atoi e atof, che per un testo non numerico danno 0 senza segnalarlo.

Provate: argomenti sbagliati

  1. ./build/parametri 100, e poi echo $?. Cosa stampano?
    Il messaggio Uso: ./build/parametri <epoche> <learning_rate>, poi 1: echo $? stampa il valore restituito dall’ultimo programma.
  2. ./build/parametri 100 abc. Cosa succede?
    terminate called after throwing an instance of 'std::invalid_argument', what(): stod, poi Aborted: è l’eccezione della Lezione 11, ma qui nessun catch la riceve.
  3. Togliete il controllo su argc (righe 5-9) e lanciate ./build/parametri. Cosa succede?
    argv[1] è un puntatore nullo: costruirci una stringa ha comportamento indefinito. g++ su Linux: what(): basic_string: construction from null is not valid, poi Aborted; clang su macOS: Segmentation fault.

Ripasso: catturare l’errore di conversione

parametri.cpp
#include <iostream>
#include <stdexcept>
#include <string>

int main(int argc, char* argv[]) {
    if (argc < 3) {
        std::cerr << "Uso: " << argv[0]
                  << " <epoche> <learning_rate>\n";
        return 1;
    }
    try {
        int epoche = std::stoi(argv[1]);
        double lr = std::stod(argv[2]);
        std::cout << "epoche: " << epoche << ", lr: " << lr << "\n";
        std::cout << "doppio delle epoche: " << 2 * epoche << "\n";
    } catch (const std::invalid_argument& e) {
        std::cerr << "Argomento non numerico (" << e.what() << ")\n";
        return 1;
    }
    return 0;
}

Come nella Lezione 11, il catch riceve std::invalid_argument, da <stdexcept>: con 100 abc si legge Argomento non numerico (stod).

Con 99999999999, troppo grande per un int, std::stoi lancia std::out_of_range, che qui nessuno riceve.

Esercizio: tre iperparametri

Scopo: leggere dalla riga di comando argomenti di tipi diversi, controllando che ci siano tutti.

esercizio_iperparametri.cpp (slide seguente) riceve un batch size, un learning rate e il nome di un dataset.

  1. Se argc è minore di 4, stampate su std::cerr Uso:, argv[0] e <batch_size> <learning_rate> <dataset>, poi return 1;.
  2. Convertite argv[1] nell’int batch con std::stoi, argv[2] nel double lr con std::stod. Il nome non si converte: std::string dataset = argv[3];
  3. Stampate Training sul dataset: mnist. Batch: 64, LR: 0.01, con i valori letti.
  4. Mettete i punti 2 e 3 in un try, con il catch di parametri.cpp.

Si lancia con ./build/esercizio_iperparametri 64 0.01 mnist.

Iperparametri: il file da completare

esercizio_iperparametri.cpp
#include <iostream>
#include <stdexcept>
#include <string>

int main(int argc, char* argv[]) {
    // da completare: se gli argomenti sono meno di tre, stampate su std::cerr
    // come si usa il programma e restituite 1

    // da completare: batch (int) da argv[1], lr (double) da argv[2],
    // dataset (std::string) da argv[3]

    // da completare: la stampa del risultato

    return 0;
}

Il file compila così com’è e non stampa niente. Il punto 4 si scrive per ultimo: prima il programma deve funzionare con argomenti corretti.

Soluzione dell’esercizio sugli iperparametri

esercizio_iperparametri.cpp
#include <iostream>
#include <stdexcept>
#include <string>

int main(int argc, char* argv[]) {
    if (argc < 4) {
        std::cerr << "Uso: " << argv[0]
                  << " <batch_size> <learning_rate> <dataset>\n";
        return 1;
    }
    try {
        int batch = std::stoi(argv[1]);
        double lr = std::stod(argv[2]);
        std::string dataset = argv[3];
        std::cout << "Training sul dataset: " << dataset
                  << ". Batch: " << batch << ", LR: " << lr << "\n";
    } catch (const std::invalid_argument& e) {
        std::cerr << "Argomento non numerico (" << e.what() << ")\n";
        return 1;
    }
    return 0;
}

Riga 6: con il nome del programma, argv[0], argc deve valere almeno 4, non 3.

Righe 12-13: dalla riga di comando arriva testo. "64" diventa un numero solo con std::stoi.

Riga 14: il nome resta testo, e si copia in una std::string.

Soluzione: come si lancia

$ ./build/esercizio_iperparametri 64 0.01 mnist
Training sul dataset: mnist. Batch: 64, LR: 0.01

$ ./build/esercizio_iperparametri 64 0.01
Uso: ./build/esercizio_iperparametri <batch_size> <learning_rate> <dataset>

$ ./build/esercizio_iperparametri 64 abc mnist
Argomento non numerico (stod)

$ ./build/esercizio_iperparametri 64 1e-3 "mnist ruotato"
Training sul dataset: mnist ruotato. Batch: 64, LR: 0.001

L’ultima riga: 1e-3 è un double valido per std::stod, e le virgolette fanno di mnist ruotato un solo argomento.