Module 1: Machine Learning Foundations

pip install numpy pandas matplotlib seaborn scikit-learn \
           xgboost lightgbm scipy jupyterlab plotly

import numpy as np

# Creating arrays
a = np.array([1, 2, 3, 4, 5])          # 1D array (vector)
b = np.array([[1,2,3],[4,5,6]])         # 2D array (matrix)
c = np.zeros((3, 4))                    # 3×4 matrix of zeros
d = np.ones((2, 3))                     # 2×3 matrix of ones
e = np.arange(0, 10, 2)                # [0, 2, 4, 6, 8]
f = np.linspace(0, 1, 5)              # [0.0, 0.25, 0.5, 0.75, 1.0]
g = np.random.randn(3, 3)             # 3×3 matrix of random normal values

# Shape and dimensions
print(b.shape)   # (2, 3)
print(b.ndim)    # 2
print(b.dtype)   # int64

# Indexing & Slicing
arr = np.array([[10, 20, 30], [40, 50, 60]])
print(arr[0, 1])      # 20
print(arr[:, 1])      # [20, 50] — entire second column
print(arr[0, :])      # [10, 20, 30] — entire first row
print(arr[arr > 25])  # [30, 40, 50, 60] — boolean masking

# Vectorized operations (no loops needed!)
x = np.array([1, 2, 3, 4])
print(x * 2)         # [2, 4, 6, 8]
print(x ** 2)        # [1, 4, 9, 16]
print(np.sqrt(x))    # [1., 1.414, 1.732, 2.]
print(np.log(x))     # natural log of each element

import numpy as np

# Matrix multiplication (dot product) — core of neural nets
A = np.array([[1,2],[3,4]])   # 2×2
B = np.array([[5,6],[7,8]])   # 2×2
print(A @ B)                  # matrix multiply: [[19,22],[43,50]]
print(np.dot(A, B))           # same result

# Transpose
print(A.T)                    # [[1,3],[2,4]]

# Statistics — key for EDA
data = np.array([2, 5, 7, 1, 8, 3, 9])
print(np.mean(data))     # 5.0
print(np.median(data))   # 5.0
print(np.std(data))      # standard deviation
print(np.var(data))      # variance
print(np.min(data), np.max(data))  # 1, 9
print(np.percentile(data, [25, 50, 75]))  # quartiles

# Reshaping
arr = np.arange(12)
matrix = arr.reshape(3, 4)     # 3 rows × 4 columns
flat = matrix.flatten()        # back to 1D

# Stacking arrays
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
print(np.vstack([a, b]))   # vertical stack → 2×3
print(np.hstack([a, b]))   # horizontal stack → [1,2,3,4,5,6]

import pandas as pd
import numpy as np

# ── Creating DataFrames ──────────────────────────────────────
df = pd.read_csv('data.csv')                    # Load CSV
df = pd.read_excel('data.xlsx')                  # Load Excel
df = pd.read_json('data.json')                   # Load JSON

# Create from dictionary
df = pd.DataFrame({
    'Name':   ['Alice', 'Bob', 'Charlie', 'David'],
    'Age':    [25, 30, 35, 28],
    'Salary': [50000, 60000, 75000, 55000],
    'Dept':   ['HR', 'IT', 'Finance', 'IT']
})

# ── First Look at Data ────────────────────────────────────────
df.head(3)           # first 3 rows (default: 5)
df.tail(3)           # last 3 rows
df.shape             # (4, 4) — rows, cols
df.columns           # Index(['Name','Age','Salary','Dept'])
df.dtypes            # data type of each column
df.info()            # non-null count + dtype summary
df.describe()        # count, mean, std, min, quartiles, max

# ── Selecting Data ────────────────────────────────────────────
df['Age']                        # Series — single column
df[['Name', 'Salary']]           # DataFrame — multiple columns
df.loc[0]                        # Row by index label
df.iloc[0]                       # Row by integer position
df.loc[df['Dept'] == 'IT']       # Rows where Dept is 'IT'
df[df['Age'] > 28]               # Rows where Age > 28
df.loc[df['Dept']=='IT', 'Salary']  # IT employees' salaries only

# ── Adding & Modifying Columns ──────────────────────────────
df['Bonus'] = df['Salary'] * 0.1
df['Seniority'] = df['Age'].apply(lambda x: 'Senior' if x >= 30 else 'Junior')

# ── Sorting ──────────────────────────────────────────────────
df.sort_values('Salary', ascending=False)
df.sort_values(['Dept', 'Age'], ascending=[True, False])

# ── Aggregation ──────────────────────────────────────────────
df['Salary'].mean()               # 60000.0
df.groupby('Dept')['Salary'].mean()   # avg salary per department
df.groupby('Dept').agg({'Salary': ['mean', 'max'], 'Age': 'mean'})

# ── Missing Values ───────────────────────────────────────────
df.isnull().sum()              # count nulls per column
df.isnull().sum() / len(df)   # null percentage
df.dropna()                    # drop rows with any null
df.fillna(df.mean())           # fill nulls with column mean
df['Age'].fillna(df['Age'].median(), inplace=True)

# ── Filtering & Conditions ───────────────────────────────────
senior_it = df[(df['Dept'] == 'IT') & (df['Age'] >= 30)]
high_earners = df[df['Salary'].between(60000, 80000)]

import pandas as pd

employees = pd.DataFrame({
    'emp_id': [1, 2, 3, 4],
    'name':   ['Alice', 'Bob', 'Charlie', 'David'],
    'dept_id': [10, 20, 10, 30]
})
departments = pd.DataFrame({
    'dept_id':   [10, 20, 30],
    'dept_name': ['HR', 'IT', 'Finance']
})

# INNER JOIN — only rows that match in both
result = pd.merge(employees, departments, on='dept_id', how='inner')

# LEFT JOIN — keep all employees, nulls for missing dept
result = pd.merge(employees, departments, on='dept_id', how='left')

# Merge on different column names
result = pd.merge(
    left_df, right_df,
    left_on='emp_dept', right_on='dept_id',
    how='inner'
)

# Concatenation — stack vertically
combined = pd.concat([df1, df2], ignore_index=True)

# Concatenation — stack horizontally
combined = pd.concat([df1, df2], axis=1)

import pandas as pd

# Pivot Table — like Excel pivot
pivot = df.pivot_table(
    values='Salary',
    index='Dept',
    columns='Seniority',
    aggfunc='mean',
    fill_value=0
)

# GroupBy with transform — adds group stats back to original df
df['dept_avg_salary'] = df.groupby('Dept')['Salary'].transform('mean')
df['salary_diff_from_avg'] = df['Salary'] - df['dept_avg_salary']

# Apply — custom functions on columns or rows
def salary_band(x):
    if x < 50000: return 'Low'
    elif x < 70000: return 'Medium'
    else: return 'High'

df['salary_band'] = df['Salary'].apply(salary_band)

# Apply on multiple columns
df['name_age'] = df.apply(lambda row: f"{row['Name']} ({row['Age']})", axis=1)

# String operations (vectorized — no loops!)
df['Name'].str.lower()
df['Name'].str.upper()
df['Name'].str.contains('a', case=False)  # boolean mask
df['email'].str.extract(r'@(.+)')         # extract domain

# DateTime handling — critical for time-series ML
df['date'] = pd.to_datetime(df['date_string'])
df['year']  = df['date'].dt.year
df['month'] = df['date'].dt.month
df['day_of_week'] = df['date'].dt.dayofweek  # 0=Monday
df['is_weekend'] = df['day_of_week'] >= 5

from sklearn.linear_model import LinearRegression   # import
from sklearn.ensemble import RandomForestClassifier
from sklearn.preprocessing import StandardScaler

# ── Step 1: Instantiate ─────────────────────────────────────
model = RandomForestClassifier(n_estimators=100, random_state=42)

# ── Step 2: Fit (train) ──────────────────────────────────────
model.fit(X_train, y_train)

# ── Step 3: Predict ──────────────────────────────────────────
predictions = model.predict(X_test)
probabilities = model.predict_proba(X_test)  # for classifiers

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, classification_report

# ── 1. Load Data ─────────────────────────────────────────────
from sklearn.datasets import load_breast_cancer
data = load_breast_cancer()
X = pd.DataFrame(data.data, columns=data.feature_names)
y = data.target  # 0 = malignant, 1 = benign

# ── 2. Split ─────────────────────────────────────────────────
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# ── 3. Preprocess ────────────────────────────────────────────
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)   # learn stats + scale
X_test_scaled  = scaler.transform(X_test)         # only scale (don't refit!)

# ── 4. Train ─────────────────────────────────────────────────
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train_scaled, y_train)

# ── 5. Evaluate ──────────────────────────────────────────────
y_pred = model.predict(X_test_scaled)
print(f"Accuracy: {accuracy_score(y_test, y_pred):.4f}")
print(classification_report(y_test, y_pred, target_names=data.target_names))

# ── 6. Feature Importance ────────────────────────────────────
import pandas as pd
importances = pd.Series(model.feature_importances_, index=data.feature_names)
print(importances.sort_values(ascending=False).head(10))