1. EDA: Análise Exploratória

O código está dividido em dois arquivos:

• code/cardekho.py é o módulo importável: leitura, deduplicação, harmonização, split e o pipeline. As entregas seguintes importam daqui.
• code/eda.py gera as figuras e os números deste relatório.

Tarefa: regressão do preço de venda (price, em rúpias) de carros usados anunciados no site indiano CarDekho, a partir das características do carro.

1. Inspeção inicial

1A. Dicionário de dados

Seleção das fontes

O Kaggle publica quatro arquivos sob o mesmo nome. Eles não são versões complementares de uma mesma tabela: são raspagens diferentes do site, com colunas, tamanhos e populações diferentes. Antes de definir o dataset, os quatro foram comparados com os mesmos critérios.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

PRICE = {"car data": ("Selling_Price", 1e5),  # car data vem em lakhs
         "FROM DEKHO": ("selling_price", 1), "v3": ("selling_price", 1),
         "v4": ("Price", 1)}
YEAR = {"car data": "Year", "FROM DEKHO": "year", "v3": "year", "v4": "Year"}
BANDS = [0, 3e5, 6e5, 1e6, 2e6, np.inf]
BAND_LABELS = ["< 3 lakh", "3–6 lakh", "6–10 lakh", "10–20 lakh", "> 20 lakh"]

raw = {k: load_raw(k) for k in PRICE}
profile, coverage = {}, {}
for k, df in raw.items():
    col, mult = PRICE[k]
    p = df[col] * mult
    profile[k] = {
        "linhas": len(df), "colunas": df.shape[1],
        "duplicatas": int(df.duplicated().sum()),
        "linhas c/ ausente": int(df.isna().any(axis=1).sum()),
        "p10": p.quantile(0.10), "mediana": p.median(),
        "média": p.mean(), "p90": p.quantile(0.90),
        "anos": f"{df[YEAR[k]].min()}–{df[YEAR[k]].max()}",
    }
    coverage[k] = (pd.cut(p, BANDS, labels=BAND_LABELS)
                   .value_counts(normalize=True).reindex(BAND_LABELS) * 100)
profile = pd.DataFrame(profile)
coverage = pd.DataFrame(coverage).T

A Figura 1 é o argumento central da seleção. car data, FROM DEKHO e v3 cobrem a mesma faixa: de 68% a 76% dos anúncios ficam abaixo de 6 lakh. O v4 é outra população: 42,9% dos anúncios acima de 10 lakh, contra 10,1% no v3. Com o v3 sozinho, um modelo veria poucos carros caros e extrapolaria nessa faixa.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

CONCEPTS = {
    "preço": ["Selling_Price", "selling_price", "selling_price", "Price"],
    "ano": ["Year", "year", "year", "Year"],
    "km": ["Kms_Driven", "km_driven", "km_driven", "Kilometer"],
    "combustível": ["Fuel_Type", "fuel", "fuel", "Fuel Type"],
    "câmbio": ["Transmission", "transmission", "transmission", "Transmission"],
    "vendedor": ["Seller_Type", "seller_type", "seller_type", "Seller Type"],
    "dono": ["Owner", "owner", "owner", "Owner"],
    "marca": [None, "name", "name", "Make"],
    "motor (cc)": [None, None, "engine", "Engine"],
    "potência": [None, None, "max_power", "Max Power"],
    "torque": [None, None, "torque", "Max Torque"],
    "assentos": [None, None, "seats", "Seating Capacity"],
    "consumo": [None, None, "mileage", None],
    "preço do novo": ["Present_Price", None, None, None],
    "tração": [None, None, None, "Drivetrain"],
    "dimensões (3)": [None, None, None, "Length"],
    "tanque": [None, None, None, "Fuel Tank Capacity"],
    "cidade": [None, None, None, "Location"],
    "cor": [None, None, None, "Color"],
}
presence = pd.DataFrame(
    {k: [np.nan if cols[i] is None else 100 * raw[k][cols[i]].notna().mean()
         for cols in CONCEPTS.values()] for i, k in enumerate(PRICE)},
    index=list(CONCEPTS))
common_all = presence.dropna().index.tolist()
common_v3v4 = presence[["v3", "v4"]].dropna().index.tolist()

Critérios aplicados, nesta ordem:

1. Mínimo de 1000 linhas (exigência do enunciado). car data tem 301 e sai. Ele traria ainda Present_Price, o preço do carro novo, que é praticamente o alvo com outro nome.
2. A fonte precisa acrescentar algo e não pode conflitar com outra. FROM DEKHO não tem nenhuma coluna que o v3 não tenha e cobre a mesma faixa de preço (Figura 1). Além disso, 321 carros aparecem nele e no v3 com o mesmo nome, ano e km, e só 59 com o mesmo preço: empilhar os dois colocaria o mesmo carro com dois alvos diferentes no dataset. Sai.
3. Uma coluna só fica se existir em todas as fontes escolhidas. Com as quatro fontes, sobrariam 7 colunas, sem motor, potência ou torque, justamente o bloco técnico. Com v3 + v4, sobram 12. As colunas de um arquivo só caem: mileage (só v3) teria 20,2% de ausência estrutural na união, e as 7 exclusivas do v4 (tração, três dimensões, tanque, cidade, cor) teriam 79,8%. Imputar 80% de uma coluna seria inventar dado.

Dataset escolhido: v3 + v4, harmonizados nas 12 colunas comuns.

Harmonização

Cada arquivo é deduplicado antes da harmonização (ver 1B) e depois levado ao esquema comum:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

# Marca: primeira palavra do nome no v3, coluna Make no v4. Três grafias não batem.
BRAND_FIX = {"Land": "Land Rover", "Ashok": "Ashok Leyland", "Maruti Suzuki": "Maruti"}

# Combustível: o v4 tem misturas e elétricos/híbridos que o v3 não tem.
FUEL_V4 = {"CNG + CNG": "CNG", "Petrol + CNG": "CNG", "Petrol + LPG": "LPG",
           "Electric": "Other", "Hybrid": "Other"}

# Dono: as duas escalas viram o mesmo ordinal. "Test Drive Car" e "UnRegistered Car"
# são carros sem dono anterior: 0.
OWNER_V3 = {"Test Drive Car": 0, "First Owner": 1, "Second Owner": 2,
            "Third Owner": 3, "Fourth & Above Owner": 4}
OWNER_V4 = {"UnRegistered Car": 0, "First": 1, "Second": 2, "Third": 3,
            "Fourth": 4, "4 or More": 4}


def first_number(s):
    """Primeiro número de uma string ("1248 CC", "74 bhp", "190Nm@ 2000rpm")."""
    return pd.to_numeric(s.astype("string").str.extract(r"(\d+\.?\d*)")[0],
                         errors="coerce").astype(float)


def torque_nm(s):
    """Torque em Nm. No v3, ~500 linhas vêm em kgm (1 kgm = 9,80665 Nm).

    Algumas strings marcadas como kgm já trazem o número em Nm ("115@ 2,500(kgm@ rpm)"
    num Tata Sumo): nenhum carro passa de ~60 kgm, então só converte abaixo de 100.
    """
    value = first_number(s)
    is_kgm = s.astype("string").str.contains("kgm", case=False, na=False) & (value < 100)
    return value.where(~is_kgm, value * 9.80665)


def harmonize(v3, v4):
    """Leva v3 e v4 ao esquema comum: só as colunas que existem nos dois arquivos."""
    a = pd.DataFrame({
        "price": v3["selling_price"],
        "year": v3["year"],
        "km": v3["km_driven"],
        "fuel": v3["fuel"],
        "transmission": v3["transmission"],
        "owner": v3["owner"].map(OWNER_V3),
        "is_individual": (v3["seller_type"] == "Individual").astype(int),
        "brand": v3["name"].str.split().str[0].replace(BRAND_FIX),
        "engine_cc": first_number(v3["engine"]),
        "power_bhp": first_number(v3["max_power"]),
        "torque_nm": torque_nm(v3["torque"]),
        "seats": v3["seats"],
        "source": "v3",
    })
    b = pd.DataFrame({
        "price": v4["Price"],
        "year": v4["Year"],
        "km": v4["Kilometer"],
        "fuel": v4["Fuel Type"].replace(FUEL_V4),
        "transmission": v4["Transmission"],
        "owner": v4["Owner"].map(OWNER_V4),
        "is_individual": (v4["Seller Type"] == "Individual").astype(int),
        "brand": v4["Make"].replace(BRAND_FIX),
        "engine_cc": first_number(v4["Engine"]),
        "power_bhp": first_number(v4["Max Power"]),
        "torque_nm": torque_nm(v4["Max Torque"]),
        "seats": v4["Seating Capacity"],
        "source": "v4",
    })
    df = pd.concat([a, b], ignore_index=True)
    # Potência 0 bhp é impossível (6 linhas do v3): é ausência disfarçada.
    df.loc[df["power_bhp"] == 0, "power_bhp"] = np.nan
    # Torque/cilindrada acima de 0,4 Nm/cc não existe em motor de rua (o máximo real
    # aqui é 0,33): é o "789Nm" do Maruti Zen D de 58 bhp, erro de digitação na fonte.
    df.loc[df["torque_nm"] / df["engine_cc"] > 0.4, "torque_nm"] = np.nan
    for c in ["fuel", "transmission", "brand", "source"]:
        df[c] = df[c].astype(object)
    return df

Duas regras merecem justificativa. No v4, o número sem unidade em torque e potência está em Nm e bhp: o Swift VDi aparece como "190@2000" e "75@4000", os mesmos valores que o v3 traz com unidade. E 3 linhas do "Maruti Zen D" (58 bhp, 1527 cc) trazem 789 Nm: a razão torque/cilindrada de 0,52 Nm/cc é impossível num motor de rua, quando a maior razão real do dataset é 0,33 (um Volvo XC90 híbrido). O valor vira ausente.

Dicionário final

O que é uma linha: um anúncio de carro usado no CarDekho, com as características do carro e o preço pedido. Um carro pode ser anunciado mais de uma vez (ver 1B).

owner é texto no arquivo bruto ("First Owner", "Second Owner"), mas a ordem tem significado, por isso entra como ordinal e não como one-hot. source não é feature: um carro novo a ser avaliado não tem "arquivo de origem". Ela serve para estratificar o split (1D) e para o teste de mudança de distribuição em 3B.

1B. Qualidade

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

h_raw = harmonize(v3raw, v4raw)  # antes de deduplicar, para medir a ausência estrutural
mileage_missing = 100 * len(v4raw) / (len(v3raw) + len(v4raw))
v4_only_missing = 100 * len(v3raw) / (len(v3raw) + len(v4raw))

missing = pd.DataFrame({
    "ausentes": df.isna().sum(),
    "%": 100 * df.isna().mean(),
    "% no v3": 100 * df[df.source == "v3"].isna().mean(),
    "% no v4": 100 * df[df.source == "v4"].isna().mean(),
}).query("ausentes > 0")
tech = ["engine_cc", "power_bhp", "torque_nm", "seats"]
pattern = df[tech].isna().value_counts()

Valores ausentes

A ausência é um único evento, não quatro: das 287 linhas com algum ausente (3,28%), 267 não têm nenhuma das quatro colunas técnicas. Outras 16 não têm motor, potência e torque, 3 só o torque e 1 potência e torque. Os dois arquivos têm taxas parecidas (Figura 3), então não é efeito de origem.

E a ausência não é aleatória. As 267 linhas sem ficha técnica têm preço mediano de 210.000 ₹, contra 475.000 ₹ no dataset todo, e ano mediano 2009 contra 2015. São carros velhos e baratos, para os quais o site não tinha a ficha. Imputar a mediana sem mais nada diria ao modelo que esses carros têm motor e potência típicos. Por isso o pipeline acrescenta uma coluna 0/1 de ausência (4A).

Duplicatas

Os 213 grupos do v3 têm o mesmo nome, ano, km, dono, consumo, motor, potência, torque e assentos, e só o preço difere: razão máximo/mínimo mediana de 1,107 (11%), máxima de 2,31. É o mesmo carro anunciado de novo com desconto. Mantidas, as cópias poderiam cair uma no treino e outra no teste, o que é vazamento: o modelo seria avaliado num carro que já viu.

A deduplicação roda no arquivo bruto, antes de harmonizar. Depois de descartar name e mileage, 27 linhas ficam iguais a outra, mas são versões diferentes do mesmo modelo (por exemplo "Maruti Alto 800 LXI Anniversary Edition" e "Maruti Alto 800 LXI Airbag", de 2013, com 60.000 km e 190.000 ₹). Deduplicar nesse ponto apagaria carros distintos.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

def deduplicate(raw, price_col):
    """Remove duplicatas no arquivo bruto, antes da harmonização.

    1. Linhas idênticas em todas as colunas: cópia, fica uma.
    2. Linhas idênticas em tudo menos o preço: o mesmo carro reanunciado (diferença
       mediana de ~11%). Viram uma linha com o preço mediano do grupo, senão o mesmo
       carro pode cair no treino e no teste.

    Deduplicar depois de harmonizar seria errado: sem ``name``/``mileage``, versões
    diferentes do mesmo modelo passariam por cópias.
    """
    raw = raw.drop_duplicates()
    keys = [c for c in raw.columns if c != price_col]
    return (raw.groupby(keys, dropna=False, sort=False)[price_col].median()
               .reset_index()[raw.columns])


def load_dataset():
    """Dataset final do projeto: v3 + v4 deduplicados e harmonizados."""
    v3 = deduplicate(load_raw("v3"), "selling_price")
    v4 = deduplicate(load_raw("v4"), "Price")
    return harmonize(v3, v4)

Valores impossíveis e inconsistentes

Colunas descartadas

Nenhuma coluna é constante.

Riscos de vazamento

Nenhuma das 11 features é calculada a partir do preço. Os riscos que existem são de dois tipos: informação do alvo entrando como feature, e informação do teste entrando no pré-processamento ou no próprio treino.

flowchart LR
    raw[Dados brutos v3 + v4] --> dedup[Deduplicação<br/>e harmonização]
    dedup --> split{{split treino/teste}}
    split -->|treino| fit["fit_transform<br/>(estatísticas saem só daqui)"]
    split -->|teste| apply[transform]
    fit --> model[Modelo]
    apply --> model

1C. Alvo

1
2
3
4
5

y = df["price"]
logy = np.log(y)
target_stats = {"média": y.mean(), "mediana": y.median(), "dp": y.std(),
                "mín": y.min(), "máx": y.max(), "assimetria": y.skew(),
                "assimetria log": logy.skew(), "curtose": y.kurt()}

O preço tem assimetria 8,39: a média (7,96 lakh) fica 68% acima da mediana (4,75 lakh), puxada por 94 anúncios acima de 60 lakh, que nem cabem no eixo da esquerda. Em log, a assimetria cai para 0,43. Por isso o alvo será modelado como log(preço). Sem isso, o erro quadrático seria dominado pelas poucas Ferraris e Rolls-Royces, e um erro de 1 lakh pesaria igual num carro de 2 lakh e num de 50.

A Figura 4 (direita) também mostra os dois arquivos como duas populações: o v4 está deslocado para a direita (mediana de 825.000 ₹, contra 400.000 ₹ no v3 deduplicado). O estudo dessa diferença está em 3B.

1D. Divisão treino/teste

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

NUMERIC = ["year", "km", "engine_cc", "power_bhp", "torque_nm", "seats",
           "owner", "is_individual"]
CATEGORICAL = ["fuel", "transmission", "brand"]


def split(df, test_size=0.2):
    """Split 80/20 estratificado por origem x quintil de log(preço).

    Estratificar só por origem deixaria a faixa de preço ao acaso; só por preço, a
    proporção v3/v4 (que difere em preço, câmbio e potência) poderia mudar entre os
    lados. Os quintis servem só para o sorteio e não entram no modelo.
    """
    strata = df["source"] + "_" + pd.qcut(np.log(df[TARGET]), 5, labels=False).astype(str)
    train, test = train_test_split(df, test_size=test_size, random_state=SEED,
                                   stratify=strata)
    X_train, X_test = train[NUMERIC + CATEGORICAL], test[NUMERIC + CATEGORICAL]
    y_train, y_test = np.log(train[TARGET]), np.log(test[TARGET])
    return X_train, X_test, y_train, y_test, train["source"], test["source"]

Divisão 80/20, random_state=42, feita logo depois da deduplicação e antes de qualquer estatística aprendida: mediana de imputação, quantis de corte, média e desvio da padronização, categorias frequentes e PCA saem só do treino (4C prova isso). As figuras de 1–3 usam o dataset inteiro, porque o EDA pode olhar tudo. O que não pode é aprender um parâmetro olhando o teste.

A estratificação combina origem × quintil de log(preço):

• só por preço, a proporção v3/v4 poderia mudar entre os lados. Como os arquivos diferem em preço, câmbio e potência (3B), o teste deixaria de representar o treino;
• só por origem, as faixas de preço ficariam ao acaso.

Os quintis servem apenas para o sorteio e não entram no modelo. Não há split temporal: year é o ano de fabricação, não a data do anúncio, e os dois arquivos não trazem data de coleta.

Uma marca, Peugeot (1 anúncio), caiu só no teste: é o caso de categoria nunca vista que o encoder precisa tratar (4A).

Baseline: prever sempre a mediana do treino (475.000 ₹) dá, no teste, RMSE de 0,914 em log(preço) e erro absoluto médio de 516.232 ₹. As entregas seguintes precisam superar esses números.

2. Análise univariada

2A. Features numéricas

1
2
3
4
5

desc = df[NUMERIC + ["price"]].describe(percentiles=[0.25, 0.5, 0.75]).T
desc["assimetria"] = df[NUMERIC + ["price"]].skew()
iqr = desc["75%"] - desc["25%"]
desc["outliers IQR"] = [((df[c] < q1 - 1.5 * i) | (df[c] > q3 + 1.5 * i)).sum()
                        for c, q1, q3, i in zip(desc.index, desc["25%"], desc["75%"], iqr)]

O que a Figura 5 mostra, feature por feature:

• km tem a maior assimetria (13,43). A cauda é feita de 5 anúncios acima de 500 mil km, o máximo com 2,36 milhões, o que equivale a 59 voltas na Terra. Há também 7 anúncios abaixo de 1000 km, um deles com 0. As duas pontas são suspeitas.
• engine_cc é multimodal: picos em 796, ~1200, ~1500, ~2000 e ~2500 cc. Não é ruído, são as famílias de motor das montadoras. A cilindrada se comporta quase como categórica com ordem. Os 870 "outliers" pelo IQR são, em boa parte, esses motores grandes, perfeitamente reais.
• power_bhp e torque_nm têm cauda longa à direita (assimetria 2,69 e 1,45), formada pelos carros de luxo do v4.
• year tem assimetria negativa (−0,94): poucos carros antigos, cauda para a esquerda.
• seats tem Q1 = Q3 = 5 (78,7% dos carros têm 5 lugares). Com IQR zero, a regra do 1,5·IQR marca como outlier todo carro que não tem 5 lugares (1807), o que é absurdo. Para uma discreta concentrada, a regra do IQR não se aplica.

A Figura 6 justifica o log das quatro numéricas assimétricas no pipeline. A assimetria cai de 1,53 para 0,47 em engine_cc, de 2,69 para 0,61 em power_bhp e de 1,45 para 0,14 em torque_nm. Em km, o log troca a cauda direita por uma esquerda (−1,83), criada pelos 7 anúncios abaixo de 1000 km. Por isso o pipeline corta nos quantis antes do log (4A).

2B. Features categóricas

• brand é a de alta cardinalidade, com 39 marcas e distribuição muito concentrada: as três maiores somam 56,0% das linhas. 16 marcas têm menos de 20 anúncios, somando 77 linhas (0,88%), e 6 delas aparecem uma única vez. Um one-hot ingênuo criaria colunas que quase nunca valem 1, e o modelo não teria como aprender um coeficiente para elas.
• A cardinalidade depende da origem. 6 marcas existem só no v3 (Ambassador, Ashok Leyland, Daewoo, Force, Opel, Peugeot: as antigas e populares) e 7 só no v4 (Ferrari, Lamborghini, MINI, Maserati, Porsche, Rolls-Royce, Ssangyong: as de luxo). É a mesma diferença de população da Figura 1, vista pelas marcas.
• fuel: CNG, LPG e Other somam 1,8%. Other tem só 10 linhas (7 elétricos e 3 híbridos), todas do v4.
• transmission é desbalanceada, com 82,8% manual.
• owner = 0 tem só 25 linhas: 5 "Test Drive Car" do v3 e 20 "UnRegistered Car" do v4 (dos 21 da Tabela 2, um saiu na deduplicação). 17 das 25 são Mercedes-Benz, Audi ou Porsche.

3. Análise bivariada e multivariada

3A. Numérica × numérica

1
2
3

corr_cols = NUM_CONT + ["owner", "price"]
spear = df[corr_cols].corr(method="spearman")
pear = df[corr_cols].corr(method="pearson")

Método: Spearman. As numéricas têm assimetrias de até 13,4 (Tabela 10) e o alvo de 8,4. Pearson mede relação linear e é sensível à cauda; Spearman mede relação monótona sobre os postos e não liga para a escala. A diferença aparece nos números: a correlação entre ano e preço é 0,347 por Pearson e 0,704 por Spearman. O preço sobe com o ano de forma exponencial, não linear, e Pearson subestima a relação pela metade.

Pares redundantes: o bloco técnico.

Motor, potência e torque medem quase a mesma coisa: "o tamanho do motor". A Figura 9 mostra que a relação não é uma nuvem difusa: são faixas paralelas. Na potência × torque, por exemplo, há duas faixas distintas, a de cima com os motores a diesel e a de baixo com os a gasolina: a razão torque/potência mediana é 2,33 Nm/bhp no diesel e 1,37 na gasolina. Os três pares não serão descartados agora: a informação que um tem e os outros não (o tipo de motor) é útil, e uma rede neural lida com colinearidade melhor que uma regressão linear. Mas o PCA vai concentrá-los numa só componente (4B), e uma regressão linear precisaria de regularização.

O ano anda junto com km (−0,594) e com o número de donos (−0,501): carro velho rodou mais e passou por mais mãos. É a segunda dimensão do dataset, "idade/uso", e reaparece em 4B.

Checagem de Simpson: a correlação muda dentro dos grupos? Sim, e numa feature importante.

No agregado, mais km significa carro mais barato. Mas entre carros do mesmo ano, mais km está associado a preço mais alto. O ano é o confundidor: carros velhos rodaram mais e valem menos, e isso produz a correlação negativa geral. Dentro de um mesmo ano, quem roda muito é o diesel (3C: mediana de 77.000 km, contra 47.000 da gasolina), e o diesel é mais caro (3B). A consequência para a modelagem é que km não é um bom preditor isolado: o efeito dele só aparece corretamente com o ano no mesmo modelo.

Outras relações também mudam com o grupo, sem inverter o sinal. A correlação entre potência e preço é 0,633 no v3 e 0,855 no v4. A entre cilindrada e preço é 0,456 nos manuais e 0,639 nos automáticos. A entre dono e preço é −0,396 no v3 e só −0,109 no v4.

3B. Categórica × alvo

Conclusões da Figura 10:

• Câmbio é a categórica que mais separa: o automático tem mediana 3,7× a do manual, e as caixas mal se sobrepõem.
• Combustível: o diesel custa 1,7× a gasolina. LPG é o mais barato e tem só 44 anúncios. Other (elétrico/híbrido) é caro, mas com 10 linhas é estatisticamente frágil, o que justifica agrupá-lo como infrequente (4A).
• Donos: o preço cai de forma monótona de 1 para 4 donos anteriores. Isso justifica manter owner como ordinal numérica em vez de one-hot. O grupo 0 (5,2 milhões ₹) não mostra que "carro sem uso valoriza": 17 das 25 linhas são Mercedes-Benz, Audi ou Porsche (2B). Com 25 linhas, é um grupo pequeno e de composição atípica.
• Vendedor: lojas e empresas pedem mais (mediana 650 mil contra 450 mil), mas a sobreposição é grande. É o efeito mais fraco dos quatro.

Conclusão da Figura 11: a marca separa o preço em uma ordem de grandeza. A mediana vai de 225.000 ₹ (Chevrolet) a 4.637.500 ₹ (Land Rover), 20,6×. As marcas formam patamares: as populares (Chevrolet 2,2, Fiat 2,8, Tata 2,9, Datsun 3,0, Maruti 3,8 lakh) abaixo de 5 lakh, um degrau intermediário (Kia, Jeep, MG, de 15 a 18 lakh) e as de luxo (Audi, Volvo, Mercedes-Benz, BMW, Jaguar, Land Rover) acima de 20 lakh. brand é, provavelmente, a feature categórica mais informativa. A alta cardinalidade não pode ser resolvida descartando a marca.

A origem continua importando quando se comparam carros parecidos?

1
2
3
4
5
6
7
8

d["year_bin"] = pd.cut(d.year, [1980, 2010, 2013, 2016, 2018, 2023])
cells = (d.groupby(["brand", "year_bin", "transmission", "source"], observed=True)["logp"]
          .agg(["median", "size"]).unstack("source"))
cells = cells[(cells[("size", "v3")] >= 3) & (cells[("size", "v4")] >= 3)]
diff = cells[("median", "v4")] - cells[("median", "v3")]
w = cells[("size", "v3")] + cells[("size", "v4")]
raw_gap = d[d.source == "v4"].logp.median() - d[d.source == "v3"].logp.median()
matched_gap = np.average(diff, weights=w)

Conclusão da Figura 12: a maior parte da diferença entre os arquivos é composição, e não preço. No câmbio manual, as duas curvas praticamente se sobrepõem ano a ano. A diferença fica no automático, onde o v4 tem mais carros de luxo (3C: potência mediana de 174 bhp, contra 126 no v3). Comparando dentro de mesma marca, faixa de ano e câmbio, o v4 é só 11% mais caro, e é mais caro em 65% das células. Esse resíduo é compatível com uma coleta mais recente, com preços maiores no período. Para a modelagem, isso significa que as features explicam a diferença entre as fontes. Empilhar os arquivos não cria dois mercados incompatíveis, e source pode ficar fora do modelo.

3C. Numérica × categórica

Leitura por posição e dispersão:

• Potência × câmbio (esquerda): o automático tem o dobro da potência mediana e 2,6× a dispersão. O manual é um grupo homogêneo de carros populares. O automático mistura carros médios e superesportivos. A separação por origem dentro do automático (126 bhp no v3, 174 no v4) é o mecanismo do efeito da Figura 12.
• km × combustível (centro): o diesel roda mais (mediana 77.000 km) e com a maior dispersão. É o elo que explica o paradoxo de Simpson de 3A: o carro que roda muito é o diesel, que vale mais. Os elétricos e híbridos (Other) têm a menor quilometragem, porque são os mais novos.
• Ano × dono (direita): cada dono a mais corresponde, em mediana, a 2 a 4 anos a menos (2016 → 2012 → 2010 → 2009), com dispersão estável de 4 a 5 anos. owner e year medem em parte a mesma coisa (ρ = −0,501, 3A), mas a dispersão mostra que não são substitutos: há carros de 2015 com 3 donos e de 2010 com 1.

4. Pré-processamento

4A. Estratégias

Cada escolha aponta para o achado que a motiva:

Por que cortar e não remover outliers: as caudas misturam valores impossíveis (2,36 milhões de km) com valores reais e raros (a Ferrari de 660 bhp e 35 milhões ₹). Remover a linha descartaria o preço de um carro real. O corte mantém a linha e limita a influência do valor extremo. Os limites aprendidos no treino foram:

• km de 2.389 a 260.000;
• engine_cc de 796 a 2996;
• power_bhp de 35,5 a 279,9;
• torque_nm de 59 a 600.

As linhas afetadas por coluna foram 71 em km, 58 em engine_cc, 72 em power_bhp e 56 em torque_nm.

4B. Redução de dimensionalidade

As três projeções usam as features já transformadas do treino (Z_train, 37 colunas), coloridas por log10(preço). O alvo não entra na projeção, serve só para colorir.

PCA:

1
2
3

pca = PCA(random_state=SEED).fit(Z_train)
cum = np.cumsum(pca.explained_variance_ratio_)
A_train = pca.transform(Z_train)[:, :2]

PC1 + PC2 retêm 54,55% da variância. São precisas 5 componentes para 80% e 8 para 90%. Três componentes têm variância zero: são as três dependências lineares do one-hot (em fuel, transmission e brand, as colunas de cada bloco somam 1). Ou seja, 37 colunas, 34 direções reais.

Loadings:

• PC1: torque_nm 0,528, engine_cc 0,518, power_bhp 0,490, seats 0,285, diesel 0,174, gasolina −0,164. A PC1 é o "tamanho do carro": os três redundantes de 3A entram juntos e com pesos quase iguais, como previsto.
• PC2: km 0,567, year −0,552, owner 0,489. A PC2 é a "idade/uso", o segundo bloco de 3A.

As duas componentes estão ligadas ao preço: a correlação com log(preço) é 0,741 na PC1 e −0,510 na PC2. Na Figura 14, o preço cresce da esquerda para a direita (carros maiores) e de cima para baixo (carros mais novos). O dataset tem duas dimensões principais, e as duas importam para a tarefa.

t-SNE e UMAP rodam numa amostra de 3000 linhas do treino (sorteada com o RNG de semente 42), com dois valores do parâmetro de vizinhança cada:

1
2
3
4
5
6
7
8

for perp in [15, 50]:
    t0 = time.time()
    E = TSNE(2, perplexity=perp, init="pca", random_state=SEED).fit_transform(Zs)
    evaluate(f"t-SNE perp={perp}", E, time.time() - t0)
for nn in [15, 50]:
    t0 = time.time()
    E = umap.UMAP(n_neighbors=nn, min_dist=0.1, random_state=SEED).fit_transform(Zs)
    evaluate(f"UMAP nn={nn}", E, time.time() - t0)

Para comparar os mapas com o mesmo critério, usamos duas medidas:

• trustworthiness com k = 5 (vizinhança local) e k = 30 (mais ampla): os vizinhos no mapa eram vizinhos nos dados?
• coerência de preço: o desvio do log(preço) entre os 10 vizinhos de cada ponto no mapa, dividido pelo desvio global. Vale 1 se a vizinhança é tão variada quanto o dataset inteiro e 0 se os vizinhos têm todos o mesmo preço. Só usa vizinhos mais próximos, nenhum modelo é ajustado.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

N_SAMPLE = 3000
idx = RNG.choice(len(Z_train), size=N_SAMPLE, replace=False)
Zs, ys = Z_train[idx], y_train.to_numpy()[idx] / np.log(10)  # log10, como nas figuras


def price_coherence(E, y, k=10):
    """Desvio do log(preço) entre os k vizinhos no mapa / desvio global.

    Mede se o mapa põe carros de preço parecido perto uns dos outros: 1 = vizinhança
    tão variada quanto o dataset inteiro (nenhuma organização por preço), 0 = vizinhos
    com o mesmo preço. Só vizinhos mais próximos, nenhum modelo é ajustado.
    """
    nn = NearestNeighbors(n_neighbors=k + 1).fit(E)
    _, ind = nn.kneighbors(E)
    return float(np.mean(y[ind[:, 1:]].std(axis=1)) / y.std())

O controle. Antes de interpretar os grupos dos mapas não lineares, rodamos o t-SNE sobre as mesmas colunas embaralhadas uma a uma: as distribuições ficam idênticas, mas as relações entre colunas são destruídas.

1
2
3
4

Z_shuf = np.column_stack([RNG.permutation(col) for col in Zs.T])
E_shuf = TSNE(2, perplexity=50, init="pca", random_state=SEED).fit_transform(Z_shuf)
coh_shuf = price_coherence(E_shuf, ys)
coh_raw = price_coherence(Zs, ys)

O t-SNE também desenha grupos limpos nesse ruído, mas a coerência de preço vai a 0,916, contra 0,31 nos dados reais. A organização por preço que aparece nas Figuras 15 e 16 é dos dados, não do algoritmo.

O que as projeções não lineares mostram e o PCA não mostra:

• Grupos discretos. O PCA mostra uma nuvem contínua (Figura 14). t-SNE e UMAP a quebram em ilhas separadas, que são as combinações de câmbio e combustível. No UMAP com n_neighbors 50, 95,9% dos 10 vizinhos de cada ponto têm o mesmo combustível (o acaso daria 48,6%), 89,5% têm o mesmo câmbio e combustível (acaso: 35,1%) e 69,4% a mesma marca (acaso: 14,1%). Como o one-hot cria coordenadas 0/1, carros do mesmo grupo ficam a uma distância fixa dos demais, e os métodos de vizinhança os isolam. Dentro de cada ilha, o preço varia gradualmente (gradiente de cor). O PCA, sendo linear, mostra essas ilhas sobrepostas em dois eixos.
• Os carros mais caros ficam juntos. Nas Figuras 15 e 16, os pontos escuros ocupam ilhas pequenas e compactas. 84,0% dos 10% mais caros da amostra são automáticos, contra 16,4% na amostra toda. A ilha cara é a do câmbio automático, coerente com a Figura 10.
• Preservação local. A trustworthiness local é 0,991–0,997 nos não lineares, contra 0,887 no PCA. Na escala mais ampla (k = 30), a vantagem diminui. Isso é coerente com o que cada método otimiza: o PCA preserva a variância global, t-SNE e UMAP preservam vizinhança.
• A coerência de preço é parecida em todos (0,31–0,35) e próxima à do espaço original (0,304). Os métodos não lineares não "descobrem" uma relação com o preço que as 37 dimensões não tenham. Só a mostram melhor em 2D.
• O parâmetro muda a aparência, não a conclusão. Perplexidade 15 fragmenta mais e 50 agrupa mais. As medidas mudam na terceira casa decimal. O que é estável nos quatro mapas é o que se pode interpretar: ilhas por marca, câmbio e combustível, com o preço como gradiente dentro delas.
• Uso prático. Só o PCA e o UMAP têm .transform() para projetar dados novos. O t-SNE otimiza posições, não aprende uma função, e serve só para exploração.

4C. Pipeline

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

class QuantileClipper(BaseEstimator, TransformerMixin):
    """Limita cada coluna aos quantis [q, 1-q] aprendidos no treino."""

    def __init__(self, q=0.005):
        self.q = q

    def fit(self, X, y=None):
        X = np.asarray(X, dtype=float)
        self.low_ = np.nanquantile(X, self.q, axis=0)
        self.high_ = np.nanquantile(X, 1 - self.q, axis=0)
        return self

    def transform(self, X):
        return np.clip(np.asarray(X, dtype=float), self.low_, self.high_)

    def get_feature_names_out(self, input_features=None):
        return np.asarray(input_features, dtype=object)


# Assimetria forte (km, potência, torque, cilindrada): log antes de padronizar.
LOG_FEATURES = ["km", "engine_cc", "power_bhp", "torque_nm"]
LINEAR_FEATURES = [c for c in NUMERIC if c not in LOG_FEATURES]


def build_preprocess(min_brand_frequency=20):
    """ColumnTransformer do projeto. Toda estatística é aprendida no ``fit`` (treino)."""
    log_pipe = Pipeline([
        ("impute", SimpleImputer(strategy="median")),
        ("clip", QuantileClipper(q=0.005)),
        ("log", FunctionTransformer(np.log1p, feature_names_out="one-to-one")),
        ("scale", StandardScaler()),
    ])
    linear_pipe = Pipeline([
        ("impute", SimpleImputer(strategy="median")),
        ("scale", StandardScaler()),
    ])
    cat_pipe = Pipeline([
        ("impute", SimpleImputer(strategy="most_frequent")),
        ("onehot", OneHotEncoder(handle_unknown="infrequent_if_exist",
                                 min_frequency=min_brand_frequency,
                                 sparse_output=False)),
    ])
    return ColumnTransformer([
        # A ausência das colunas técnicas não é aleatória (carros mais velhos e mais
        # baratos): a imputação apagaria isso, então uma coluna 0/1 guarda o fato.
        ("missing", MissingIndicator(features="all"), ["engine_cc"]),
        ("log", log_pipe, LOG_FEATURES),
        ("num", linear_pipe, LINEAR_FEATURES),
        ("cat", cat_pipe, CATEGORICAL),
    ])

O pipeline é importável de code/, e é assim que o script e as entregas seguintes o usam:

1
2
3
4

preprocess = build_preprocess()
Z_train = preprocess.fit_transform(X_train)   # aprende E transforma (só treino)
Z_test = preprocess.transform(X_test)         # SÓ transforma
names = preprocess.get_feature_names_out()

Features finais (37): são produzidas na ordem abaixo.

• missingindicator_engine_cc;
• km, engine_cc, power_bhp e torque_nm (log), mais year, seats, owner e is_individual (padronizadas);
• 5 colunas de fuel: CNG, Diesel, LPG, Petrol e infrequent (Other);
• 2 colunas de transmission;
• 21 colunas de brand: 20 marcas com ≥ 20 anúncios no treino (Audi, BMW, Chevrolet, Datsun, Fiat, Ford, Honda, Hyundai, Jeep, Land Rover, Mahindra, Maruti, Mercedes-Benz, Nissan, Renault, Skoda, Tata, Toyota, Volkswagen, Volvo) e infrequent, que agrupa as 18 restantes e as marcas nunca vistas.

Prova de que o teste não vazou para o pré-processamento:

• A média das contínuas é zero no treino (máximo |média| = 2,2 × 10⁻¹⁵) e não no teste: [0,003, 0,004, 0,001, 0,008, −0,025, −0,012]. Se o teste também desse exatamente zero, a padronização teria visto o teste.
• As medianas de imputação são as do treino: engine_cc 1364 e torque_nm 175, contra 1353 e 178 no dataset inteiro. A diferença é pequena, e é por ser pequena que o erro de ajustar na base toda passaria despercebido.

5. Síntese

Principais achados:

1. Os dois arquivos são duas populações (Figura 1, Tabela 1): o v4 tem 43% dos anúncios acima de 10 lakh, contra 10% no v3. Combiná-los amplia a faixa de preço coberta. A diferença entre eles é quase toda de composição (2,06× bruto, 1,11× pareado; Figura 12), então as features a explicam.
2. O alvo é muito assimétrico (8,39 → 0,43 em log; Figura 4) e será modelado em log.
3. Motor, potência e torque são redundantes (ρ de 0,77 a 0,86; Figuras 8 e 9) e formam a PC1. Ano, km e donos formam a PC2 (Figura 14). As duas componentes se correlacionam com o preço.
4. km tem um paradoxo de Simpson (Tabela 13): ρ = −0,33 no geral e +0,16 dentro do mesmo ano, mediado pelo diesel (Figura 13).
5. Marca e câmbio são as categóricas mais fortes (20,6× e 3,7× entre medianas; Figuras 10 e 11).
6. A ausência carrega informação (1B): os carros sem ficha técnica são mais velhos e baratos.

Riscos para a modelagem e plano:

Results summary

Conclusão

O dataset permite a regressão pretendida. O sinal está nas features e não depende de vazamento: - ano e potência têm ρ de 0,70 e 0,72 com o preço; - a marca separa o preço em 20,6× entre medianas; - o câmbio, em 3,7×.

O que ele impede ou limita:

• Extrapolar para o topo e para os anos recentes. Carros acima de 20 lakh e de 2021–2022 existem quase só no v4, em poucas centenas de linhas. O erro nessa faixa deve ser medido à parte, não só o global.
• Separar versões do mesmo modelo. Sem name/Model (identificadores com milhares de valores), um "Alto LXI" e um "Alto LXI Airbag" são o mesmo carro para o modelo. Parte da variação de preço não tem como ser explicada.
• Usar o tempo. Os arquivos não trazem a data do anúncio. Não há como fazer um split temporal nem corrigir a inflação entre as duas coletas. O resíduo de 1,11× entre v4 e v3 (3B) pode ser exatamente isso.
• Saber o estado do carro. Não há coluna sobre conservação, sinistros ou cidade (esta só existia no v4). Dois carros iguais nas 11 features podem ter preços legitimamente diferentes.

Nenhum desses achados inviabiliza a tarefa. A equipe segue com regressão de log(preço) sobre v3 + v4, usando o pipeline de 4C. Para ser útil, a próxima entrega precisa superar o baseline de RMSE 0,914 em log(preço) (1D).

Referências

• Birla, N. Vehicle dataset (CarDekho). Kaggle. https://www.kaggle.com/datasets/nehalbirla/vehicle-dataset-from-cardekho
• scikit-learn: ColumnTransformer, OneHotEncoder (min_frequency, handle_unknown="infrequent_if_exist"), MissingIndicator, trustworthiness.
• McInnes, L., Healy, J., Melville, J. UMAP: Uniform Manifold Approximation and Projection for Dimension Reduction, 2018.
• van der Maaten, L., Hinton, G. Visualizing Data using t-SNE. JMLR, 2008.