Practice Questions — Linear Regression - Your First ML Algorithm

import numpy as np
from sklearn.linear_model import LinearRegression

class LinearRegressionGD:
    def __init__(self, lr=0.1, n_iter=500):
        self.lr = lr
        self.n_iter = n_iter
        self.losses = []
    def fit(self, X, y):
        n = len(X)
        self.w = np.zeros(X.shape[1])
        self.b = 0.0
        for _ in range(self.n_iter):
            y_pred = X @ self.w + self.b
            self.losses.append(np.mean((y - y_pred)**2))
            self.w -= self.lr * (1/n) * X.T @ (y_pred - y)
            self.b -= self.lr * (1/n) * np.sum(y_pred - y)
    def predict(self, X): return X @ self.w + self.b

np.random.seed(42)
x = np.random.uniform(0, 10, 100)
y = 4*x + 10 + np.random.normal(0, 2, 100)
X = ((x - x.mean()) / x.std()).reshape(-1, 1)

my_model = LinearRegressionGD()
my_model.fit(X, y)
print(f'Scratch: w={my_model.w[0]:.4f}, b={my_model.b:.4f}, MSE={my_model.losses[-1]:.4f}')

sk_model = LinearRegression().fit(X, y)
print(f'sklearn: w={sk_model.coef_[0]:.4f}, b={sk_model.intercept_:.4f}')

import numpy as np
import pandas as pd
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import r2_score, mean_squared_error

np.random.seed(42)
n = 200
df = pd.DataFrame({'Area': np.random.uniform(500, 3000, n).round(0), 'Beds': np.random.randint(1, 6, n), 'Age': np.random.randint(0, 30, n), 'Distance': np.random.uniform(1, 25, n).round(1)})
df['Price'] = (20 + 0.03*df['Area'] + 8*df['Beds'] - 0.5*df['Age'] + np.random.normal(0, 5, n)).round(2)

X = df.drop('Price', axis=1)
y = df['Price']
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2, random_state=42)
scaler = StandardScaler()
X_tr_s = scaler.fit_transform(X_tr)
X_te_s = scaler.transform(X_te)

model = LinearRegression().fit(X_tr_s, y_tr)
y_pred = model.predict(X_te_s)
print(f'R^2: {r2_score(y_te, y_pred):.4f}')
print(f'RMSE: {np.sqrt(mean_squared_error(y_te, y_pred)):.2f}')
for feat, coef in zip(X.columns, model.coef_):
    print(f'{feat}: {coef:.4f}')
new = scaler.transform([[1500, 3, 5, 10]])
print(f'Prediction for [1500, 3, 5, 10]: {model.predict(new)[0]:.2f}')

import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.preprocessing import PolynomialFeatures
from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score

np.random.seed(42)
X = np.random.uniform(-5, 5, 80).reshape(-1, 1)
y = 0.5*X.squeeze()**2 - 2*X.squeeze() + 10 + np.random.normal(0, 2, 80)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2, random_state=42)

best_r2, best_deg = -1, 0
for deg in [1, 2, 3]:
    poly = PolynomialFeatures(degree=deg)
    X_tr_p = poly.fit_transform(X_tr)
    X_te_p = poly.transform(X_te)
    model = LinearRegression().fit(X_tr_p, y_tr)
    r2 = r2_score(y_te, model.predict(X_te_p))
    print(f'Degree {deg}: R^2 = {r2:.4f}')
    if r2 > best_r2: best_r2, best_deg = r2, deg
print(f'Best: degree {best_deg} (R^2 = {best_r2:.4f}')

import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score

np.random.seed(42)
exp = np.array([1, 2, 3, 4, 5, 6, 8, 10, 12, 15, 1.5, 3.5, 7, 9, 11, 14, 4.5, 6.5, 8.5, 13]).reshape(-1, 1)
sal = 25 + 7*exp.squeeze() + np.random.normal(0, 3, 20)

X_tr, X_te, y_tr, y_te = train_test_split(exp, sal, test_size=0.2, random_state=42)
model = LinearRegression().fit(X_tr, y_tr)
y_pred = model.predict(X_te)

print(f'Equation: salary = {model.coef_[0]:.2f} * experience + {model.intercept_:.2f}')
print(f'MAE: {mean_absolute_error(y_te, y_pred):.2f}K')
print(f'RMSE: {np.sqrt(mean_squared_error(y_te, y_pred)):.2f}K')
print(f'R^2: {r2_score(y_te, y_pred):.4f}')
print('\nPredictions:')
for yr in [0, 5, 10, 15, 20]:
    print(f'  {yr} years -> {model.predict([[yr]])[0]:.1f}K')

import numpy as np

np.random.seed(42)
X = np.random.uniform(0, 10, 50)
y = 3*X + 10 + np.random.normal(0, 2, 50)
X_norm = (X - X.mean()) / X.std()

print(f'{"LR":<8}{"Final MSE":<12}{"Converged":<12}{"Steps to MSE<5"}')
print('-' * 44)
for lr in [0.001, 0.01, 0.05, 0.1, 0.5]:
    w, b = 0.0, 0.0
    steps_to_5 = 'N/A'
    for i in range(200):
        y_pred = w*X_norm + b
        mse = np.mean((y - y_pred)**2)
        if mse < 5 and steps_to_5 == 'N/A':
            steps_to_5 = str(i)
        dw = (2/50)*np.sum(X_norm*(y_pred-y))
        db = (2/50)*np.sum(y_pred-y)
        w -= lr*dw
        b -= lr*db
    final_mse = np.mean((y-(w*X_norm+b))**2)
    converged = 'Yes' if final_mse < 10 else 'No'
    print(f'{lr:<8}{final_mse:<12.4f}{converged:<12}{steps_to_5}')

import numpy as np
import pandas as pd
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score

np.random.seed(42)
n = 150
df = pd.DataFrame({
    'Hours': np.random.uniform(1, 10, n).round(1),
    'Attendance': np.random.uniform(40, 100, n).round(1),
    'Prev_Score': np.random.uniform(30, 90, n).round(1)
})
df['Final'] = (10 + 5*df['Hours'] + 0.3*df['Attendance'] + 0.4*df['Prev_Score'] + np.random.normal(0, 5, n)).round(1).clip(0, 100)
df.loc[np.random.choice(n, 10), 'Hours'] = np.nan
df.loc[np.random.choice(n, 5), 'Attendance'] = np.nan

print('=== EDA ===')
print(f'Shape: {df.shape}')
print(f'Missing: {df.isnull().sum().to_dict()}')
print(f'Correlations with Final:')
print(df.corr()['Final'].drop('Final').round(3))

df['Hours'] = df['Hours'].fillna(df['Hours'].median())
df['Attendance'] = df['Attendance'].fillna(df['Attendance'].median())

X = df.drop('Final', axis=1)
y = df['Final']
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2, random_state=42)
scaler = StandardScaler()
X_tr_s = scaler.fit_transform(X_tr)
X_te_s = scaler.transform(X_te)

model = LinearRegression().fit(X_tr_s, y_tr)
y_pred = model.predict(X_te_s)

print(f'\n=== Evaluation ===')
print(f'MAE: {mean_absolute_error(y_te, y_pred):.2f}')
print(f'RMSE: {np.sqrt(mean_squared_error(y_te, y_pred)):.2f}')
print(f'R^2: {r2_score(y_te, y_pred):.4f}')

for feat, coef in zip(X.columns, model.coef_):
    print(f'{feat}: {coef:.4f}')

new_student = scaler.transform([[6, 85, 70]])
print(f'\nNew student (6hrs, 85% att, 70 prev): {model.predict(new_student)[0]:.1f}')