1.
) Write a Python program to prepare Scatter Plot (Use Forge Dataset / Iris Dataset)
import [Link] as plt
from [Link] import load_iris
import pandas as pd
# Load Iris dataset
iris = load_iris()
df = [Link](data=[Link], columns=iris.feature_names)
df['target'] = [Link]
# Scatter plot of sepal length vs sepal width
[Link](figsize=(8,6))
for target, color in zip([0,1,2], ['red', 'green', 'blue']):
subset = df[df['target'] == target]
[Link](subset['sepal length (cm)'], subset['sepal width (cm)'],
label=iris.target_names[target], c=color)
[Link]('Sepal Length (cm)')
[Link]('Sepal Width (cm)')
[Link]('Scatter Plot of Iris Dataset')
[Link]()
[Link]()
2.) Write a Python program to find all null values in a given data set and remove them.
import pandas as pd
# Example dataset with nulls
data = {'A':[1,2,None,4], 'B':[5,None,7,8]}
df = [Link](data)
print("Before removing nulls:\n", df)
# Drop null values
df_clean = [Link]()
print("\nAfter removing nulls:\n", df_clean)
3.) Write a Python program to map the categorical values in numeric format for a given
dataset.
import pandas as pd
data = {'Name':['Tom','Jerry','Mickey','Donald'],
'Gender':['Male','Male','Male','Male'],
'Category':['A','B','A','C']}
df = [Link](data)
print("Before encoding:\n", df)
# Convert categorical to numeric using factorize
df['Category_encoded'] = [Link](df['Category'])[0]
print("\nAfter encoding:\n", df)
4.) Write a Python program to implement simple Linear Regression for predicting house
price.
import pandas as pd
from sklearn.linear_model import LinearRegression
# Example dataset
data = {'Size':[1000,1500,2000,2500,3000],
'Price':[150000,200000,250000,300000,350000]}
df = [Link](data)
X = df[['Size']]
y = df['Price']
model = LinearRegression()
[Link](X,y)
print("Coefficient:", model.coef_)
print("Intercept:", model.intercept_)
# Predict price for 2800 sq ft house
print("Predicted price:", [Link]([[2800]])[0])
5.) Write a Python program to implement multiple Linear Regression for a given dataset.
import pandas as pd
from sklearn.linear_model import LinearRegression
data = {'Size':[1000,1500,2000,2500,3000],
'Bedrooms':[2,3,3,4,5],
'Price':[150000,200000,250000,300000,350000]}
df = [Link](data)
X = df[['Size','Bedrooms']]
y = df['Price']
model = LinearRegression()
[Link](X,y)
print("Coefficients:", model.coef_)
print("Intercept:", model.intercept_)
print("Prediction:", [Link]([[2800,4]])[0])
6.) Write a Python program to implement Polynomial Regression for a given dataset.
import numpy as np
import [Link] as plt
from sklearn.linear_model import LinearRegression
from [Link] import PolynomialFeatures
# Dataset
X = [Link]([1,2,3,4,5,6]).reshape(-1,1)
y = [Link]([1,4,9,16,25,36])
poly = PolynomialFeatures(degree=2)
X_poly = poly.fit_transform(X)
model = LinearRegression()
[Link](X_poly, y)
# Prediction
y_pred = [Link](X_poly)
[Link](X,y,color='red')
[Link](X,y_pred,color='blue')
[Link]("Polynomial Regression")
[Link]()
7.) Write a Python program to implement Naïve Bayes.
from [Link] import load_iris
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
from [Link] import accuracy_score
iris = load_iris()
X, y = [Link], [Link]
X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.3,random_state=42)
model = GaussianNB()
[Link](X_train, y_train)
y_pred = [Link](X_test)
print("Accuracy:", accuracy_score(y_test,y_pred))
8.) Write a Python program to implement Decision Tree (whether or not to play tennis).
import pandas as pd
from [Link] import DecisionTreeClassifier, plot_tree
import [Link] as plt
# Tennis dataset
data = {'Outlook':
['Sunny','Sunny','Overcast','Rain','Rain','Rain','Overcast','Sunny','Sunny','Rain','Sunny','Overca
st','Overcast','Rain'], 'Temperature':
['Hot','Hot','Hot','Mild','Cool','Cool','Cool','Mild','Cool','Mild','Mild','Mild','Hot','Mild'],
'Humidity':
['High','High','High','High','Normal','Normal','Normal','High','Normal','Normal','Normal','High
','Normal','High'], 'Wind':
['Weak','Strong','Weak','Weak','Weak','Strong','Strong','Weak','Weak','Weak','Strong','Strong','
Weak','Strong'],
'PlayTennis':['No','No','Yes','Yes','Yes','No','Yes','No','Yes','Yes','Yes','Yes','Yes','No']
}
df = [Link](data)
X = pd.get_dummies(df[['Outlook','Temperature','Humidity','Wind']])
y = df['PlayTennis']
model = DecisionTreeClassifier()
[Link](X,y)
[Link](figsize=(12,8))
plot_tree(model, feature_names=[Link], class_names=model.classes_, filled=True)
[Link]()
9.) Write a Python program to implement linear SVM.
from sklearn import datasets
from sklearn.model_selection import train_test_split
from [Link] import SVC
from [Link] import accuracy_score
iris = datasets.load_iris()
X, y = [Link], [Link]
X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.3,random_state=42)
model = SVC(kernel='linear')
[Link](X_train, y_train)
y_pred = [Link](X_test)
print("Accuracy:", accuracy_score(y_test,y_pred))
10.) Write a Python program to find decision boundary by using a neural network with 10
hidden units on two moons dataset.
from [Link] import make_moons
from sklearn.neural_network import MLPClassifier
import [Link] as plt
import numpy as np
X, y = make_moons(n_samples=200, noise=0.2, random_state=42)
model = MLPClassifier(hidden_layer_sizes=(10,), max_iter=2000)
[Link](X, y)
# Plot decision boundary
xx, yy = [Link]([Link](X[:,0].min()-1, X[:,0].max()+1, 200),
[Link](X[:,1].min()-1, X[:,1].max()+1, 200))
Z = [Link](np.c_[[Link](), [Link]()])
Z = [Link]([Link])
[Link](xx, yy, Z, alpha=0.5, cmap=[Link])
[Link](X[:,0], X[:,1], c=y, s=30, edgecolor='k')
[Link]("Neural Network Decision Boundary (Two Moons)")
[Link]()
11.) Write a Python program to transform data with Principal Component Analysis (PCA).
from [Link] import load_iris
from [Link] import PCA
import [Link] as plt
iris = load_iris()
X = [Link]
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X)
[Link](X_pca[:,0], X_pca[:,1], c=[Link], cmap='viridis')
[Link]("PC1")
[Link]("PC2")
[Link]("PCA on Iris Dataset")
[Link]()
12.) Write a Python program to implement k-nearest Neighbors ML algorithm to build
prediction model (Use Forge Dataset).
from [Link] import make_classification
from [Link] import KNeighborsClassifier
from sklearn.model_selection import train_test_split
from [Link] import accuracy_score
# Forge-like dataset
X, y = make_classification(n_samples=100, n_features=2, n_classes=2,
n_clusters_per_class=1, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X,y,test_size=0.3,random_state=42)
model = KNeighborsClassifier(n_neighbors=3)
[Link](X_train, y_train)
y_pred = [Link](X_test)
print("Accuracy:", accuracy_score(y_test,y_pred))
13.) Write a Python program to implement k-means algorithm on a synthetic dataset.
from [Link] import make_blobs
from [Link] import KMeans
import [Link] as plt
X, _ = make_blobs(n_samples=300, centers=4, cluster_std=0.6, random_state=0)
kmeans = KMeans(n_clusters=4, random_state=0)
y_kmeans = kmeans.fit_predict(X)
[Link](X[:,0], X[:,1], c=y_kmeans, cmap='rainbow')
[Link](kmeans.cluster_centers_[:,0], kmeans.cluster_centers_[:,1], s=200, c='black',
marker='X')
[Link]("K-Means Clustering")
[Link]()
14.) Write a Python program to implement Agglomerative clustering on a synthetic dataset.
from [Link] import make_blobs
from [Link] import AgglomerativeClustering
import [Link] as plt
X, _ = make_blobs(n_samples=300, centers=3, cluster_std=0.7, random_state=42)
model = AgglomerativeClustering(n_clusters=3)
y_pred = model.fit_predict(X)
[Link](X[:,0], X[:,1], c=y_pred, cmap='rainbow')
[Link]("Agglomerative Clustering")
[Link]()
