Deep Learning PyTorch Course, What is Machine Learning

1. Definition of Machine Learning

Machine Learning is a subfield of artificial intelligence that enables computers to learn from data and perform specific tasks. Typically, machine learning is characterized by the use of algorithms that can learn without being explicitly programmed. This is very useful for recognizing patterns in data, making predictions, and automating decision-making.

2. Basic Principles of Machine Learning

Machine learning models generally operate through the following process:

  1. Data Collection: Collect the data to be used for learning.
  2. Data Preprocessing: Perform tasks such as handling missing values and normalization to improve the quality of the data.
  3. Model Selection: Choose a machine learning model that is suitable for the problem.
  4. Training: Train the selected model using the data.
  5. Evaluation: Assess the model’s performance and adjust it if necessary.
  6. Prediction: Use the trained model to make predictions on new data.

3. Types of Machine Learning

Machine learning can primarily be divided into three types:

  • Supervised Learning: Learns the relationship between input and output when given input and output data. This mainly includes regression and classification problems.
  • Unsupervised Learning: Focuses on finding the structure or patterns in data when there is no output data available. Clustering is a representative example.
  • Reinforcement Learning: An agent learns strategies to maximize rewards through interaction with the environment.

4. What is PyTorch?

PyTorch is an open-source machine learning library developed by Facebook, primarily used as a framework for deep learning. PyTorch provides dynamic computation graphs, enabling flexible and intuitive coding. This is one of the reasons it is popular among researchers and developers.

Main Features of PyTorch

  • Dynamic Computation Graph: The computation graph is generated as soon as the code is executed, allowing easy modification of the model structure.
  • Diverse Tensor Operations: Enables tensor operations similar to NumPy, making it easy to preprocess training data.
  • GPU Support: Allows fast execution of large-scale operations by utilizing GPUs.
  • Scalability: Custom layers and models can be easily defined, making it applicable for various deep learning research.

5. Hands-on Machine Learning with PyTorch

Now we will build a simple machine learning model using PyTorch. We will be using the Iris dataset to create a model that classifies the types of flowers.

5.1. Loading the Dataset

First, we install the required libraries and load the data.


import torch
import torch.nn as nn
import torch.optim as optim
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.preprocessing import LabelEncoder
import numpy as np

5.2. Data Preprocessing

After loading the Iris dataset, we separate the features and labels and carry out data preprocessing.


# Load the Iris dataset
iris = datasets.load_iris()
X = iris.data
y = iris.target

# Split the Data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Normalize the Data
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# Convert to Tensors
X_train_tensor = torch.FloatTensor(X_train)
y_train_tensor = torch.LongTensor(y_train)
X_test_tensor = torch.FloatTensor(X_test)
y_test_tensor = torch.LongTensor(y_test)

5.3. Defining the Model

We define a simple neural network model consisting of an input layer, a hidden layer, and an output layer.


class IrisModel(nn.Module):
    def __init__(self):
        super(IrisModel, self).__init__()
        self.fc1 = nn.Linear(4, 10)  # 4 input features and 10 hidden nodes
        self.fc2 = nn.Linear(10, 3)   # 10 hidden nodes and 3 output nodes (types of flowers)

    def forward(self, x):
        x = torch.relu(self.fc1(x))  # Using ReLU as the activation function
        x = self.fc2(x)
        return x

model = IrisModel()

5.4. Training the Model

After defining the loss function and optimization technique, we train the model.


# Define Loss Function and Optimization Technique
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)

# Train the Model
num_epochs = 100
for epoch in range(num_epochs):
    model.train()
    
    # Forward Pass
    outputs = model(X_train_tensor)
    loss = criterion(outputs, y_train_tensor)
    
    # Backward Pass and Optimization
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()
    
    if (epoch+1) % 10 == 0:
        print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')

5.5. Evaluating the Model

Using the trained model, we perform predictions on the test data and evaluate the accuracy.


# Evaluate the Model
model.eval()
with torch.no_grad():
    test_outputs = model(X_test_tensor)
    _, predicted = torch.max(test_outputs.data, 1)
    accuracy = (predicted == y_test_tensor).sum().item() / y_test_tensor.size(0)
    print(f'Accuracy: {accuracy:.2f}')

6. Conclusion

In this tutorial, we explored the basic concepts of machine learning and the process of building a simple machine learning model using PyTorch. Machine learning is utilized in various fields, and PyTorch serves as a powerful tool for this purpose. We hope you will conduct in-depth research on a wider range of topics in the future.

We wish the advancements in deep learning and machine learning will aid your research!