To start: why should you care about Python and machine learning anyway? Let’s start with the basics. Python is a popular programming language that can be used for various purposes such as web development, data analysis, and scientific computing. It has a simple syntax and is easy to learn, making it perfect for beginners.
Now machine learning. In layman’s terms, it’s like teaching a computer how to do something without explicitly telling it what to do. For example, you can train a model to recognize cats in images by showing it thousands of cat pictures and letting it figure out the patterns on its own. Pretty cool, right?
But enough with the boring stuff! Time to get going with some sassy examples that will make your head spin (in a good way). First off, let’s create a simple program to print “Hello World!” in Python:
# This script prints "Hello World!" in Python
# Use the print() function to output the string "Hello World!"
print("Hello World!")
That was easy enough. Now let’s move on to something more exciting installing the necessary libraries for machine learning. If you haven’t already, make sure to download and install Anaconda (a popular package manager) and Jupyter Notebook (an interactive environment). Once that’s done, open up a new notebook and run this code:
# Install the necessary library for machine learning
# The exclamation mark (!) is used to run shell commands within a Jupyter Notebook
!pip install scikit-learn
# Import the scikit-learn library
import sklearn
# The "install" function from the "pip" library is used to install packages
# "scikit-learn" is the name of the package being installed
# The "import" keyword is used to import libraries or modules into the current script
# "sklearn" is the name of the library being imported
# The "as" keyword is used to create an alias for the imported library
# This allows for easier referencing of the library in the code
# The "import" statement should always be placed at the top of the script, before any other code
# The "sklearn" library is a popular library for machine learning algorithms and tools
# It contains various modules for data preprocessing, model selection, and evaluation
# By importing the library, we can access these modules and use them in our code
# It is important to install and import the necessary libraries before using them in our code
# This ensures that all the required dependencies are available and the code can run smoothly
This will install the Scikit-Learn library which is one of the most popular machine learning libraries in Python. Now let’s load some data to work with. For example, we can use the Iris dataset (a classic in the field) to predict whether a flower is from the setosa or versicolor species based on its petal length and width:
# Import the pandas library and rename it as "pd"
import pandas as pd
# Import the load_iris function from the sklearn.datasets library
from sklearn.datasets import load_iris
# Use the load_iris function to load the Iris dataset and assign it to the variable "data"
data = load_iris()
# Create a dataframe using the data from the "data" variable
df = pd.DataFrame(data['data'])
# Assign the "target" column from the "data" variable to the variable "targets"
targets = data['target']
# Create a new dataframe "X" with only the columns "petal length (cm)" and "petal width (cm)" from the "df" dataframe
X = df[['petal length (cm)', 'petal width (cm)']]
# Assign the "targets" variable to the variable "y"
y = targets
# The purpose of this script is to import the necessary libraries and load the Iris dataset to be used for machine learning tasks. The data is then organized into a dataframe and the target column is separated from the rest of the data. Finally, the data is split into input features (X) and target variable (y) for further analysis.
Now that we have our data, let’s split it into training and testing sets:
# Importing the necessary library for splitting the data
from sklearn.model_selection import train_test_split
# Splitting the data into training and testing sets with a test size of 20%
# X represents the features and y represents the target variable
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
Finally, let’s create a simple logistic regression model to predict whether the flower is from setosa or versicolor:
# Import the necessary library for logistic regression
from sklearn.linear_model import LogisticRegression
# Create an instance of the logistic regression model
model = LogisticRegression()
# Train the model using the training data
model.fit(X_train, y_train)
# Make predictions on the test data
predictions = model.predict(X_test)
# Calculate and print the accuracy of the model
print("Accuracy:", round((model.score(X_test, y_test)*100), 2))
# The above code imports the necessary library for logistic regression and creates an instance of the model.
# Then, it trains the model using the training data and makes predictions on the test data.
# Finally, it calculates and prints the accuracy of the model.
You’ve just created your first machine learning model in Python using Scikit-Learn. Pretty sassy, right?