0Pricing
Pandas & NumPy Academy · Lezione

Uniformare le categorie incoerenti

Normalizzi le colonne categoriche a testo libero mappando gli alias, correggendo gli errori con il fuzzy matching e applicando un elenco canonico.

Uniformare le categorie incoerenti è una lezione Pandas & NumPy Academy gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Pandas & NumPy Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Pandas & NumPy Academy include 4 lezioni in totale.

Il problema delle categorie incoerenti

Quando i dati categoriali vengono inseriti manualmente, lo stesso concetto può comparire con molte grafie diverse: Electronics, electronics, ELECTRONICS, Electronicss. Un groupby su questa colonna produce decine di piccoli gruppi invece di un unico gruppo significativo. Standardizzare le categorie in un elenco canonico è uno dei passaggi di pulizia più importanti prima di qualsiasi aggregazione o della creazione di feature per il machine learning.

import pandas as pd

df = pd.read_csv('products.csv')
print(df['category'].value_counts().head(20))

Normalizzazione di maiuscole e spazi bianchi

Il primo e più semplice passaggio di standardizzazione consiste nel normalizzare maiuscole e minuscole e gli spazi bianchi. Applichi .str.strip().str.lower() per rimuovere gli spazi iniziali e finali e convertire tutto in minuscolo prima di qualsiasi altro confronto. Questo singolo passaggio riunisce molte varianti: Electronics, electronics e ' Electronics ' diventano tutte electronics dopo la normalizzazione.

df['category_clean'] = df['category'].str.strip().str.lower()

print('Before:', df['category'].nunique())
print('After:', df['category_clean'].nunique())

Mappatura degli alias con un Dict

Dopo la normalizzazione delle maiuscole e minuscole, molte varianti restano distinte a causa di abbreviazioni, sinonimi o nomi obsoleti. Crei un dizionario di mappatura degli alias in cui le chiavi sono le grafie alternative e i valori sono la forma canonica. Lo applichi con df['category_clean'].map(alias_map).fillna(df['category_clean']): fillna conserva i valori non presenti nel dizionario invece di sostituirli con NaN.

alias_map = {
    'elect': 'electronics',
    'elec': 'electronics',
    'tech': 'electronics',
    'clothing': 'apparel',
    'clothes': 'apparel',
    'garments': 'apparel'
}

df['category_clean'] = df['category_clean'].map(alias_map).fillna(df['category_clean'])
print(df['category_clean'].value_counts().head())

Utilizzo di str.replace per correggere i modelli

Alcuni nomi di categoria presentano errori di formattazione ricorrenti, come doppi spazi o numeri finali. Utilizzi .str.replace() con un'espressione regolare per correggere questi modelli in tutte le righe contemporaneamente. Ad esempio, .str.replace(r'\s+', ' ', regex=True) riduce più spazi a uno solo, mentre .str.replace(r'\d+$', '', regex=True) rimuove le cifre finali dai nomi delle categorie.

df['category_clean'] = (
    df['category_clean']
    .str.replace(r'\s+', ' ', regex=True)  # collapse spaces
    .str.replace(r'\d+$', '', regex=True)   # strip trailing numbers
    .str.strip()
)

print(df['category_clean'].value_counts())

Corrispondenza approssimata con difflib

Quando i refusi sono imprevedibili, utilizzi la corrispondenza approssimata per trovare la categoria canonica più simile per ogni variante. difflib.get_close_matches(), integrato in Python, restituisce le corrispondenze migliori da un elenco di categorie valide in base alla similarità delle stringhe. Lo applichi come funzione di supporto tramite df['category'].apply() per risolvere le varianti che map() non riesce a intercettare.

from difflib import get_close_matches

CANONICAL = ['electronics', 'apparel', 'home', 'sports', 'beauty']

def fuzzy_fix(val):
    matches = get_close_matches(str(val).lower().strip(), CANONICAL, n=1, cutoff=0.7)
    return matches[0] if matches else val

df['category_fuzzy'] = df['category_clean'].apply(fuzzy_fix)
print(df[['category_clean', 'category_fuzzy']].head(10))

Creazione di un elenco canonico di categorie

Definisca esplicitamente le categorie canoniche invece di dedurle dai dati. Un elenco definito nel codice obbliga ogni valore a passare attraverso un controllo di convalida; qualsiasi valore non presente nell'elenco viene contrassegnato come sconosciuto. Mantenga l'elenco canonico in un file di configurazione o in una colonna separata di un DataFrame, così sarà facile aggiornarlo quando l'azienda aggiunge una nuova categoria di prodotto senza modificare il codice di pulizia.

CANONICAL_CATEGORIES = {
    'electronics', 'apparel', 'home', 'sports',
    'beauty', 'food', 'toys', 'automotive'
}

df['is_known_category'] = df['category_fuzzy'].isin(CANONICAL_CATEGORIES)
unknown = df[~df['is_known_category']]['category_fuzzy'].unique()
print('Unknown categories remaining:', unknown)

Gestione delle categorie sconosciute

Le categorie sconosciute che, dopo la correzione approssimata, non corrispondono ad alcun valore canonico devono essere raggruppate sotto l'etichetta Other invece di essere eliminate, così non perderà righe senza accorgersene. Le imposti su 'other' con np.where() o con una semplice assegnazione condizionale. Registri quante righe sono state mappate su 'other' e le esamini per individuare schemi che potrebbero giustificare una nuova categoria canonica.

import numpy as np

df['category_final'] = np.where(
    df['category_fuzzy'].isin(CANONICAL_CATEGORIES),
    df['category_fuzzy'],
    'other'
)

print(df['category_final'].value_counts())

Imposizione di un Dtype categoriale

Dopo la standardizzazione, converta la colonna delle categorie pulita nel tipo Pandas Categorical, specificando un elenco esplicito di categorie valide. In questo modo si applica lo schema: qualsiasi tentativo di assegnare una categoria non valida genera un errore. Inoltre, si riduce l'uso di memoria perché le stringhe delle categorie vengono memorizzate internamente come codici interi e si velocizzano le operazioni groupby su DataFrame di grandi dimensioni.

df['category_final'] = pd.Categorical(
    df['category_final'],
    categories=list(CANONICAL_CATEGORIES) + ['other']
)

print(df['category_final'].dtype)
print(df['category_final'].cat.categories)

Convalida della colonna pulita

Dopo tutti i passaggi di standardizzazione, esegua una convalida finale: verifichi che nella colonna pulita non esistano valori al di fuori dell'insieme canonico. Utilizzi assert df['category_final'].isin(valid_set).all(). Inserisca questa asserzione alla fine della funzione di pulizia, in modo che venga eseguita ogni volta che la pipeline viene eseguita e rilevi eventuali regressioni quando i nuovi dati grezzi contengono etichette di categoria mai viste prima.

valid_set = set(CANONICAL_CATEGORIES) | {'other'}

assert df['category_final'].isin(valid_set).all(), 'Invalid category found'
print('All categories valid. Distribution:')
print(df['category_final'].value_counts())

Monitoraggio delle modifiche di standardizzazione

Crei una tabella delle differenze che mostri il valore originale e la relativa sostituzione pulita per ogni riga modificata. Questa traccia di audit consente ai responsabili dei dati di esaminare e approvare o rifiutare mappature specifiche. Utilizzi una maschera booleana per selezionare le righe modificate e confronti affiancate le colonne originale e finale. Esporti le differenze in formato CSV affinché gli stakeholder non tecnici possano esaminarle.

changed = df['category'] != df['category_final']
diff_table = df[changed][['category', 'category_final']].drop_duplicates()
diff_table.columns = ['original', 'mapped_to']
print(f'Unique mappings applied: {len(diff_table)}')
print(diff_table)

Salvataggio del dataset standardizzato

Sostituisca la colonna originale delle categorie, contenente dati non uniformi, con quella standardizzata ed elimini le colonne intermedie di lavoro prima del salvataggio. Memorizzi il dizionario di mappatura degli alias e la soglia di correzione fuzzy nella configurazione della pipeline, così da rendere la standardizzazione completamente riproducibile. Un'esecuzione della pulizia due mesi dopo, su un nuovo dump di dati, dovrebbe produrre risultati identici per gli stessi valori di input.

df_out = df.drop(columns=['category_clean', 'category_fuzzy', 'is_known_category'])
df_out = df_out.rename(columns={'category_final': 'category'})

df_out.to_parquet('products_clean.parquet', index=False)
print('Saved. Category distribution:')
print(df_out['category'].value_counts())

Controllo rapido

Verifichi la Sua comprensione dei concetti di analisi dei dati trattati in questa lezione.

Riepilogo della lezione

In questa lezione ha imparato a: normalizzare maiuscole, minuscole e spazi bianchi come primo passaggio di standardizzazione, mappare gli alias e applicare il fuzzy matching per correggere gli errori di battitura e imporre un elenco canonico di categorie con il tipo Categorical e le asserzioni. Nel prossimo argomento esamineremo la convalida dello schema e le asserzioni a runtime per proteggere ogni fase della pipeline.

Domande Frequenti

La lezione «Uniformare le categorie incoerenti» è gratuita?

Sì — il testo completo di «Uniformare le categorie incoerenti» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Pandas & NumPy Academy, passa a CoddyKit PRO. Il corso Pandas & NumPy Academy include 4 lezioni in totale.

Cosa imparerò in «Uniformare le categorie incoerenti»?

Normalizzi le colonne categoriche a testo libero mappando gli alias, correggendo gli errori con il fuzzy matching e applicando un elenco canonico. Eserciti Pandas & NumPy Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Pandas & NumPy Academy?

Non è richiesta alcuna esperienza precedente. Pandas & NumPy Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Uniformare le categorie incoerenti»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Pandas & NumPy Academy?

Sì. Ogni lezione Pandas & NumPy Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Rilevare e rimuovere i duplicati
  2. Rilevare e trattare gli outlier
  3. Uniformare le categorie incoerenti
  4. Validazione dello schema e asserzioni
← Torna a Pandas & NumPy Academy