Leggere e scrivere file, il formato CSV
Alcuni di voi hanno proposto di portare la rete fuori dal PC:
ESP32 e Arduino sono microcontrollori: calcolatori completi su un solo chip (processore, memoria, ingressi e uscite), che costano pochi euro e leggono direttamente i sensori.
La domanda è se la rete che costruiamo nei laboratori possa funzionare su un dispositivo del genere.
| PC portatile | ESP32 | Arduino Nano ESP32 | Arduino Uno R4 | |
|---|---|---|---|---|
| RAM | alcuni GB | 520 KB | 512 KB (+ 8 MB) | 32 KB |
| Flash | disco | 4 MB | 16 MB | 256 KB |
| Frequenza | alcuni GHz | 240 MHz | 240 MHz | 48 MHz |
| Sistema operativo | completo | minimo | minimo | nessuno |
| Costo | centinaia di € | 6–13 € | circa 20 € | circa 22 € |
Sotto i 10 € e simulati in Wokwi anche Raspberry Pi Pico (264 KB di RAM, 2 MB di flash) ed ESP32-C3 (400 KB, 4 MB). La rete dei laboratori, 784 → 128 → 10, ha 101 770 parametri: circa 407 KB in float, 102 KB a un byte per peso.
const, restano nella flash e il programma li legge da lì, senza copiarli in RAM. In RAM servono solo gli ingressi e le uscite degli strati.const i pesi verrebbero copiati in RAM all’avvio: i 407 KB della rete non entrano nemmeno nell’ESP32, che per i dati fissati in compilazione riserva al più 160 KB di RAM.Il microcontrollore acquisisce le misure; sul PC il framework addestra la rete; i pesi diventano un file .hpp che si compila nel programma del microcontrollore, un unico programma scritto di norma in C o C++, dove si calcola soltanto l’uscita della rete.
Per classificare misure basta una rete piccola. Una forma d’onda di 64 campioni, segnale o rumore, con una rete 64 → 16 → 2: 1074 parametri, circa 4 KB in float. Entra anche nell’Uno R4.
Perché non mandare i dati a un PC? Decidere sulla scheda conviene per:
È l’idea dei trigger negli esperimenti delle alte energie: reti neurali vicino al rivelatore scelgono in pochi microsecondi quali eventi registrare.
float.float. L’Arduino Uno classico (R3) è troppo piccolo per la rete.Rete 784 → \(h\) → 10: \(795\,h + 10\) parametri (1 KB = 1024 byte, 1 MB = 1024 KB).
float, \(h \le 5275\) a un byte; Nano ESP32 (16 MB): \(h \le 5275\) in float; Uno R4 (256 KB): \(h \le 82\) in float, \(h \le 329\) a un byte. Sono limiti teorici: la flash contiene anche il programma (slide «Dove stanno i pesi»).float?float: troppi per la RAM e per lo spazio predefinito per il programma. A un byte (776 KB) entrano nella flash di ESP32 e Nano ESP32, non nell’Uno R4.std::stringstd::ifstream, il controllo dell’apertura, il percorso del file, std::getlinestd::stringstream e std::stoistd::ofstream e la precisione dei numeriusing namespace std in un headermnist_train.csv (60 000 immagini) e mnist_test.csv (10 000), con una riga per immagine: l’etichetta e i 784 pixel. La classe del framework che li carica, MnistDataset, apre il file con uno stream, lo legge riga per riga con std::getline, spezza ogni riga sulle virgole e converte i campi in numeri con std::stoi: sono gli strumenti di oggi.Sequential salva i pesi della rete in un file di testo con std::ofstream, con 17 cifre significative, e li rilegge con std::ifstream. Con i float del framework finale ne basteranno 9.basic_neural_plusplus, e MnistDataset li aprirà con il solo nome, come "mnist_train.csv": è la regola di oggi.Oggi ogni esempio si scrive e si compila durante la lezione, in un progetto CMake come quello dei laboratori, ma in una cartella a parte.
CMakeLists.txt
cmake_minimum_required(VERSION 3.15)
project(Lezione11)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall")
# AddressSanitizer (Lezione 08)
add_compile_options(-fsanitize=address -g)
add_link_options(-fsanitize=address)
# qui una riga add_executable per esempioLEZIONE_11, fuori da basic_neural_plusplus, e apritela in VS Code.CMakeLists.txt qui a sinistra.mnist_test.csv da mnist_csv.zip (home del corso, «Dataset MNIST»).LEZIONE_11:cmake -B build.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(stringhe stringhe.cpp)
add_executable(apri_file apri_file.cpp)
add_executable(leggi_righe leggi_righe.cpp)
add_executable(spezza_riga spezza_riga.cpp)
add_executable(converti converti.cpp)
add_executable(scrivi_file scrivi_file.cpp)
add_executable(precisione precisione.cpp)
add_executable(csv csv.cpp) # esercizio
add_executable(ambiguita ambiguita.cpp) # ripasso: non compilaPoi, dalla cartella LEZIONE_11, compilate ed eseguite solo quell’esempio:
cmake -B build rilegge il CMakeLists.txt: senza, --target non trova un esempio appena aggiunto. Con --target si compila solo l’esempio indicato: un esercizio non ancora finito non blocca gli altri. I messaggi citati sono quelli di g++ su Linux; con clang (macOS) il testo cambia, il significato no.
std::stringIn C un testo è un array di char terminato da '\0', di dimensione fissata. In C++ si usa la classe std::string, da <string>.
stringhe.cpp
empty(): true se non ci sono caratteri; size(): quanti sono.
+ unisce due stringhe (overloading, Lezione 10).
Output:
mnist_test.csv ha 14 caratteri
1
../mnist_test.csv
Un bool stampato con std::cout compare come 1 (true) o 0 (false).
In stringhe.cpp cambiate la riga 10 in:
Compila?
No: invalid operands of types ‘const char [4]’ and ‘const char [15]’ to binary ‘operator+’. Un testo fra virgolette è un array di char del C, non una std::string: il + della classe (overloading, Lezione 10) richiede che almeno uno dei due operandi sia una std::string.
std::ifstreamapri_file.cpp
std::ifstream (input file stream, da <fstream>) apre il file in lettura; si usa come std::cin.
is_open() vale true solo se il file esiste e si può leggere.
dataset viene distrutto: std::ifstream segue il RAII (Lezione 09).
Senza il controllo di is_open(), le letture da un file che non si è aperto falliscono senza alcun messaggio.
Il metodo close() serve solo per chiudere il file prima che l’oggetto venga distrutto.
Il valore restituito dal main arriva alla shell. Con && il comando successivo parte solo se il precedente ha restituito 0: per questo ./build/nome non parte se la compilazione fallisce.
Un nome come "mnist_test.csv" o "../dati/mnist_test.csv" è un percorso relativo: il programma lo cerca a partire dalla cartella di lavoro, cioè la cartella da cui è stato lanciato, non da quella del sorgente o dell’eseguibile. Con l’eseguibile in progetto/build e il file in progetto/mnist_test.csv:
| Comando | Cartella di lavoro | "mnist_test.csv" |
|---|---|---|
./build/prog da progetto |
progetto |
trovato |
cd build, poi ./prog |
progetto/build |
non trovato |
Un percorso assoluto, come /home/utente/mnist_test.csv, non dipende dalla cartella di lavoro, ma cambia da un computer all’altro.
Importante
La regola del corso. I file di dati stanno nella cartella del progetto (oggi LEZIONE_11) e il programma li apre con il solo nome, come "mnist_test.csv". Il programma si lancia da quella cartella: dal terminale con ./build/nome, oppure con il ▷ di CMake Tools come nelle due slide seguenti. Niente cd build e niente percorsi assoluti.
In VS Code ci sono due pulsanti ▷:
CMakeLists.txt (niente C++17, -Wall, AddressSanitizer, Eigen). Non usatelo;CMakeLists.txt e lancia l’eseguibile che scegliete. Di default parte da build (Laboratorio 01).Create in LEZIONE_11 la cartella .vscode e al suo interno il file settings.json:
.vscode/settings.json
CMakeLists.txt (C++17, Eigen): senza, IntelliSense usa uno standard suo, spesso C++14, e segna in rosso codice che compila.Provate: lanciate apri_file con il ▷ in basso, prima e dopo aver creato settings.json. Cosa stampa? Prima l’errore, perché parte da build; dopo File aperto.
std::getlineleggi_righe.cpp
#include <fstream>
#include <iostream>
#include <string>
int main() {
std::ifstream dataset("mnist_test.csv");
if (!dataset.is_open()) {
std::cerr << "Errore: impossibile "
"aprire mnist_test.csv\n";
return 1;
}
std::string riga;
int n = 0;
1 while (std::getline(dataset, riga)) {
n++;
}
std::cout << "Lette " << n << " righe\n";
return 0;
}riga, senza l’a capo.
std::getline restituisce lo stream, che come condizione vale false quando l’ultima lettura è fallita: alla fine del file il ciclo termina. È lo stato che nella Lezione 04 si controllava con std::cin.fail().
Con mnist_test.csv il programma stampa Lette 10001 righe: l’intestazione e le 10 000 immagini.
Entrate nella cartella build, lanciate apri_file da lì e tornate nella cartella LEZIONE_11:
Cosa stampa?
Errore: impossibile aprire mnist_test.csv: la cartella di lavoro è build, e lì mnist_test.csv non c’è.
In leggi_righe.cpp togliete il controllo di is_open() (righe 7–11), ricompilate e lanciatelo allo stesso modo, da build. Cosa stampa?
Lette 0 righe, senza alcun messaggio: le letture da un file che non si è aperto falliscono in silenzio. Per questo si controlla is_open().
Un file CSV (comma-separated values) è un file di testo con un record per riga e i campi separati da virgole. I file MNIST del corso cominciano così:
label,1x1,1x2,1x3,...,28x28
7,0,0,0,...,0
2,0,0,0,...,0
1x2: riga 1, colonna 2 dell’immagine): va saltata.Per ogni immagine servono due passi: leggere la riga con std::getline, poi spezzarla sulle virgole e convertire ogni campo in un numero.
std::stringstreamspezza_riga.cpp
std::stringstream (da <sstream>) legge da una stringa invece che da un file; si usa come uno std::ifstream.
std::getline è il separatore: la lettura si ferma alla virgola invece che all’a capo.
Output:
[7]
[0]
[128]
[255]
I campi sono ancora testo: "128" è una stringa di tre caratteri, non il numero 128.
std::stoiconverti.cpp
#include <iostream>
#include <sstream>
#include <stdexcept>
#include <string>
int main() {
std::stringstream ss("7,0,128,255");
std::string campo;
std::getline(ss, campo, ','); // l'etichetta
1 int etichetta = std::stoi(campo);
int somma = 0;
while (std::getline(ss, campo, ',')) {
somma += std::stoi(campo);
}
std::cout << etichetta << " " << somma << "\n";
try {
2 std::stoi("abc");
} catch (const std::invalid_argument& e) {
std::cout << "eccezione: " << e.what() << "\n";
}
return 0;
}std::stoi (string to int, da <string>) converte "7" in 7.
std::invalid_argument (Lezione 10).
Output:
7 383
eccezione: stoi
Il messaggio dell’eccezione è solo il nome della funzione. Il framework la cattura e indica la riga sbagliata del file.
Per i double c’è std::stod.
spezza_riga.cpp togliete il terzo argomento di std::getline, ',', alla riga 9. Cosa stampa?[7,0,128,255]: senza separatore std::getline legge fino all’a capo, cioè tutta la stringa.converti.cpp, alla riga 6, scrivete "7,0,128.9,255" al posto di "7,0,128,255". Cosa stampa?7 383, senza eccezioni: std::stoi converte i caratteri iniziali che formano un intero, 128, e ignora il resto. L’eccezione arriva solo se il campo non comincia con un numero.std::ofstreamscrivi_file.cpp
#include <fstream>
#include <iostream>
int main() {
1 std::ofstream os("loss.csv");
if (!os.is_open()) {
std::cerr << "Errore: impossibile "
"scrivere loss.csv\n";
return 1;
}
2 os << "epoca,loss\n";
for (int epoca = 1; epoca <= 3; epoca++) {
os << epoca << "," << 1.0 / epoca << "\n";
}
3 return 0;
}std::ofstream (output file stream) apre il file in scrittura nella cartella di lavoro; un file esistente viene svuotato.
<<, come su std::cout.
os.
Il file loss.csv:
epoca,loss
1,1
2,0.5
3,0.333333
std::ofstream è lo stream dell’Approfondimento sul RAII della Lezione 09.
Uno stream scrive i numeri con 6 cifre significative: è il 0.333333 della slide precedente. Per una curva della loss bastano; per salvare i pesi di una rete no, perché i pesi riletti non sarebbero quelli scritti.
Output:
0.333333
0.33333333333333331
precision(n) fissa il numero di cifre significative per tutte le scritture successive su quello stream. Con 17 cifre un double riletto è identico a quello scritto; per un float ne bastano 9. Il framework, con i double, usa precision(17).scrivi_file dalla cartella build, come nella slide «Provate: la cartella di lavoro». Dove compare loss.csv?build: std::ofstream crea il file nella cartella di lavoro, come std::ifstream lo cerca lì.precisione.cpp, alla riga 4, scrivete float w = 1.0f / 3.0f; (con il suffisso f le costanti sono float, come in C; senza sarebbero double). Cosa stampa?0.333333 e 0.3333333432674408: un float ha circa 7 cifre significative, e le successive vengono dalla sua rappresentazione in binario. Per rileggerlo identico ne bastano 9.Scopo: usare insieme std::ofstream, i due std::getline e std::stoi, come fa il framework con il CSV di MNIST.
Il programma csv.cpp ha due funzioni, chiamate dal main una dopo l’altra:
scrivi_csv, già scritta, crea nella cartella di lavoro finto_mnist.csv (a sinistra);leggi_csv, da completare, lo rilegge e stampa le immagini (a destra).label,p0,p1,p2
3,0,128,255
1,0,0,255
Trovata immagine del numero: 3. Pixel: 0 128 255
Trovata immagine del numero: 1. Pixel: 0 0 255
Il codice è nelle due slide seguenti. Si compila ed esegue con:
scrivi_csv, già scrittaSono le prime righe di csv.cpp, prima di leggi_csv.
scrivi_csv scrive il file e, alla sua fine, lo chiude: quando leggi_csv lo apre, il file è completo.
csv.cpp
void leggi_csv() {
std::ifstream f("finto_mnist.csv");
if (!f.is_open()) {
std::cerr << "Errore: impossibile aprire finto_mnist.csv\n";
return;
}
std::string riga;
std::getline(f, riga); // salta l'intestazione
while (std::getline(f, riga)) {
// da completare:
// 1. uno std::stringstream ss costruito da riga
// 2. l'etichetta, con std::getline(ss, campo, ',')
// 3. la stampa di "Trovata immagine del numero: ",
// dell'etichetta convertita con std::stoi e di ". Pixel:"
// 4. un ciclo sugli altri campi: per ognuno, uno spazio
// e il valore convertito con std::stoi
// 5. un a capo
}
}
int main() {
scrivi_csv();
leggi_csv();
return 0;
}leggi_csv legge il file come il programma della slide “Leggere riga per riga”, con un std::getline in più prima del ciclo, che consuma l’intestazione.
Dentro il ciclo, ogni riga si spezza come nella slide “Da testo a numero”.
csv.cpp
void leggi_csv() {
std::ifstream f("finto_mnist.csv");
if (!f.is_open()) {
std::cerr << "Errore: impossibile aprire finto_mnist.csv\n";
return;
}
std::string riga;
std::getline(f, riga); // salta l'intestazione
while (std::getline(f, riga)) {
std::stringstream ss(riga);
std::string campo;
std::getline(ss, campo, ',');
std::cout << "Trovata immagine del numero: "
<< std::stoi(campo) << ". Pixel:";
while (std::getline(ss, campo, ',')) {
std::cout << " " << std::stoi(campo);
}
std::cout << "\n";
}
}
int main() {
scrivi_csv();
leggi_csv();
return 0;
}Il ciclo esterno legge le righe, quello interno i campi: la stessa std::getline con due separatori, l’a capo e la virgola.
Senza il controllo di is_open(), con un file che manca il programma terminerebbe senza stampare nulla.
using namespace stdDalla Lezione 04: con using namespace std; ogni nome viene cercato anche in std, e un nome comune come count diventa ambiguo. In un header la direttiva entra in ogni file che lo include (Lezione 08), anche in quelli che non l’hanno scritta.
Il compilatore si ferma:
error: reference to 'count' is ambiguous
count può essere la variabile di ambiguita.cpp o std::count, una funzione di <algorithm>. Chi ha scritto ambiguita.cpp non ha usato using namespace std e non trova la causa nel proprio file.
Per questo negli header si scrive sempre std::; nel corso lo si scrive ovunque.
Togliete using namespace std; da statistiche.hpp (riga 3) e ricompilate ambiguita. Cosa succede?
Compila e stampa 1: senza la direttiva, count nel main è solo la variabile di ambiguita.cpp.
Un file come loss.csv serve a disegnare una curva, ma il C++ non ha una libreria grafica standard. In Python si userebbe matplotlib; in fisica delle alte energie, dove il C++ è il linguaggio principale, si usa ROOT, la libreria per l’analisi dei dati sviluppata al CERN dalla metà degli anni ’90.
ROOT è fatta di classi:
TH1F;TGraph;TCanvas, che salva il disegno in un file PDF o PNG.Si usano con costruttori, metodi e distruttori, come le classi delle lezioni precedenti. ROOT non serve per il corso e va installata a parte. Nella slide seguente un istogramma; un TGraph si usa allo stesso modo.
istogramma.cpp
#include "TH1F.h"
#include "TCanvas.h"
int main() {
// nome, titolo, intervalli, minimo, massimo
TH1F h1("h1", "Pesi iniziali", 100, -3.0, 3.0);
1 h1.FillRandom("gaus", 10000);
// nome, titolo, larghezza e altezza in pixel
TCanvas c1("c1", "Pesi", 800, 600);
2 h1.Draw();
3 c1.SaveAs("pesi.pdf");
return 0;
}TCanvas creato per ultimo.
pesi.pdf; vanno bene anche .png e .root.
Resta fuori dal progetto della lezione: si compila con le opzioni date da root-config:
g++ -Wall istogramma.cpp \
$(root-config --cflags --libs) \
-o istogramma
All’esecuzione ROOT conferma con il messaggio Info in <TCanvas::Print>: pdf file pesi.pdf has been created.