Deep learning is a field of artificial intelligence (AI) that involves creating machines that learn from data through artificial neural networks to perform prediction and classification tasks. The advancements in deep learning over the past few years have brought about revolutionary changes and achievements in the field of artificial intelligence. In this course, we will explore the fundamental structure of deep learning in detail using PyTorch.<\/p>\n
In deep learning, data is received as input, processed through multiple layers, and generates the final output. During this process, artificial neural networks (ANN) are used. Neural networks are composed of multiple connected units called nodes (or neurons), and each neuron receives input, multiplies it by weights, adds a bias, and applies a nonlinear activation function.<\/p>\n
The basic structure of a neural network consists of an input layer, hidden layers, and an output layer. Each layer is connected to the neurons of the next layer; the input layer accepts data, and the output layer provides results.<\/p>\n
class SimpleNN(nn.Module):\n def __init__(self):\n super(SimpleNN, self).__init__()\n self.fc1 = nn.Linear(2, 3) # 2 inputs, 3 outputs\n self.fc2 = nn.Linear(3, 1) # 3 inputs, 1 output\n\n def forward(self, x):\n x = F.relu(self.fc1(x))\n x = self.fc2(x)\n return x\n<\/code><\/pre>\n2. Introduction to PyTorch<\/h2>\n
PyTorch is a popular deep learning framework developed by Facebook AI Research, which offers easy-to-use and flexible features. Using PyTorch allows for simple GPU acceleration with tensor operations and supports dynamic computation graphs.<\/p>\n
2.1 Basic Tensor<\/h3>\n
In deep learning, a tensor is the fundamental structure for representing data. A 1D tensor can be thought of as a vector, a 2D tensor as a matrix, and a 3D tensor as a multidimensional array.<\/p>\n
import torch\n\n # 1D tensor\n tensor_1d = torch.tensor([1, 2, 3])\n\n # 2D tensor\n tensor_2d = torch.tensor([[1, 2], [3, 4]])\n\n # 3D tensor\n tensor_3d = torch.tensor([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])\n<\/code><\/pre>\n3. Building a Deep Learning Model<\/h2>\n
Now, let’s build a simple deep learning model. We will create a basic neural network model using various APIs provided by PyTorch.<\/p>\n
3.1 Data Preprocessing<\/h3>\n
Data preprocessing plays an important role in deep learning. It is necessary to prepare the dataset and transform it into a suitable format for training.<\/p>\n
from sklearn.datasets import make_moons\n from sklearn.model_selection import train_test_split\n from sklearn.preprocessing import StandardScaler\n\n X, y = make_moons(n_samples=1000, noise=0.2, random_state=42)\n X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n\n # Data standardization\n scaler = StandardScaler()\n X_train = scaler.fit_transform(X_train)\n X_test = scaler.transform(X_test)\n<\/code><\/pre>\n3.2 Model Definition<\/h3>\n
As mentioned earlier, the model is defined by inheriting from nn.Module. This time, let’s use the sigmoid activation function instead of Relu.<\/p>\n
import torch.nn as nn\n import torch.nn.functional as F\n\n class SimpleNN(nn.Module):\n def __init__(self):\n super(SimpleNN, self).__init__()\n self.fc1 = nn.Linear(2, 3)\n self.fc2 = nn.Linear(3, 1)\n\n def forward(self, x):\n x = F.sigmoid(self.fc1(x))\n x = self.fc2(x)\n return x\n<\/code><\/pre>\n3.3 Model Training<\/h3>\n
To train the model, we need to define the loss function and optimization algorithm. We can use binary cross-entropy (BCE) as the loss function and Adam for optimization.<\/p>\n
import torch.optim as optim\n\n model = SimpleNN()\n criterion = nn.BCEWithLogitsLoss()\n optimizer = optim.Adam(model.parameters(), lr=0.001)\n\n X_train_tensor = torch.tensor(X_train, dtype=torch.float32)\n y_train_tensor = torch.tensor(y_train, dtype=torch.float32).view(-1, 1)\n\n for epoch in range(1000):\n model.train()\n optimizer.zero_grad()\n outputs = model(X_train_tensor)\n loss = criterion(outputs, y_train_tensor)\n loss.backward()\n optimizer.step()\n\n if (epoch + 1) % 100 == 0:\n print(f'Epoch [{epoch + 1}\/1000], Loss: {loss.item():.4f}')\n<\/code><\/pre>\n3.4 Model Evaluation<\/h3>\n
After the model training is complete, we evaluate the model’s performance using the test data. Here, we measure accuracy.<\/p>\n
model.eval()\n with torch.no_grad():\n X_test_tensor = torch.tensor(X_test, dtype=torch.float32)\n y_pred = model(X_test_tensor)\n y_pred = (y_pred > 0).float()\n accuracy = (y_pred.view(-1) == torch.tensor(y_test, dtype=torch.float32)).float().mean()\n print(f'Accuracy: {accuracy:.4f}')\n<\/code><\/pre>\n4. Conclusion<\/h2>\n
In this lecture, we examined the basic concepts of deep learning and the process of building a simple neural network model using PyTorch. Deep learning can be applied to various fields, and more complex models require deeper structures and diverse techniques. In the next lecture, we will learn about more complex deep learning architectures such as CNNs (Convolutional Neural Networks) and RNNs (Recurrent Neural Networks).<\/p>\n
<\/body><\/p>\n","protected":false},"excerpt":{"rendered":"