{"id":436,"date":"2022-08-01T10:50:38","date_gmt":"2022-08-01T09:50:38","guid":{"rendered":"https:\/\/wp.coventry.domains\/e2edu\/?page_id=436"},"modified":"2022-08-23T18:55:27","modified_gmt":"2022-08-23T17:55:27","slug":"pytorch","status":"publish","type":"page","link":"https:\/\/wp.coventry.domains\/e2edu\/pytorch\/","title":{"rendered":"PyTorch"},"content":{"rendered":"\n

PyTorch <\/a>is a popular open source framework for developing, training, and deploying deep learning models. PyTorch is developed by Meta <\/a>and is available for the three major operating systems (Linux, Windows, MacOS). <\/p>\n\n\n\n

Pytorch is a Python <\/a>wrapper for Torch. Torch is a library for conducting mathematical operations on tensors and offers strong GPU support. Torch employs a script language based on the Lua programming language that uses an underlying C implementation. The combination of Pytorch and Torch offers the flexibility and ease of development from Python and the performance of GPU-based parallel computation from Torch. <\/p>\n\n\n\n

This article introduces some of the basic programming principles of Pytorch. More information about Torch itself or about other language bindings for Torch can be found on the Pytorch website<\/a>.<\/p>\n\n\n\n

Tensors<\/h3>\n\n\n\n

A tensor is a multi-dimensional matrix that contains elements of a single data type. <\/p>\n\n\n

\n
\"\"
Tensors of Different Dimensions. \u00a9Sayak Paul<\/figcaption><\/figure>\n<\/div>\n\n\n

Tensors are used to store a variety of data such as the data neural networks operate on or the parameters of the networks. Tensors can be used in a very similar manner as Python numpy arrays<\/a>. At the same time, Tensors surpass the capabilities of numpy arrays since they can run either on the CPU or CPU and keep track of gradients. <\/p>\n\n\n\n

Tensor Creation<\/h4>\n\n\n\n

Tensors can be created in a variety of ways. <\/p>\n\n\n\n

The content and datatype of a tensor can be directly specified when creating it.<\/p>\n\n\n\n

import torch\n\n# create a one dimensional tensor with 3 elements of datatype float64\nx = torch.tensor([1.3, 2.5, 1.0], dtype=torch.float64)\n\n# create a two dimensional tensor with 2x2 elements of datatype float32\nx = torch.tensor([[1.1, 1.2],[2.1, 2.2]], dtype=torch.float32)<\/code><\/pre>\n\n\n\n
Torch tensors can also be created from other torch tensors. For this, the clone function is provided. This function creates a new tensor with its own memory. If only a regular assignment operator is used, then the new tensor uses the same memory as the original tensor.<\/p>\n\n\n\n
import torch\n\n# copy a tensor from another tensor\nx = torch.tensor([1.3, 2.5, 1.0], dtype=torch.float64)\ny = torch.clone(x)<\/code><\/pre>\n\n\n\n
Alternatively,  torch tensors can be created from numpy arrays by using the “from_numpy” function.<\/p>\n\n\n\n
import torch\nimport numpy as np\n\n# copy a tensor from a numpy array\nx = np.array([1.3, 2.5, 1.0], dtype=np.float64)\ny = torch.from_numpy(x)\n<\/code><\/pre>\n\n\n\n
Tensors whose elements all have a value of zero or one can be created directly from the corresponding “zeros” and “ones” functions.<\/p>\n\n\n\n
import torch\n\n# create a one dimensional tensor with 3 zero values of datatype int32\nx = torch.zeros([3], dtype=torch.int32)\n\n# create a two dimensional tensor with 2x2 one values of datatype float32\nx = torch.ones([2, 2], dtype=torch.float32)<\/code><\/pre>\n\n\n\n
Tensors can also be created with random values by using the “rand” function. The random values are from a uniform distribution in the interval from 0.0 to 1.0 (excluding 1.0). <\/p>\n\n\n\n
import torch\n\n# create a two dimensional tensor with 5x3 random values of datatype float32\nx = torch.rand([5, 3], dtype=torch.float32)<\/code><\/pre>\n\n\n\n
When creating a tensor, this tensor initially resides in the memory of the CPU. To conduct tensor operations on the GPU, the tensor has to be moved to the GPU. The member function of the tensor class for moving a tensor from CPU memory to GPU memory (or vice versa) is “to”. <\/p>\n\n\n\n
import torch\n\nx = torch.rand([5, 3], dtype=torch.float32)\n\n# move tensor from cpu memory to gpu memory\nx = x.to(\"cuda\")\n\n# move tensor from gpu memory to cpu memory\nx = x.to(\"cpu\")\n\n# an alternative method for copying a tensor from gpu to cpu memory is to call the member function \"cpu\" on the tensor\nx = x.cpu()\n\n# when creating a new tensor, the move into gpu memory can be done right away.\nx = torch.rand([5, 3], dtype=torch.float32).to(\"cuda\")<\/code><\/pre>\n\n\n\n
When transferring a tensor from GPU memory to CPU memory, attention has to be paid on whether the tensor forms part of a computational graph (more about this later on). If that is the case, then the tensor has to be first detached from the computational graph before it can be moved to CPU memory.  For this, the member function “detach” can be called on the tensor. <\/p>\n\n\n\n
import torch\n\n# assuming that the tensor x exists and has for instance been obtained as output from a model\n\nx = x.detach().cpu()<\/code><\/pre>\n\n\n\n
Tensor Attributes<\/h4>\n\n\n\n
Tensors possess a variety of attributes that can be accessed for inspection using the corresponding member variables. The tensor attributes that are commonly inspected are dtype, device, and shape. <\/p>\n\n\n\n
import torch\n\nx = torch.rand([5, 3], dtype=torch.float32)\n\n# the data type of the values in a tensor is stored in the member variable \"dtype\"\n\nprint(x.dtype)\n\n# the device memory in which the tensor is stored is stored in the member variable \"device\"\n\nprint(x.device)\n\n# one of the most frequently referred to attributes of a tensor is its shape. The shape of a tensor refers to the number of elements along each dimension. The shape can be obtained in the member variable \"shape\".\n\nprint(x.shape)<\/code><\/pre>\n\n\n\n
Casting Tensors<\/h4>\n\n\n\n
Tensors containing elements of a data type can be casted into tensors containing elements of another data type. For this, the member function “type” can be used.<\/p>\n\n\n\n
import torch\n\nx = torch.tensor([5.3, 1.2], dtype=torch.float32)\n\n# cast tensor into a new tensor with a different data type for its elements\ny = x.type(torch.float64)<\/code><\/pre>\n\n\n\n
Accessing Tensor Elements<\/h4>\n\n\n\n
The elements stored in a tensor can be accessed using standard square bracket notation and numerical indices. The calls for accessing the elements are identical to those used for numpy arrays. Accordingly, these calls provide the same level of flexibility for accessing ranges of elements or indexing backwards from the end of a tensor. <\/p>\n\n\n\n
import torch\n\n# create a 3x4 tensor with values that make it simple to verify that the correct elements are accessed\nx = torch.tensor([[0.0, 0.1, 0.2, 0.3],[1.0, 1.1, 1.2, 1.3],[2.0, 2.1, 2.2, 2.3]], dtype=torch.float32)\n\n# access a scalar element by specifying all indices with indices being counted upwards from zero\nx[1, 3]\n\n# access the same scalar element by specifying all indices with indices being counted downwards from the length along each tensor dimension\nx[-2, -1]\n\n# access an entire row of values\nx[1]\n\n# access an entire column of values\nx[:,3]\n\n# access a sub-region of the tensor\nx[1:,1:3]<\/code><\/pre>\n\n\n\n
Tensor Mathematical Operations<\/h4>\n\n\n\n
Basic mathematical operations such as addition, subtraction, multiplication and division are available for tensors. These operations can be conducted between tensors and scalars as well as tensors and tensors. <\/p>\n\n\n\n
import torch\n\nx = torch.tensor([1.2, 3.4, 6.1], dtype=torch.float32)\ny = torch.tensor([5.1, 0.3, 2.8], dtype=torch.float32)\n\n# mathematical operations between tensor and scalar. \nx + 3\nx - 10\nx * 0.3\nx \/ 2.1\n\n# mathematical operations between tensor and tensor. \nx + y\nx - y\nx * y\nx \/ y<\/code><\/pre>\n\n\n\n
Vector and matrix operations can also available for tensors. <\/p>\n\n\n\n
import torch\n\nv1 = torch.tensor([1., 0., 0.], dtype=torch.float64)\nv2 = torch.tensor([0., 1., 0.], dtype=torch.float64)    \nm1 = torch.tensor([[0.0, 0.1],[1.0, 1.1]], dtype=torch.float64) \nm2 = torch.tensor([[3.0, 0.0],[0.0, 3.0]], dtype=torch.float64) \n\ntorch.cross(v2, v1) # vector cross product\ntorch.dot(v2, v1) # vector dot product\ntorch.matmul(m1, m2) # matrix multiplication\ntorch.svd(m1) # singular value decomposition<\/code><\/pre>\n\n\n\n
Other common mathematical operations include clamping, bitwise operations, comparisons, and reductions.<\/p>\n\n\n\n
import torch\nimport math\n\nx = torch.rand([2, 4], dtype=torch.float64)\n\n# absolute values, rounding, clamping\ntorch.abs(x) # absolute\ntorch.ceil(x) # round up\ntorch.floor(x) # round down\ntorch.clamp(x, -0.5, 0.5) # clamp\n\n# trigonometric functions\nangles = torch.tensor([0, math.pi \/ 4, math.pi \/ 2, 3 * math.pi \/ 4])\ntorch.sin(angles) # sine\ntorch.asin(torch.sin(angles)) # inverse sine\n\n# bitwise operations\nb = torch.tensor([1, 5, 11], dtype=torch.int32)\nc = torch.tensor([2, 7, 10], dtype=torch.int32)\ntorch.bitwise_xor(b, c) # bitwise xor\n\n# comparisons\ntorch.eq(b, c) # equality\n\n# reductions\ntorch.max(x) # maximum value\ntorch.mean(x) # mean value\ntorch.std(x) # standard deviation\ntorch.prod(x) # product<\/code><\/pre>\n\n\n\n
Datasets<\/h3>\n\n\n\n
Data used for training or inference is organised in datasets. PyTorch offers two classes for this. The Dataset class stores the data and the DataLoader class allows to iterate over the data. These classes offer functions for randomising data, for associating input data and labels, for splitting data into batches, and for pre-processing data. The basic Dataset class needs to be sub-classed to handle any actual data. Pytorch provides convenience classes for dealing with standard datasets and standard types of data (such as images and audio). The following section describes how to work with custom data that involves features and labels. The code example can be easily modified for data that doesn’t have labels. <\/p>\n\n\n\n
When writing you own custom Dataset class, there are three functions that need to be implemented. The constructor “__init__” which takes as arguments at least the features and labels that will be stored by the dataset. The function “__len__” which returns the size of the dataset which corresponds to the number of data instances stored in it. The function “__getitem__” which returns a data instance. <\/p>\n\n\n\n
import torch\nfrom torch.utils.data import Dataset, DataLoader\n\n# create to random tensors representing dummy data for the dataset\ndata_count = 100 # number of data instances\ndata_dim = 8 # number of features per instance\nlabel_count = 4 # number of class labels\n\ndummy_features = torch.rand([data_count, data_dim], dtype=torch.float32)\ndummy_labels = torch.randint(0, label_count, [data_count], dtype=torch.int32)\n\n# Create class for a simple customised Dataset by subclassing Dataset\nclass CustomDataset(Dataset):\n    def __init__(self, features, labels):\n        self.features = features\n        self.labels = labels\n    def __len__(self):\n        return len(self.features)\n    def __getitem__(self, idx):\n        feature = self.features[idx]\n        label = self.labels[idx]\n        return feature, label\n\n# Create an instance of the customised dataset\ncustomDataset = CustomDataset(dummy_features, dummy_labels)\n\n#print length of dataset\nprint(len(customDataset))\n\n#iterate over all data instances\nfor instance in iter(customDataset):\n    print(instance)<\/code><\/pre>\n\n\n\n
To split a full dataset into two datasets, one for training and one for testing, the torch.utils.data.random_split can be used.<\/p>\n\n\n\n
# continuation from previous code block\n\n# split full dataset into train and test dataset\n\ntrain_test_ratio = 0.8 # 80% of data goes into training set, 20% into test set\ntrain_size = int(len(customDataset) * train_test_ratio)\ntest_size = len(customDataset) - train_size \n\ntrain_dataset, test_dataset = torch.utils.data.random_split(customDataset , [train_size, test_size])\n\nprint(\"train dataset size: \", len(train_dataset))\nprint(\"test dataset size: \", len(test_dataset))<\/code><\/pre>\n\n\n\n
An instance of the DataLoader class can be created by passing an instance of the Dataset class to the DataLoader constructor. This is the only mandatory argument. Other typically used arguments include “batch_size” and “shuffle”. “Batch_size” specifies the number of data instances in a batch. “Shuffle” specifies if the data instances should be picked randomly from a Dataset. Once a Dataloader has been instantiated, it can be iterated over with each iteration returning a batch of training data. <\/p>\n\n\n\n
# continuation from previous code block\n\n# instantiate DataLoaders\n\nbatch_size = 16\n\ntrain_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)\ntest_dataloader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)\n\nbatch = next(iter(train_dataloader))\n\nbatch_features = batch[0]\nbatch_labels = batch[1]\n\nprint(\"batch features shape \", batch_features.shape)\nprint(\"batch labels shape\", batch_labels.shape)\n\n# iterate over DataLoader for test dataset\n\nfor (idx, batch) in enumerate(test_dataloader):\n    print(\"batch \", idx, \" features: \", batch[0])\n    print(\"batch \", idx, \" labels: \", batch[1])\n<\/code><\/pre>\n\n\n\n
Network Layers<\/h3>\n\n\n\n
PyTorch provides a large number of different layer types from which neural networks can be constructed. These layers are accessible via the torch.nn module. This module contains among others conventional neural network layers (torch.nn.Linear), convolution layers (e.g. torch.nn.Conv2d), and recurrent layers (e.g. torch.nn.LSTM). Activation functions are added to a network as separate layers (e.g. torch.nn.ReLU). <\/p>\n\n\n\n
A single conventional artificial neural network layer can be created as follows:<\/p>\n\n\n\n
import torch\nimport torch.nn as nn\n\n# create a single classical network layer\ninput_feature_count = 8\noutput_feature_count = 1\n\ndummy_layer = nn.Linear(input_feature_count, output_feature_count)\n\n# pass dummy data through layer\n\nbatch_size = 16\ndummy_input = torch.rand([batch_size, input_feature_count], dtype=torch.float32)\ndummy_output = dummy_layer(dummy_input)\n\nprint(\"dummy_input shape \", dummy_input.shape)\nprint(\"dummy_output shape \", dummy_output.shape)<\/code><\/pre>\n\n\n\n
A tensor that is passed into a classical artificial neural network layer needs to possess the following shape: batch size x feature count. The feature count needs to match the number of input features specified when creating the layer. The tensor that is output by the layer also has the shape: batch size x feature count. but this time the feature count matches the number of output features that has been specified when creating the layer.<\/p>\n\n\n\n
A single 2d convolution layer can be created as follows:<\/p>\n\n\n\n
import torch\nimport torch.nn as nn\n\n# create a single convolutional network layer\ninput_channel_count = 3 # number of channels in the input feature map\noutput_channel_count = 8 # number of channels in the output feature map\nkernel_size = 5 # 5 x 5 kernel\nstride = 2\npadding = 0\n\ndummy_layer = nn.Conv2d(input_channel_count, output_channel_count, kernel_size, stride, padding)\n\n# pass dummy data through layer\nbatch_size = 16\ninput_size = [64, 64]\ndummy_input = torch.rand([batch_size, input_channel_count, input_size[0], input_size[1]], dtype=torch.float32)\ndummy_output = dummy_layer(dummy_input)\n\nprint(\"dummy_input shape \", dummy_input.shape)\nprint(\"dummy_output shape \", dummy_output.shape)\n<\/code><\/pre>\n\n\n\n
For convolution network layers, the shape of the input tensor is batch size x channel count x feature map height x feature map width. The channel count needs to match the number of input channels specified when creating the layer. The shape of the output tensor is also batch size x channel count x feature map height x feature map width. Here, the channel count corresponds to the number of output channels specified when creating the layer. Calculating the height and width of the output tensor is a bit more involved since it depends not only on the height and width of the input tensor but also on the size of the kernel, the stride, and the padding (and also dilation when used). The equations to calculate the output height and width are as follows:<\/p>\n\n\n
\n
\"\"
Equations for Calculating the Size of a Feature Map Output by a Convolution Layer. N stands for batch size, C for Channel Count, H for height, W for Width.<\/figcaption><\/figure>\n<\/div>\n\n\n
A single or multiple recurrent layers (LSTM) can be created as follows:<\/p>\n\n\n\n
import torch\nimport torch.nn as nn\n\n# create a LSTM network layer\ninput_feature_count = 8\nhidden_feature_count = 512 # number of features in the hidden state h\nlayer_count = 2 # number of recurrent layers\nbatch_first = True\n\ndummy_layer = nn.LSTM(input_feature_count, hidden_feature_count, layer_count, batch_first=batch_first)\n\n# pass dummy data through layer\nbatch_size = 16\nsequence_length = 64\ndummy_input = torch.rand([batch_size, sequence_length, input_feature_count], dtype=torch.float32)\ndummy_output, (hidden_state, cell_state) = dummy_layer(dummy_input)\n\nprint(\"dummy_input shape \", dummy_input.shape)\nprint(\"dummy_output shape \", dummy_output.shape)\nprint(\"hidden_state shape \", hidden_state.shape)\nprint(\"cell_state shape \", cell_state.shape)\n<\/code><\/pre>\n\n\n\n
The construction and use of LSTM layers differs significantly from conventional or convolution network layers. First, LSTM layers are typically not constructed one single layer after the other. Instead, the layer constructor takes as argument the number of layers. If this number is larger than one, the constructor automatically creates a stack of LSTM layers. LSTM layers return not only one but three output tensors. The first tensor represents the regular data output. The second tensor  contains the hidden states of the layers. The last tensor contains the cell states of the layers. When the batch_first constructor argument is set to False (which is the default value), then the input and output data possess the following shape: sequence length x batch size x feature dimension. If the batch_first argument is set to True, then shape of the input and output data is:  batch size x sequence length x feature dimension. The batch_first flag doesn’t affect the shape of the hidden states. These are always: layer count x batch size x hidden feature count. As a side note, another flag that can be specified when creating a stack of LSTM layers is “bidirectional”. The default value is False. If the flag is set to true, the LSTM operates in bidirectional mode which means that the sequence of data runs in both directions, backwards (future to past) and forward (past to future). If this is the case, then the shape of the hidden layer changes to:   layer count * 2 x batch size x hidden feature count.<\/p>\n\n\n\n
Combining Multiple Network Layers<\/h3>\n\n\n\n
PyTorch offers different options to combine multiple layers when processing input data. One option is to explicitly pass the output data of one layer as input into the next layer. While this option requires the largest amount of code writing, it also offers the greatest flexibility including for instance conditional passes of data through layers. <\/p>\n\n\n\n
# the code assumes that the layers and the tensor containing input data already exist. \n# The variables for the layers are named layer0 to layerN and the variable for the input tensor is x. \n# Then an explicit forward pass of the input data can be specified as follows:\n\nx = layer0(x) # pass x into 1. layer and assign output tensor to x\nx = layer1(x) # pass x into 2. layer and assign output tensor to x\nx = layer2(x) # pass x into 3. layer and assign output tensor to x\n....\ny = layerN(x) # pass x into last layer and assign output tensor to y<\/code><\/pre>\n\n\n\n
Another option is to use the class torch.nn.Sequential. This class serves as sequential container for layers. Layers that are added to an instance of this class are cascaded one after the other. When data is input input into a sequential container, then this data is internally forwarded as input into the first layer, then the output of the first layer is passed as input into the second layer, and so on. The output of the last layer is returned as output of the sequential container. <\/p>\n\n\n\n
# the code assumes that the tensor containing input data already exist. \n\n# add all layers to a sequential container\n\nlayers = nn.Sequential(\n          nn.Conv2d(1,20,5),\n          nn.ReLU(),\n          nn.Conv2d(20,64,5),\n          nn.ReLU()\n        )\n\n# directly pass input data into the sequential container\n\ny = layers(x)\n<\/code><\/pre>\n\n\n\n
A variation of using the  class torch.nn.Sequential is to combine it with an instance of an OrderedDict. An OrderedDict is, as the name implies, an ordered dictionary. To such a dictionary, the layers are added as values. The keys could then be used to name the layers. This approach offers two benefits. First, naming the layers makes it easier to identify layers for instance during debugging. Second, the layers can be added using procedures instead of hard-coding them. Such procedures offer the flexibility to compute the number and settings of layers automatically.<\/p>\n\n\n\n
# the code assumes that the tensor containing input data already exist.\n\nfrom collections import OrderedDict\n\n# add all layers to a python list\n\nlayer_list = []\nlayer_list.append((\"conv1\", nn.Conv2d(1,20,5)))\nlayer_list.append((\"relu1\", nn.ReLU()))\nlayer_list.append((\"conv1\", nn.Conv2d(20,64,5)))\nlayer_list.append((\"relu1\", nn.ReLU()))\n\n# create sequential container from an OrderedDict\n\nlayers = nn.Sequential(OrderedDict(layer_list))\n\n# directly pass input data into the sequential container\n\ny = layers(x)<\/code><\/pre>\n\n\n\n
Models<\/h3>\n\n\n\n
In Pytorch, machine-learning models are created by subclassing the nn.Module class. Doing so involves overwriting the constructor and a forward function of the base class. Typically, the constructor is used to create all layers and the forward function is used to process data with a forward pass. Other than that, the model class inherits from the nn.Module base class functions to switch between training and evaluation mode, and to load previously stored weights. <\/p>\n\n\n\n
import torch\nimport torch.nn as nn\nfrom collections import OrderedDict\n\n# declare model class by subclassing nn.Module\nclass Model(nn.Module):\n    def __init__(self):\n        super().__init__()\n        \n        layer_list = []\n        layer_list.append((\"conv1\", nn.Conv2d(1,20,5)))\n        layer_list.append((\"relu1\", nn.ReLU()))\n        layer_list.append((\"conv2\", nn.Conv2d(20,64,5)))\n        layer_list.append((\"relu2\", nn.ReLU()))\n        \n        self.layers = nn.Sequential(OrderedDict(layer_list))\n\n    def forward(self, x):\n        return self.layers(x)\n    \n# instantiate model\nmodel = Model()\n\n# print textual summary of model\nprint(model)\n\n# set model into evaluation mode\nmodel.eval()\n\n# create a test input tensor for the model\nbatch_size = 16\ninput_channel_count = 1\ninput_size = [64, 64]\ndummy_input = torch.rand([batch_size, input_channel_count, input_size[0], input_size[1]], dtype=torch.float32)\nprint(\"dummy_input shape \", dummy_input.shape)\n\n# conduct a forward pass with the dummy input\ndummy_output = model(dummy_input)\n\n# verify shape of output tensor\nprint(\"dummy_output shape \", dummy_output.shape)\n\n# set model back into training mode\nmodel.train()\n\n# save model weights\ntorch.save(model.state_dict(), \"model_weights\")\n\n# load model weights\nmodel.load_state_dict(torch.load(\"model_weights\"))<\/code><\/pre>\n\n\n\n
A brief note on the evaluation and training modes of models. Changing this mode only has an effect for models that contain certain types of layers such as Dropout <\/a>layers or BatchNormalisation <\/a>layers. <\/p>\n\n\n\n
Apart from saving and loading model weights, a model can also be saved. Models can be saved in three different formats: in a directly serialised format using  Python’s pickle <\/a>module, in the ONNX (Open Neural Network eXchange<\/a>) format, or as TorchScript <\/a>code. <\/p>\n\n\n\n
Using pickle is easy but comes with the drawback that the saved model is bound to specific classes and directory structures used when saving the model. Models that are saved in the ONNX format can be used by any of the runtimes <\/a>that support this format. Models that are saved as Torchscript Saving a model in ONNX format or as TorchScript requires an example of an input tensor that can be processed by the model. <\/p>\n\n\n\n
# continuation from previous code block\n\n# save model using pickle\nmodel.eval()\ntorch.save(model, \"model.pth\")\nmodel.train()\n\n\n#load model using pickle\nmodel = torch.load(\"model.pth\")\nmodel.eval()\n\n# save model in ONNX format\nmodel.eval()\ntorch.onnx.export(model, dummy_input, \"model.onnx\")\nmodel.train()\n\n# save model as TorchScript\nmodel.eval()\nscript_module = torch.jit.trace(model, dummy_input)\nscript_module.save(\"model.pt\")\nmodel.train()<\/code><\/pre>\n\n\n\n
Training an Model<\/h3>\n\n\n\n
Training a model involves the following steps. <\/p>\n\n\n\n