Train-test split for time series in ML Python - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why is random train-test splitting not suitable for time series data?

In time series data, why should we avoid randomly splitting data into training and testing sets?

A Because random splitting breaks the time order, causing data leakage from future to past.

B Because random splitting reduces the size of the training set too much.

C Because random splitting always causes the model to overfit.

D Because random splitting makes the test set too small to evaluate.

💡 Hint

Think about how time flows and what it means to predict future values.

Random splitting mixes past and future data, letting the model see future information during training, which is unrealistic and causes data leakage.

❓ Predict Output

intermediate

Output of a time series train-test split code

What is the length of the training and testing sets after this split?

ML Python

import numpy as np
from sklearn.model_selection import train_test_split

data = np.arange(10)
train, test = train_test_split(data, test_size=0.3, random_state=42)
print(len(train), len(test))

A 3 7

B 7 3

C 10 0

D 6 4

💡 Hint

Check how train_test_split divides data by default.

train_test_split splits data randomly; with test_size=0.3 on 10 items, training has 7 and testing has 3 items.

❓ Model Choice

advanced

Best method to split time series data for forecasting

Which method correctly splits time series data to avoid data leakage and respect temporal order?

A Randomly shuffle data then split into train and test sets.

B Split data by selecting every other data point for testing.

C Use k-fold cross-validation with random folds.

D Split data by taking the first 80% as training and last 20% as testing.

💡 Hint

Think about keeping the time order intact.

Using the first 80% as training and last 20% as testing preserves time order and prevents future data leakage.

❓ Hyperparameter

advanced

Choosing test size for time series split

What is a key consideration when choosing the test size for a time series train-test split?

A Test size should be as small as possible to maximize training data.

B Test size should be random to avoid bias.

C Test size should cover a full seasonal cycle if seasonality exists.

D Test size should always be 50% for balance.

💡 Hint

Think about repeating patterns in time series.

Choosing a test size that covers a full seasonal cycle ensures the model is tested on all seasonal patterns.

🔧 Debug

expert

Identify the error in this time series split code

What error will this code raise when splitting time series data?

ML Python

import numpy as np
from sklearn.model_selection import train_test_split

data = np.arange(10)
train, test = train_test_split(data, test_size=0.3, shuffle=False)
print(train)
print(test)

A No error; train contains first 7 elements, test last 3 elements.

B TypeError because test_size must be an integer when shuffle=False.

C ValueError because shuffle=False is not allowed with train_test_split.

D IndexError because data is too small for test_size=0.3.

💡 Hint

Check sklearn docs for shuffle parameter behavior.

train_test_split allows shuffle=False; it splits data sequentially without error.

Practice

1. Why is it important to keep the order of data when doing a train-test split for time series?

easy

A. Because time series data depends on the order of events and future data should not be used to predict past data.

B. Because random shuffling improves model accuracy in time series.

C. Because train and test sets must have the same number of samples.

D. Because test data should always come before train data.

Solution

1. Step 1: Understand time series data nature

   Time series data is sequential and depends on the order of events over time.

2. Step 2: Importance of order in train-test split

   Using future data to predict past data breaks the time flow and causes unrealistic model evaluation.

3. Final Answer:

   Because time series data depends on the order of events and future data should not be used to predict past data. -> Option A

4. Quick Check:

   Keep order to respect time flow = A [OK]

Hint: Always keep time order to avoid future data leakage [OK]

Common Mistakes:

• Randomly shuffling time series data
• Mixing future data into training
• Ignoring time dependency

2. Which of the following Python code snippets correctly splits a time series dataset data into 80% train and 20% test sets while preserving order?

easy

A. train = data[:int(len(data)*0.8)]
test = data[int(len(data)*0.8):]

B. train = data.sample(frac=0.8)
test = data.drop(train.index)

C. train = data[int(len(data)*0.2):]
test = data[:int(len(data)*0.2)]

D. train = data.shuffle().iloc[:80]
test = data.shuffle().iloc[80:]

Solution

1. Step 1: Understand slicing for time series split

   We use slicing to keep the order: first 80% for training, last 20% for testing.

2. Step 2: Check each code snippet

   train = data[:int(len(data)*0.8)] test = data[int(len(data)*0.8):] slices data correctly without shuffling. Options B and D shuffle data, breaking order. train = data[int(len(data)*0.2):] test = data[:int(len(data)*0.2)] reverses train and test.

3. Final Answer:

   train = data[:int(len(data)*0.8)] test = data[int(len(data)*0.8):] -> Option A

4. Quick Check:

   Slicing without shuffle = C [OK]

Hint: Use slicing, not shuffle, to keep time order [OK]

Common Mistakes:

• Using sample() which shuffles data
• Reversing train and test slices
• Shuffling data before splitting

3. Given the following code, what will be the length of test if data has 1000 samples?

split_index = int(len(data) * 0.75)
train = data[:split_index]
test = data[split_index:]

medium

A. 750

B. 250

C. 1000

D. 500

Solution

1. Step 1: Calculate split index

   split_index = int(1000 * 0.75) = 750

2. Step 2: Calculate test length

   test = data[750:] means test has samples from index 750 to 999, total 1000 - 750 = 250 samples.

3. Final Answer:

   250 -> Option B

4. Quick Check:

   Test length = total - train length = 250 [OK]

Hint: Test size = total samples minus train size [OK]

Common Mistakes:

• Confusing train size with test size
• Forgetting zero-based indexing
• Using float instead of int for index

4. You wrote this code to split a time series dataset data:

from sklearn.model_selection import train_test_split
train, test = train_test_split(data, test_size=0.2)

What is the main problem with this approach?

medium

A. test_size=0.2 is too small for time series

B. train and test sets will have overlapping samples

C. train_test_split cannot handle numeric data

D. train_test_split shuffles data by default, breaking time order

Solution

1. Step 1: Understand train_test_split default behavior

   By default, train_test_split shuffles data before splitting.

2. Step 2: Why shuffling is a problem for time series

   Shuffling breaks the time order, causing future data to leak into training, invalidating model evaluation.

3. Final Answer:

   train_test_split shuffles data by default, breaking time order -> Option D

4. Quick Check:

   Default shuffle breaks time order = B [OK]

Hint: train_test_split shuffles unless shuffle=False [OK]

Common Mistakes:

• Ignoring shuffle=True default
• Assuming test_size controls order
• Thinking train_test_split is time-series aware

5. You have daily sales data for 3 years and want to train a model to predict future sales. Which approach correctly splits the data to train on the first 2.5 years and test on the last 0.5 year, ensuring no data leakage?

hard

A. train = data[int(len(data)*0.5):]
test = data[:int(len(data)*0.5)]

B. train = data.sample(frac=0.83)
test = data.drop(train.index)

C. train = data[:int(len(data)*5/6)]
test = data[int(len(data)*5/6):]

D. train = data.shuffle().iloc[:900]
test = data.shuffle().iloc[900:]

Solution

1. Step 1: Calculate split fraction for 2.5 years out of 3 years

   2.5 years / 3 years = 5/6 ≈ 0.8333, so train is first 5/6 of data.

2. Step 2: Use slicing to split data preserving order

   train = data[:int(len(data)*5/6)] test = data[int(len(data)*5/6):] slices data correctly from start to 5/6 for train, and last 1/6 for test, preserving time order and avoiding leakage.

3. Final Answer:

   train = data[:int(len(data)*5/6)] test = data[int(len(data)*5/6):] -> Option C

4. Quick Check:

   Slice first 5/6 for train, last 1/6 for test = A [OK]

Hint: Split by slicing using fraction of total length [OK]

Common Mistakes:

• Using random sampling instead of slicing
• Reversing train and test sets
• Shuffling data before splitting