ট্রান্সফার লার্নিং, প্রি-ট্রেইন্ড মডেল এবং PyTorch-এ দক্ষতা বাড়ানোর জন্য কিছু প্র্যাকটিস প্রোজেক্ট নিচে দেওয়া হলো। এই প্রোজেক্টগুলি বিভিন্ন ডেটাসেট এবং মডেল ব্যবহার করে ডিপ লার্নিংয়ের বিভিন্ন দিক সম্পর্কে আরও গভীর জ্ঞান অর্জন করতে সহায়ক হবে।
বিবরণ: কুকুর এবং বিড়ালের ছবি নিয়ে একটি প্রি-ট্রেইন্ড মডেল (যেমন ResNet) ব্যবহার করে ট্রান্সফার লার্নিং প্রয়োগ করে কুকুর এবং বিড়াল শ্রেণীবিভাজন করুন।
বিবরণ: MNIST ডেটাসেট ব্যবহার করে প্রি-ট্রেইন্ড মডেল দিয়ে হাতের লেখা ডিজিট শনাক্ত করুন।
torchvision থেকে MNIST ডেটাসেট ব্যবহার করুন।বিবরণ: ফলের বিভিন্ন প্রকার (যেমন আপেল, কলা, কমলা) শনাক্ত করতে ট্রান্সফার লার্নিং প্রয়োগ করুন।
বিবরণ: মানুষের মুখের বিভিন্ন অভিব্যক্তি (যেমন হাসি, দুঃখ, রাগ) শনাক্ত করার জন্য মডেল তৈরি করুন।
বিবরণ: বিভিন্ন ধরনের ফুল শনাক্ত করতে প্রি-ট্রেইন্ড মডেল ব্যবহার করে মডেল তৈরি করুন।
বিবরণ: ফ্যাশন MNIST ডেটাসেট ব্যবহার করে কাপড়ের বিভিন্ন প্রকার (যেমন জুতো, জামা, ব্যাগ) শ্রেণীবিভাজন করুন।
torchvision থেকে Fashion MNIST ডেটাসেট ব্যবহার করুন।বিবরণ: PyTorch এবং ট্রান্সফার লার্নিং ব্যবহার করে ছবি থেকে বিভিন্ন বস্তু শনাক্ত করার মডেল তৈরি করুন।
বিবরণ: ফলের পাকাভাব (যেমন কাঁচা, আধা-পাকা, পাকা) শনাক্ত করতে মডেল তৈরি করুন।
বিবরণ: বিভিন্ন প্রাকৃতিক এবং কৃত্রিম ল্যান্ডমার্ক শনাক্ত করার মডেল তৈরি করুন।
বিবরণ: একটি ছবির স্টাইল (যেমন পেইন্টিং বা ফটোগ্রাফ) ট্রান্সফার করে অন্য ছবিতে প্রয়োগ করুন।
এই প্রোজেক্টগুলো PyTorch, ট্রান্সফার লার্নিং, এবং প্রি-ট্রেইন্ড মডেলের কনসেপ্ট শেখার জন্য খুবই উপযোগী। এগুলোর মাধ্যমে আপনি মডেল তৈরি, ট্রেনিং, ফাইন-টিউনিং, এবং অপ্টিমাইজেশন সম্পর্কে গভীর জ্ঞান অর্জন করতে পারবেন।
Torch (PyTorch) ব্যবহার করে একটি Basic Image Classification মডেল তৈরি করা সহজ এবং কার্যকর। এখানে আমরা একটি সহজ CNN (Convolutional Neural Network) মডেল তৈরি করব, যা MNIST ডেটাসেট ব্যবহার করে হ্যান্ডরিটেন ডিজিট ক্লাসিফিকেশন করতে সক্ষম হবে।
লাইব্রেরি ইনস্টল এবং ইম্পোর্ট করা: প্রথমে, PyTorch এবং torchvision লাইব্রেরি ইনস্টল করতে হবে (যদি আগে ইনস্টল না থাকে)।
pip install torch torchvision
MNIST ডেটাসেট লোড করা: torchvision লাইব্রেরি ব্যবহার করে MNIST ডেটাসেট ডাউনলোড এবং লোড করা।
মডেল ডিজাইন করা: একটি সরল CNN মডেল তৈরি করা, যা ইমেজ ফিচার এক্সট্র্যাক্ট করতে এবং ক্লাসিফিকেশন করতে পারবে।
মডেল ট্রেনিং করা: মডেল ট্রেনিং করার জন্য ট্রেনিং লুপ তৈরি করা এবং ভ্যালিডেশন ডেটা ব্যবহার করে মডেলের পারফরম্যান্স যাচাই করা।
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
# ডিভাইস চেক করা (GPU থাকলে CUDA ব্যবহার করা)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# 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)
test_dataset = torchvision.datasets.MNIST(root='./data', train=False, transform=transform, download=True)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False)
# CNN মডেল ডিজাইন
class SimpleCNN(nn.Module):
def __init__(self):
super(SimpleCNN, self).__init__()
self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1)
self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)
self.pool = nn.MaxPool2d(2, 2)
self.fc1 = nn.Linear(64 * 7 * 7, 128)
self.fc2 = nn.Linear(128, 10)
self.relu = nn.ReLU()
self.dropout = nn.Dropout(0.25)
def forward(self, x):
x = self.pool(self.relu(self.conv1(x)))
x = self.pool(self.relu(self.conv2(x)))
x = x.view(-1, 64 * 7 * 7) # ফ্ল্যাট করা
x = self.relu(self.fc1(x))
x = self.dropout(x)
x = self.fc2(x)
return x
# মডেল ইনস্ট্যান্স তৈরি এবং ডিভাইসে সরানো
model = SimpleCNN().to(device)
# লস ফাংশন এবং অপ্টিমাইজার নির্ধারণ
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
# ট্রেনিং ফাংশন
def train(model, train_loader, criterion, optimizer, device):
model.train()
running_loss = 0.0
for images, labels in train_loader:
images, labels = images.to(device), labels.to(device)
optimizer.zero_grad() # গ্রেডিয়েন্ট রিসেট করা
outputs = model(images) # মডেলে ইনপুট প্রয়োগ
loss = criterion(outputs, labels) # লস গণনা
loss.backward() # ব্যাকপ্রোপাগেশন
optimizer.step() # অপ্টিমাইজেশন
running_loss += loss.item()
return running_loss / len(train_loader)
# এভালুয়েশন ফাংশন
def evaluate(model, test_loader, criterion, device):
model.eval()
correct = 0
total = 0
with torch.no_grad():
for images, labels in test_loader:
images, labels = images.to(device), labels.to(device)
outputs = model(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
accuracy = 100 * correct / total
return accuracy
# মডেল ট্রেনিং
num_epochs = 10
for epoch in range(num_epochs):
train_loss = train(model, train_loader, criterion, optimizer, device)
accuracy = evaluate(model, test_loader, criterion, device)
print(f"Epoch [{epoch+1}/{num_epochs}], Loss: {train_loss:.4f}, Accuracy: {accuracy:.2f}%")
# মডেল সংরক্ষণ করা
torch.save(model.state_dict(), 'simple_cnn_mnist.pth')
conv1 এবং conv2), একটি ম্যাক্সপুল লেয়ার, এবং দুটি ফFully connected লেয়ার (fc1 এবং fc2) রয়েছে।train ফাংশন এবং মডেলের পারফরম্যান্স যাচাই করার জন্য একটি evaluate ফাংশন তৈরি করেছি।'simple_cnn_mnist.pth' নামে সংরক্ষণ করা হয়েছে।এই পদ্ধতিতে, আপনি PyTorch ব্যবহার করে একটি Basic Image Classification মডেল তৈরি করতে পারেন। মডেলের আর্কিটেকচার এবং ডেটাসেট পরিবর্তন করে আপনার প্রয়োজন অনুযায়ী আরও উন্নত মডেল তৈরি করা সম্ভব।
Transfer Learning ব্যবহার করে মডেল ট্রেনিং করার জন্য প্রি-ট্রেইন্ড মডেল (যেমন ResNet, VGG, বা MobileNet) ব্যবহার করা হয় এবং এটি নতুন ডেটাসেটে ফাইন-টিউন করা হয়। Transfer Learning মূলত প্রি-ট্রেইন্ড মডেলের ফিচারগুলোকে পুনরায় ব্যবহার করে নতুন ডেটাসেটে মডেলকে ট্রেনিং করে, যা ট্রেনিং টাইম এবং কম্পিউটেশন কমায়। নিচে PyTorch ব্যবহার করে Transfer Learning এর উদাহরণ দেওয়া হয়েছে।
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, models, transforms
from torch.utils.data import DataLoader
# ডেটা ট্রান্সফর্মেশন ডিফাইন করা (ইমেজ রিসাইজ এবং নরমালাইজেশন)
transform = transforms.Compose([
transforms.Resize((224, 224)), # ইমেজকে 224x224 রিসাইজ করা
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) # ImageNet এর জন্য স্ট্যান্ডার্ড নরমালাইজেশন
])
# ট্রেনিং এবং ভ্যালিডেশন ডেটাসেট লোড করা
train_dataset = datasets.CIFAR10(root='./data', train=True, transform=transform, download=True)
val_dataset = datasets.CIFAR10(root='./data', train=False, transform=transform, download=True)
# DataLoader তৈরি করা
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False)
# ডিভাইস সেট করা (GPU থাকলে CUDA, নাহলে CPU)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# প্রি-ট্রেইন্ড ResNet18 মডেল লোড করা
model = models.resnet18(pretrained=True)
# সমস্ত লেয়ারের গ্রেডিয়েন্ট ফ্রিজ করা (Feature Extraction)
for param in model.parameters():
param.requires_grad = False
# আউটপুট লেয়ার পরিবর্তন করা (CIFAR-10 এ ১০টি ক্লাস আছে)
num_features = model.fc.in_features
model.fc = nn.Linear(num_features, 10)
# মডেলকে ডিভাইসে মুভ করা
model = model.to(device)
# শুধুমাত্র ফাইনাল লেয়ারের প্যারামিটার ট্রেনিং হবে
optimizer = optim.SGD(model.fc.parameters(), lr=0.001, momentum=0.9)
# ক্রস এন্ট্রপি লস ফাংশন ব্যবহার করা
criterion = nn.CrossEntropyLoss()
num_epochs = 5
for epoch in range(num_epochs):
model.train() # ট্রেনিং মোডে সেট করা
running_loss = 0.0
for images, labels in train_loader:
images, labels = images.to(device), labels.to(device)
# ফরওয়ার্ড পাস
outputs = model(images)
loss = criterion(outputs, labels)
# ব্যাকওয়ার্ড পাস এবং অপ্টিমাইজেশন
optimizer.zero_grad()
loss.backward()
optimizer.step()
running_loss += loss.item()
print(f"Epoch [{epoch+1}/{num_epochs}], Loss: {running_loss/len(train_loader):.4f}")
model.eval() # ইভালুয়েশন মোডে সেট করা
correct = 0
total = 0
with torch.no_grad():
for images, labels in val_loader:
images, labels = images.to(device), labels.to(device)
outputs = model(images)
_, predicted = torch.max(outputs, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
accuracy = 100 * correct / total
print(f'Validation Accuracy: {accuracy:.2f}%')
প্রি-ট্রেইন্ড মডেল লোড এবং মডিফাই:
models.resnet18(pretrained=True) দিয়ে প্রি-ট্রেইন্ড ResNet-18 মডেল লোড করা হয়েছে।অপ্টিমাইজার এবং লস ফাংশন:
model.fc.parameters() ব্যবহার করে ফাইনাল লেয়ারের প্যারামিটারগুলো অপ্টিমাইজারের সাথে যুক্ত করা হয়েছে।nn.CrossEntropyLoss() ব্যবহার করে লস ফাংশন সেট করা হয়েছে।ট্রেনিং এবং ভ্যালিডেশন লুপ:
model.eval()) সেট করা হয় এবং আউটপুটের সাথে আসল লেবেলের মিল চেক করা হয়।এইভাবে, Transfer Learning ব্যবহার করে দ্রুত এবং কার্যকরভাবে নতুন ডেটাসেটে মডেল ট্রেনিং করা যায়।
PyTorch-এ Custom Dataset ব্যবহার করে মডেল তৈরি এবং ট্রেনিং করতে হলে, আমাদের torch.utils.data.Dataset ক্লাসটি ইনহেরিট করে একটি কাস্টম ডেটাসেট ক্লাস তৈরি করতে হবে। এটি আমাদের ডেটাসেটের জন্য ডেটা লোডিং এবং প্রিপ্রসেসিং কাস্টমাইজ করার সুবিধা দেয়। এরপর, DataLoader ব্যবহার করে সেই ডেটাসেটকে ব্যাচ হিসেবে লোড করা যায় এবং মডেল ট্রেনিং করা যায়। নিচে একটি পূর্ণাঙ্গ উদাহরণ দেখানো হলো।
আমরা torch.utils.data.Dataset ক্লাস ইনহেরিট করে একটি কাস্টম ডেটাসেট তৈরি করবো, যা ইমেজ ডেটাসেট লোড করবে।
import torch
from torch.utils.data import Dataset
from torchvision import transforms
from PIL import Image
import os
class CustomImageDataset(Dataset):
def __init__(self, image_dir, transform=None):
self.image_dir = image_dir
self.transform = transform
self.image_names = os.listdir(image_dir)
def __len__(self):
return len(self.image_names)
def __getitem__(self, idx):
img_name = os.path.join(self.image_dir, self.image_names[idx])
image = Image.open(img_name).convert('RGB')
label = 0 if 'cat' in img_name else 1 # ফাইলের নাম দেখে লেবেল নির্ধারণ
if self.transform:
image = self.transform(image)
return image, label
ব্যাখ্যা:
__init__: ডেটাসেটের ডিরেক্টরি এবং ট্রান্সফর্ম প্যারামিটার হিসেবে নেওয়া হয়েছে।__len__: ডেটাসেটের সাইজ রিটার্ন করে।__getitem__: ইমেজ এবং লেবেল লোড করে এবং রিটার্ন করে।from torch.utils.data import DataLoader
# ডেটা ট্রান্সফর্ম সেট করা
data_transform = transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
# Custom Dataset তৈরি করা
train_dataset = CustomImageDataset(image_dir='data/train', transform=data_transform)
val_dataset = CustomImageDataset(image_dir='data/val', transform=data_transform)
# DataLoader তৈরি করা
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True, num_workers=4)
val_loader = DataLoader(val_dataset, batch_size=32, shuffle=False, num_workers=4)
import torch.nn as nn
import torchvision.models as models
# প্রি-ট্রেইনড মডেল লোড করা (ResNet18)
model = models.resnet18(pretrained=True)
num_ftrs = model.fc.in_features
model.fc = nn.Linear(num_ftrs, 2) # Cat এবং Dog, দুটি ক্লাস
# মডেলকে GPU তে স্থানান্তর করা
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
model = model.to(device)
import torch.optim as optim
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
num_epochs = 10
for epoch in range(num_epochs):
print(f'Epoch {epoch+1}/{num_epochs}')
print('-' * 10)
# Training Loop
model.train() # মডেলকে ট্রেনিং মোডে সেট করা
running_loss = 0.0
running_corrects = 0
for inputs, labels in train_loader:
inputs = inputs.to(device)
labels = labels.to(device)
optimizer.zero_grad() # গ্রেডিয়েন্ট রিসেট করা
# Forward Pass
outputs = model(inputs)
_, preds = torch.max(outputs, 1)
loss = criterion(outputs, labels)
# Backward Pass এবং Optimizer Step
loss.backward()
optimizer.step()
running_loss += loss.item() * inputs.size(0)
running_corrects += torch.sum(preds == labels.data)
epoch_loss = running_loss / len(train_dataset)
epoch_acc = running_corrects.double() / len(train_dataset)
print(f'Training Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f}')
# Validation Loop
model.eval() # মডেলকে ইভ্যালুয়েশন মোডে সেট করা
val_running_loss = 0.0
val_running_corrects = 0
with torch.no_grad():
for inputs, labels in val_loader:
inputs = inputs.to(device)
labels = labels.to(device)
outputs = model(inputs)
_, preds = torch.max(outputs, 1)
loss = criterion(outputs, labels)
val_running_loss += loss.item() * inputs.size(0)
val_running_corrects += torch.sum(preds == labels.data)
val_loss = val_running_loss / len(val_dataset)
val_acc = val_running_corrects.double() / len(val_dataset)
print(f'Validation Loss: {val_loss:.4f} Acc: {val_acc:.4f}')
CustomImageDataset ক্লাস ব্যবহার করে ট্রেনিং এবং ভ্যালিডেশন ডেটাসেট লোড করা হয়েছে।DataLoader দিয়ে ডেটা ব্যাচ আকারে লোড করা হয়েছে।torch.save(model.state_dict(), 'custom_model.pth')
এভাবে PyTorch-এ Custom Dataset ব্যবহার করে মডেল তৈরি এবং ট্রেনিং করা যায়। Custom Dataset ক্লাস ব্যবহার করে আমরা যে কোনো ধরনের ডেটা সহজেই লোড এবং প্রিপ্রসেস করতে পারি।
GPU ব্যবহার করে মডেল ট্রেনিং প্রজেক্টে আমরা দ্রুত এবং কার্যকরীভাবে মডেল ট্রেনিং করতে পারি, যা বড় ডেটাসেট এবং কমপ্লেক্স মডেলগুলির জন্য গুরুত্বপূর্ণ। এখানে আমরা একটি প্রকল্পের মাধ্যমে GPU ব্যবহার করে একটি মডেল ট্রেনিং এর ধাপ দেখাবো। এই প্রকল্পে, আমরা CIFAR-10 ডেটাসেট ব্যবহার করবো এবং ResNet18 মডেলের মাধ্যমে ইমেজ ক্লাসিফিকেশন করবো।
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
from torchvision import models
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(f'Using device: {device}')
transform = transforms.Compose([
transforms.Resize((224, 224)), # ResNet এর জন্য ইমেজ রিসাইজ
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
train_dataset = torchvision.datasets.CIFAR10(root='./data', train=True, transform=transform, download=True)
train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)
test_dataset = torchvision.datasets.CIFAR10(root='./data', train=False, transform=transform, download=True)
test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)
# ResNet18 প্রি-ট্রেইনড মডেল লোড করা
model = models.resnet18(pretrained=True)
# ফিচার লেয়ারগুলো ফ্রিজ করা
for param in model.parameters():
param.requires_grad = False
# মডেলের শেষ লেয়ার কাস্টমাইজ করা
num_features = model.fc.in_features
model.fc = nn.Linear(num_features, 10) # CIFAR-10 এর জন্য আউটপুট ক্লাস সংখ্যা ১০
# মডেলকে GPU তে স্থানান্তর করা
model = model.to(device)
criterion = nn.CrossEntropyLoss()
# শুধুমাত্র শেষ লেয়ার (classifier) ট্রেনিং হবে
optimizer = optim.Adam(model.fc.parameters(), lr=0.001)
def train_model(model, train_loader, criterion, optimizer, device, num_epochs=10):
model.train()
for epoch in range(num_epochs):
running_loss = 0.0
for images, labels in train_loader:
images, labels = images.to(device), labels.to(device)
outputs = model(images)
loss = criterion(outputs, labels)
optimizer.zero_grad()
loss.backward()
optimizer.step()
running_loss += loss.item()
print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {running_loss / len(train_loader):.4f}')
# মডেল ট্রেনিং চালানো
train_model(model, train_loader, criterion, optimizer, device)
def validate_model(model, test_loader, criterion, device):
model.eval()
correct = 0
total = 0
val_loss = 0.0
with torch.no_grad():
for images, labels in test_loader:
images, labels = images.to(device), labels.to(device)
outputs = model(images)
loss = criterion(outputs, labels)
val_loss += loss.item()
_, predicted = torch.max(outputs, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
accuracy = 100 * correct / total
print(f'Validation Loss: {val_loss / len(test_loader):.4f}, Accuracy: {accuracy:.2f}%')
# মডেল ভ্যালিডেশন চালানো
validate_model(model, test_loader, criterion, device)
torch.save(model.state_dict(), 'resnet18_cifar10_gpu.pth')
# মডেলের নতুন ইনস্ট্যান্স তৈরি এবং GPU তে স্থানান্তর করা
loaded_model = models.resnet18(pretrained=False)
loaded_model.fc = nn.Linear(num_features, 10)
loaded_model.load_state_dict(torch.load('resnet18_cifar10_gpu.pth'))
loaded_model = loaded_model.to(device)
loaded_model.eval()
# একটি ইমেজে প্রেডিকশন করা
images, labels = next(iter(test_loader))
image = images[0].unsqueeze(0).to(device)
with torch.no_grad():
output = loaded_model(image)
_, predicted = torch.max(output, 1)
print(f'Predicted: {predicted.item()}, Actual: {labels[0].item()}')
এই প্রকল্পের মাধ্যমে, আপনি GPU ব্যবহার করে PyTorch-এ কিভাবে মডেল ট্রেনিং করতে হয় তা শিখতে পারবেন এবং মডেলের পারফরমেন্স উন্নত করতে পারবেন।
Read more
or
Lorem ipsum dolor, sit amet consectetur adipisicing elit. Ducimus nihil, quo, quis minus aspernatur expedita, incidunt facilis aliquid inventore voluptate dolores accusantium laborum labore a dolorum dolore omnis qui? Consequuntur sed facilis repellendus corrupti amet in quibusdam ducimus illo autem, a praesentium.
1 hour ago
Lorem ipsum dolor, sit amet consectetur adipisicing elit. Ducimus nihil, quo, quis minus aspernatur expedita, incidunt facilis aliquid inventore voluptate dolores accusantium laborum labore a dolorum dolore omnis qui? Consequuntur sed facilis repellendus corrupti amet in quibusdam ducimus illo autem, a praesentium.
1 hour ago
Lorem ipsum dolor, sit amet consectetur adipisicing elit. Ducimus nihil, quo, quis minus aspernatur expedita, incidunt facilis aliquid inventore voluptate dolores accusantium laborum labore a dolorum dolore omnis qui? Consequuntur sed facilis repellendus corrupti amet in quibusdam ducimus illo autem, a praesentium.
1 hour ago
Lorem ipsum dolor, sit amet consectetur adipisicing elit. Ducimus nihil, quo, quis minus aspernatur expedita, incidunt facilis aliquid inventore voluptate dolores accusantium laborum labore a dolorum dolore omnis qui? Consequuntur sed facilis repellendus corrupti amet in quibusdam ducimus illo autem, a praesentium.
1 hour ago
Lorem ipsum dolor, sit amet consectetur adipisicing elit. Ducimus nihil, quo, quis minus aspernatur expedita, incidunt facilis aliquid inventore voluptate dolores accusantium laborum labore a dolorum dolore omnis qui? Consequuntur sed facilis repellendus corrupti amet in quibusdam ducimus illo autem, a praesentium.
1 hour ago
Lorem ipsum dolor, sit amet consectetur adipisicing elit. Ducimus nihil, quo, quis minus aspernatur expedita, incidunt facilis aliquid inventore voluptate dolores accusantium laborum labore a dolorum dolore omnis qui? Consequuntur sed facilis repellendus corrupti amet in quibusdam ducimus illo autem, a praesentium.
1 hour ago
Lorem ipsum dolor, sit amet consectetur adipisicing elit. Ducimus nihil, quo, quis minus aspernatur expedita, incidunt facilis aliquid inventore voluptate dolores accusantium laborum labore a dolorum dolore omnis qui? Consequuntur sed facilis repellendus corrupti amet in quibusdam ducimus illo autem, a praesentium.
1 hour ago
Lorem ipsum dolor, sit amet consectetur adipisicing elit. Ducimus nihil, quo, quis minus aspernatur expedita, incidunt facilis aliquid inventore voluptate dolores accusantium laborum labore a dolorum dolore omnis qui? Consequuntur sed facilis repellendus corrupti amet in quibusdam ducimus illo autem, a praesentium.
1 hour ago
Lorem ipsum dolor, sit amet consectetur adipisicing elit. Ducimus nihil, quo, quis minus aspernatur expedita, incidunt facilis aliquid inventore voluptate dolores accusantium laborum labore a dolorum dolore omnis qui? Consequuntur sed facilis repellendus corrupti amet in quibusdam ducimus illo autem, a praesentium.
1 hour ago
Lorem ipsum dolor, sit amet consectetur adipisicing elit. Ducimus nihil, quo, quis minus aspernatur expedita, incidunt facilis aliquid inventore voluptate dolores accusantium laborum labore a dolorum dolore omnis qui? Consequuntur sed facilis repellendus corrupti amet in quibusdam ducimus illo autem, a praesentium.
1 hour ago
