Welcome to the second lesson of our Feature Engineering and Problem Handling course! In our previous lesson, we diagnosed our baseline model by examining correlations between our features and the target variable Listening_Time_minutes. We discovered some interesting patterns in our podcast dataset:

As you can see, Episode_Length_minutes has a very strong correlation (0.917) with our target, which makes intuitive sense — longer episodes generally lead to longer listening times. However, the other features show much weaker correlations, particularly Guest_Popularity_percentage and Host_Popularity_percentage.

Does this mean these weakly correlated features are useless? Not necessarily! Through feature engineering, we can transform these features or combine them in ways that might reveal stronger relationships with our target variable.

In this lesson, we'll explore three fundamental feature engineering techniques:

1. Rounding features to reduce noise
2. Normalizing features to bring them onto a similar scale
3. Creating interaction features by multiplying variables together

These techniques can help us extract more predictive power from our existing features, even those that initially showed weak correlations with our target variable.

Our first technique is feature rounding, which can help reduce noise in continuous variables and create more generalizable patterns. Rounding is particularly useful when the exact precision of a feature might not be necessary and could even introduce noise into our model.

For example, does it really matter if a podcast episode is 42.7 minutes versus 43.1 minutes? Probably not. By rounding these values, we can group similar instances together and potentially reveal clearer patterns.

However, keep in mind that rounding can also introduce information loss by discarding small but potentially meaningful differences between values. It’s important to consider whether the precision you’re removing is actually noise, or if it might contain useful signal for your model.

One detail worth remembering: Python's built-in round() uses bankers' rounding, which means values exactly halfway between two integers are rounded to the nearest even integer. For example, round(2.5) becomes 2, while round(3.5) becomes 4. In practice this usually has only a small effect, but it is helpful to know when you inspect edge cases.

Let's implement rounding for two of our features: Episode_Length_minutes and Host_Popularity_percentage:

In this code, we first use Python's round() function to round each value to the nearest integer. Then, we use the floor division operator (//) to divide by 2, which effectively creates bins of size 2. For example, episodes of length 40–41 minutes would be grouped into bin 20, episodes of length 42–43 minutes would be in bin 21, and so on. Bins of size 2 are chosen here to strike a balance between reducing noise and still preserving enough variation in the data for meaningful analysis.

Our next technique is feature normalization, which is especially useful when features have different scales or units. Normalization rescales features to a common range, typically [0, 1], making it easier for many machine learning algorithms to learn from the data. It also helps prevent features with larger scales from dominating the learning process.

For example, Episode_Length_minutes might range from 10 to 120, while Host_Popularity_percentage ranges from 0 to 100. By normalizing, we ensure that each feature contributes equally to the model.

We'll use min-max normalization, which rescales each value to the [0, 1] range:

Let's see what the output might look like:

Now, both features are on the same scale, which can help the model learn more effectively and make feature importance more interpretable.

Normalization is especially helpful for models that are sensitive to feature scale, such as linear regression, regularized linear models, neural networks, and distance-based methods. Tree-based models such as Random Forests, Gradient Boosting, and LightGBM usually do not require feature scaling, because they split on thresholds rather than distances.

Our third technique is creating interaction features, which can capture relationships between multiple features that might not be apparent when considering each feature individually.

Remember that both Host_Popularity_percentage and Guest_Popularity_percentage had very weak correlations with our target variable. However, it's possible that these features become more predictive when combined with other features, particularly the strongly correlated Episode_Length_minutes.

For example, perhaps popular hosts have a stronger effect on listening time for longer episodes, or maybe guest popularity matters more for certain episode lengths. We can capture these potential interactions by multiplying features together:

In this code, we're creating two new features:

1. Mul_Hpp_Elm: The product of host popularity and rounded episode length
2. Mul_Gpp_Elm: The product of guest popularity and rounded episode length

Let's see what the output might look like:

These interaction features might reveal patterns that weren't visible in the individual features. For instance, a high value for Mul_Hpp_Elm indicates both a popular host and a longer episode, which might have a synergistic effect on listening time that's greater than what we'd predict from looking at each feature separately.

In this lesson, you learned how to enhance your dataset using three core feature engineering techniques: rounding (binning) to reduce noise and group similar values, normalization to bring features onto a common scale, and interaction features to capture combined effects between variables. Use rounding when small differences in a feature are not meaningful or may introduce noise. Apply normalization when your features have different scales or units to ensure fair contribution to the model. Create interaction features when you suspect that the relationship between two or more features may be more predictive than the features individually. These methods can help reveal hidden patterns and improve your model’s predictive power, even when original features show weak correlations with the target. Mastering these foundational techniques prepares you for more advanced feature engineering strategies in the next units of the course.