PyTorch-এ মডেল সেভ এবং লোড করার জন্য সহজ এবং কার্যকর উপায় রয়েছে। এটি মডেলের প্রশিক্ষিত প্যারামিটার সংরক্ষণ এবং পুনরায় লোড করে মডেলটি ব্যবহার করার সুযোগ দেয়। নিচে ধাপে ধাপে কিভাবে PyTorch-এ মডেল সেভ এবং লোড করা যায় তা দেখানো হয়েছে।

মডেল সেভ করা

মডেল সেভ করার জন্য torch.save() ফাংশনটি ব্যবহার করা হয়। সাধারণত, মডেলের স্টেট ডিকশনারি (যা মডেলের সমস্ত প্যারামিটার সংরক্ষণ করে) সেভ করা হয়। এটি মডেলের সঠিক ওজন এবং বায়াস সংরক্ষণ করতে সাহায্য করে।

import torch

# মডেলের স্টেট ডিকশনারি সেভ করা
torch.save(model.state_dict(), 'model.pth')
Copy

এখানে, 'model.pth' ফাইলের নাম যা মডেলের প্যারামিটার সংরক্ষণ করবে। আপনি ফাইলের নাম যেকোনো কিছু দিতে পারেন, তবে .pth বা .pt এক্সটেনশন ব্যবহার করা ভালো।

মডেল লোড করা

মডেল লোড করার জন্য প্রথমে মডেলের স্ট্রাকচার বা আর্কিটেকচার ডিফাইন করতে হবে, তারপর সংরক্ষিত স্টেট ডিকশনারি লোড করতে হবে।

# মডেল ইনস্ট্যান্স তৈরি করা (আর্কিটেকচার ডিফাইন করে)
loaded_model = SimpleLinearModel()

# মডেলের স্টেট ডিকশনারি লোড করা
loaded_model.load_state_dict(torch.load('model.pth'))

# মডেলকে ইভ্যালুয়েশন মোডে সেট করা (যদি প্রয়োজন হয়)
loaded_model.eval()
Copy

বিস্তারিত

1. মডেল আর্কিটেকচার ডিফাইন করা: মডেল লোড করার আগে মডেলের আর্কিটেকচার অবশ্যই ডিফাইন করতে হবে, যেটি ট্রেনিংয়ের সময় ব্যবহৃত আর্কিটেকচারের সাথে মিলতে হবে।
2. load_state_dict() ফাংশন: এটি মডেলের প্যারামিটারগুলি লোড করতে ব্যবহৃত হয়। এখানে, আমরা আগে সেভ করা 'model.pth' ফাইলটি লোড করছি।
3. মডেল ইভ্যালুয়েশন মোড: যদি আপনি মডেলটি ইভ্যালুয়েশনের জন্য (ভ্যালিডেশন বা টেস্টিং) ব্যবহার করতে চান, তবে loaded_model.eval() ব্যবহার করতে হবে। এটি মডেলকে ইভ্যালুয়েশন মোডে রাখে, যাতে ড্রপআউট এবং ব্যাচ নরমালাইজেশনের মতো লেয়ারগুলি সঠিকভাবে কাজ করে।

উদাহরণ: সম্পূর্ণ প্রক্রিয়া

import torch
import torch.nn as nn
import torch.optim as optim

# মডেল ডিফাইন করা
class SimpleLinearModel(nn.Module):
    def __init__(self):
        super(SimpleLinearModel, self).__init__()
        self.linear = nn.Linear(1, 1)

    def forward(self, x):
        return self.linear(x)

# মডেল ইনস্ট্যান্স তৈরি করা
model = SimpleLinearModel()

# লস ফাংশন এবং অপটিমাইজার
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

# মডেল সেভ করা
torch.save(model.state_dict(), 'simple_model.pth')

# নতুন মডেল ইনস্ট্যান্স তৈরি করে লোড করা
new_model = SimpleLinearModel()
new_model.load_state_dict(torch.load('simple_model.pth'))
new_model.eval()

# টেস্টিং ইনপুট
test_input = torch.tensor([[5.0]])
test_output = new_model(test_input)
print(f'Prediction for input 5.0: {test_output.item()}')
Copy

সারসংক্ষেপ

• মডেল সেভ: মডেলের স্টেট ডিকশনারি (ওজন এবং বায়াস) torch.save() ফাংশন ব্যবহার করে সেভ করা হয়।
• মডেল লোড: torch.load() এবং load_state_dict() ফাংশন ব্যবহার করে মডেলের স্টেট ডিকশনারি লোড করা হয়।
• ইভ্যালুয়েশন মোড: model.eval() মডেলকে ইভ্যালুয়েশন মোডে সেট করে, যা টেস্টিং বা প্রেডিকশনের সময় ব্যবহৃত হয়।

এভাবে PyTorch-এ মডেল সেভ এবং লোড করা সহজ এবং কার্যকর, যা প্রশিক্ষিত মডেল সংরক্ষণ এবং পুনরায় ব্যবহার করার সুযোগ দেয়।

মডেল সেভ করা এবং চেকপয়েন্টিং (Checkpointing) মডেল ট্রেনিংয়ের একটি গুরুত্বপূর্ণ অংশ, বিশেষ করে যখন ট্রেনিং প্রক্রিয়া দীর্ঘ সময় নেয়। মডেল সেভ এবং চেকপয়েন্টিংয়ের মাধ্যমে আমরা মডেলের বর্তমান অবস্থা সংরক্ষণ করতে পারি এবং প্রয়োজন হলে সেখান থেকে পুনরায় ট্রেনিং শুরু করতে পারি। PyTorch ব্যবহার করে মডেল সেভ করার পদ্ধতি এবং চেকপয়েন্টিং নিচে আলোচনা করা হলো:

১. মডেল সেভ করার পদ্ধতি

মডেল ট্রেনিং শেষে মডেল সংরক্ষণ করা যায়, যাতে এটি পুনরায় ব্যবহার করা যায় বা ডেপলয়মেন্ট করা যায়। PyTorch-এ সাধারণত মডেল সেভ করার জন্য torch.save() ফাংশন ব্যবহার করা হয়।

উদাহরণ: মডেলের ওজন (weights) সংরক্ষণ করা

import torch

# মডেলের ওজন সংরক্ষণ করা
torch.save(model.state_dict(), 'model_weights.pth')
Copy

• এখানে, model.state_dict() মডেলের ওজন এবং অন্যান্য প্যারামিটার সংরক্ষণ করে। ফাইলটি 'model_weights.pth' নামে সেভ করা হয়েছে।
• মডেলের ওজন লোড করার জন্য:

# মডেলের আর্কিটেকচার পুনরায় তৈরি করা
model = SimpleNN()
# সংরক্ষিত ওজন লোড করা
model.load_state_dict(torch.load('model_weights.pth'))
# মডেলকে এভালুয়েশন মোডে সেট করা (যদি টেস্ট বা ডেপলয় করতে চান)
model.eval()
Copy

মডেলের সম্পূর্ণ অবস্থা সংরক্ষণ করা

মডেলের ওজনের পাশাপাশি, সম্পূর্ণ মডেল সংরক্ষণ করার জন্য:

# সম্পূর্ণ মডেল সংরক্ষণ করা
torch.save(model, 'full_model.pth')
Copy

• সম্পূর্ণ মডেল লোড করার জন্য:

# সম্পূর্ণ মডেল লোড করা
model = torch.load('full_model.pth')
model.eval()
Copy

এভাবে, আপনি সম্পূর্ণ মডেল আর্কিটেকচার ও ওজন একসাথে সংরক্ষণ এবং পুনরায় লোড করতে পারেন।

২. Checkpointing

Checkpointing হলো মডেলের ট্রেনিং প্রক্রিয়ার একটি নির্দিষ্ট অবস্থায় মডেল সংরক্ষণ করা, যাতে ট্রেনিং পুনরায় শুরু করলে পূর্ববর্তী অবস্থান থেকে শুরু করা যায়। এটি বিশেষ করে লম্বা সময়ের ট্রেনিংয়ে বা মডেল টিউনিংয়ের সময় সহায়ক।

Checkpointing-এর উদাহরণ

import torch

# চেকপয়েন্ট সংরক্ষণ করা
checkpoint = {
    'epoch': epoch,
    'model_state': model.state_dict(),
    'optimizer_state': optimizer.state_dict(),
    'loss': loss
}
torch.save(checkpoint, 'checkpoint.pth')
Copy

এখানে, আমরা মডেলের বর্তমান অবস্থা, অপ্টিমাইজারের অবস্থা, এবং বর্তমান ইপক সংরক্ষণ করছি।

Checkpoint থেকে মডেল লোড করা

# চেকপয়েন্ট লোড করা
checkpoint = torch.load('checkpoint.pth')
model.load_state_dict(checkpoint['model_state'])
optimizer.load_state_dict(checkpoint['optimizer_state'])
start_epoch = checkpoint['epoch']
loss = checkpoint['loss']

# ট্রেনিং পুনরায় শুরু করা
for epoch in range(start_epoch, num_epochs):
    # ট্রেনিং কোড
    pass
Copy

এভাবে, চেকপয়েন্ট থেকে মডেলের ওজন এবং অপ্টিমাইজারের অবস্থা পুনরায় লোড করে পূর্ববর্তী অবস্থান থেকে ট্রেনিং শুরু করা যায়।

৩. Checkpointing পদ্ধতির কিছু Best Practices

ইপকের নির্দিষ্ট ইন্টারভালে চেকপয়েন্ট সংরক্ষণ: প্রতিটি ইপক বা নির্দিষ্ট ইন্টারভালে চেকপয়েন্ট সংরক্ষণ করলে, মডেল ট্রেনিং চলাকালীন হঠাৎ কোনো সমস্যা হলে আগের অবস্থান থেকে পুনরায় শুরু করা যায়।

লস বা পারফরম্যান্সের উপর ভিত্তি করে চেকপয়েন্ট সংরক্ষণ: কিছু ক্ষেত্রে, মডেলের লস বা পারফরম্যান্স কম হলে (যেমন: লস ভ্যালু সর্বনিম্ন হলে) চেকপয়েন্ট সংরক্ষণ করতে পারেন। এভাবে, আপনি সর্বোত্তম অবস্থায় মডেলটি সংরক্ষণ করতে পারবেন।

if loss < best_loss:
    best_loss = loss
    torch.save(model.state_dict(), 'best_model.pth')
Copy

• সংরক্ষিত চেকপয়েন্ট নামকরণ: ট্রেনিং ইপকের সাথে চেকপয়েন্ট ফাইলের নাম যুক্ত করলে সহজে চেকপয়েন্ট ট্র্যাক করা যায়, যেমন 'checkpoint_epoch_10.pth'।

এইভাবে, মডেল সেভ এবং চেকপয়েন্টিং ব্যবহার করে আপনি মডেল ট্রেনিংয়ের সময় সঠিকভাবে মডেল সংরক্ষণ এবং পুনরায় লোড করতে পারবেন, যা মডেল ট্রেনিং এবং উন্নয়নের একটি গুরুত্বপূর্ণ দিক।

PyTorch-এ মডেল লোড করা এবং পুনরায় ব্যবহার করার জন্য torch.save() এবং torch.load() ফাংশনগুলো ব্যবহার করা হয়। সাধারণত মডেল ট্রেনিংয়ের পর মডেলের ওজন (weights) সংরক্ষণ করা হয়, এবং পরে এটি পুনরায় লোড করে ব্যবহার করা হয়। নিচে মডেল সেভ এবং লোড করার একটি উদাহরণ দেওয়া হল:

মডেল সেভ এবং লোড করার উদাহরণ

১. মডেল সেভ করা

import torch

# মডেল ইনস্ট্যানশিয়েট করা
model = CustomModel()

# ট্রেনিং কোড (মডেল ট্রেনিং করার পর)
# ...

# মডেলের স্টেট ডিকশনারি (ওজন) সেভ করা
torch.save(model.state_dict(), 'custom_model.pth')
Copy

• torch.save() ফাংশনটি ব্যবহার করে মডেলের ওজন (weights) সংরক্ষণ করা হয়।
• 'custom_model.pth' নামক একটি ফাইলে ওজন সংরক্ষণ করা হয়েছে।

২. মডেল লোড করা এবং পুনরায় ব্যবহার করা

# মডেলের স্ট্রাকচার তৈরি করা
model = CustomModel()

# সেভ করা ওজন লোড করা
model.load_state_dict(torch.load('custom_model.pth'))

# মডেলকে ইভালুয়েশন মোডে সেট করা
model.eval()

# মডেলের মাধ্যমে প্রেডিকশন করা
# একটি ডামি ইনপুট তৈরি করা (১ টি ইমেজের ব্যাচ সাইজ ধরে)
dummy_input = torch.randn(1, 1, 28, 28)  # ব্যাচ সাইজ, চ্যানেল, হাইট, উইডথ

# মডেলের মাধ্যমে আউটপুট পাওয়া
output = model(dummy_input)
print(output)
Copy

ব্যাখ্যা:

মডেল সেভ করা:

• torch.save(model.state_dict(), 'custom_model.pth') দ্বারা মডেলের ওজন একটি .pth ফাইলে সংরক্ষণ করা হয়েছে।
• এটি শুধু মডেলের ওজন সংরক্ষণ করে, পুরো মডেল নয়। এটি করলে মডেল ফাইলটি ছোট থাকে এবং পরে লোড করা সহজ হয়।

মডেল লোড করা:

• মডেলের স্ট্রাকচার প্রথমে তৈরি করা হয় (model = CustomModel()) এবং তারপর model.load_state_dict(torch.load('custom_model.pth')) দিয়ে সংরক্ষিত ওজন লোড করা হয়।
• মডেলকে ইভালুয়েশন মোডে (model.eval()) সেট করা হয়, যাতে এটি ড্রপআউট বা ব্যাচ নরমালাইজেশন লেয়ারের মত কিছু মডিফিকেশন অ্যাপ্লাই না করে।

প্রেডিকশন করা:

• একটি ডামি ইনপুট তৈরি করা হয় (dummy_input), যা মডেলের ইনপুট আকারের সাথে ম্যাচ করে। এরপর মডেলকে ইনপুট দিয়ে আউটপুট প্রেডিক্ট করা হয়।

টিপস:

• মডেল ট্রেনিংয়ের পরে মডেল ইভালুয়েশন বা প্রেডিকশনের জন্য model.eval() এবং ট্রেনিংয়ের জন্য model.train() ব্যবহার করা উচিৎ।
• মডেল ও ওজন লোড করার সময় মডেলের স্ট্রাকচার ও ওজনের ফাইল একসাথে ম্যাচ করা প্রয়োজন।

State Dictionary এবং Model Serialization PyTorch-এ মডেল সংরক্ষণ এবং পুনরায় লোড করার জন্য ব্যবহৃত হয়। এগুলো মডেল ট্রেনিংয়ের পরে মডেলের ওজন এবং প্যারামিটার সংরক্ষণ এবং পুনরুদ্ধারে গুরুত্বপূর্ণ ভূমিকা পালন করে।

1. State Dictionary

PyTorch-এ State Dictionary হলো একটি Python dictionary যেখানে মডেলের সমস্ত লেয়ারের প্যারামিটার এবং optimizer এর অবস্থা (state) সংরক্ষিত থাকে। এটি মডেলের ওজন এবং বায়াস (biases) ইত্যাদির তথ্য সংরক্ষণ করে। State Dictionary ব্যবহার করে মডেলের বর্তমান অবস্থা সেভ বা লোড করা যায়।

State Dictionary এর উদাহরণ:

import torch
import torch.nn as nn
import torch.optim as optim

# একটি সাধারণ নিউরাল নেটওয়ার্ক তৈরি
class SimpleNN(nn.Module):
    def __init__(self, input_size, hidden_size, output_size):
        super(SimpleNN, self).__init__()
        self.hidden = nn.Linear(input_size, hidden_size)
        self.output = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        x = torch.relu(self.hidden(x))
        x = self.output(x)
        return x

# মডেল এবং optimizer ইনিশিয়ালাইজ
model = SimpleNN(input_size=2, hidden_size=5, output_size=1)
optimizer = optim.SGD(model.parameters(), lr=0.01)

# State Dictionary প্রিন্ট করা
print("Model's State Dictionary:")
for param_tensor in model.state_dict():
    print(param_tensor, "\t", model.state_dict()[param_tensor].size())

print("\nOptimizer's State Dictionary:")
for var_name in optimizer.state_dict():
    print(var_name, "\t", optimizer.state_dict()[var_name])
Copy

2. Model Serialization

Model Serialization PyTorch-এ মডেলের state dictionary সংরক্ষণ এবং পুনরায় লোড করার প্রক্রিয়া। এটি মডেল ট্রেনিং শেষ হওয়ার পর মডেলের ওজন সংরক্ষণ করতে এবং পরবর্তী সময়ে মডেল পুনরায় ব্যবহার করতে সাহায্য করে।

মডেল সংরক্ষণ (Saving the Model):

# মডেলের state dictionary সংরক্ষণ করা
torch.save(model.state_dict(), 'model.pth')
Copy

মডেল পুনরায় লোড (Loading the Model):

# একই আর্কিটেকচার দিয়ে একটি মডেল ইনিশিয়ালাইজ করা
model = SimpleNN(input_size=2, hidden_size=5, output_size=1)

# সংরক্ষিত state dictionary লোড করা
model.load_state_dict(torch.load('model.pth'))

# মডেলকে ইভ্যালুয়েশন মোডে সেট করা
model.eval()
Copy

3. Optimizer Serialization

মডেল সংরক্ষণের পাশাপাশি optimizer এর অবস্থা (state) সংরক্ষণ করাও গুরুত্বপূর্ণ, বিশেষ করে যখন আপনি ট্রেনিং পুনরায় শুরু করতে চান।

Optimizer সংরক্ষণ:

# Optimizer-এর state dictionary সংরক্ষণ করা
torch.save(optimizer.state_dict(), 'optimizer.pth')
Copy

Optimizer পুনরায় লোড:

# মডেলের মতোই একই optimizer ইনিশিয়ালাইজ করা
optimizer = optim.SGD(model.parameters(), lr=0.01)

# সংরক্ষিত state dictionary লোড করা
optimizer.load_state_dict(torch.load('optimizer.pth'))
Copy

4. সম্পূর্ণ মডেল সংরক্ষণ (Saving the Entire Model)

আপনি মডেলের পুরো অবস্থা সরাসরি সংরক্ষণ করতে পারেন, তবে এটি কিছু ক্ষেত্রে সমস্যার সৃষ্টি করতে পারে, যেমন মডেলের ক্লাসের সংজ্ঞা পরিবর্তন করলে বা PyTorch আপডেট করলে। তবে এটি একটি সহজ পদ্ধতি এবং বিশেষ করে ছোট প্রজেক্টের জন্য উপযুক্ত।

সম্পূর্ণ মডেল সংরক্ষণ এবং লোড করার উদাহরণ:

# মডেল সম্পূর্ণভাবে সংরক্ষণ করা
torch.save(model, 'entire_model.pth')

# মডেল পুনরায় লোড করা
model = torch.load('entire_model.pth')
model.eval()
Copy

গুরুত্বপূর্ণ টিপস:

1. State Dictionary পদ্ধতি প্রাধান্য দেওয়া: torch.save(model.state_dict(), PATH) পদ্ধতিটি সবচেয়ে সাধারণ এবং মডেলের পোর্টেবিলিটি বাড়াতে সহায়ক।
2. মডেল আর্কিটেকচার বজায় রাখা: মডেলের state dictionary লোড করার আগে অবশ্যই মডেলের আর্কিটেকচার একই রাখতে হবে।
3. Eval Mode: মডেল লোড করার পরে মডেলকে eval() মোডে সেট করা উচিত, যাতে Dropout এবং Batch Normalization সঠিকভাবে কাজ করে।

এভাবে PyTorch-এ মডেল সংরক্ষণ এবং পুনরায় লোড করার জন্য State Dictionary এবং Model Serialization ব্যবহার করা হয়।

PyTorch-এ মডেল সেভ এবং লোড করার জন্য আমরা দুটি প্রধান ধাপ অনুসরণ করি:

1. মডেল সেভ করা: আমরা মডেলের বর্তমান স্টেট (weights এবং biases) সংরক্ষণ করি, যাতে পরবর্তীতে মডেলটি পুনরায় ব্যবহার করা যায়।
2. মডেল লোড করা: সংরক্ষিত মডেল পুনরায় লোড করে, এটি দিয়ে ইনফারেন্স বা পুনরায় ট্রেনিং করা।

নিচে উদাহরণসহ এই প্রক্রিয়া ব্যাখ্যা করা হয়েছে।

ধাপ ১: প্যাকেজ ইমপোর্ট করা

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
Copy

ধাপ ২: ডেটাসেট লোড করা

আমরা MNIST ডাটাসেট লোড করবো, যেমন আমরা আগেও করেছি।

transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

train_dataset = torchvision.datasets.MNIST(root='./data', train=True, transform=transform, download=True)
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)
Copy

ধাপ ৩: মডেল তৈরি করা

একটি সিম্পল নিউরাল নেটওয়ার্ক মডেল তৈরি করা:

class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(28 * 28, 128)
        self.fc2 = nn.Linear(128, 64)
        self.fc3 = nn.Linear(64, 10)

    def forward(self, x):
        x = x.view(-1, 28 * 28)  # ইনপুট ফ্ল্যাট করা
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x

model = SimpleNN()
Copy

ধাপ ৪: লস ফাংশন এবং অপ্টিমাইজার সেট করা

criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
Copy

ধাপ ৫: মডেল ট্রেনিং

আমরা একটি এপক চালিয়ে মডেলটি ট্রেন করবো।

def train_model(model, train_loader, criterion, optimizer):
    model.train()  # মডেলকে ট্রেনিং মোডে সেট করা
    for images, labels in train_loader:
        outputs = model(images)
        loss = criterion(outputs, labels)
        
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()
    
train_model(model, train_loader, criterion, optimizer)
Copy

ধাপ ৬: মডেল সেভ করা

মডেলটি সেভ করার জন্য PyTorch-এর torch.save ফাংশন ব্যবহার করা হয়। এখানে মডেলের স্টেট ডিকশনারি সংরক্ষণ করা হবে।

torch.save(model.state_dict(), 'simple_nn_model.pth')
Copy

• model.state_dict(): এটি মডেলের বর্তমান স্টেট (weights এবং biases) সংরক্ষণ করে।
• 'simple_nn_model.pth': ফাইলের নাম যেখানে মডেল সংরক্ষণ করা হবে।

ধাপ ৭: মডেল লোড করা

সংরক্ষিত মডেলটি লোড করতে, প্রথমে একই আর্কিটেকচারের একটি মডেল তৈরি করতে হবে, তারপর সংরক্ষিত স্টেট লোড করতে হবে।

# মডেলের নতুন ইনস্ট্যান্স তৈরি করা
loaded_model = SimpleNN()

# সেভ করা মডেল স্টেট লোড করা
loaded_model.load_state_dict(torch.load('simple_nn_model.pth'))

# মডেলকে ইভালুয়েশন মোডে সেট করা
loaded_model.eval()
Copy

ধাপ ৮: ইনফারেন্স করা

লোড করা মডেল দিয়ে এখন ইনফারেন্স করা যাবে। আমরা এখানে একটি ইমেজে প্রেডিকশন করবো।

# একটি ব্যাচ থেকে একটি ইমেজ এবং লেবেল নেওয়া
images, labels = next(iter(train_loader))
image = images[0].unsqueeze(0)  # একটি ইমেজ নিয়ে এক্সট্রা ব্যাচ ডাইমেনশন যোগ করা

# মডেল দিয়ে প্রেডিকশন করা
with torch.no_grad():
    output = loaded_model(image)
    _, predicted = torch.max(output, 1)
    print(f'Predicted: {predicted.item()}, Actual: {labels[0].item()}')
Copy

মডেল সেভ এবং লোড করার প্রক্রিয়ার সংক্ষেপ:

মডেল সেভ করা:

torch.save(model.state_dict(), 'simple_nn_model.pth')
Copy

মডেল লোড করা:

loaded_model = SimpleNN()
loaded_model.load_state_dict(torch.load('simple_nn_model.pth'))
loaded_model.eval()
Copy

এভাবে, PyTorch-এ মডেল সেভ এবং লোড করা হয়। এই পদ্ধতিতে মডেল সংরক্ষণ করলে, আপনি পরবর্তীতে সহজেই মডেল লোড করে ইনফারেন্স বা পুনরায় ট্রেনিং করতে পারবেন।