UNITED INSTITUTE OF TECHNOLOGY

Periyanaickenpalayam, Coimbatore- 641 020.

AD8311 DATA SCIENCE LABORATORY

DEPARTMENT OF
COMPUTER SCIENCE AND ENGINEERING
 INDEX

EX.NO DATE NAME OF THE EXPERIMENT PAGE Faculty

NO. sign

Download Install and Explore the features

1 3
of Numpy,Scipy,Jupyter,Statsmodels and Pandas
Packages

2 Working With Numpy Arrays 6

3 Working With Pandas Data Frames 9

Implementation Of Various Data Sampling

4 12
Methods Using Python

Reading Data from text files ,Excel and the web and
5 exploring various commands for doing descriptive 15
analytics on the IRIS Dataset

Implementation Of Classification And

6 17
Clustering Of Data Using
Python

Use The Diabetes Data Set From Uci

7 20
And Pima Indians Diabetes Data Set
Performing The Following

Apply And Explore Various Plotting Functionson

8 26
Uci Data Sets

9 Visualizing Geographic Data With Basemap 29

10 Arithmetic Operation Between Two Panda 31

Series

11 33
Scatter Plots In Python Using Pokemon
EX.NO: 1 DOWNLOAD INSTALL AND EXPLORE THE FEATURES OF
DATE: NUMPY,SCIPY, JUPYTER, STATSMODELS AND PANDAS PACKAGES.

AIM:
To download, install and explore the features of Numpy, Scipy, Jupyter, Statsmodels and
pandas packages.

ALGORITHM:
Step 1: Go to Command prompt.
Step 2: Type pip install Numpy.
Step3: Numpy packages have been installed.
Step 4: Type pip Scipy, Scipy packages get installed.
Step 5: Type pip install Jupyter, Jupyter packages get installed.
Step 6: Type pip install Statsmodel, the packages get installed.
Step 7: Type pip install pandas, the packages get installed.

INSTALLATION PROCESS:
Numpy Installation: pip install numpy
Scipy Installation: pip install scipy

Jupyter Installation: pip install jupyter

 Statsmodels installation: pip install statsmodels

pi Pandas installation:

RESULT:
Thus the working with commands executed successfully.
EX: NO: 2 WORKING WITH NUMPY ARRAY

DATE:

AIM:
Write a python code to implement the concept of Numpy arrays.

ALGORITHM:

Step 1: Import the NumPy library using the import statement.

Step 2:Define the input data that you want to work with. You can do this by either creating
a NumPy array or loading data from a file.
Step 3:Perform any necessary operations on the data. This may include things like
calculating statistics, manipulating the data, or applying filters.
Step 4:Display the results of your operations. This could be as simple as printing out the
result to the console, or it could involve creating a visualization of the data.

PROGRAM:

import numpy as np

# Creating a 1-D NumPy

array arr1d = np.array([1, 2, 3,
4, 5]) print("1-D Array:")
print(arr1d)

# Creating a 2-D NumPy array

arr2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print("2-D
Array:")
print(arr2d)

# Creating a random 1-D NumPy array

rand_arr = np.random.rand(5)
print("Random Array:")
print(rand_arr)

# Performing element-wise multiplication of two NumPy arrays

arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5,
6]) result = arr1 * arr2
print("Element-wise
multiplication:") print(result)

# Performing matrix multiplication of two NumPy arrays

mat1 = np.array([[1, 2], [3, 4]])
mat2 = np.array([[5, 6], [7, 8]])
result = np.matmul(mat1,
mat2)

print("Matrix
multiplication:") print(result)

# create a 1D NumPy
array a = np.array([1, 2, 3,
4, 5]) print(a)

# create a 2D NumPy array

b = np.array([[1, 2, 3], [4, 5, 6]])
print(b)

# use NumPy functions to perform operations on

arrays g = np.sum(b)
h=
np.mean(b) i =
np.max(b)
j = np.min(b)

# print the
results print(g)
print(h
)
print(i)
print(j)

OUTPUT:

1-D Array:
[1 2 3 4 5]
2-D Array:
[[1 2 3]
[4 5 6]
[7 8 9]]
Random Array:
[0.21995867 0.92288075 0.69384057 0.7043604 0.80637838]
Element-wise
multiplication: [ 4 10 18]
Matrix
multiplication: [[19
22]
[43 50]]
[1 2 3 4 5]
(5,)
[[1 2 3]
[4 5 6]]
(2,3)

21
3.5
6
1

RESULT:
Thus the working with numpy array was completed successfully
.
EXP:3 WORKING WITH PANDAS DATA
DATE:

AIM:
Write a python code to implement the concept of Pandas Data frames.

ALGORITHM:
Step 1: Import pandas library
Step 2: Load data into a DataFrame.
Step 3: Explore the DataFrame
Step 4: Selecting data.
Step 5: Manipulating data
Step 6: Cleaning data
Step 7: Saving the modified DataFrame

Pandas Data Frame is two-dimensional size-mutable, potentially heterogeneous.

Tabular data structure with labelled axes (rows and columns). A data frame is
a two-dimensional data structure i.e. data is aligned in a tabular fashion in
rows and columns. Pandas Data frame consists of three principle
components the data, rows and columns.

PROGRAM:

import pandas as pd

# create a sample dataframe

data = {'Name': ['John', 'Jane', 'Bob',
'Mary'], 'Age': [30, 25, 40, 35],
'Gender': ['M', 'F', 'M', 'F']}
df = pd.DataFrame(data)

# print the
dataframe print(df)

# select specific
columns
print(df[['Name',
'Age']])

# filter rows based on a

condition print(df[df['Age'] >
30])

# add a new column

df['Salary'] = [50000, 60000, 70000, 80000]
print(df)

# drop a column
df = df.drop('Gender',
axis=1) print(df)

# group by a column and calculate statistics

grouped = df.groupby('Gender')

#Creating a data frame using List:

# Create a list of dictionaries

data = [{'Name': 'Alice', 'Age': 25, 'Gender': 'Female'},
{'Name': 'Bob', 'Age': 30, 'Gender': 'Male'},
{'Name': 'Charlie', 'Age': 35, 'Gender': 'Male'},
{'Name': 'David', 'Age': 40, 'Gender': 'Male'},
{'Name': 'Eve', 'Age': 45, 'Gender': 'Female'}]

# Create a DataFrame from the

list df = pd.DataFrame(data)

# Print the
DataFrame print(df)

OUTPUT:

Name Age
Gender 0 John 30
M
1 Jane 25 F
2 Bob 40 M
3 Mary 35 F

Name Ag
0 John e
30
1 Jane 25
2 Bob 40
3 Mary 35
 Name Age Gender
2 Bob 40 M
3 Mary 35 F

Name Age Gender Salary

0 John 30 M 50000
1 Jane 25 F 60000
2 Bob 40 M 70000
3 Mary 35 F 80000

Age
Salary
Gender
F 30.0 70000.0
M 35.0 60000.0

Name Age Salary

Gender
F Mary 35 80000
M John 40 70000

Name Age Salary

0 John 30 50000
1 Jane 25 60000
2 Bob 40 70000
3 Mary 35 80000

RESULT: Thus the working with pandas Data Frame was completed successfully.
 EXP NO:4 IMPLEMENTATION OF VARIOUS DATA
DATE : SAMPLING METHODS USING

AIM:
Write a python code to implement the data sampling method.

ALGORITHM:
Step 1: import pandas.
Step 2: get data
Step 3: start by generating a sample dataset with two columns, 'A' and 'B'.
We then implement four different sampling methods:
● Simple random sampling: We use the sample() method from the Pandas library to
randomly select 30 rows from the dataset.
● Systematic sampling: We select every 10th row of the dataset using Python's slicing syntax.
● Stratified sampling: We group the dataset by quantiles of the 'B' column
using the groupby() method from Pandas. We then select a random sample of 20% of rows
from each group using the sample() method.
● Cluster sampling: We randomly select 5 clusters of rows from the 'A' column and include all
rows with those values using the apply() method.
Step 4:Finally, we output the results for each sampling method using the print() function.

PROGRAM

import random
import numpy as
np import pandas
as pd

# Generate a sample dataset

data = pd.DataFrame({'A': range(1, 101), 'B': np.random.rand(100)})

# Simple random sampling

simple_random_sample =
data.sample(n=30)

# Systematic sampling
systematic_sample = data.iloc[::10,
:]

# Stratified sampling
strata = data.groupby(pd.qcut(data['B'], 3))
stratified_sample = strata.apply(lambda x: x.sample(frac=0.2))

# Cluster sampling
clusters = np.random.choice(range(1, 11), size=5, replace=False)
cluster_sample = data[data['A'].apply(lambda x: x in clusters)]

# Output the results

print('Simple random sample:\n', simple_random_sample)
print('\nSystematic sample:\n', systematic_sample)
print('\nStratified sample:\n', stratified_sample)
print('\nCluster sample:\n', cluster_sample)

OUTPUT:
Simple random sample:
A B
79 80 0.878277
40 41 0.639264
57 58 0.897447
58 59 0.600354
13 14 0.661578
95 96 0.246993
7 8 0.934867
94 95 0.812213
24 25 0.837017
49 50 0.186842
0 1 0.940231
42 43 0.394464
33 34 0.793838
60 61 0.181043
54 55 0.190086
56 57 0.773640
74 75 0.228341
4 5 0.514767
34 35 0.640982
87 88 0.102709
53 54 0.594242
23 24 0.689938
72 73 0.800255
52 53 0.898425
65 66 0.530389
61 62 0.322569
77 78 0.029112
80 81 0.596407
35 36 0.699136
99 100 0.637643

Systematic
sample: A
B
0 1 0.940231
10 11 0.721191
20 21 0.242574
30 31 0.275564
40 41 0.639264
50 51 0.663985
60 61 0.181043
70 71 0.409256
 80 81 0.596407
90 91 0.133356

Stratified sample:
A B
B
(0.012400000000000001, 0.334] 60 61 0.181043
69 70 0.177240
96 97 0.124787
87 88 0.102709
19 20 0.122518
31 32 0.118424
93 94 0.152851
(0.334, 0.641] 42 43 0.394464
80 81 0.596407
14 15 0.444850
83 84 0.633580
75 76 0.475987
82 83 0.416136
66 67 0.340407
(0.641, 0.967] 44 45 0.814840
28 29 0.836442
46 47 0.680723
32 33 0.653128
57 58 0.897447
86 87 0.837541
10 11 0.721191

Cluster sample:
A B
2 3 0.621991
3 4 0.576675
4 5 0.514767
6 7 0.308789
9 10 0.013366

RESULT:Thus the implementation of sampling method executed successfully.

 EX: NO: 5 READING DATA FROM TEXT FILES, EXCEL AND THE
DATE: WEB AND EXPLORING VARIOUS COMMANDS FOR
DOING DESCRIPTIVE ANALYTICS ON THE IRIS DATA SET

AIM:
To Read the data from text files, Excel and the web and exploring various commands for doing
descriptive analytics on the Iris data set.

ALGORITHM:

Step 1: Import the pandas library as pd and the requests library.

Step 2: From the io library, import the BytesIO function.
Step 3: Read data from a text file called iris.txt using the pd.read_csv() function. Assign
the resulting DataFrame to iris_txt. The file has no header row, so header=None is passed as an
argument. The column names are specified as a list of strings using the names argument.
Step 4: Read data from an Excel file called iris.xlsx using the pd.read_excel() function.
Assign the resulting DataFrame to iris_excel.
Step 5: Read data from a CSV file from the web using the requests.get() function to
retrieve the file contents, and then pass the contents to the pd.read_csv() function using BytesIO to create
a file-like object. Assign the resulting DataFrame to iris_web. The file has no header row, so
header=None is passed as an argument. The column names are specified as a list of strings using the
names argument.
Step 6: Concatenate the three DataFrames using pd.concat(), and assign the result to iris.
ignore_index=True is passed as an argument to reset the index of the concatenated DataFrame.
Step 7: Display the descriptive statistics of the entire dataset using iris.describe().
Step 8:Group the data by species and display the mean values for each species using
iris.groupby('species').mean().
Step 9: Create a box plot for each variable by species using iris.boxplot(by='species',
figsize=(10, 8)).

PROGRAM:

import pandas as pd import requests

from io import BytesIO

# Read data from web

url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data'
response = requests.get(url)
iris_web = pd.read_csv(BytesIO(response.content),
header=None,
names=['sepal_length', 'sepal_width', 'petal_length', 'petal_width', 'species'])

# Display descriptive statistics

print('Descriptive statistics for Iris
dataset:')
print(iris_web.describe())

# Group data by species and display mean values

print('\nMean values for each species:')
print(iris_web.groupby('species').mean())

OUTPUT:

sepal_length sepal_width petal_length petal_width

count 150.000000 150.000000 150.000000
150.000000
mean 5.843333 3.054000 3.758667 1.198667
std 0.828066 0.433594 1.764420 0.763161
min 4.300000 2.000000 1.000000 0.100000
25% 5.100000 2.800000 1.600000 0.300000
50% 5.800000 3.000000 4.350000 1.300000
75% 6.400000 3.300000 5.100000 1.800000
max 7.900000 4.400000 6.900000 2.500000

Mean values for each species:

sepal_length sepal_width petal_length petal_width
species
Iris-setosa 5.006 3.418 1.464 0.244
Iris-versicolor 5.936 2.770 4.260 1.326
Iris-virginica 6.588 2.974 5.552 2.026

RESULT:Thus the program was executed successfully.

AIM:

Implementation of classification and clustering of data using python

ALGORITHM:

Step 1: Import the necessary libraries:

● pandas for data manipulation
● matplotlib.pyplot for data visualization
● sklearn.datasets for loading the iris dataset
● sklearn.model_selection for splitting the data into training and testing sets
● sklearn.neighbors for k-nearest neighbors classification
● sklearn.cluster for k-means clustering
Step 2: Load the iris dataset using the load_iris() function and create a pandas dataframe from
the data.
Step 3: Add a column to the dataframe that maps the target values (0, 1, 2) to the
corresponding species names ('setosa', 'versicolor', 'virginica').
Step 4:Split the data into training and testing sets using the train_test_split() function.
Step 5: Create a k-nearest neighbors classifier object with k=3 using the
KNeighborsClassifier() function.
Step 6: Train the classifier on the training data using the fit() method.
Step 7: Print the accuracy of the classifier on the testing set using the score() method.
Step 8: Create a k-means clustering object with k=3 using the KMeans() function.
Step 9: Train the clustering algorithm on the data using the fit() method.
Step 10: Add a new column to the dataframe that contains the cluster labels assigned by
the k-means algorithm.
Step 11: Map each cluster label to a color and add a new column to the dataframe that
contains the corresponding color.
Step 12: Visualize the clusters using a scatter plot, where the x-axis is the petal length and the
y-axis is the petal width. Use the color column to color-code the points according to their
cluster.
PROGRAM :

import pandas as pd
from sklearn.datasets import load_iris

from sklearn.model_selection import train_test_split

from sklearn.neighbors import
KNeighborsClassifier from sklearn.cluster import
KMeans
import matplotlib.pyplot as plt

# Load the iris

dataset iris =
load_iris()

# Create a Pandas DataFrame of the iris data

df = pd.DataFrame(data=iris.data, columns=iris.feature_names)

# Print the first 5 rows of the

dataset print(df.head())

# Split the dataset into training and testing data

X_train, X_test, y_train, y_test = train_test_split(df, iris.target, test_size=0.2)

# Implement classification using K-Nearest Neighbors

knn = KNeighborsClassifier(n_neighbors=3)
knn.fit(X_train, y_train)
print('Accuracy:', knn.score(X_test, y_test))

# Implement clustering using K-Means

kmeans = KMeans(n_clusters=3, random_state=0)
kmeans.fit(X_train)
y_pred = kmeans.predict(X_test)
plt.scatter(X_test.iloc[:, 0], X_test.iloc[:, 1],
c=y_pred) plt.title('K-Means Clustering')
plt.xlabel('Sepal
Length')
plt.ylabel('Sepal Width')
plt.show()
 OUTPUT:

sepal length (cm) sepal width (cm) petal length (cm) petal width (cm)
0 5.1 3.5 1.4 0.2
1 4.9 3.0 1.4 0.2
2 4.7 3.2 1.3 0.2
3 4.6 3.1 1.5 0.2
4 5.0 3.6 1.4 0.2
Accuracy: 0.9333333333333333

RESULT:Thus the implementation of classification and clustering successfully completed.

EX: NO: 7 USE THE DIABETES DATA SET FROM UCI AND PIMA
DATE: INDIANS DIABETES DATA SET PERFORMING THE FOLLOWING

AIM:

To use the diabetes data set from UCI and Pima Indians diabetes data set performing the
following.
a) Implement Univariate analysis: Frequency, Mean, Median, Mode, Variance, Standard
Deviation, Skewness and Kurtosis from UCI dataset.
b) Bivariate analysis: Linear and Logistic Regression Modeling.
c) Multiple Regression Analysis.

ALGORITHM:
Step 1: Download the Pima Indians Diabetes dataset
Link: https://www.kaggle.com/datasets/uciml/pima-indians-diabetes-
database?resource=download
Step 2: Install Packages.
Step 3: Open the pycharm and type the following Commands.
Step 4: The output will display.

PROGRAM:
a) Univariate analysis: Frequency, Mean, Median, Mode, Variance, Standard
Deviation, Skewness and Kurtosis.

import pandas as
pd import numpy
as np
from scipy.stats import skew, kurtosis
import statistics as st

# Load the UCI diabetes dataset

diabetes_df =
pd.read_csv('diabetes.csv')

# Calculate descriptive statistics for each column

for col in diabetes_df.columns:
freq = diabetes_df[col].value_counts()

# Mean
mean =diabetes_df[col].mean()

# Median
median = diabetes_df[col].median()

# Mode
mode = diabetes_df[col].mode()
# Variance
variance = diabetes_df[col].var()

# Standard deviation
std_dev = diabetes_df[col].std()
# Skewness skewness =
skew(diabetes_df[col])

# Kurtosis
kurt = kurtosis(diabetes_df[col])

# Print the results

print('Column:', col)
print('Frequency:', freq)
print('Mean:', mean)
print('Median:', median)
print('Mode:', mode)
print('Variance:', variance)
print('Standard Deviation:',
std_dev) print('Skewness:',
skewness) print('Kurtosis:', kurt)
print(' ')
print(df.shape
)
print(df.info()
)
print(df.mean())
print(df.median()
) print(df.mode())
print(df.std())
print(df.var())
print(df.skew())

Output:
Column: Outcome
Frequency:
Outcome 0 500
1 268
Name: count, dtype: int64
Mean:
0.3489583333333333
Median: 0.0
Mode: 0 0
Name: Outcome, dtype: int64
Variance:
0.22748261625380273
Standard Deviation: 0.47695137724279896
Skewness: 0.6337757030614577
Kurtosis: -1.5983283582089547

(768, 9)
<class
'pandas.core.frame.DataFrame'>
RangeIndex: 768 entries, 0 to 767
Data columns (total 9 columns):
# Column Non-Null Count Dtype
0 Pregnancies 768 non-null int64
1 Glucose 768 non-null int64
2 BloodPressure 768 non-null int64
3 SkinThickness 768 non-null int64
4 Insulin 768 non-null int64
5 BMI 768 non-null float64
6 DiabetesPedigreeFunction 768 non-null float64
7 Age 768 non-null int64
8 Outcome 768 non-null int64
dtypes: float64(2), int64(7)
memory usage: 54.1
KB None
Pregnancies 3.845052
Glucose 120.894531
BloodPressure 69.105469
SkinThickness 20.536458
Insulin 79.799479
BMI 31.992578
DiabetesPedigreeFunction 0.471876
Age 33.240885
Outcome 0.348958
dtype: float64
Pregnancies 3.0000
Glucose 117.0000
BloodPressure 72.0000
SkinThickness 23.0000
Insulin 30.5000
BMI 32.0000
DiabetesPedigreeFunction 0.3725
Age 29.0000
Outcome 0.0000
dtype: float64
Pregnancies Glucose BloodPressure SkinThickness Insulin BMI \ 0
1.0 99 70.0 0.0 0.0 32.0
1 NaN 100 NaN NaN NaN NaN

DiabetesPedigreeFunction Age Outcome

0 0.254 22.0 0.0
1 0.258 NaN
NaN Pregnancies
3.369578
Glucose 31.972618
BloodPressure 19.355807
SkinThickness 15.952218
Insulin 115.244002
BMI 7.884160
DiabetesPedigreeFunction 0.331329
Age 11.760232
Outcome 0.476951
dtype: float64
Pregnancies 11.354056
Glucose 1022.248314
BloodPressure 374.647271
SkinThickness 254.473245
Insulin 13281.180078
BMI 62.159984
DiabetesPedigreeFunction 0.109779
Age 138.303046
Outcome 0.227483
dtype: float64
Pregnancies 0.901674
Glucose 0.173754
BloodPressure -1.843608
SkinThickness 0.109372
Insulin 2.272251
BMI -0.428982
DiabetesPedigreeFunction 1.919911
Age 1.129597
Outcome 0.635017
dtype: float64

7 b) Bivariate Analysis: Linear and Logistic Regression Modeling

PROGRAM:
diabetes =
datasets.load_diabetes()
diabetes.keys()
df=pd.DataFrame(diabetes['data'],columns=diabetes['feature_names'])
x=df
y=diabetes['target']
from sklearn.model_selection import train_test_split
#to split our data into training and testing set
x_train,x_test,y_train,y_test = train_test_split(x,y,test_size = 0.3,random_state = 101)
#splitting our data

from sklearn import linear_model

model=linear_model.LinearRegression()
model.fit (x_train,y_train) #Training data is used always
#prediction of testset result of the Prepared Model
y_pre=model.predict(x_test) #puts the test feature value to get the label value which are
predicted by the mode

from sklearn.model_selection import cross_val_score #importing

scores=cross_val_score(model,x,x,scoring="neg_mean_squared_error",cv=10
) rmse_scores=np.sqrt(-scores).mean()
rmse_scores

from sklearn.metrics import mean_squared_error

rms=mean_squared_error(y_test,y_pre,squared=False)
mse=mean_squared_error(y_test,y_pre)
rmse=np.sqrt(mse)
rmse

print("\nWeights :",model.coef_)
print("\nIntercept",model.intercept_)
 Output:

Weights : [ -8.02358048 -308.83941066 583.63743356 299.99074281 -360.66454462

95.11692608 -93.03587104 118.15977759 662.11309186 26.07805489]

Intercept 153.72032548545178

LOGISTIC REGRESSION:

PROGRAM:
import matplotlib.pyplot as
plt import numpy as np
import pandas as pd
from sklearn import datasets,linear_model
from sklearn.metrics import
mean_squared_error
diabetes=datasets.load_diabetes()
diabetes.keys()
df=pd.DataFrame(diabetes['data'],columns=diabetes['fea
ture_names'])
x=df
y=diabetes['target']

from sklearn.model_selection import train_test_split

x_train,x_test,y_train,y_test=train_test_split(x,y,test_siz
e=0.3,random_state=101)

from sklearn import linear_model

model=linear_model.LinearRegression()
model.fit(x_train,y_train)
y_pre=model.predict(x_test)

from sklearn.model_selection import cross_val_score

scores=cross_val_score(model,x,y,scoring="neg_mean_
squared_error",cv=10)
rmse_scores=np.sqrt(-scores).mean(
) print('Cross
validation:',rmse_scores)

from sklearn.metrics import r2_score

print('r^2:',r2_score(y_test,y_pre))
mse=mean_squared_error(y_test,y_pre)
rmse=np.sqrt(mse)
print('RMSE:',rmse)
print("Weights:",model.coef_)
print("\nIntercept",model.intercept_)
Output:
r^2 : -0.44401265478624397
RMSE : 94.65723681369009

7 c) MULTIPLE REGRESSION ANALYSIS.

ALGORITHM:
Step 1: Import
Libraries. Step 2: Import
dataset.
Step 3: Define x and y.
Step 4: Train the model on the training set.
Step 5: Predict the test set results.
Step 6: Evaluate the
model.
Step 7: Plot the results.
PROGRAM:

import matplotlib.pyplot as
plt import numpy as np
import pandas as pd
from sklearn import datasets
from sklearn.metrics import
mean_squared_error from sklearn.linear_model
import LogisticRegression
diabetes=datasets.load_diabetes()
diabetes.keys()
df.head()
df=pd.DataFrame(diabetes['data'],columns=diabetes[
'feature_names'])
x=df
y=diabetes['target']
from sklearn.model_selection import
train_test_split
x_train,x_test,y_train,y_test=train_test_split(x,y,test
_size=0.3,random_state=101)
reg =linear_model.LinearRegression()
reg.fit(x_train,y_train)
y_predict=reg.predict(x_test)
print('\ncoefficients :' ,reg.coef_)
print('\nVariance
score:{}',format(reg.score(x_test,y_test)))
from sklearn.metrics import r2_score
print('r^2 :' ,r2_score(y_test,y_predict))
from sklearn.metrics import mean_squared_error
mse=mean_squared_error(y_test,y_predict)
rmse=np.sqrt(mse)
 print('\nRMSE :',rmse)
Output:
coefficients : [ -8.02358048 -308.83941066 583.63743356 299.99074281 -360.66454462
95.11692608 -93.03587104 118.15977759 662.11309186 26.07805489]

Variance score:{} 0.45767579788519963

r^2 : 0.45767579788519963

RMSE : 58.00932552866432

RESULT:
Thus the program was executed successfully.
AIM:
To apply and explore various plotting functions on
UCI data sets.
a) Normal Curves.
b) Density and Contour Plots.
c) Correlation and Scatter Plots.
d) Histograms.
e) Three Dimensional Plotting.

ALGORITHM:
Step 1: Download Heart dataset from kaggle.
Link: https://www.kaggle.com/datasets/zhaoyingzhu/heartcsv
Step 2: Save that in downloads or any other Folder and install packages.
Step 3: Apply these following commands on the dataset.
Step 4: The Output will display.

PROGRAM:

import pandas as pd
import matplotlib.pyplot as plt

# Load the dataset

data_url = "https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data"
names = ['sepal-length', 'sepal-width', 'petal-length', 'petal-width', 'class']
dataset = pd.read_csv(data_url, names=names)

# Plot a histogram of sepal length

plt.hist(dataset['sepal-length'],
bins=10) plt.xlabel('Sepal Length')
plt.ylabel('Frequency')
plt.title('Histogram of Sepal Length')
plt.show()

# Plot a scatter plot of sepal length vs sepal width

plt.scatter(dataset['sepal-length'],
dataset['sepal-width']) plt.xlabel('Sepal Length')
plt.ylabel('Sepal Width')
plt.title('Scatter Plot of Sepal Length vs Sepal Width')
# Plot a box plot of petal length for each class
dataset.boxplot(column='petal-length', by='class')
plt.title('Box Plot of Petal Length for Each
Class') plt.xlabel('Class')
plt.ylabel('Petal
Length') plt.show()

# Plot a bar chart of the mean petal width for each class
class_means = dataset.groupby('class')['petal-width'].mean()
class_means.plot(kind='bar')
plt.title('Mean Petal Width for Each Class')
plt.xlabel('Class')
plt.ylabel('Mean Petal
Width')
plt.show()

OUTPUT:
RESULT:
Thus the program was executed successfully.
AIM:
To create an insight Geographic Data with Basemap.

ALGORITHM:
Step 1: Install Basemap. The zip file occurs extract the original file.
Step 2: import Packages.
Step3: Save that in downloads or any other Folder.
Step 4: Apply these following commands.
Step 5: The Output will display.

PROGRAM & OUTPUT:

%matplotlib inline
import numpy as
np
import matplotlib.pyplot as plt
from mpl_toolkits.basemap import Basemap

plt.figure(figsize=(8, 8))
m = Basemap(projection='ortho', resolution=None, lat_0=50, lon_0=-100)
m.bluemarble(scale=0.5);

fig = plt.figure(figsize=(8, 8))

m = Basemap(projection='lcc', resolution=None,
width=8E6, height=8E6,
lat_0=45, lon_0=-100,)

m.etopo(scale=0.5,

alpha=0.5)

# Map (long, lat) to (x, y) for

plotting x, y = m(-122.3, 47.6)
plt.plot(x, y, 'ok', markersize=5)
plt.text(x, y, ' Seattle',
fontsize=12);
OUTPUT:

RESULT:

Thus the program was executed successfully.

AIM
To write a python program to perform arithmetic operation between two panda series

ALGORITHM
STEP 1: Start
STEP 2: Import pandas package
STEP 3: Initialise ds1 and ds2
STEP 4: For addition, calculate ds1+ds2
STEP 5: For subtraction, calculate ds1-ds2
STEP 6: For multiplication, calculate
ds1*ds2 STEP 7: For division, calculate
ds1/ds2 STEP 8: Print the desired results
STEP 9: Stop

PROGRAM

import pandas as pd
ds1=pd.Series([2,4,6,8,10])
ds2=pd.Series([1,3,5,7,9])
print("Add two series")
ds=ds1+ds2
print(ds)
print("Subtract two
series") ds=ds1-ds2
print(ds)
print("Multiply two
series") ds=ds1*ds2
print(ds)
print("Divide two
series") ds=ds1/ds2
print(ds)
 OUTPUT

Add two
series 0 3
1 7
2 11
3 15
4 19
dtype: int64
Subtract two
series 0 1
1 1
2 1
3 1
4 1
dtype: int64
Multiply two
series 0 2
1 12
2 30
3 56
4 90
dtype: int64
Divide two
series 0
2.000000
1 1.333333
2 1.200000
3 1.142857
4 1.111111
dtype: float64

RESULT:Thus the program to perform arithmetic operations between two panda

series has been executed successfully
EX: NO: 11 SCATTER PLOTS IN PYTHON USING POKEMON

DATE: DATASET

AIM
To perform a scatter plots in Python, using Matplotlib and Seaborn library with Pokemondataset.

ALGORITHM:
Step 1: Download pokemon dataset from kaggle.
Link: https://www.kaggle.com/datasets/rounakbanik/pokemon
Step 2: Save that in downloads or any other Folder and install packages.
Step 3: Apply these following commands on the dataset.
Step 4: The Output will display.

PROGRAM:
import numpy as
np import pandas
as pd
import matplotlib.pyplot as
plt import seaborn as sns
data =
pd.read_csv("pokemon.csv")
data.shape
data.head()
g1 =
data.loc[data.generation==1,:] #
dataframe.plot.scatter() method
g1.plot.scatter('attack', 'defense');
# The ';' is to avoid showing a message before showing t e plot
# plt.scatter() function
plt.scatter('attack', 'defense', data=g1);
g1.plot.scatter('attack', 'defense', s = 40, c = 'orange', marker = 's', figsize=(8,5.5));
plt.figure(figsize=(10,7)) # Specify size of the chart
plt.scatter('attack', 'defense', data=data[data.is_legendary==1], marker = 'x', c = 'magenta')
plt.scatter('attack', 'defense', data=data[data.is_legendary==0], marker = 'o', c = 'blue')
plt.legend(('Yes', 'No'), title='Is legendary?')
plt.show()
plt.figure(figsize=(10,7))
sns.scatterplot(x = 'attack', y = 'defense', s = 70, hue ='is_legendary', data=data);
# hue represents color
plt.figure(figsize=(10,7))
sns.scatterplot(x = 'attack', y = 'defense', s = 50, hue = 'is_legendary', style ='is_legendary',
data=data);
# style represents
marker
plt.figure(figsize=(11,7))
sns.scatterplot(x = 'attack', y = 'defense', s = 50, hue = 'type1', data=data)
plt.legend(bbox_to_anchor=(1.02, 1))
# move legend to outside of the chart
plt.title('Defense vs Attack for All Pokemons', fontsize=16)
plt.xlabel('Attack', fontsize=12)
plt.ylabel('Defense', fontsize=12)
plt.show()

water = data[data.type1 == 'water']

water.plot.scatter('height_m', 'weight_kg',
figsize=(10,6)) plt.grid(True) # add gridlines
plt.show()
water.plot.scatter('height_m', 'weight_kg', figsize=(10,6))
plt.grid(True)
for index, row in water.nlargest(5, 'height_m').iterrows():
plt.annotate(row['name']) # text to show
xy = (row['height_m'], row['weight_kg']), # the point to annotate
xytext = (row['height_m']+0.2, row['weight_kg']),
# where to show the text fontsize=12)
plt.xlim(0, ) # x-axis has minimum 0
plt.ylim(0, ) # y-axis has minimum 0
plt.show()
RESULT: Thus the above program was executed successfully.