Funzioni friend, ottimizzazione (-O3) e libreria Eigen
friend: una funzione, non un metodo, a cui una classe permette di leggere i suoi membri private-O del compilatore, e come misurare il tempo con <chrono>-Imain(int argc, char* argv[]), e la conversione da testo a numero della Lezione 11friend, e un programma che legge gli iperparametri da riga di comandofriend. 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.-O. Il framework si compila con -O3, e durante l’addestramento si misura con <chrono> la durata di ogni epoca.-I o con la sua variante -isystem.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 esempioLEZIONE_14, fuori da basic_neural_plusplus, e apritela in VS Code.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.
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) # esercizioPoi, dalla cartella LEZIONE_14, compilate ed eseguite solo quell’esempio:
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.
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:
5.0 * v1 diventa operator*(5.0, v1): la funzione riceve i due operandi, nell’ordine in cui compaiono.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.
<<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:
os è lo stream su cui scrivere, qui std::cout; si passa per reference, perché uno stream non si copia.os, per poter scrivere std::cout << v << "\n": prima std::cout << v, che restituisce std::cout, poi std::cout << "\n".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ì).
friendstampa.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;
}friend la funzione operator<<, che così può leggere i membri private.Vettore2D:: (riga 12) e senza this.friend da sola.Output: v = (3, 4)
friendIn stampa.cpp, un esperimento alla volta:
'double Vettore2D::x_' is private within this context, e lo stesso per y_: senza friend la funzione non può leggere gli attributi private.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.friend e spostate le righe 8-9 subito dopo la riga 5, nella parte private. Cosa cambia?friend vale nella parte public come nella parte private.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.
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:
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.
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.
friend le funzionistd::ostream& operator<<(std::ostream& os, const Complesso& z) eComplesso operator*(double s, const Complesso& z).operator<< scrive z nella forma (1.5 + i*2); operator* restituisce il Complesso con parti s * re_ e s * im_.main scommentate le due stampe.Output atteso, su tre righe: |z| = 2.5, z = (1.5 + i*2), 2 * z = (3 + i*4).
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_.
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.
mainesercizio_complesso.cpp
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.
-O del compilatoreSenza 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:
Con CMake: -O2 -Wall al posto di -Wall nella riga di CMAKE_CXX_FLAGS.
-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 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).
<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
-Oprodotto così com’è, a -O0, e annotate il tempo.CMakeLists.txt, alla riga 5, scrivete -O1 -Wall al posto di -Wall; ricompilate ed eseguite. Poi con -O2 e con -O3. Cambia il risultato?-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.
A -O3, riscrivete prodotto() con l’ordine i, j, k della formula: cosa succede al tempo?
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.
Msomma.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.
-O3, eseguite somma e annotate il tempo.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.
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:
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.
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:
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;target_include_directories(... PRIVATE ...) con il percorso di libs/eigen aggiunge -I.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.
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?fatal error: Eigen/Dense: No such file or directory: nel comando di compilazione manca -isystem, e il preprocessore non trova l’header./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.
-O0Alla 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.
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?
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.
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.
batching, con -O3. Quale dei due modi è più veloce?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.
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
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.
argc e argv./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../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.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;
}argv[1] e argv[2] si controlla che ci siano.
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.
./build/parametri 100, e poi echo $?. Cosa stampano?Uso: ./build/parametri <epoche> <learning_rate>, poi 1: echo $? stampa il valore restituito dall’ultimo programma../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.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.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.
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.
argc è minore di 4, stampate su std::cerr Uso:, argv[0] e <batch_size> <learning_rate> <dataset>, poi return 1;.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];Training sul dataset: mnist. Batch: 64, LR: 0.01, con i valori letti.try, con il catch di parametri.cpp.Si lancia con ./build/esercizio_iperparametri 64 0.01 mnist.
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.
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.
$ ./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.