AUTOGRAD: AUTOMATIC DIFFERENTIATION
পাইটর্চের সমস্ত নিউরাল নেটওয়ার্কের কেন্দ্রীয় হ'ল অটোগ্রাড প্যাকেজ। আসুন প্রথমে সংক্ষিপ্তভাবে এটি পরিদর্শন করা যাক এবং তারপরে আমরা আমাদের প্রথম নিউরাল নেটওয়ার্ক প্রশিক্ষণ নেব।
অটোগ্রাড প্যাকেজ টেনসরগুলিতে সমস্ত ক্রিয়াকলাপের জন্য স্বয়ংক্রিয় পার্থক্য সরবরাহ করে। এটি একটি সংজ্ঞা দ্বারা চালিত কাঠামো, যার অর্থ আপনার ব্যাকপ্রপটি আপনার কোডটি কীভাবে চালিত হয় তা দ্বারা সংজ্ঞায়িত করা হয় এবং প্রতিটি একক পুনরাবৃত্তি আলাদা হতে পারে।আসুন কয়েকটি উদাহরণ সহ এটি আরও সাধারণ পদে দেখুন।
টেন্সর
torch.Tensor
প্যাকেজের কেন্দ্রীয় শ্রেণি। যদি আপনি এর বৈশিষ্ট্যটি .requires_grad
হিসাবে সেট True
করেন তবে এটি এতে সমস্ত ক্রিয়াকলাপ ট্র্যাক করতে শুরু করে। আপনি যখন আপনার গণনা শেষ করবেন আপনি কল করতে পারবেন .backward()
এবং সমস্ত গ্রেডিয়েন্ট স্বয়ংক্রিয়ভাবে গণিত করতে পারবেন । এই টেন্সরের গ্রেডিয়েন্টটি .grad
অ্যাট্রিবিউটে জমা করা হবে ।
ইতিহাসকে ট্র্যাকিং করা থেকে বিরত রাখতে, আপনি
.detach()
এটি গণনার ইতিহাস থেকে আলাদা করতে এবং ভবিষ্যতের গণনাটিকে ট্র্যাক হওয়া থেকে রোধ করতে কল করতে পারেন ।
ট্র্যাকিংয়ের ইতিহাস (এবং মেমরি ব্যবহার করে) রোধ করতে, আপনি কোড ব্লকটি মোড়ানো করতে পারেন । কোনও মডেলকে মূল্যায়ন করার সময় এটি বিশেষত সহায়ক হতে পারে কারণ মডেলটির সাথে প্রশিক্ষণযোগ্য পরামিতি থাকতে পারে তবে যার জন্য আমাদের গ্রেডিয়েন্টের প্রয়োজন নেই।
with torch.no_grad():
requires_grad=True
অটোগ্রাড বাস্তবায়নের জন্য আরও একটি বর্গ রয়েছে যা - ক
Function
।Tensor
এবং Function
একে অপরের সাথে সংযুক্ত এবং একটি অ্যাসাইক্লিক গ্রাফ তৈরি করে, যা গণনার সম্পূর্ণ ইতিহাসকে এনকোড করে। প্রতিটি টেন্সর টি .grad_fn
অ্যাট্রিবিউটে একটি রেফারেন্স যে Function
সৃষ্টি করেছেন যে Tensor
(ব্যবহারকারী দ্বারা নির্মিত Tensors ছাড়া - তাদের )।grad_fn is None
আপনি ডেরাইভেটিভস গনা করতে চান তাহলে, আপনি কল করতে পারেন
.backward()
একটি উপর Tensor
। যদি Tensor
কোনও স্কেলার হয় (যেমন এটিতে একটি উপাদান সম্পর্কিত ডেটা রয়েছে) backward()
তবে আপনার কোনও যুক্তি নির্দিষ্ট করার দরকার নেই , তবে এর মধ্যে আরও উপাদান রয়েছে তবে আপনাকে একটি gradient
যুক্তি নির্দিষ্ট করতে হবে যা মেলানো আকৃতির টেন্সর।import torch
একটি সেন্সর তৈরি করুন এবং
requires_grad=True
এটির সাথে গণনা ট্র্যাক করতে সেট করুনx = torch.ones(2, 2, requires_grad=True)
print(x)
বাইরে:
tensor([[1., 1.],
[1., 1.]], requires_grad=True)
একটি সেন্সর অপারেশন করুন:
y = x + 2
print(y)
বাইরে:
tensor([[3., 3.],
[3., 3.]], grad_fn=)
y
অপারেশনের ফলে তৈরি করা হয়েছিল, সুতরাং এটির একটি রয়েছে grad_fn
।print(y.grad_fn)
বাইরে:
আরও অপারেশন চালু আছে
y
z = y * y * 3
out = z.mean()
print(z, out)
বাইরে:
tensor([[27., 27.],
[27., 27.]], grad_fn=) tensor(27., grad_fn=)
.requires_grad_( ... )
requires_grad
জায়গায় বিদ্যমান টেনসরের পতাকা পরিবর্তন করে । False
যদি না দেওয়া হয় তবে ইনপুট ফ্ল্যাগটি ডিফল্ট হয় ।a = torch.randn(2, 2)
a = ((a * 3) / (a - 1))
print(a.requires_grad)
a.requires_grad_(True)
print(a.requires_grad)
b = (a * a).sum()
print(b.grad_fn)
বাইরে:
False
True
গ্রেডিয়েন্ট
এখন ব্যাকপ্রপণ করা যাক। কারণ
out
একটি একক স্কেলার রয়েছে, out.backward()
সমান out.backward(torch.tensor(1.))
।out.backward()
গ্রেডিয়েন্টগুলি মুদ্রণ করুন d (আউট) / ডিএক্স
print(x.grad)
বাইরে:
tensor([[4.5000, 4.5000],
[4.5000, 4.5000]])
আপনার একটি ম্যাট্রিক্স পাওয়া উচিত ছিল
4.5
। এর কল করা যাক out
টেন্সর ""। আমাদের তা আছে, এবং । অতএব, তাই, ।
গাণিতিকভাবে, যদি আপনার কোনও ভেক্টর মূল্যবান ফাংশন থাকে তারপরে গ্রেডিয়েন্ট সম্মানের সাথে একটি জ্যাকবীয় ম্যাট্রিক্স:
সাধারণত বলতে গেলে,
torch.autograd
ভেক্টর-জ্যাকবীয়িয়ান পণ্যগুলির কম্পিউটিংয়ের জন্য একটি ইঞ্জিন। যে কোনও ভেক্টর দেওয়া হয় , পণ্য গণনা । যদি স্কেলার ফাংশনের গ্রেডিয়েন্ট হতে পারে , এটাই, তারপরে, চেইন বিধি অনুসারে ভেক্টর-জ্যাকবিয়ান পণ্যটি গ্রেডিয়েন্ট হবে সম্মানের সাথে :
(মনে রাখবেন যে একটি সারি ভেক্টর দেয় যা গ্রহণ করে কলাম ভেক্টর হিসাবে বিবেচনা করা যেতে পারে ।)
ভেক্টর-জ্যাকবীয়িয়ান পণ্যের এই বৈশিষ্ট্যটি বহিরাগত গ্রেডিয়েন্টগুলিকে এমন একটি মডেলগুলিতে খাওয়ানো খুব সুবিধাজনক করে তোলে যা স্কেলারের আউটপুট না করে।
এখন ভেক্টর-জ্যাকবীয়িয়ান পণ্যের উদাহরণ দেখুন:
x = torch.randn(3, requires_grad=True)
y = x * 2
while y.data.norm() < 1000:
y = y * 2
print(y)
বাইরে:
tensor([-626.3561, 1018.6344, 249.6874], grad_fn=)
এখন
y
এক্ষেত্রে আর স্কেলার নয়। torch.autograd
সম্পূর্ণ জ্যাকবীয়িয়ান সরাসরি গণনা করতে পারিনি, তবে আমরা যদি কেবল ভেক্টর-জ্যাকবীয়িয়ান পণ্যটি চাই, কেবল ভেক্টরকে backward
যুক্তি হিসাবে পাস করুন :v = torch.tensor([0.1, 1.0, 0.0001], dtype=torch.float)
y.backward(v)
print(x.grad)
বাইরে:
tensor([5.1200e+01, 5.1200e+02, 5.1200e-02])
আপনি
.requires_grad=True
কোড ব্লক ইন মোড়ক দিয়ে টেনসরগুলিতে ইতিহাস ট্র্যাকিং থেকে অটোগ্রাড বন্ধ করতে পারেনwith torch.no_grad():
print(x.requires_grad)
print((x ** 2).requires_grad)
with torch.no_grad():
print((x ** 2).requires_grad)
বাইরে:
True
True
False
পরে পড়ুন:
স্ক্রিপ্টের মোট চলমান সময়: (0 মিনিট 3.481 সেকেন্ড)
0 comments:
Post a Comment