Feature Engineering for NLP

# Import pandas, numpy, and re (regular expressions) for text cleaning
import pandas as pd
import numpy as np
import re  # built-in Python library for pattern matching in strings

# Create a product review DataFrame — 10 rows, binary sentiment target
reviews_df = pd.DataFrame({
    'review_id': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
    'review': [
        "This product is absolutely amazing! Best purchase I have ever made.",
        "Terrible quality. Broke after two days. COMPLETE WASTE OF MONEY!!!",
        "Good value for the price. Works as described. Happy with it.",
        "DO NOT BUY THIS. Worst product ever. Total garbage!! Returning immediately.",
        "Decent product. Nothing special but gets the job done. Okay.",
        "Exceeded my expectations! Fantastic build quality. Highly recommend!",
        "Awful. Stopped working after one week. Very disappointed and frustrated.",
        "Perfect for my needs. Easy to use and looks great. Love it!",
        "Cheap and nasty. Breaks easily. Customer service was useless too.",
        "Outstanding quality! Works perfectly. Will definitely buy again!!"
    ],
    'sentiment': [1, 0, 1, 0, 1, 1, 0, 1, 0, 1]  # 1=positive, 0=negative
})

# --- Step 1: Text cleaning — create a normalised version for vectorisation ---
def clean_text(text):
    text = text.lower()                          # lowercase everything
    text = re.sub(r'[^a-z\s]', '', text)         # remove all non-letter characters (punctuation, digits)
    text = re.sub(r'\s+', ' ', text).strip()     # collapse multiple spaces into one
    return text

reviews_df['clean_review'] = reviews_df['review'].apply(clean_text)  # apply to every row

# --- Step 2: Statistical meta-features — structural signals ---
reviews_df['word_count']      = reviews_df['review'].str.split().str.len()             # total word count
reviews_df['char_count']      = reviews_df['review'].str.len()                         # total character count
reviews_df['avg_word_len']    = reviews_df['char_count'] / (reviews_df['word_count'] + 1e-9)  # avg word length
reviews_df['exclaim_count']   = reviews_df['review'].str.count(r'!')                   # number of exclamation marks
reviews_df['capital_ratio']   = reviews_df['review'].apply(
    lambda x: sum(1 for c in x if c.isupper()) / (len(x) + 1e-9)                      # fraction of uppercase letters
)
reviews_df['unique_word_ratio'] = reviews_df['clean_review'].apply(
    lambda x: len(set(x.split())) / (len(x.split()) + 1e-9)                            # vocabulary diversity score
)

# Round for clean display
reviews_df = reviews_df.round(3)

# Show meta-features alongside sentiment
print(reviews_df[['review_id','word_count','exclaim_count',
                  'capital_ratio','unique_word_ratio','sentiment']].to_string(index=False))

# Check class separation for each meta-feature
print("\nMean meta-feature values by sentiment class:")
print(reviews_df.groupby('sentiment')[
    ['word_count','exclaim_count','capital_ratio','unique_word_ratio']
].mean().round(3).to_string())

# Import sklearn's TF-IDF vectoriser and pandas
import pandas as pd
import numpy as np
from sklearn.feature_extraction.text import TfidfVectorizer  # converts text to TF-IDF feature matrix

# Cleaned reviews from the previous block
clean_reviews = [
    "this product is absolutely amazing best purchase i have ever made",
    "terrible quality broke after two days complete waste of money",
    "good value for the price works as described happy with it",
    "do not buy this worst product ever total garbage returning immediately",
    "decent product nothing special but gets the job done okay",
    "exceeded my expectations fantastic build quality highly recommend",
    "awful stopped working after one week very disappointed and frustrated",
    "perfect for my needs easy to use and looks great love it",
    "cheap and nasty breaks easily customer service was useless too",
    "outstanding quality works perfectly will definitely buy again"
]
sentiments = [1, 0, 1, 0, 1, 1, 0, 1, 0, 1]  # 1=positive, 0=negative

# Initialise TF-IDF vectoriser with unigrams and bigrams
# ngram_range=(1,2) means: include single words AND pairs of adjacent words
# max_features=20 keeps only the 20 highest-scoring terms for readability
# min_df=1 includes terms that appear in at least 1 document (all terms for small dataset)
tfidf = TfidfVectorizer(
    ngram_range=(1, 2),   # unigrams and bigrams
    max_features=20,      # top 20 features by TF-IDF score
    min_df=1,             # minimum document frequency
    sublinear_tf=True     # apply log(1+tf) instead of raw tf — reduces impact of very frequent terms
)

# Fit on all reviews and transform to feature matrix
X_tfidf = tfidf.fit_transform(clean_reviews)   # returns a sparse matrix

# Convert to a dense DataFrame for inspection
tfidf_df = pd.DataFrame(
    X_tfidf.toarray(),                          # convert sparse to dense array
    columns=tfidf.get_feature_names_out()       # use vocabulary terms as column names
)
tfidf_df['sentiment'] = sentiments              # add target column for analysis

# Show the TF-IDF matrix (transposed for readability — terms as rows)
print("TF-IDF feature matrix (top 20 terms, rows=reviews, cols=terms):")
print(tfidf_df.drop('sentiment', axis=1).round(3).to_string())

# Identify the highest mean TF-IDF weight per class — which terms define each class?
print("\nTop terms by mean TF-IDF weight per class:")
for label, name in [(1, 'POSITIVE'), (0, 'NEGATIVE')]:
    class_means = tfidf_df[tfidf_df['sentiment'] == label].drop('sentiment', axis=1).mean()
    top5 = class_means.sort_values(ascending=False).head(5)  # top 5 terms for this class
    print(f"\n  {name} reviews — top 5 terms:")
    for term, score in top5.items():
        print(f"    {term:<25} {score:.4f}")

# Import libraries
import pandas as pd
import numpy as np
import re
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.preprocessing import StandardScaler   # scale meta-features to same range as TF-IDF
from scipy.sparse import hstack, csr_matrix        # hstack combines sparse matrices horizontally

# Reviews and targets
raw_reviews = [
    "This product is absolutely amazing! Best purchase I have ever made.",
    "Terrible quality. Broke after two days. COMPLETE WASTE OF MONEY!!!",
    "Good value for the price. Works as described. Happy with it.",
    "DO NOT BUY THIS. Worst product ever. Total garbage!! Returning immediately.",
    "Decent product. Nothing special but gets the job done. Okay.",
    "Exceeded my expectations! Fantastic build quality. Highly recommend!",
    "Awful. Stopped working after one week. Very disappointed and frustrated.",
    "Perfect for my needs. Easy to use and looks great. Love it!",
    "Cheap and nasty. Breaks easily. Customer service was useless too.",
    "Outstanding quality! Works perfectly. Will definitely buy again!!"
]
sentiments = [1, 0, 1, 0, 1, 1, 0, 1, 0, 1]

# --- Step 1: Clean text for TF-IDF ---
def clean_text(text):
    text = text.lower()
    text = re.sub(r'[^a-z\s]', '', text)
    return re.sub(r'\s+', ' ', text).strip()

clean_reviews = [clean_text(r) for r in raw_reviews]  # list of cleaned strings

# --- Step 2: TF-IDF features (sparse matrix) ---
tfidf = TfidfVectorizer(ngram_range=(1, 2), max_features=15, sublinear_tf=True)
X_tfidf = tfidf.fit_transform(clean_reviews)   # shape: (10, 15) sparse matrix

# --- Step 3: Meta-features (dense array) ---
meta = pd.DataFrame({
    'word_count':    [len(r.split()) for r in raw_reviews],                        # word count
    'exclaim_count': [r.count('!') for r in raw_reviews],                          # exclamation marks
    'capital_ratio': [sum(1 for c in r if c.isupper()) / (len(r) + 1e-9)           # capital letter ratio
                      for r in raw_reviews],
    'avg_word_len':  [np.mean([len(w) for w in r.split()]) for r in raw_reviews]   # average word length
})

# Scale meta-features: TF-IDF values are already in [0,1] range;
# meta-features like word_count can be 10+ — StandardScaler brings them to comparable scale
scaler = StandardScaler()
X_meta_scaled = scaler.fit_transform(meta)         # returns numpy array, shape (10, 4)

# Convert scaled meta-features to sparse for hstack compatibility
X_meta_sparse = csr_matrix(X_meta_scaled)          # wrap dense array in sparse format

# --- Step 4: Horizontally stack TF-IDF + meta-features ---
X_combined = hstack([X_tfidf, X_meta_sparse])      # shape: (10, 15+4) = (10, 19)

# Report shapes
print(f"TF-IDF feature matrix shape:   {X_tfidf.shape}")
print(f"Meta-features matrix shape:    {X_meta_scaled.shape}")
print(f"Combined feature matrix shape: {X_combined.shape}")

# Convert combined to dense and show column names
feature_names = list(tfidf.get_feature_names_out()) + list(meta.columns)  # all 19 feature names
combined_df = pd.DataFrame(X_combined.toarray(), columns=feature_names)
combined_df['sentiment'] = sentiments

print(f"\nTotal features: {len(feature_names)} ({X_tfidf.shape[1]} TF-IDF + {len(meta.columns)} meta)")
print("\nFirst 3 rows of combined feature matrix (meta-features shown at right):")
print(combined_df[['word_count','exclaim_count','capital_ratio','avg_word_len','sentiment']].round(3).to_string(index=False))