Introduction to Machine Learning by MARK

Machine Learning

1. Introduction to ML Presenter: Muhammad Rizwan Khan Usafzai 1

2. NUMpy Library? NumPy : NumPy is a library for the Python programming language, adding support for large, multi-dimensional arrays and matrices, along with a collection of mathematical functions to operate on these arrays. Key Features: Array creation and manipulation Mathematical operations on arrays Linear algebra operations Fourier transforms Random number generation Applications: Scientific computing Data analysis and manipulation Machine learning 2

3. How to install NumPy on Jupyter ? Open the jupyter notebook and type the following code: !pip install numpy Import numpy as np Solve the following code then: n = np.array ((1,2,3)) Print(n) Type of object: Print(type(n)) 3

4. Open cv Library? OpenCV (Open Source Computer Vision Library): OpenCV is an open-source computer vision and machine learning software library. It provides a wide range of functionalities for real-time computer vision, including image and video processing, object detection, face recognition, and more. Key Features: Image and video I/O Image processing algorithms Object detection and tracking Machine learning algorithms for computer vision tasks Applications: Robotics Augmented reality Surveillance systems Medical image analysis 4

5. How to install Open CV on Jupyter ? Open the jupyter notebook and type the following code: !pip install opencv -python import cv2 img = cv2.imread("img1.png") cv2.imshow("MRK", img ) cv2.waitKey(10000) cv2 .destroyAllWindows() 5

6. Matplotlib : Matplotlib is a comprehensive library for creating static, animated, and interactive visualizations in Python. It provides a MATLAB-like interface and supports a wide variety of plots and graphs. Key Features: Line plots, scatter plots, and histograms 2D and 3D plotting Customization of plots Integration with NumPy arrays Applications: Data visualization Scientific plotting Statistical analysis 6

7. How to install Matplotlib on Jupyter ? Open the jupyter notebook and type the following code: !pip install matplotlib Import matplotlib.pyplot as plt // as means alias (named) import numpy as np xpts = np.array ([0,4]) ypts = np.array ([0,6]) plt.plot ( xpts,ypts ) plt.show () 7

8. Skimage scikit -image, commonly abbreviated as skimage , is an open-source image processing library for Python. It provides a collection of algorithms for image division, feature extraction, image filtering, and other image processing tasks Image Processing Integration: It seamlessly integrates with other scientific Python libraries such as NumPy , SciPy, and Matplotlib , allowing for efficient image manipulation and analysis. User-Friendly API Community Support: Skimage benefits from an active community of developers and users, 8

9. Installing scikit -image library: Pip install scikit -image Import skimage from skimage import io # Load an image from a file image = io.imread ('example_image.jpg') # Display the image io.imshow (image) io.show () 9

10. Pillow Pillow is a Python Imaging Library (PIL) fork, which adds extensive image processing capabilities to Python. It provides support for opening, manipulating, and saving many different image file formats. Image Manipulation: Pillow offers a wide range of image handling functionalities such as resizing, cropping, rotating, filtering, and enhancing images. Image File Support: It supports various image file formats including JPEG, PNG, GIF, etc. making it suitable for handling varied image data. Integration: Pillow seamlessly integrates with other Python libraries such as NumPy and Matplotlib , enabling easy interoperability with scientific computing and data visualization tools. Ease of Use: Pillow provides a simple and intuitive API for working with images, making it accessible to users with varying levels of programming experience. Activeness: Pillow is actively maintained and updated, ensuring compatibility with the latest Python versions and continued support for new features and improvements. 10

11. Installing Pillow library: Pip install pillow from PIL import Image # Open an image file original_image = Image.open ("example.jpg") # Display basic information about the image print("Original Image Format:", original_image.format ) print("Original Image Size:", original_image.size ) # Resize the image new_size = ( original_image.size [0] // 2, original_image.size [1] // 2) # Reduce size by half resized_image = original_image.resize ( new_size ) 11 # Display new size print("Resized Image Size:", resized_image.size ) # Save the resized image with a new name resized_image.save ("resized_example.jpg") # Close the original and resized images original_image.close () resized_image.close () print("Resized image saved successfully!")

12. pandas Pandas is a powerful Python library for data manipulation and analysis. It offers data structures and functions to efficiently work with structured data like time series, tabular, and heterogeneous data. Data Structures: Pandas provides two main data structures: Series (1D labeled array) and DataFrame (2D labeled data structure), which offer powerful data manipulation capabilities. Data Handling: It offers functionalities for reading and writing data from various formats like CSV, Excel, SQL databases etc. Data Analysis: Pandas supports data analysis tasks including data cleaning, filtering, grouping, merging, and reshaping, making it indispensable for exploratory data analysis. Integration: It seamlessly integrates with other Python libraries such as NumPy , Matplotlib , and scikit -learn, enhancing its capabilities in scientific computing and machine learning tasks. 12

13. Installing Pandas library: Pip install pandas Some time it shows for pip upgrade then use the following to upgrade your pip: Python.exe -m pip install --upgrade pip import pandas as pd # Read a CSV file into a DataFrame df = pd.read_csv ("example.csv") # Display the first few rows of the DataFrame print("First few rows of the DataFrame :") print( df.head ()) 13 # Display summary information about the DataFrame print("\ nSummary information:") print(df.info()) # Display basic statistics of numerical columns print("\ nBasic statistics:") print( df.describe ())

14. scikit -learn Definition: scikit -learn is a versatile machine learning library for Python. It offers simple and efficient tools for data mining and data analysis, implementing a wide range of machine learning algorithms. Machine Learning Algorithms: scikit -learn provides implementations for various machine learning algorithms including classification, regression, clustering, dimensionality reduction, and model selection. Model Evaluation: It offers tools for model evaluation, cross-validation, and hyperparameter tuning, facilitating the development of robust and accurate machine learning models. Integration: scikit -learn seamlessly integrates with other Python libraries such as NumPy , SciPy, and Pandas, enabling easy preprocessing, training, and evaluation of machine learning models. Scalability: It is designed to be scalable and efficient, making it suitable for working with large datasets and complex models. 14

15. Installing scikit -learn library: Pip install scikit -learn Import sklearn from sklearn.datasets import load_iris from sklearn.model_selection import train_test_split from sklearn.ensemble import RandomForestClassifier from sklearn.metrics import accuracy_score , classification_report # Load the Iris dataset iris = load_iris () X = iris.data # Features y = iris.target # Target variable # Split the dataset into training and testing sets X_train , X_test , y_train , y_test = train_test_split (X, y, test_size =0.2, random_state =42) 15 # Initialize the Random Forest classifier rf_classifier = RandomForestClassifier ( n_estimators =100, random_state =42) # Train the classifier rf_classifier.fit ( X_train , y_train ) # Predict on the test set y_pred = rf_classifier.predict ( X_test ) # Evaluate the model accuracy = accuracy_score ( y_test , y_pred ) print("Accuracy:", accuracy) # Display classification report print("\ nClassification Report:") print( classification_report ( y_test , y_pred , target_names = iris.target_names ))

16. Seaborn Seaborn is a Python library for creating attractive statistical graphics. Statistical Visualization: Seaborn excels in generating plots like scatter plots, bar charts, and heatmaps for effective data exploration. Integration with Pandas: It seamlessly works with Pandas DataFrames , making data visualization straightforward. Customization: Users can easily customize plot aesthetics to suit their preferences. Statistical Analysis: Seaborn offers tools for visualizing relationships between variables and conducting statistical analysis. Community and Documentation: Supported by an active community and comprehensive documentation for easy learning. 16

17. Installing seaborn library: Pip install seaborn import seaborn as sns import matplotlib.pyplot as plt from sklearn.datasets import load_iris # Load the Iris dataset iris = load_iris () iris_df = sns.load_dataset ("iris") # Load Iris dataset as a DataFrame # Create a pairplot using Seaborn sns.pairplot ( iris_df , hue='species', palette='Set1') # Add title plt.suptitle (" Pairplot of Iris Dataset") # Show the plot plt.show () 17

18. Plotly Plotly is a Python library for creating interactive and publication-quality graphs. Interactive Visualization: Plotly allows users to interactively explore data through zooming and hovering over data points. Online Platform: It offers an online platform for hosting and sharing interactive plots. Chart Types: Supports a wide range of chart types including scatter plots, line plots, and 3D surface plots. Integration: Easily integrates with other Python libraries for seamless data manipulation and visualization. Customization: Provides extensive options for customizing plot appearance for tailored visualizations. 18

19. Installing plotly library: Pip install plotly import plotly.graph_objects as go # Sample data x_values = [1, 2, 3, 4, 5] y_values = [2, 3, 5, 7, 11] # Create a line plot fig = go.Figure (data= go.Scatter (x= x_values , y= y_values , mode='lines')) # Add title and axis labels fig.update_layout (title='Simple Line Plot', xaxis_title ='X-axis', yaxis_title ='Y-axis') # Show the plot fig.show () 19

20. Data Pre Processing: Data preprocessing is a critical step in machine learning pipelines. It is define as the techniques and procedures used to prepare raw data for analysis. It involves several tasks such as importing and exporting data, cleaning and formatting data, handling missing values, and feature scaling. 20 Importing and Exporting Data : Importing data involves loading datasets into the machine learning environment. This can be done using libraries like Pandas in Python or functions like read_csv () for CSV files, read_excel () for Excel files, etc. import pandas as pd df = pd.read_csv (‘ML.csv’) df.shape #show number of rows and columns d f.describe () #calculate the SD, mean etc.

21. Exporting the Data : import pandas as pd # Example DataFrame data = { 'Name': ['John', 'Alice', 'Bob'], 'Age': [25, 30, 35], 'City': ['New York', 'Los Angeles', 'Chicago'] } df = pd.DataFrame (data) # Export DataFrame to CSV df.to_csv ('output.csv', index=False) 21

22. Cleaning and Formatting Data : Cleaning data involves identifying and handling anomalies, inconsistencies, and errors in the dataset. This may include removing duplicates, correcting data types, dealing with outliers, etc. Formatting data involves ensuring that data is in the appropriate format for analysis. For example, converting categorical variables into numerical representations, standardizing date formats, etc. 22

23. import pandas as pd # Load the dataset data = { 'Name': ['John', 'Alice', 'Bob', 'Anna', 'Mike', 'Emily'], 'Age': [25, 30, None, 35, 40, ''], 'City': ['New York', 'Los Angeles', 'Chicago', 'San Francisco', '', 'Seattle'], 'Gender': ['Male', 'Female', 'Male', '', 'Male', 'Female'], 'Salary': ['$50000', '$60000', '$70000', '$80000', '90000', '$100000'] } df = pd.DataFrame (data) # Display the original DataFrame print("Original DataFrame :") print( df ) print() # Clean and format the data # 1. Convert Age to numeric and fill missing values with the median age df ['Age'] = pd.to_numeric ( df ['Age'], errors='coerce') 23 median_age = df ['Age'].median() # Calculate median age df ['Age']. fillna ( median_age , inplace =True) # Fill missing values with median # 2. Remove rows with missing or empty values in City and Gender columns df = df [ df ['City']. notna () & df ['Gender']. notna () & ( df ['Gender'] != '')] # 3. Convert Salary to numeric and remove dollar signs df ['Salary'] = df ['Salary'].replace('[\$,]', '', regex=True). astype (float) # Display the cleaned and formatted DataFrame print("Cleaned and Formatted DataFrame :") print( df )

24. Handling Missing Values : Missing values are common in datasets and can significantly affect the performance of machine learning models if not handled properly. Techniques for handling missing values include: Imputation: Replacing missing values with a calculated or estimated value (e.g., mean, median, mode). Deletion: Removing rows or columns with missing values. Advanced techniques like predictive modeling to estimate missing values based on other features. The example is same as previous. 24

25. Feature Scaling : Feature scaling is the process of standardizing or normalizing the range of independent variables or features in the dataset. It is essential for algorithms that are sensitive to the scale of the input features, such as gradient descent-based algorithms (e.g., linear regression, logistic regression) or distance-based algorithms (e.g., k-nearest neighbors, support vector machines). Common techniques for feature scaling include: Min-Max Scaling: Scaling features to a fixed range, usually [0, 1]. Standardization (Z-score normalization): Scaling features so that they have the properties of a standard normal distribution with a mean of 0 and a standard deviation of 1. Robust Scaling: Scaling features using statistics that are robust to outliers, such as the median and interquartile range. 25

26. Feature Scaling : import numpy as np from sklearn.preprocessing import MinMaxScaler , StandardScaler # Sample dataset with two features data = np.array ([[10, 0.5], [20, 0.7], [30, 0.9]]) # Min-Max Scaling scaler_minmax = MinMaxScaler () # Initialize MinMaxScaler data_minmax = scaler_minmax.fit_transform (data) # Perform Min-Max Scaling print("Min-Max Scaled Data:") print( data_minmax ) print() # Standardization (Z-score normalization) scaler_standard = StandardScaler () # Initialize StandardScaler data_standard = scaler_standard.fit_transform (data) # Perform Standardization print("Standardized Data:") print( data_standard ) 26