Lesson 5

Welcome to this lesson where we’ll delve into a critical aspect of text data analysis: **Dimensionality Reduction**. As you have learned in the previous lessons, the raw text is transformed into a feature matrix using techniques like Bag-of-Words and TF-IDF representation. But these matrices are often high-dimensional, which increases the complexity of the model, causes longer training times, and can even degrade model performance due to the so-called “curse of dimensionality”. To address these issues, we resort to Dimensionality Reduction techniques which reduce the size of the feature space. By the end of this lesson, you will have learned the basics of Dimensionality Reduction and how to implement the `TruncatedSVD`

method in Python on the *IMDB movie reviews dataset*.

In many machine learning problems, data is represented using a large number of features or dimensions. When the dimensionality or number of features is too large, data can become sparse and scattered, potentially making the learning algorithm perform poorly, struggle to find patterns, or even overfit to the training set noise.

This is a well-known problem called "curse of dimensionality" and to tackle it, we use a set of techniques known as Dimensionality Reduction. The goal of dimensionality reduction is to reduce the number of features in your data while retaining the essential information and structure. The transformed data is a new representation of the original data but in a reduced feature space. It generally results in lesser computational requirements, lower storage space, and perhaps most importantly, improved performance by reducing overfitting.

One popular method for dimensionality reduction is *Singular Value Decomposition (SVD)*. In NLP, we often use its variant called `TruncatedSVD`

, which reduces the feature space to a user-specified smaller dimension, while preserving maximum data variance.

The dimensionality reduction technique we'll be using in this lesson is `TruncatedSVD`

, which is available in the `sklearn.decomposition`

module of the `scikit-learn`

library. We can instantiate a `TruncatedSVD`

object and specify the number of desired output features in the `n_components`

parameter.

Python`1from sklearn.decomposition import TruncatedSVD 2 3svd = TruncatedSVD(n_components=50)`

In the above code, `n_components=50`

specifies that we want to reduce our feature space to 50 dimensions. The `fit_transform`

method is then used to apply this transformation to a given matrix.

We can apply dimensionality reduction directly on the TF-IDF matrix. The `TruncatedSVD`

transformer is fit on the TF-IDF matrix and then used to transform the matrix to its reduced form.

Python`1features = svd.fit_transform(tfidf_matrix)`

In the above code, the `fit_transform`

method applies the `TruncatedSVD`

transformation to the `tfidf_matrix`

and stores the reduced feature matrix in 'features'.

Now, let's combine all the steps and apply this to our *IMDB movie reviews dataset*.

Python`1# Import necessary Libraries 2import nltk 3from nltk.corpus import movie_reviews 4from sklearn.feature_extraction.text import TfidfVectorizer 5from sklearn.decomposition import TruncatedSVD 6 7# Load IMDB Movie Reviews Dataset 8nltk.download('movie_reviews', quiet=True) 9 10# We will be working with first 100 reviews 11first_100_reviewids = movie_reviews.fileids()[:100] 12reviews = [movie_reviews.raw(fileid) for fileid in first_100_reviewids] 13 14# Transform raw data into TF-IDF matrix 15vectorizer = TfidfVectorizer(stop_words='english') 16tfidf_matrix = vectorizer.fit_transform(reviews) 17print(f"Shape of the features matrix before dimensionality reduction: {tfidf_matrix.shape}\n") 18 19# Now we will apply TruncatedSVD for Dimensionality Reduction 20# We've set n_components=50, which specifies we want to reduce our feature space to 50 dimensions. 21svd = TruncatedSVD(n_components=50) 22features = svd.fit_transform(tfidf_matrix) 23 24# Print shape after dimensionality reduction 25print(f"Shape of the features matrix after dimensionality reduction: {features.shape}")`

The output of the above code will be:

Plain text`1Shape of the features matrix before dimensionality reduction: (100, 8865) 2 3Shape of the features matrix after dimensionality reduction: (100, 50)`

This output highlights the effectiveness of `TruncatedSVD`

in reducing the dimensionality of the TF-IDF matrix from 8865 to just 50. This significant reduction in the number of features can simplify models and potentially improve their performance on predictive tasks.

In the previous code, you saw how `TruncatedSVD`

was implemented on the TF-IDF matrix of the IMDB movie reviews. The primary parameter we set was `n_components=50`

, meaning we wanted to reduce our original feature space down to 50 dimensions. But how does this reduction actually happen?

`TruncatedSVD`

uses a mathematical technique called Singular Value Decomposition. This method breaks down the original feature matrix into three components - two orthogonal matrices, and a diagonal matrix containing singular values. In `TruncatedSVD`

case, the technique only keeps the top 'n' largest singular values, effectively reducing the dimension of the matrix.

Selecting the number of components or 'n' value is a critical decision. A smaller value could speed up the training process and potentially prevent overfitting but might lose essential information. On the contrary, a larger value would preserve more information but might not address the 'curse of dimensionality' effectively.

A common strategy is to fit the SVD transformer and plot the explained variance ratio as a function of number of components. The ideal number of components is typically chosen at a point where the explained variance ratio plot starts to show diminishing returns.

Remember, dimensions play a critical part in most machine learning algorithms. Reducing dimensionality can often make your models more interpretable and less prone to overfitting. But these benefits need to be balanced against the risk of losing potentially useful information. That's part of the art of machine learning!

That's a wrap on this lesson about dimensionality reduction in text classification! You've learned about the importance of dimensionality reduction, the theory behind `TruncatedSVD`

– a popular dimensionality reduction technique, and implemented it in Python on a real-world text dataset.

As always, understanding the principles is just the first step. The effectiveness of learning lies in the practice. We've curated some fun and challenging exercises for you to solidify this new knowledge, which you'll find in the subsequent practice segment. Remember the principle - learning happens by doing. So go ahead and apply your newly acquired skills!