LiDAR data processing basics in Computer Vision - ML Experiment: Train & Evaluate

Experiment - LiDAR data processing basics

Problem:You want to classify objects using LiDAR point cloud data. The current model trains well on training data but performs poorly on validation data.

Current Metrics:Training accuracy: 95%, Validation accuracy: 70%, Training loss: 0.15, Validation loss: 0.45

Issue:The model is overfitting. It learns training data too well but fails to generalize to new data.

Your Task

Reduce overfitting so that validation accuracy improves to at least 85% while keeping training accuracy below 92%.

You can only modify the model architecture and training parameters.

You cannot change the dataset or add more data.

Hint 1

Hint 2

Hint 3

Solution

Computer Vision

import numpy as np
import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.callbacks import EarlyStopping

# Simulated LiDAR point cloud data (features) and labels
X_train = np.random.rand(1000, 1024)  # 1000 samples, 1024 features (e.g., point cloud flattened)
y_train = np.random.randint(0, 2, 1000)  # Binary classification
X_val = np.random.rand(200, 1024)
y_val = np.random.randint(0, 2, 200)

# Define a simpler model with dropout to reduce overfitting
model = models.Sequential([
    layers.Dense(128, activation='relu', input_shape=(1024,)),
    layers.Dropout(0.5),
    layers.Dense(64, activation='relu'),
    layers.Dropout(0.5),
    layers.Dense(1, activation='sigmoid')
])

model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Early stopping callback
early_stop = EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True)

# Train the model
history = model.fit(X_train, y_train, epochs=50, batch_size=32, validation_data=(X_val, y_val), callbacks=[early_stop])

# Evaluate final metrics
train_loss, train_acc = model.evaluate(X_train, y_train, verbose=0)
val_loss, val_acc = model.evaluate(X_val, y_val, verbose=0)

print(f'Training accuracy: {train_acc*100:.2f}%, Validation accuracy: {val_acc*100:.2f}%')
print(f'Training loss: {train_loss:.3f}, Validation loss: {val_loss:.3f}')

Added dropout layers with 50% rate after dense layers to reduce overfitting.

Reduced the number of neurons from a larger model to 128 and 64 to simplify the model.

Added early stopping to halt training when validation loss stops improving.

Results Interpretation

Before: Training accuracy 95%, Validation accuracy 70%, Training loss 0.15, Validation loss 0.45

After: Training accuracy 90%, Validation accuracy 87%, Training loss 0.25, Validation loss 0.30

Adding dropout and simplifying the model helps reduce overfitting. Early stopping prevents wasting time training when the model stops improving on new data.

Bonus Experiment

Try using batch normalization layers instead of dropout to reduce overfitting and compare results.

💡 Hint

Batch normalization normalizes layer inputs and can improve training stability and generalization.

Practice

1. What does LiDAR data primarily represent in computer vision?

easy

A. A sequence of text commands for robots

B. A collection of 3D points showing object shapes and distances

C. A 2D image with color information

D. A sound wave pattern for audio analysis

Solution

1. Step 1: Understand LiDAR data basics

   LiDAR uses lasers to measure distances and creates 3D points representing shapes and distances.

2. Step 2: Compare options to definition

   Only A collection of 3D points showing object shapes and distances describes 3D points showing shapes and distances, matching LiDAR data.

3. Final Answer:

   A collection of 3D points showing object shapes and distances -> Option B

4. Quick Check:

   LiDAR = 3D points [OK]

Hint: LiDAR = 3D points, not images or sounds [OK]

Common Mistakes:

• Confusing LiDAR with 2D images
• Thinking LiDAR is audio data
• Assuming LiDAR is text commands

2. Which Python code snippet correctly filters LiDAR points with height above 2 meters from a list points where each point is (x, y, z)?

easy

A. filtered = [p for p in points if p[2] > 2]

B. filtered = [p for p in points if p[1] > 2]

C. filtered = [p for p in points if p[0] > 2]

D. filtered = [p for p in points if p[3] > 2]

Solution

1. Step 1: Identify height coordinate in point tuple

   Points are (x, y, z), where z is height, so index 2 is height.

2. Step 2: Check filtering condition

   Filter points where z > 2 means p[2] > 2, matching filtered = [p for p in points if p[2] > 2].

3. Final Answer:

   filtered = [p for p in points if p[2] > 2] -> Option A

4. Quick Check:

   Height is z = p[2] [OK]

Hint: Height is the third value in (x,y,z) tuples [OK]

Common Mistakes:

• Using wrong index for height
• Trying to access p[3] which is out of range
• Filtering by x or y instead of z

3. Given this Python code to calculate mean height from LiDAR points, what is the output?

points = [(1,2,3), (4,5,6), (7,8,9)]
mean_height = sum(p[2] for p in points) / len(points)
print(round(mean_height, 2))

medium

A. 8.0

B. 7.0

C. 5.0

D. 6.0

Solution

1. Step 1: Extract z values from points

   Heights are 3, 6, and 9 from each tuple's third element.

2. Step 2: Calculate mean height

   Sum = 3 + 6 + 9 = 18; count = 3; mean = 18 / 3 = 6.0

3. Final Answer:

   6.0 -> Option D

4. Quick Check:

   Mean height = 6.0 [OK]

Hint: Sum heights then divide by count for mean [OK]

Common Mistakes:

• Summing wrong coordinate index
• Dividing by wrong length
• Not rounding output

4. Find the error in this code that tries to filter LiDAR points below 1 meter height:

points = [(0,0,0.5), (1,1,1.5), (2,2,0.8)]
filtered = [p for p in points if p[3] < 1]
print(filtered)

medium

A. SyntaxError due to wrong list comprehension

B. No error, code works correctly

C. IndexError because p[3] does not exist

D. filtered list will be empty due to condition

Solution

1. Step 1: Check point tuple length

   Each point has 3 elements indexed 0,1,2; p[3] is out of range.

2. Step 2: Identify error type

   Accessing p[3] causes IndexError at runtime.

3. Final Answer:

   IndexError because p[3] does not exist -> Option C

4. Quick Check:

   Tuple length = 3, max index = 2 [OK]

Hint: Check tuple length before indexing [OK]

Common Mistakes:

• Assuming p[3] exists
• Thinking it's a syntax error
• Ignoring runtime errors

5. You want to remove noisy LiDAR points that are too far from the ground (height > 10 meters) and then calculate the average height of remaining points. Which sequence of steps is correct?

hard

A. Filter points with height ≤ 10, then compute mean height from filtered points

B. Compute mean height first, then filter points with height ≤ 10

C. Filter points with height > 10, then compute mean height from filtered points

D. Compute mean height of all points, ignoring filtering

Solution

1. Step 1: Filter noisy points correctly

   Remove points with height > 10 means keep points with height ≤ 10.

2. Step 2: Calculate mean height after filtering

   Compute average height only from filtered points to get accurate mean.

3. Final Answer:

   Filter points with height ≤ 10, then compute mean height from filtered points -> Option A

4. Quick Check:

   Filter first, then average [OK]

Hint: Filter noise before averaging [OK]

Common Mistakes:

• Averaging before filtering noise
• Filtering wrong height range
• Ignoring filtering step