After the images of project 2, another kind of non-tabular data: text. In this project you will build, end to end, a sentiment classifier — positive or negative — for social-media opinions about a home delivery service, using classical NLP: text cleaning, bag-of-words and TF-IDF representations, and the models from module 4, with the multinomial Naive Bayes from 04-06 in the leading role (back there we promised it to you "for text"; today it delivers). To keep the project self-contained, the dataset is fictional but realistic: around 40 opinions about "RepartoYa", a delivery service in the style of MercaFresh, built right in the code. In a real case they would be thousands of rows from a public CSV — at the end of the project we tell you where to get them.

1. Problem definition and target metric
2. Building the dataset
3. Exploring the text
4. Cleaning and normalization
5. Representation: from words to numbers
6. Modeling: Naive Bayes, logistic regression and linear SVM
7. Evaluation with stratified cross-validation
8. Interpretation: which words carry weight
9. Limits of the classical approach
10. Conclusions

• Problem: binary classification of short texts — is the opinion positive (1) or negative (0)?
• Business use: prioritizing customer support (answering angry customers first) and measuring brand health on social media.
• Metric: with balanced classes like here, accuracy plus the confusion matrix; in a real deployment you would care especially about the recall of the negative class (no furious customer slips through), the same cost-based reasoning as in 06-04 "ROC curve and AUC".
• Success criterion: clearly beat random guessing (50%) and, above all, keep the model interpretable: we must be able to see which words convince it.

With 40 examples you do not train a product: you learn a workflow. We build them balanced and with the real vices of social-media text (caps, URLs, mentions, emojis, excessive punctuation):

Methodological transparency: in a real project this step would be pd.read_csv(...) over thousands of labeled opinions (labeled by hand or by rules such as a review's star rating). Everything that follows works identically with 40 rows or with 40,000 — only the statistical solidity of the results changes, as 02-04 "Statistical inference" taught you: with small samples, wide intervals and humility.

Text EDA starts by counting things:

Clues are already visible: the negatives are full of "late", "terrible", "nobody", "again"; the positives of "fast", "perfect", "fresh". The classifier we are about to build will formalize exactly this intuition.

Raw social-media text carries noise with no sentiment signal (URLs, mentions) and superficial variants of the same thing ("Amazing" vs. "amazing"). Cleaning is the textual equivalent of 03-01 "Data cleaning":

Every step is a decision with a cost: by removing emojis we lose 😡 and 😍, which are the purest sentiment signal there is (an obvious improvement would be converting them into tokens like emoji_angry before cleaning). Tokenization — chopping the text into words — will be done for us by the vectorizer, splitting on non-alphanumerics; for this simple approach that is enough.

No model from module 4 eats text: they eat numeric matrices. The classical solution is bag-of-words: every distinct word in the vocabulary becomes a column, and every text becomes a row with the number of times it uses each word. You lose the order ("not good at all" and "good not at all" look identical) but you gain a table on which everything you have learned just works.

CountVectorizer builds that matrix; TfidfVectorizer improves it by weighting: TF-IDF multiplies the word's frequency in the document (TF) by a factor that penalizes words appearing in almost every document (IDF). So "order", which is everywhere, weighs little, while "expired", rare but revealing, weighs a lot.

Two parameters deserve an explanation:

• ngram_range=(1, 2): besides single words, it uses consecutive pairs (bigrams). It is the cheap way to recover some word order: "not recommend" as a term of its own distinguishes what "not" and "recommend" taken separately would confuse.
• stop_words: filler words ("the", "of", "that") that only add noise. Careful: with sentiment you must prune with caution — "not" must never be a stopword here.

The resulting matrix is sparse (almost all zeros): each text uses a few dozen terms out of a vocabulary of hundreds. sklearn handles it efficiently without ever converting it to dense.

Three classics ideally suited to high-dimensional sparse matrices, each in its own Pipeline (vectorizer included, so the vocabulary is learned only from the training portion of each fold — the anti-leak discipline from 06-01):

MultinomialNB is the reunion promised in 04-06 "Naive Bayes": it models the probability of each word given the class (what is the probability of seeing "expired" in a negative opinion?) and combines them all with Bayes' theorem from 02-05, assuming independence between words — a false assumption that works surprisingly well on text. The logistic regression from 04-02 and the linear SVM from 04-04 instead learn one weight per term, which makes them highly interpretable.

With 40 examples, a single train/test split would be a lottery. We use the stratified CV from 06-03 "Cross-validation", which also keeps the 50/50 class balance in every fold:

With 8 examples per test fold, every single hit moves the metric by 12.5%: the deviations are enormous and no ranking among these three is conclusive. The honest conclusion is the opposite one: all three clearly beat random guessing, a sign that the lexical signal of sentiment is strong. With thousands of examples the differences would indeed become measurable.

The great virtue of the classical approach: it can be audited. We train the logistic regression on everything and look at its coefficients per term (positive = pushes toward positive sentiment):

You should see "fast", "perfect", "fresh" at the top and "late", "terrible", "nobody", "not" at the bottom. This serves three purposes: validating that the model learns sentiment rather than coincidences ("if 'flights' came out as a negative term, I would get suspicious"), explaining individual predictions to the business, and detecting bias — if a proper name or a demographic group showed up with a strong weight, you would be looking at the proxy problem from 08-04 "Ethical and privacy considerations".

Honesty is mandatory here: bag-of-words does not understand language, it counts words.

• Negation and context: "not bad at all" is positive; to a bag of words it is "not" + "bad" = extremely negative. Bigrams mitigate this, they do not cure it.
• Irony and sarcasm: "great, late again 👏" defeats any word counter.
• Closed vocabulary: a word never seen in training contributes nothing, even if it is "atrocious".

The transformers mentioned in 07-04 "Deep neural networks (Deep Learning)" and among the frameworks in 08-01 (Hugging Face) solve much of this: they read the whole sentence, understand context and come pretrained with the language already learned. In exchange: higher compute cost, less direct interpretability and more infrastructure. In professional practice, TF-IDF + a linear model remains an excellent baseline and is often enough — and it is always the first rung against which any transformer should be measured.

• Vectorizing before splitting. Fitting the TfidfVectorizer on all the texts leaks vocabulary (and IDF frequencies!) from the test set into training. Inside the Pipeline, it is impossible to get wrong.
• Removing "not" as a stopword. Generic stopword lists include negations; in sentiment they are the most informative words there are. Always review the list for your problem.
• Over-cleaning. Emojis, sustained caps ("EXPIRED") and repeated punctuation ("!!!") carry emotional signal. Before deleting them, ask yourself whether they could be features.
• Believing an accuracy computed on 40 examples. Always report the deviation across folds and, with small samples, prefer qualitative conclusions ("it beats random") over rankings decided by tenths of a point.
• Lazy labels. If you label reviews by stars (1–2 = negative, 4–5 = positive), document what you do with the 3-star ones: including them mislabeled pollutes more than discarding them.

1. Scale up to a real dataset. Replace the 40 sentences with thousands: the classic IMDb movie-review dataset, the Multilingual Amazon Reviews corpus, or other public review datasets available on Hugging Face Datasets (if you ever work with Spanish-language data, the TASS corpora from the SEPLN sentiment workshops are the reference). Hint: with thousands of examples, rerun the three-model comparison and check whether the SVM overtakes Naive Bayes; add min_df=5 to prune rarities.
2. Lemmatization with spaCy. Install spacy and the en_core_web_sm model, and replace each word with its lemma ("arrived" → "arrive", "charged" → "charge") before vectorizing. Hint: it shrinks the vocabulary by grouping variants; measure whether it improves the CV or just slows things down — it does not always pay off.
3. A transformer in three lines. Try Hugging Face's pipeline("sentiment-analysis", model=...) with an English model (search for "sentiment" on their hub) over your 40 sentences and compare its hits with your TF-IDF's, looking especially at the sentences with negation or sarcasm. Hint: it needs no training — it comes pretrained; also note how long it takes per sentence compared to your linear model.

Third project done: you have turned free text into a matrix that the models from module 4 know how to digest — cleaning with regular expressions, bag-of-words, TF-IDF with n-grams —, you have reunited with MultinomialNB on the very ground we promised you in 04-06, you have evaluated with the stratified CV that the small sample demanded, and you have audited the model word by word, which is the superpower of the classical approach over blacker boxes. And you have learned to declare limits: negation and sarcasm mark the border where transformers take over, at their cost. Notice the pattern repeating across these three projects: the representation of the data matters as much as the algorithm. In the next project the challenge will lie not in the representation but in the distribution: detecting fraud when 99% of transactions are legitimate and accuracy becomes a professional liar.