Marcona Plant — defect classification

The plant logs one row per production batch: twenty columns of process settings and sensor readings. Quality wants the defect type predicted for every batch in data/holdout.csv so the rework cell can be staffed.

Time: 90 minutes. Write everything in solution.py.

Four classes: none (≈62%), scratch (≈18%), void (≈13%), warp (≈7%). Calling everything none is 62% accurate. warp is the one that costs money.

Files

Columns

Known defects, stated as rules

1. Re-measured batches. When a batch is measured twice the logger appends the second pass, so some batch_id values appear twice with slightly different sensor readings. The rows are not identical, so de-duplicating on every column removes nothing.
2. Mixed temperature units. Roughly a third of the rows are Fahrenheit; temp_unit says which. Celsius = (F − 32) × 5/9.
3. Dead weight in the table. Some columns never vary, and one column is another column rescaled — an exact linear function of it, correlation 1.0.

Tasks

T1 — useless_columns(df) -> list[str] (15 pts)

Return the columns that carry no information: every column that never varies, plus, for each pair of numeric columns whose absolute correlation is essentially 1, the one that appears later in the column order. Do not include the id or the target.

T2 — deduplicate(df) -> pd.DataFrame (10 pts)

Return a frame with exactly one row per batch_id.

T3 — normalise_units(df) -> pd.DataFrame (15 pts)

Return the frame with every temperature in Celsius. Convert only the rows temp_unit marks as F. No rows dropped.

T4 — class_counts(df) -> dict (10 pts)

Return {defect_type: number of batches} — one row per batch, so rule 1 has to be dealt with first.

T5 — stratified_split(df, valid_share) -> (train, valid) (10 pts)

Split into train and validation so that valid is valid_share of the rows and the class mix of valid matches the whole frame to within 0.02 per class. Every row goes to exactly one side.

T6 — fit_predict(train, holdout) -> np.ndarray (40 pts)

Both frames arrive raw. Return a class label per holdout row — one of none, scratch, void, warp — in file order. Not probabilities.

Graded on macro F1 (every class weighted equally, so the 7% class counts as much as the 62% one): >= 0.300 beats calling everything none, >= 0.430 is competent, >= 0.510 means the rare class is genuinely being found. Measured across 21 daily seeds, balancing the class weights is worth about 0.03 of that on its own.

Allowed: pandas, numpy, scikit-learn.

Visible cases — Marcona Plant — defect classification

What CodeSignal shows next to Run tests: small inputs with the output they should produce. Run them with make drill-test. They use toy data, never the day's CSVs, so passing them is not a grade — make drill-grade is.

T1 — useless_columns (Which of the 20 columns are worth nothing)

a constant, a rescaled copy, and a flag that never changes

Input:

batch_id  sensor_01  sensor_02  sensor_03  sensor_04 calibration_flag defect_type
      B1        0.5        1.0        6.0        0.1               OK        none
      B2       -1.2        1.0        2.6        0.4               OK        warp
      B3        0.3        1.0        5.6       -0.3               OK        none
      B4        2.0        1.0        9.0        0.9               OK     scratch
      B5       -0.7        1.0        3.6        0.2               OK        void

Expected:

['sensor_02', 'sensor_03', 'calibration_flag']  (any order)
sensor_03 = 2 * sensor_01 + 5 and comes later, so it is the one to drop

T2 — deduplicate (One row per batch)

a re-measured batch differs in the fourth decimal

Input:

batch_id  sensor_01 defect_type
      B1      0.500        warp
      B2     -1.200        none
      B1      0.503        warp
      B3      0.300        none
      B4      2.000     scratch

Expected:

4 rows, batch_id unique (B1 once)

T3 — normalise_units (Put every thermocouple in Celsius)

only the F rows are converted

Input:

batch_id  temperature temp_unit
      B1        212.0         F
      B2         25.0         C
      B3         32.0         F

Expected:

temperature == [100.0, 25.0, 0.0]

a file that is already Celsius is left alone

Input:

batch_id  temperature temp_unit
      B1         25.0         C
      B2         30.5         C

Expected:

temperature == [25.0, 30.5]

T4 — class_counts (How the four defects are distributed)

counts are per batch, not per row

Input:

batch_id  sensor_01 defect_type
      B1      0.500        warp
      B2     -1.200        none
      B1      0.503        warp
      B3      0.300        none
      B4      2.000     scratch

Expected:

{'warp': 1, 'none': 2, 'scratch': 1}  (B1 is one batch)

T5 — stratified_split (A validation split that keeps the rare class)

a quarter of the rows, with the class mix preserved

Input:

100 rows: 60 none, 20 scratch, 12 void, 8 warp
valid_share = 0.25

Expected:

valid has 25 rows: about 15 none, 5 scratch, 3 void, 2 warp

T6 — fit_predict (Classify the defect)

one label per holdout batch, from the four defect types

Input:

410-row toy training frame (every column, F rows, blank pressure, ten batches listed twice); 25-row raw holdout

Expected:

array of 25 strings, each one of none / scratch / void / warp