Guadagni:
- Capacità di stabilire un flusso di lavoro di analisi ripetibile che carica e pulisce i dati di telemetria, test e produzione con Panda
- Capacità di comprendere e verificare l'output riga per riga ricevendo codice, attributi e assistenza di visualizzazione dall'intelligenza artificiale
- Capacità di verificare i risultati dell'analisi per verificarne la coerenza delle unità, la perdita di dati e la riproducibilità
Nelle unità precedenti abbiamo utilizzato l'intelligenza artificiale come un "consigliere". In questa unità faremo un ulteriore passo avanti e stabiliremo un flusso di lavoro che analizza i dati automobilistici con le nostre mani, utilizzando Python. L'obiettivo non è farti diventare uno sviluppatore di software; Si tratta di creare un ingegnere in grado di comprendere e verificare il codice riga per riga ricevendo assistenza sul codice dall'intelligenza artificiale. Perché il codice prodotto dall'AI può essere difettoso, proprio come il testo prodotto dall'AI; potrebbe confondere il volume, perdere dati, centrare la colonna sbagliata. Eseguire il codice senza capirlo è come pubblicare un rapporto non firmato.
Pitone perché? Perché è lo standard de facto nell'analisi dei dati: puoi elaborare facilmente dati di telemetria, test e produzione con le librerie pandas (dati tabulari), numpy (elaborazione numerica), matplotlib (trama) e scikit-learn (apprendimento automatico).
Sei passaggi per un'analisi riproducibile
Un’analisi solida segue sempre lo stesso quadro:
- Carica: legge i dati dal file.
- Esamina: dimensione, colonne, tipi di dati, valori mancanti.
- Pulito: correzione mancante/valore anomalo, unità, timestamp.
- Funzionalità di estrazione: deriva variabili significative.
- Analisi/modello: statistiche, visualizzazione o modello.
- Verificare e segnalare: fornitura dei risultati, controllo del volume/perdite, registrazione.
Suggerimento: quando chiedi il codice all’intelligenza artificiale, dì “commenta ciò che stai facendo in ogni passaggio e scrivi le tue ipotesi”. Quindi puoi verificare il codice mentre lo leggi.
Esempio passo passo: analisi della telemetria
Il codice seguente carica un record CAN/telemetria ed esegue un controllo di base. (Nota: assicurati di comprendere i codici prima di eseguirli; i nomi delle colonne variano a seconda dei dati.)
importa panda come pd# 1) Carica: CSV semi-punteggiato, prima colonna timestampdf = pd.read_csv("telemetry.csv", parse_dates=["time"])# 2) Checkprint(df.shape) # quante righe, quante colonneprint(df.dtypes) # tipo di ciascuna colonna (numero o testo)print(df.isna().sum()) # numero di valori mancanti per columnprint(df.describe()) # statistiche riassuntive: min, max, media
L'output description() è la prima opportunità di verificare: se il valore massimo della velocità del motore è 45.000 giri/min (tipico motore passeggeri ~7.000 giri/min), c'è un guasto all'unità o al sensore.
I comandi Panda utilizzati più frequentemente nella fase di controllo e cosa fanno:
comando
Cosa fa
Cosa conferma?
df.forma
Numero di righe/colonne
È la dimensione prevista?
df.dtypes
Tipi di colonne
La colonna dei numeri è diventata testo?
df.isna().sum()
Conteggio valori mancanti
Quanto spazio c'è?
df.descrivi()
Min/max/media
È fisicamente ragionevole?
df.duplicated().sum()
riga duplicata
Esiste la doppia registrazione?
# 3) Cancella: segna i valori fisicamente impossibili
Attenzione: non eliminare immediatamente il valore anomalo; Per prima cosa capisci perché è un valore anomalo. Si tratta di un evento reale (riscaldamento improvviso) o di un guasto del sensore? L'eliminazione cieca può nascondere il vero difetto.
# 4) Funzionalità di estrazione: tasso di aumento della temperatura (derivato)df = df.sort_values("time")df["sic_increase_speed"] = df["motor_sic"].diff() / df["time"].diff().dt.total_seconds()# 5) Visualizzazione sempliceimport matplotlib.pyplot as pltplt.plot(df["time"], df["motor_sic"])plt.xlabel("Ora"); plt.ylabel("Temperatura del motore (C)") plt.title("Andamento della temperatura del motore")plt.show()
Prevenire la fuga di dati in Python
L'errore più pericoloso quando si costruisce un modello di previsione è la perdita di dati (unità 5): quando il modello vede informazioni che non possono essere conosciute al momento della previsione. La regola d'oro per evitare ciò nelle serie temporali: allenarsi con il passato, testare con il futuro, senza mescolare casualmente.
da sklearn.model_selection import train_test_split# FALSE: la suddivisione casuale delle serie temporali fa trapelare il futuro# df[df["time"] > soglia] # ultimo 20% futuro
Attenzione: train_test_split mescola i dati per impostazione predefinita (shuffle=True). Nella serie temporale, ciò confonde il futuro con l’istruzione e produce un falso punteggio elevato. Se l'intelligenza artificiale ha fatto questo nel codice che produce, assicurati di risolverlo.
Coerenza dell'unità: killer silenzioso
Gli errori più insidiosi nel settore automobilistico sono gli errori di unità: da km/h a m/s, da Nm a lb-ft, da bar a kPa, da °C a K. Tenere un dizionario di quale sia l'unità di ciascuna colonna nell'analisi e annotare le conversioni salva chiaramente vite umane.
# Documentare esplicitamente le unità = {"speed": "km/h", "motor_sic": "C", "pressione": "bar"}# Conversione esplicita se necessaria (km/h -> m/s)df["speed_ms"] = df["speed"] / 3.6
Mini casi di studio
Caso 1 - Errore rilevato con description(). Un analista esegue il codice dell’IA ed effettua una stima dell’intervallo; Il risultato è assurdamente alto. Quando guardiamo l'output description(), vediamo che la capacità della batteria è inserita in Wh in alcune righe e in kWh in altre (differenza di 1000 volte). Quando l'unità viene portata a un tipo uniforme, il risultato migliora. Conclusione: una semplice statistica riassuntiva ha impedito una previsione errata.
Caso 2 – Trappola della confusione. Il modello di usura dei freni di uno stagista era accurato al 98% sul set di prova. Quando si esamina il codice, si può vedere che train_test_split(shuffle=True) e le serie temporali sono miste, il che significa che i punti futuri si riversano nell'addestramento. Se divisa per il tempo, la precisione scende all'80%, ma ora è realistica. Conclusione: solo perché il codice AI funzionava, non era giusto; L'essere umano ha rilevato la perdita.
Caso 3 - Comprendere l'outlier. In un record di durabilità, il codice AI elimina automaticamente i valori di deformazione anomali. L'ingegnere guarda i punti cancellati; Questi erano esattamente i momenti dell'inizio del crack a cui il test era interessato. La cancellazione viene rimossa e le violazioni vengono prese in esame separatamente. Risultato: in "Pulizia" è possibile eliminare il segnale reale; mettere in discussione ogni passo.
modelli di prompt
Modello 1 - Codice richiesta (con spiegazione):
Ruolo: sei un mentore di analista dati Python. Compito: scrivi codice che carica e controlla un CSV di telemetria. Contesto: colonne: tempo, velocità (km/h), motore_sic (C), rivoluzione (rpm). Vincolo: commenta ogni riga; Spiegare quale controllo è stato effettuato e perché; aggiungere un controllo del valore fisicamente impossibile; eliminando silenziosamente nulla. Output: codice commentato + quale output dovrei guardare e perché.
Modello 2 - Ispezione delle perdite:
Ruolo: sei un revisore di codici di machine learning. Attività: verificare la presenza di fughe di dati nel seguente codice di suddivisione di training/test. Contesto: questa è una serie temporale (telemetria del veicolo). Vincolo: avvisa in caso di mescolamento casuale; Suggerire e giustificare la suddivisione in base al tempo. Risultato: risultati + codice corretto + spiegazione.
Modello 3 - Convalida dell'unità:
Ruolo: sei un revisore della qualità dei dati. Compito: suggerisci controlli per individuare l'incoerenza delle unità in un DataFrame. Contesto: la capacità può essere kWh in alcune righe e Wh in altre. Risultato: controlla il codice + come trovare il modello sospetto.
Modello 4 - Visualizzazione + commento:
Ruolo: sei un esperto di visualizzazione dei dati. Compito: scrivere il codice che traccia l'andamento della temperatura del motore e il tasso di aumento. Vincolo: etichettare gli assi con l'unità; segnalare visivamente l'anomalia; non rivendicare una colpa definitiva nell'interpretazione del grafico. Output: codice + cosa cercare nel grafico.
Prompt debole / Prompt forte
Suggerimento debole:
Costruisci un modello con questi dati.
Non è chiaro quale obiettivo, quale compartimento, quale verifica; L'intelligenza artificiale può produrre codice codificato, con perdite e cieco per unità.
Suggerimento potente:
Ruolo: sei un mentore di Python ML. Compito: scrivere un flusso di lavoro iniziale per prevedere l'usura delle pastiglie dei freni e dimostrare le insidie della convalida. Contesto: telemetria delle serie temporali; target: spessore rimanente del pad. Vincolo: suddivisione delle serie temporali in base al tempo (nessun mescolamento); contrassegnare gli attributi a rischio di fuga di dati; unità di documento; interpretare ogni passaggio; Annotare quali controlli sono necessari prima che il risultato venga messo sul campo. Output: codice commentato + checklist di verifica.
Errori comuni
- Eseguire il codice senza capirlo. Anche il codice AI potrebbe essere difettoso; Leggi riga per riga.
- Miscelazione di serie temporali. shuffle=True fa trapelare il futuro e produce un punteggio falso.
- Elimina ciecamente il valore anomalo. Il segnale effettivo (insorgenza del guasto) può essere cancellato.
- Non documentare l'unità. Errori come km/h vs m/s, Wh vs kWh crescono silenziosamente.
- Saltare il passaggio description()/check. La maggior parte degli errori compaiono nelle prime statistiche riassuntive.
In sintesi
- Python (pandas, numpy, matplotlib, scikit-learn) è lo standard de facto per l'analisi dei dati automobilistici.
- Analisi ripetibile: caricamento, ispezione, pulizia, funzionalità, analisi, convalida e report.
- È fondamentale comprendere e verificare il codice che l’intelligenza artificiale produce riga per riga; Solo perché funziona non significa che sia giusto.
- Mantenere la distinzione passato/futuro nelle serie temporali; Il rimescolamento casuale crea perdita di dati.
- La coerenza unitaria e l'interpretazione dei valori anomali sono punti di verifica silenziosi ma critici.
Compito dell'applicazione
Prendi un piccolo set di dati (telemetria reale o sintetica). (1) Seguendo la struttura in sei passaggi, genera il codice di caricamento e controllo con il modello 1 e conferma di aver compreso ogni riga. (2) Trova almeno un valore sospetto nell'output description() e indaga il motivo. (3) In un'attività di previsione, cronometrare la suddivisione tra addestramento e test e verificare il rischio di perdite con il Modello 2. (4) Documentare l'unità di ciascuna colonna utilizzata in un dizionario.
lista di controllo
- [ ] Ho impostato l'analisi con una struttura in sei fasi.
- [ ] Ho letto e compreso riga per riga il codice prodotto dall'AI.
- [ ] Ho cercato valori sospetti con description()/audit.
- [] Ho diviso le serie temporali in base al tempo (senza mescolare).
- [ ] Ho contrassegnato gli attributi che sono a rischio di perdita di dati.
- [ ] Ho documentato l'unità di ciascuna colonna e ho scritto esplicitamente le conversioni.