Practice Questions — Introduction to AI and Machine Learning

import sklearn
print(f"scikit-learn version: {sklearn.__version__}")

import subprocess
import sys

libraries = ['numpy', 'pandas', 'scikit-learn', 'matplotlib']
for lib in libraries:
    subprocess.check_call([sys.executable, '-m', 'pip', 'install', lib])
    print(f"{lib} installed successfully")

from sklearn.datasets import load_iris

iris = load_iris()
print(f"Number of samples: {iris.data.shape[0]}")
print(f"Number of features: {iris.data.shape[1]}")
print(f"Feature names: {iris.feature_names}")
print(f"Target classes: {list(iris.target_names)}")

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.2, random_state=42
)
print(f"Training set: {X_train.shape[0]} samples")
print(f"Testing set: {X_test.shape[0]} samples")

ml_types = {
    'Supervised Learning': {
        'description': 'Learns from labeled data (input-output pairs)',
        'example': 'Email spam detection'
    },
    'Unsupervised Learning': {
        'description': 'Finds patterns in unlabeled data',
        'example': 'Customer segmentation'
    },
    'Reinforcement Learning': {
        'description': 'Learns through rewards and penalties',
        'example': 'Game-playing AI (AlphaGo)'
    }
}

for ml_type, info in ml_types.items():
    print(f"{ml_type}:")
    print(f"  Description: {info['description']}")
    print(f"  Example: {info['example']}")
    print()

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.2, random_state=42
)

knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train, y_train)
y_pred = knn.predict(X_test)

accuracy = accuracy_score(y_test, y_pred)
print(f"KNN Accuracy: {accuracy * 100:.1f}%")

def count_labels(data):
    counts = {}
    for feature, label in data:
        counts[label] = counts.get(label, 0) + 1
    return counts

# Simulated dataset
dataset = [
    ([5.1, 3.5], 'setosa'),
    ([7.0, 3.2], 'versicolor'),
    ([4.9, 3.0], 'setosa'),
    ([6.3, 2.8], 'virginica'),
    ([5.8, 2.7], 'virginica'),
    ([6.7, 3.1], 'versicolor'),
]

result = count_labels(dataset)
for label, count in result.items():
    print(f"{label}: {count} samples")

students = [
    {'name': 'Aarav', 'marks': 85, 'result': 'Pass'},
    {'name': 'Priya', 'marks': 42, 'result': 'Fail'},
    {'name': 'Rohan', 'marks': 91, 'result': 'Pass'},
    {'name': 'Ananya', 'marks': 38, 'result': 'Fail'}
]

for s in students:
    print(f"{s['name']}: {s['marks']} marks - {s['result']}")

from sklearn.datasets import load_iris
import pandas as pd

iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['species'] = iris.target

print("Shape:", df.shape)
print("\nFirst 5 rows:")
print(df.head())

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score

iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.2, random_state=42
)

dt = DecisionTreeClassifier(random_state=42)
dt.fit(X_train, y_train)
y_pred = dt.predict(X_test)

print(f"Accuracy: {accuracy_score(y_test, y_pred) * 100:.1f}%")

import numpy as np

arr = np.array([10, 20, 30, 40, 50])
print("Array:", arr)
print("Type:", type(arr))

features = [[4, 25], [5, 30], [20, 55], [25, 60]]
labels = ['cat', 'cat', 'dog', 'dog']

for feat, label in zip(features, labels):
    print(f"Weight: {feat[0]}kg, Height: {feat[1]}cm -> {label}")

ml_problems = {
    'Spam detection': 'Supervised (Classification)',
    'House price prediction': 'Supervised (Regression)',
    'Customer segmentation': 'Unsupervised (Clustering)',
    'Game playing AI': 'Reinforcement Learning',
    'Fraud detection': 'Supervised (Classification) or Unsupervised (Anomaly Detection)'
}

for problem, ml_type in ml_problems.items():
    print(f"{problem}: {ml_type}")

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.2, random_state=42
)

print(f"X_train shape: {X_train.shape}, dtype: {X_train.dtype}")
print(f"X_test shape: {X_test.shape}, dtype: {X_test.dtype}")
print(f"y_train shape: {y_train.shape}, dtype: {y_train.dtype}")
print(f"y_test shape: {y_test.shape}, dtype: {y_test.dtype}")

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.2, random_state=42
)

models = {
    'KNN (k=5)': KNeighborsClassifier(n_neighbors=5),
    'Decision Tree': DecisionTreeClassifier(random_state=42),
    'Logistic Regression': LogisticRegression(max_iter=200)
}

for name, model in models.items():
    model.fit(X_train, y_train)
    y_pred = model.predict(X_test)
    acc = accuracy_score(y_test, y_pred)
    print(f"{name}: {acc * 100:.1f}% accuracy")

import math

def nearest_neighbor(X_train, y_train, new_point):
    min_dist = float('inf')
    predicted_label = None
    for x, y in zip(X_train, y_train):
        dist = math.sqrt(sum((a - b) ** 2 for a, b in zip(x, new_point)))
        if dist < min_dist:
            min_dist = dist
            predicted_label = y
    return predicted_label

# Training data: [height, weight] -> category
X_train = [[150, 50], [160, 60], [170, 70], [180, 80]]
y_train = ['Short', 'Medium', 'Tall', 'Very Tall']

new_person = [165, 62]
prediction = nearest_neighbor(X_train, y_train, new_person)
print(f"Person with height=165, weight=62: {prediction}")

import numpy as np
import math

point1 = [1, 2, 3]
point2 = [4, 5, 6]

# Method 1: Manual calculation
manual_dist = math.sqrt(sum((a - b) ** 2 for a, b in zip(point1, point2)))
print(f"Manual distance: {manual_dist:.4f}")

# Method 2: Using NumPy
p1 = np.array(point1)
p2 = np.array(point2)
numpy_dist = np.linalg.norm(p1 - p2)
print(f"NumPy distance: {numpy_dist:.4f}")

import numpy as np

marks = np.array([85, 42, 91, 38, 76, 55, 67, 29])
labels = np.array(['Pass', 'Fail', 'Pass', 'Fail', 'Pass', 'Pass', 'Pass', 'Fail'])

for mark, label in zip(marks, labels):
    print(f"Marks: {mark} -> {label}")

print(f"\nPass count: {np.sum(labels == 'Pass')}")
print(f"Fail count: {np.sum(labels == 'Fail')}")