1. Distinguere quattro stati che lo schermo confonde
Una connessione aperta prova solo che puoi ancora dialogare con la macchina. Un terminale visibile può ospitare una shell il cui calcolo è già terminato. Al contrario, perdere la connessione non permette di concludere che il processo si sia fermato. Inizia quindi dando un nome all'esecuzione e al luogo dove ritrovarne le tracce.
Monitora separatamente l'esistenza del processo, il suo avanzamento operativo e l'accettazione del risultato. Il numero di righe in un log non è un contatore di dati riusciti: un programma può ripetere lo stesso avviso. Un output parziale può essere leggibile pur essendo incompleto.
Questo metodo presuppone che tu abbia ricevuto e verificato i mezzi di accesso necessari. Non promette né un protocollo di accesso particolare né una conservazione automatica dei file. Gli strumenti e le destinazioni disponibili devono essere verificati nell'ambiente effettivamente fornito.
Scorri la tabella per leggere tutte le colonne.| Osservazione | Cosa indica | Cosa non dimostra |
|---|---|---|
| Connessione attiva | Il canale risponde. | Il calcolo avanza. |
| Processo presente | Un'esecuzione esiste ancora. | Sta elaborando gli elementi giusti. |
| Contatore validato in aumento | Delle unità previste sono terminate. | L'intero corpus è terminato. |
| Codice di ritorno uguale a zero | Il programma annuncia una terminazione normale. | Il risultato rispetta il tuo contratto. |
| Output controllati e recuperati | I criteri scelti sono stati verificati. | Una qualità al di là di questi criteri. |
2. Preparare un'esecuzione identificabile prima di sganciarla
Controlla i dati, la configurazione effettiva e una prima esecuzione breve dell'applicazione. La diagnostica GPU risponde a un'altra domanda: il backend sa eseguire un calcolo? Non convalida il caricamento completo del corpus né la logica del tuo programma. Esegui queste verifiche prima di avviare una durata importante.
Scegli un identificatore di esecuzione e una cartella nuova. Conserva il comando senza segreti, la versione del codice, l'identità degli input e il risultato atteso. Prevedi dove scrivere i log e dove recuperare i file. Due avvii non devono scrivere simultaneamente nella stessa cartella.
Per un lavoro suddiviso in partizioni indipendenti, decidi quando una partizione diventa terminata: calcolo concluso, file chiuso, contenuto controllato e stato salvato. Un file in fase di scrittura non deve avere lo stesso significato di un risultato accettato. Verifica anche lo spazio realmente utilizzabile prima della partenza.
3. Mantenere un terminale ritrovabile quando il contesto lo permette
Se l'ambiente mette a disposizione una shell Unix e tmux, questo multiplexer permette di staccare un terminale e ritrovarlo dopo una riconnessione. Protegge questo percorso dalla perdita del client di connessione; non è un meccanismo di ripresa dopo il riavvio della macchina o la distruzione del processo.
I comandi seguenti sono didattici e non vengono eseguiti. Presuppongono Bash, tmux e il tuo programma trattamento.py, con le opzioni mostrate; questo file non è una risorsa fornita. Verifica prima il suo comando breve e usa un nome di sessione distinto per non confondere due calcoli.
Crea la sessione, poi avvia il secondo blocco al suo interno. La creazione della cartella fallisce se esiste già, il che evita di riutilizzare silenziosamente i suoi log. Il codice di ritorno viene conservato se la shell raggiunge la fase di scrittura; un arresto brusco può impedire la creazione di questo file. L'assenza di codice non è quindi un successo implicito.
Con le scorciatoie predefinite, stacca con Ctrl-b poi d. Dopo la riconnessione, elenca le sessioni poi riaggancia quella giusta. La shell può restare visibile mentre il programma è finito: consulta il log e il codice salvato. Non avviare immediatamente una seconda copia solo perché il tuo vecchio terminale è sparito.
tmux new -s campagne-amkdir -p runs
mkdir runs/campagne-a && (
code_retour=0
python -u traitement.py --config config.toml --output runs/campagne-a \
> runs/campagne-a/execution.log 2>&1 || code_retour=$?
printf '%s\n' "$code_retour" > runs/campagne-a/exit-code.txt
exit "$code_retour"
)tmux ls
tmux attach -t campagne-a4. Contare il lavoro accettato, non solo l'attività
L'opzione Python -u rimuove il buffering dei suoi output standard ed errore. Aiuta a vedere i messaggi emessi, ma non crea eventi di avanzamento nell'applicazione. Una libreria o una fase silenziosa può comunque richiedere un'osservazione dedicata.
Definisci fasi comprensibili: lettura, preparazione, calcolo, scrittura, verifica. Aggiungi un contatore la cui unità è stabile, oltre a un totale quando è noto. Se conti partizioni accettate, non passare a un contatore di righe lette a metà del log senza cambiargli nome.
L'esempio didattico seguente riguarda otto partizioni da cinquecento elementi, quindi quattromila elementi. Nell'istante illustrato, solo cinque partizioni sono accettate. La sesta è parziale e non deve gonfiare il totale. I numeri mostrano una regola di conteggio; non descrivono alcuna esecuzione Kernodeck.
Scorri la tabella per leggere tutte le colonne.| Partizioni | Stato | Elementi contati come accettati | Decisione |
|---|---|---|---|
| Da 1 a 5 | Verificate | 2 500 | Conservare le loro identità e i risultati. |
| 6 | Scrittura parziale | 0 | Non annunciare questa partizione come terminata. |
| 7 e 8 | Da trattare | 0 | Restare nella lista di lavoro. |
| Insieme | Incompleto | 2.500 su 4.000 | Non accettare la cartella finale. |
5. Esaminare un silenzio o un'interruzione senza creare duplicati
Quando nessun contatore si muove, identifica l'ultima fase nota e la sua ultima unità completata. Verifica se il processo esiste, se è apparso un messaggio di errore e se la destinazione resta utilizzabile. Un avvio lento del modello e un ciclo bloccato possono produrre lo stesso schermo immobile; il contesto decide il controllo successivo.
Prepara l'arresto volontario nella tua applicazione: richiesta di arresto, fine di un'unità sicura, salvataggio dello stato, poi uscita. I segnali e le interruzioni dipendono dal sistema. Python non può intercettare SIGKILL, e un gestore Python può attendere la fine di una lunga chiamata nativa prima di essere eseguito. Un salvataggio all'arresto non sostituisce quindi i salvataggi periodici.
Dopo una perdita di connessione, ritrova prima la sessione e l'esecuzione esistenti. Dopo un arresto confermato, determina ciò che è completo e ciò che è parziale. Per un addestramento, la ripresa richiede gli stati dettagliati del modello e dell'ottimizzazione; la guida dedicata verifica questo caso in un nuovo processo.
6. Riprendere solo ciò che il contratto permette
Nel nostro esempio, la ripresa per partizione presuppone che ogni partizione sia indipendente e che input, codice e configurazione rimangano identici. Può conservare i cinque risultati convalidati e ricalcolare interamente il sesto prima di proseguire con i due successivi. Se queste ipotesi non reggono, questa scorciatoia non è giustificata.
Non limitarti ad aggiungere le nuove righe al file parziale. Rischi di produrre duplicati o di mescolare due configurazioni. Usa gli identificatori previsti per distinguere completo, incompleto e assente. Conserva lo stato precedente come elemento di spiegazione, con una destinazione separata per il nuovo tentativo.
Verifica la tua strategia su un'interruzione controllata prima di dipenderne per un'elaborazione pesante. Il criterio è l'equivalenza degli output utili secondo il tuo contratto, non l'identità dei messaggi di avanzamento. Gli addestramenti, i calcoli con effetti esterni e le elaborazioni distribuite richiedono garanzie diverse rispetto a questo esempio di partizioni indipendenti.
7. Accettare e recuperare il risultato prima di chiudere il lavoro
Inizia dal codice di ritorno, poi confronta gli output con il manifest di input. Per il nostro esempio, attendi le otto partizioni e i quattromila identificatori previsti, senza mancanze né duplicati. Controlla il formato, le dimensioni e i valori pertinenti; leggere un file non dimostra che contenga il risultato corretto.
Recupera gli output accettati, la configurazione autorizzata, le versioni e il rapporto di controllo. Confronta le dimensioni e, se necessario, le impronte tra origine e copia. Un'impronta identica aiuta a verificare il trasferimento dei byte; non prova né la qualità del modello né la provenienza legittima del file.
Infine apri un risultato dalla sua destinazione di conservazione, con lo strumento che lo utilizzerà. Prevedi questa fase prima della fine del tuo accesso al calcolo. Il lavoro è terminato quando il risultato controllato è recuperabile e interpretabile, non quando l'ultima percentuale ha raggiunto cento.