کی طرف سے تصویر Deepmind on Unsplash سے
میٹرکس ضرب ایک بنیادی عمل ہے جو بہت سے نظاموں میں استعمال ہوتا ہے، نیورل نیٹ ورکس سے لے کر سائنسی کمپیوٹنگ کے معمولات تک۔ میٹرکس ضرب کے لیے موثر اور ثابت شدہ طور پر درست الگورتھم تلاش کرنا حساب کو تیز تر اور زیادہ موثر بنانے پر بہت زیادہ اثر ڈال سکتا ہے، لیکن یہ ایک بہت مشکل کام ہے۔ ممکنہ الگورتھم کی جگہ بہت زیادہ ہے، اور الگورتھم کو دریافت کرنے کے روایتی طریقے، جیسے کہ انسانی ڈیزائن کردہ ہیورسٹکس یا مشترکہ تلاش، اکثر سب سے بہتر ہوتے ہیں۔
Deepmind's recently proposed AI-based solution for automated search goes far beyond human intuition. The solution consists of a deep reinforcement learning agent called AlphaTensor, built on top of الفا زیرو. اس ایجنٹ کو سنگل پلیئر گیم، TensorGame کھیلنے کی تربیت دی جاتی ہے، جہاں مقصد میٹرکس ضرب کے لیے کمپیوٹیشنل طور پر موثر الگورتھم دریافت کرنا ہے۔
AlphaTensor بڑے میٹرکس کو چھوٹے ضربوں میں تحلیل کرکے بڑے میٹرکس کو سنبھالنے میں خاص طور پر اچھا ہے۔ مزید برآں، AlphaTensor کو مخصوص ہارڈویئر ڈیوائس پر ٹھیک ٹیون کرنے کے بعد میٹرکس ضرب کے لیے جدید ترین کارکردگی حاصل کرنے کے لیے استعمال کیا جا سکتا ہے۔
AlphaTensor میں گہری سیکھنے والی کمپیوٹنگ کو تیز کرنے کی بڑی صلاحیت ہے۔ گہری سیکھنے میں، بہت سے وقت لینے والے آپریشنز کو میٹرکس ضرب کے ساتھ نقشہ بنایا جا سکتا ہے۔ ان آپریشنز کو بہتر بنانے کے لیے AlphaTensor کا استعمال کرتے ہوئے، ڈیپ لرننگ ماڈلز کی مجموعی کارکردگی کو نمایاں طور پر بہتر بنایا جا سکتا ہے۔
حال ہی میں، OpenAlphaTensor، the AlphaTensor کا پہلا اوپن سورس نفاذ, جاری کیا گیا تھا، جو گہری سیکھنے کے ماڈلز کی کمپیوٹیشنل طاقت میں انقلاب لا سکتا ہے۔
میٹرکس ضرب ٹینسر
میٹرکس ضرب کی اصلاح کے غیر ماہرین کے لیے، یہ سمجھنا سیدھا نہیں ہو سکتا کہ میٹرکس ضرب جیسے آپریشن کو تین جہتی ٹینسر میں کیسے نقشہ بنایا جا سکتا ہے۔ میں اسے آسان الفاظ میں اور مثالوں سے سمجھانے کی کوشش کروں گا۔
آئیے پروڈکٹ C = A*B پر غور کریں، جہاں سادگی کے لیے A اور B دونوں سائز N کے مربع میٹرس ہیں۔ ضرب آپریشن کو شکل کے 3D ٹینسر (N^2, N^2, N^2) میں میپ کیا جا سکتا ہے۔ پہلی ٹینسر کی جہت چپٹی میٹرکس A، دوسری جہت چپٹی میٹرکس B اور تیسری جہت چپٹی میٹرکس C کی نمائندگی کرتی ہے۔
ٹینسر میں ہر اندراج کے لیے صرف بائنری اقدار (یا تو 1 یا 0) ہوتی ہیں۔ نوٹ کریں کہ ٹینسر ضرب کے عمل کی نمائندگی کرتا ہے، لہذا یہ میٹرکس A اور B کی قدروں سے آزاد ہے۔
ٹینسر کا ہر اندراج آپریشن کے گتانک سے مساوی ہے۔ مثال کے طور پر، C[1,1] کی گنتی کرنے کے لیے، A[1,1] اور B[1,1] دونوں کو ضرب دینا ضروری ہے۔ لہذا، ٹینسر انٹری [0,0,0]، جو A[1,1], B[1,1] اور C[1,1] کے مساوی ہے، کی قدر 1 ہوگی۔ اس کے برعکس، C[1,1 کی گنتی کرنے کے لیے ,2,1]، A[1] کی ضرورت نہیں ہے۔ اس طرح، ٹینسر قطار T[N+0, :, XNUMX] میں صرف صفر ہوں گے۔
نیچے دی گئی تصویر N=2 کے لیے ٹینسر کی ایک مثال دکھاتی ہے۔
Image from DeepMind's کاغذ میں شائع فطرت، قدرت
جیسا کہ اوپر کی تصویر میں (b) اور (c) میں دکھایا گیا ہے، 3D ٹینسر کے گلنے کا استعمال کرتے ہوئے پروڈکٹ کو کمپیوٹنگ کرنے کے لیے الگورتھم کو نافذ کرنا ممکن ہے۔ مزید خاص طور پر، نیچے دیئے گئے الگورتھم کو ٹینسر کی سڑن (میٹرکس U، V، W) کو میٹرکس ضرب الگورتھم میں تبدیل کرنے کے لیے استعمال کیا جا سکتا ہے۔
Meta-algorithm parameterized for computing the matrix product C=AB introduced in DeepMind's کاغذ
ٹینسر گیم
میٹرکس ضرب کے لیے موثر الگورتھم تلاش کرنے کا مسئلہ انتہائی مشکل ہے کیونکہ غور کرنے کے لیے ممکنہ الگورتھم کی تعداد کائنات میں ایٹموں کی تعداد سے کہیں زیادہ ہے، یہاں تک کہ میٹرکس ضرب کی چھوٹی مثالوں کے لیے بھی۔
ڈیپ مائنڈ نے اس مسئلے کو سنگل پلیئر گیم میں تبدیل کیا، اور اسے ٹینسر گیم کا نام دیا۔ اس گیم میں، کھلاڑی یہ انتخاب کرتا ہے کہ میٹرکس کے مختلف اندراجات کو کس طرح ملا کر ان کو ضرب دیا جائے۔ درست ضرب کا نتیجہ حاصل کرنے کے لیے ضروری کارروائیوں کی تعداد کی بنیاد پر ایک سکور تفویض کیا جاتا ہے۔ کھیل ختم ہوتا ہے جب صفر ٹینسر تک پہنچ جاتا ہے یا جب حرکتوں کی زیادہ سے زیادہ تعداد کی جاتی ہے۔ حتمی فیکٹرائزیشن کا اندازہ بقیہ رینک کے تخمینے اور کچھ اصلاحی معیارات کی بنیاد پر کیا جاتا ہے، جیسے کہ غیر علامتی وقت کی پیچیدگی یا عملی رن ٹائم۔
TensorGame میں ابتدائی پوزیشن کچھ بے ترتیب بنیادوں پر ظاہر کیے گئے میٹرکس ضرب ٹینسر کے مساوی ہے۔
کھیل کے ہر مرحلے میں، کھلاڑی تین ویکٹر لکھتا ہے۔
، جو درجہ 1 ٹینسر کی وضاحت کرتا ہے۔ . کھلاڑی کے منتخب کردہ ویکٹرز کو گھٹا کر گیم کی حالت کو اپ ڈیٹ کیا جاتا ہے:
کہاں
میٹرکس ضرب ٹینسر ہے۔اگر گیم p مراحل میں ختم ہوتی ہے، تو اس کا مطلب ہے کہ میٹرکس ضرب ٹینسر
p rank-1 tensors میں تحلیل کیا جا سکتا ہے۔ یعنی اس کا کم از کم درجہ p ہے۔اس کے بعد ٹینسر گیم کو رینک ڈیکمپوزیشن الگورتھم سے تعبیر کیا جا سکتا ہے اور الفا ٹینسر کو ٹینسر کے درجہ کا اندازہ لگانے کے لیے الگورتھم کے طور پر دیکھا جا سکتا ہے۔
الفا ٹینسر آرکیٹیکچر
اب تک ہم نے TensorGame کے بارے میں سیکھا ہے اور واضح کیا ہے کہ اس کے حل کو میٹرکس ضرب الگورتھم کے طور پر کیسے دیکھا جا سکتا ہے۔ آئیے اب AlphaTensor کے بنیادی تصورات کو دریافت کرتے ہیں، گیم کے لیے استعمال ہونے والا الگورتھم۔
الفا ٹینسر فن تعمیر بنیادی طور پر ایک انکوڈر-ڈیکوڈر ٹرانسفارمر فن تعمیر ہے جہاں:
- انکوڈر گیم اسٹیٹ کو ان پٹ کے طور پر لیتا ہے۔ ، n ماڈل کے ذریعہ کی گئی پچھلی کارروائیاں (عام طور پر n=7)، اور موجودہ کارروائی کا ٹائم انڈیکس t۔ معلومات کو ایک ٹینسر میں شکل کے ساتھ جمع کیا جاتا ہے (n+1, N^2, N^2, N^2)۔ اس ٹینسر کو پھر شکل کے ٹینسر (N^2, N^2, c) میں (تین لکیری تہوں کا استعمال کرتے ہوئے) نئی شکل دی جاتی ہے اور تبدیل کیا جاتا ہے جہاں c ماڈل کی اندرونی جہت ہے۔
- ڈیکوڈر انکوڈر کے ذریعہ دیے گئے ایمبیڈڈ ویکٹر سے n_steps ایکشنز کو آٹو ریگریسیو طریقے سے تیار کرتا ہے۔ ہر عمل تینوں کے نشان سے مساوی ہے۔ گیم ٹینسر کو گلنے والے ٹرپلٹس میں سے ایک کی نمائندگی کرنا (یعنی اس کا درجہ کم کرنا)
ماڈل کو متبادل بیک پروپیگیشن اور ماڈل اداکاری کے ذریعے تربیت دی جاتی ہے۔ ماڈل ایکٹنگ کا استعمال ڈیٹا تیار کرنے کے لیے کیا جاتا ہے جو پھر ماڈل کو تربیت دینے کے لیے استعمال ہوتا ہے۔ عملی طور پر، ماڈل کو مصنوعی طور پر تیار کردہ ڈیٹا اور اداکاری کے دوران ماڈل کے ذریعے تیار کردہ ڈیٹا کے مرکب سے تربیت دی جاتی ہے۔ اداکاری کا مرحلہ میٹرکس آپریشن کے مطابق 3D ٹینسر لے کر اور اس پر n_actors گیمز کھیل کر کیا جاتا ہے۔ ہر اداکار معیاری بنیادوں پر یا متبادل بنیاد پر کھیل کھیلتا ہے (بنیاد کی تبدیلی کا اطلاق ایک دیے گئے امکان کے ساتھ ہوتا ہے)۔ اس کے بعد نتائج جمع کیے جاتے ہیں اور مصنوعی ڈیٹا کے ساتھ تربیتی مرحلے میں استعمال کیے جا سکتے ہیں۔
The acting step is based on AlphaZero's Monte Carlo Tree Search (MCTS), modified to support large action spaces. In short, before choosing the action, n_sims paths are explored from the model output with a maximum future exploration of 5 steps. The probabilities generated by the model are then adjusted taking into account the generated paths. Then the action with the most promising future path(s) is chosen to continue the game.
ماڈل کی تربیت کے دوران، انعام دراصل ایک منفی انعام (جرمانہ) ہے۔ گیم کو حل کرنے کے لیے درکار ہر اضافی قدم کے ساتھ اس کی مطلق قدر بڑھ جاتی ہے۔ اگر ماڈل TensorGame کو حل کرنے کے لیے m قدم اٹھاتا ہے، تو گیم سے وابستہ انعام r=-m ہے۔ اگر ماڈل TensorGame کو max_rank کے مراحل میں حل کرنے کے قابل نہیں ہے، تو باقی ٹینسر کی درجہ بندی کا تخمینہ لگا کر انعام کا حساب لگایا جاتا ہے۔ رینک کا تخمینہ میٹرکس کے رینک کے مجموعہ کے طور پر لگایا جاتا ہے جو ٹینسر کو کمپوز کرتے ہیں۔ تخمینہ ٹینسر کے حقیقی درجے پر ایک اوپری حد ہے۔
When fine-tuning the model, the penalty reward at the terminal state should also take into account the latency of the algorithm produced by the model. The reward formula becomes rt'=rt+λbt, where rt is the reward scheme described earlier, bt is the benchmark reward (non-zero only at the terminal state), and λ صارف کی طرف سے مخصوص گتانک ہے۔
GPU اور TPU کے لیے تیار کردہ AlphaTensor کے دریافت کردہ الگورتھم کی سپیڈ اپس (%)، جو DeepMind کے پیپر سے نکالی گئی ہے۔ اسپیڈ اپ کو ایک ہی ہارڈ ویئر پر معیاری (جیسے جی پی یو کے لیے cuBLAS) میٹرکس ضرب کی نسبت اور اس کے مقابلے میں ماپا جاتا ہے۔ سٹراسن مربع الگورتھم. ماخذ: Deepmind.
میں نے حال ہی میں جاری کیا اوپن الفا ٹینسرAlphaTensor کا پہلا اوپن سورس نفاذ۔ اس سیکشن میں میں عمل درآمد کے ذریعے چلوں گا. جیسا کہ ہم نے پہلے بات کی ہے، الفا ٹینسر فن تعمیر کافی سیدھا ہے، جو ایک انکوڈر-ڈیکوڈر فن تعمیر کے ساتھ معیاری ٹرانسفارمر پر مبنی ہے۔ AlphaTensor کے سب سے دلچسپ اجزاء انکوڈر کے حصے میں پہلی پرت اور کارروائیوں کے نمونے لینے کا طریقہ ہیں۔
آئیے پہلی انکوڈنگ لیئر کے ساتھ شروع کریں۔
# x.size = (N, T, S, S, S)
# scalars.size = (N, s)
batch_size = x.shape[0]
S = x.shape[-1]
T = x.shape[1]
x1 = x.permute(0, 2, 3, 4, 1).reshape(batch_size, S, S, S * T)
x2 = x.permute(0, 4, 2, 3, 1).reshape(batch_size, S, S, S * T)
x3 = x.permute(0, 3, 4, 2, 1).reshape(batch_size, S, S, S * T)
input_list = [x1, x2, x3]
for i in range(3): temp = self.linears_1[i](scalars).reshape(batch_size, S, S, 1) input_list[i] = torch.cat([input_list[i], temp], dim=-1) input_list[i] = self.linears_2[i](input_list[i])
x1, x2, x3 = input_list
اوپر کے ٹکڑوں میں، ہم دکھاتے ہیں کہ کس طرح ان پٹ ٹینسر کو تین ٹینسر میں تحلیل کیا جاتا ہے، جو پھر ٹرانسفارمر لیئر کے استفسار، کلید اور ویلیو ان پٹ کے طور پر استعمال ہوتے ہیں۔
- تین ٹینسر کے طول و عرض میں جو چپٹی میٹرکس (A, B, C) کی نمائندگی کرتے ہیں، ان پٹ ٹینسر کو ہر جہت کے ساتھ ساتھ پچھلے اعمال کی نمائندگی کرنے والے جہت کے ساتھ چپٹا کیا جاتا ہے۔ اس طرح، ان پٹ ٹینسر کی ہر چپٹی کاپی میں، منتخب کردہ طول و عرض آخری T-1 اقدار اور اصل قدر کا مجموعہ ہے، منتخب کردہ جہت کی تمام S اقدار کے لیے، جہاں S=N^2۔ فلسفیانہ طور پر، یہ ایسا ہے جیسے، ہر ایک جہت کے لیے، ہم اس پر توجہ مرکوز کرتے ہیں کہ اس جہت میں پچھلے اعمال میں کیا ہوا تھا۔
- اسکیلرز کو طول و عرض S^2 کی تین مختلف جگہوں میں میپ کیا جاتا ہے، اور پھر پچھلے نقطہ پر حاصل کردہ ٹینسر کے ساتھ جوڑنے کے لیے دوبارہ شکل دی جاتی ہے۔ تصوراتی طور پر، اسکیلرز کو طول و عرض S^2 کی سرایت کرنے والی جگہ پر نقشہ بنایا جاتا ہے، اور پھر سرایت شدہ معلومات کو S ویکٹرز میں جوڑا جاتا ہے اور ایک ساتھ اسٹیک کیا جاتا ہے، جیسا کہ ٹوکنائز ہونے پر ٹیکسٹ کے ساتھ کیا ہوتا ہے۔
- اسکیلر ٹوکنز کو ری اسٹرکچرڈ ان پٹ ٹینسر کے ساتھ جوڑ دیا جاتا ہے اور پھر ماڈل کے اندرونی جہت میں اسکیلرز+چینل ہسٹری فوکس کی معلومات کی نقشہ سازی کے لیے ایک لکیری پرت کو ان پٹ کے طور پر دیا جاتا ہے۔
ان تینوں مراحل کو ماڈل کو اسکیلرز کے بارے میں دونوں معلومات (جیسا کہ TensorGame ٹائم سٹیپ میں) اور ہر چینل کے سابقہ اعمال پر فوکس کرنے کے طریقے کے طور پر سمجھا جا سکتا ہے۔
جس طرح سے اعمال پیدا ہوتے ہیں، اس کے بارے میں یہ نوٹ کرنا دلچسپ ہے کہ الفا ٹینسر ٹرپلٹ u, v, w کو آؤٹ پٹ کے طور پر تیار کرتا ہے، جس کا مقصد ٹینسر کی درجہ بندی کو کم کرنا ہے۔ تینوں ویکٹر کا سائز S ہے اور چونکہ وہ مربوط ہیں ماڈل کو سائز 3*S کا ایک ویکٹر بنانا پڑتا ہے۔ AlphaTensor کو RL الگورتھم کے ساتھ تربیت دی جاتی ہے، اس لیے تمام ممکنہ اعمال کا اظہار ایک گنتی ہوئی جگہ میں احتمالات کے لحاظ سے ہونا چاہیے، یعنی ماڈل مختلف اعمال پر امکان پیدا کرتا ہے۔ اس کا مطلب یہ ہے کہ 3S اسپیس میں ہر ویکٹر کو مختلف ایکشن میں میپ کیا جانا چاہیے۔ اس کے نتیجے میں سائز |F|^(3S) کی کارروائی کی جگہ پیدا ہوتی ہے، جہاں |F| مختلف قدروں کی تعداد ہے جو u, v, w کا عنصر لے سکتا ہے۔ عام طور پر، اقدار کو (-2، -1، 0، 1، 2) تک محدود کیا جاتا ہے، جس کے نتیجے میں 5 عناصر کی بنیادی حیثیت ہوتی ہے۔
یہاں ایک بڑا چیلنج آتا ہے: سائز 5 کے میٹرکس کے میٹرکس پروڈکٹ کے لیے کارروائی کے امکانات پیدا کرنے کے لیے ہمیں 5^75*4 بائٹس کی میموری کی ضرورت ہوگی، جس کا مطلب ہوگا ~10^44 GB میموری۔ واضح طور پر، ہم اتنی بڑی کارروائی کی جگہ کا انتظام نہیں کر سکتے۔
ہم مسئلہ کو کیسے حل کرتے ہیں؟ ایکشن کے امکانات کے میموری فوٹ پرنٹ کو کم کرنے کے لیے ہم ٹرپلٹس کو چھوٹے چھوٹے ٹکڑوں میں تقسیم کر سکتے ہیں، انہیں "ٹوکنائز" کر سکتے ہیں، اور ٹکڑوں کو ٹرانسفارمر فن تعمیر میں تیار کردہ ٹوکن کے طور پر استعمال کر سکتے ہیں، یعنی ٹوکنز کو ایک آٹو ریگریسیو میں ڈیکوڈر کو ان پٹ کے طور پر دیا جاتا ہے۔ راستہ اوپر دی گئی مثال میں ہم ٹرپلٹس کو 15 ٹکڑوں میں تقسیم کر سکتے ہیں، میموری کی کھپت کو 15 * 5^(75/15) * 4، یعنی 187.5 KB تک کم کر سکتے ہیں۔
def _eval_forward(self, e: torch.Tensor): bs = e.shape[0] future_g = ( torch.zeros((bs, self.n_samples, self.n_steps)).long().to(e.device) ) ps = torch.ones((bs, self.n_samples)).to(e.device) e = e.unsqueeze(1).repeat(1, self.n_samples, 1, 1) future_g = future_g.view(-1, self.n_steps) ps = ps.view(-1) e = e.view(-1, e.shape[-2], e.shape[-1]) for i in range(self.n_steps): o_s, z_s = self.core(future_g[:, : i + 1], e) future_g[:, i], p_i = sample_from_logits(o_s[:, i]) ps *= p_i future_g = future_g.view(bs, self.n_samples, self.n_steps) ps = ps.view(bs, self.n_samples) return ( future_g, ps, z_s[:, 0].view(bs, self.n_samples, *z_s.shape[2:]).mean(1), )
اوپر ہم مکمل کارروائی پیدا کرنے کے لیے کوڈ کا ٹکڑا دکھاتے ہیں۔ کوڈ میں self.core ڈیکوڈر پرت پر مشتمل ہے اور ٹینسر ای انکوڈر پرت کے آؤٹ پٹ کی نمائندگی کرتا ہے۔ صفر کے طور پر سمجھا جا سکتا ہے NLP ماڈلز میں ٹوکن اور n_steps ایکشنز جو n_steps ٹکڑوں کی نمائندگی کرتے ہیں ترقی پسند طریقے سے تیار ہوتے ہیں۔
ماڈل تین مقدار واپس کرتا ہے:
- پیدا کردہ اعمال
- مکمل عمل سے وابستہ امکان
- پہلی کارروائی (پہلا حصہ) بنانے کے لیے تیار کردہ لاگٹس جو ماڈل ویلیو کو کمپیوٹنگ کے لیے استعمال کیے جائیں گے۔
یہ n_samples پیرامیٹر پر چند الفاظ خرچ کرنے کے قابل ہے۔ پیرامیٹر کو اداکاری کے مرحلے کے لیے استعمال کیا جاتا ہے اور یہ ماڈل کو ٹرپلٹس کے مختلف ورژن تیار کرنے کی اجازت دیتا ہے جو پھر اداکاری کے عمل میں استعمال ہونے والے مونٹی کارلو ٹری سرچ الگورتھم میں ایکشن اسپیس کو تلاش کرنے کے لیے استعمال کیے جائیں گے۔ n_samples ماڈل کی طرف سے تیار کردہ پالیسی کے مطابق مختلف کارروائیوں کا نمونہ لیا جاتا ہے۔
اداکاری کا مرحلہ
پورے الگورتھم کا سب سے مشکل حصہ شاید اداکاری کا مرحلہ ہے جو TensorGame کو حل کرنے کے لیے استعمال کیا جاتا ہے۔ AlphaTensor پیپر میں الگورتھم کی گہرائی سے وضاحت نہیں کی گئی ہے، کیونکہ یہ ڈیپ مائنڈ کے کئی پچھلے کاغذات پر مبنی ہے جن کا صرف حوالہ دیا گیا ہے اور بطور جانا جاتا ہے۔ یہاں، میں تمام گمشدہ ٹکڑوں کو دوبارہ تشکیل دوں گا اور مرحلہ وار اپنے نفاذ کی وضاحت کروں گا۔
ہم اداکاری کے مراحل کو تین مختلف اجزاء میں ترتیب دے سکتے ہیں:
- مونٹی کارلو درخت کی تلاش
- گیم کا تخروپن
- بہتر پالیسی کمپیوٹیشن
آئیے ایک ایک کرکے ان کا تجزیہ کرتے ہیں۔
مونٹی کارلو ٹری سرچ (MCTS)
مونٹی کارلو ٹری سرچ (MCTS) گیم کھیلنے کے لیے ایک وسیع پیمانے پر استعمال ہونے والی مصنوعی ذہانت کی تکنیک ہے، خاص طور پر بورڈ گیمز اور ویڈیو گیمز میں۔ الگورتھم ایک گیم ٹری بناتا ہے جو ممکنہ حرکات اور نتائج کی نقالی کرتا ہے اور ہر اقدام کے لیے متوقع انعام کا اندازہ کرنے کے لیے بے ترتیب نمونے کا استعمال کرتا ہے۔ اس کے بعد الگورتھم سب سے زیادہ متوقع انعام کے ساتھ اس اقدام کو تکراری طور پر منتخب کرتا ہے اور اس وقت تک نتائج کی نقل کرتا ہے جب تک کہ یہ ٹرمینل حالت یا کسی مخصوص رکنے کی حالت تک نہ پہنچ جائے۔ نقالی کا استعمال ہر اقدام کے لیے جیتنے کے امکان کا اندازہ لگانے اور فیصلہ سازی کے عمل کی رہنمائی کے لیے کیا جاتا ہے۔ ایم سی ٹی ایس کو پیچیدہ کھیلوں میں مؤثر ثابت کیا گیا ہے جہاں ممکنہ چالوں اور نتائج کی تعداد زیادہ ہے، اور یہ گیم کھیلنے والے کامیاب AI سسٹمز، جیسے کہ AlphaGo میں استعمال کیا گیا ہے۔
AlphaTensor میں اصل MCTS کا ایک ترمیم شدہ ورژن استعمال کیا جاتا ہے۔ خاص طور پر، پوری ایکشن اسپیس سے ایکشن کو تصادفی طور پر منتخب کرنے کے بجائے، ایکشن کو ماڈل کے ذریعے براہ راست تیار کردہ ذیلی سیٹ کے درمیان منتخب کیا جاتا ہے (پہلے پیش کیے گئے n_samples کے ذریعے)۔ پالیسی کے اپ گریڈ میں تصحیح پھر بہتر پالیسی کمپیوٹیشن مرحلے میں لاگو ہوتی ہے۔
اپنے نفاذ میں، ہم نے مونٹی کارلو ٹری کے بارے میں تمام معلومات کو ایک لغت میں رکھنے کا فیصلہ کیا ہے جس میں TensorGame ریاست کے ہیش ورژن کی کلید ہے اور خود ریاست سے وابستہ معلومات کی قدر کرتی ہے۔ ہر Monte-Carlo قدم ایک نوڈ سے شروع ہوتا ہے اور n_sim منی گیمز کی نقل کرتا ہے، 5 چالوں کے افق کے ساتھ مستقبل کو تلاش کرتا ہے۔ اگر نوڈ کو پہلے ہی پچھلے سمولیشنز میں دریافت کیا جا چکا ہے، تو n_sim کو پچھلی دریافتوں کی تعداد کو مدنظر رکھتے ہوئے ایڈجسٹ کیا جاتا ہے۔ ہر نوڈ کے لیے وزٹ کی تعداد N_s_a ٹینسر میں محفوظ کی جاتی ہے، کیونکہ اس ٹینسر میں فی نوڈ چائلڈ ایکشن (ماڈل کے ذریعے نمونے کے ساتھ) وزٹس کی تعداد ہوتی ہے۔
def monte_carlo_tree_search( model: torch.nn.Module, state: torch.Tensor, n_sim: int, t_time: int, n_steps: int, game_tree: Dict, state_dict: Dict,
): """Runs the monte carlo tree search algorithm. Args: model (torch.nn.Module): The model to use for the simulation. state (torch.Tensor): The initial state. n_sim (int): The number of simulations to run. t_time (int): The current time step. n_steps (int): The maximum number of steps to simulate. game_tree (Dict): The game tree. state_dict (Dict): The dictionary containing the states. """ state_hash = to_hash(extract_present_state(state)) if state_hash in state_dict: with torch.no_grad(): N_s_a = state_dict[state_hash][3] n_sim -= int(N_s_a.sum()) n_sim = max(n_sim, 0) for _ in range(n_sim): simulate_game(model, state, t_time, n_steps, game_tree, state_dict) # return next state possible_states_dict, _, repetitions, N_s_a, q_values, _ = state_dict[ state_hash ] possible_states = _recompose_possible_states(possible_states_dict) next_state_idx = select_future_state( possible_states, q_values, N_s_a, repetitions, return_idx=True ) next_state = possible_states[next_state_idx] return next_state
اوپر والا کوڈ ہمارے الگورتھم کے نفاذ کو ظاہر کرتا ہے۔ کوڈ کی سادگی کے معاملے میں، پالیسی کی اصلاح simulate_game فنکشن میں کی جاتی ہے۔
کھیل تخروپن
simulate_game فنکشن TensorGame کی ایک خاص حالت کی نمائندگی کرنے والے نوڈس پر مشتمل درخت کو تلاش کرنے کے لیے ذمہ دار ہے۔ یہ ماڈل کو بھی چلاتا ہے جب بھی کسی لیف نوڈ کا سامنا ہوتا ہے اور یہ نوڈ کی تمام معلومات کو state_dict ڈکشنری میں محفوظ کرتا ہے۔ آئیے اس کے نفاذ پر گہری نظر ڈالتے ہیں:
@torch.no_grad()
def simulate_game( model, state: torch.Tensor, t_time: int, max_steps: int, game_tree: Dict, states_dict: Dict, horizon: int = 5,
): """Simulates a game from a given state. Args: model: The model to use for the simulation. state (torch.Tensor): The initial state. t_time (int): The current time step. max_steps (int): The maximum number of steps to simulate. game_tree (Dict): The game tree. states_dict (Dict): The states dictionary. horizon (int): The horizon to use for the simulation. """ idx = t_time max_steps = min(max_steps, t_time + horizon) state_hash = to_hash(extract_present_state(state)) trajectory = [] # selection while state_hash in game_tree: ( possible_states_dict, old_idx_to_new_idx, repetition_map, N_s_a, q_values, actions, ) = states_dict[state_hash] possible_states = _recompose_possible_states(possible_states_dict) state_idx = select_future_state( possible_states, q_values, N_s_a, repetition_map, return_idx=True ) trajectory.append((state_hash, state_idx)) # state_hash, action_idx future_state = extract_present_state(possible_states[state_idx]) state = possible_states[state_idx] state_hash = to_hash(future_state) idx += 1 # expansion if idx = max_steps: trajectory.append((state_hash, None)) if not game_is_finished(extract_present_state(state)): state = state.to(model.device) scalars = get_scalars(state, idx).to(state.device) actions, probs, q_values = model(state, scalars) ( possible_states, cloned_idx_to_idx, repetitions, not_dupl_indexes, ) = extract_children_states_from_actions( state, actions, ) not_dupl_actions = actions[:, not_dupl_indexes].to("cpu") not_dupl_q_values = torch.zeros(not_dupl_actions.shape[:-1]).to( "cpu" ) N_s_a = torch.zeros_like(not_dupl_q_values).to("cpu") present_state = extract_present_state(state) states_dict[to_hash(present_state)] = ( _reduce_memory_consumption_before_storing(possible_states), cloned_idx_to_idx, repetitions, N_s_a, not_dupl_q_values, not_dupl_actions, ) game_tree[to_hash(present_state)] = [ to_hash(extract_present_state(fut_state)) for fut_state in possible_states ] leaf_q_value = q_values else: leaf_q_value = -int(torch.linalg.matrix_rank(state).sum()) # backup backward_pass(trajectory, states_dict, leaf_q_value=leaf_q_value)
ہر تخروپن کو تین حصوں میں تقسیم کیا گیا ہے:
- سلیکشن
- توسیع
- بیک اپ
انتخاب کے حصے میں تخروپن پہلے سے تیار شدہ ٹری نوڈس پر چلائی جاتی ہے، اور درج ذیل فنکشن کا استعمال کرتے ہوئے درج ذیل نوڈ کو منتخب کیا جاتا ہے۔
def select_future_state( possible_states: List[torch.Tensor], q_values: torch.Tensor, N_s_a: torch.Tensor, repetitions: Dict[int, list], c_1: float = 1.25, c_2: float = 19652, return_idx: bool = False,
) -> torch.Tensor: """Select the future state maximizing the upper confidence bound."""
# q_values (1, K, 1) pi = torch.tensor( [ len(repetitions[i]) for i in range(len(possible_states)) if i in repetitions ] ).to(q_values.device) ucb = q_values.reshape(-1) + pi * torch.sqrt( torch.sum(N_s_a) / (1 + N_s_a) ) * (c_1 + torch.log((torch.sum(N_s_a) + c_2 + 1) / c_2)) if return_idx: return ucb.argmax() return possible_states[ucb.argmax()]
عملی طور پر، ucb فنکشن کو زیادہ سے زیادہ کرنے والی کارروائی:
دی گئی ریاست کے لیے منتخب کیا گیا ہے۔ یہاں Q ماڈل کے ذریعہ تیار کردہ Q قدروں کی نمائندگی کرتا ہے اور π ماڈل پالیسی کا استعمال کرتے ہوئے نمونے کی گئی کارروائیوں پر بے ترتیب تقسیم کی نمائندگی کرتا ہے۔ N(s, a) نوڈ s سے ایکشن تک نوڈ کے دوروں کی تعداد کی نمائندگی کرتا ہے۔
ایک بار جب انتخاب کا مرحلہ لیف نوڈ تک پہنچ جاتا ہے، اگر تخروپن کسی ٹرمینل حالت تک نہیں پہنچی ہے (زیادہ سے زیادہ ایکسپلوریشن، یعنی مستقبل کے افق، یا گیم کے اختتام کے لحاظ سے)، پھر ماڈل کو n_samples متبادل نوڈس کے انتخاب کے لیے استعمال کیا جاتا ہے (وہ پتی ہوں گے۔ لگاتار تکرار میں نوڈس)۔ اسے توسیع کا مرحلہ کہا جاتا ہے، کیونکہ درخت میں نئے نوڈس شامل کیے جاتے ہیں۔ پھر، موجودہ تخروپن میں مزید کوئی نوڈ تلاش نہیں کیا جاتا ہے، لیکن لیف q_value مندرجہ ذیل نقلی مرحلے پر بھیجا جاتا ہے: بیک اپ۔
بیک اپ ہر تخروپن کا آخری مرحلہ ہے۔ بیک اپ کے دوران، اگر لیف نوڈ ٹرمینل سٹیٹ تھا تو حتمی انعام کا حساب لگایا جاتا ہے۔ بصورت دیگر پتی کی قیمت ایک تخمینی انعام کے طور پر استعمال ہوتی ہے۔ پھر انعام کو نقلی رفتار پر واپس پھیلایا جاتا ہے جو دونوں ریاستوں کی q_values کو اپ ڈیٹ کرتا ہے اور وزٹ کاؤنٹر N(s, a) کو اپ ڈیٹ کرتا ہے۔ ذیل کے ٹکڑوں میں ہم ریوارڈ بیک پروپیگیشن کا کوڈ دکھاتے ہیں۔
def backward_pass(trajectory, states_dict, leaf_q_value: torch.Tensor): """Backward pass of the montecarlo algorithm"""
reward = 0 for idx, (state, action_idx) in enumerate(reversed(trajectory)): if action_idx is None: # leaf node reward += leaf_q_value else: ( _, old_idx_to_new_idx, _, N_s_a, q_values, _, ) = states_dict[state] if isinstance(reward, torch.Tensor): reward = reward.to(q_values.device) action_idx = int(action_idx) if action_idx in old_idx_to_new_idx: not_dupl_index = old_idx_to_new_idx[int(action_idx)] else: not_dupl_index = action_idx reward -= 1 q_values[:, not_dupl_index] = ( N_s_a[:, not_dupl_index] * q_values[:, not_dupl_index] + reward ) / (N_s_a[:, not_dupl_index] + 1) N_s_a[:, not_dupl_index] += 1
بہتر پالیسی کمپیوٹیشن
ایک بار جب تمام سمولیشنز چلا دیے جائیں اور MCTS مستقبل قریب کا ایک دلچسپ سنیپ شاٹ پیش کرے تو اب وقت آگیا ہے کہ پیشین گوئی شدہ نوڈس کے ساتھ منسلک پالیسی کو اپ ڈیٹ کیا جائے اور انہیں واپس کیا جائے، تاکہ انہیں تربیت کے دوران استعمال کیا جا سکے۔ میں بیان کردہ طریقہ پر عمل کرتے ہوئے بہتر پالیسی Hubert et al، بڑی کارروائی کی جگہوں کے انتظام کے لیے استعمال کیا جاتا ہے۔ درحقیقت، چھوٹی تلاش کی جگہ کے لیے، MCTS کے دوران ایکشن اسپیس سے تصادفی طور پر کسی عمل کا نمونہ لینا اور اس کے اثرات کا جائزہ لینا ممکن ہے۔ ایک بہت بڑی ایکشن اسپیس میں اسی طرح کا نقطہ نظر تمام رفتار کو مختلف راستوں میں موڑنے کا باعث بنے گا اور اسے بامعنی اعدادوشمار حاصل کرنے اور پھر پالیسی کو اپ ڈیٹ کرنے کے لیے لامحدود رفتار کی ضرورت ہوگی۔ چونکہ یہاں ہم پھیلاؤ سے بچنے کے لیے نمونہ-MCTS استعمال کر رہے ہیں، یعنی n_samples کی کارروائیوں کو ماڈل پالیسی کے مطابق نمونہ بنایا جاتا ہے اور پھر MCTS درخت کی تلاش کے دوران نمونے کی کارروائیوں میں سے صرف ایک کا انتخاب کرتا ہے، ہمیں کمپیوٹنگ کرتے وقت نمونے کی اصلاح کو مدنظر رکھنا ہوگا۔ حتمی اپ ڈیٹ کردہ پالیسی جو ماڈل کی تربیت کے دوران استعمال کی جائے گی۔
عملی طور پر، بہتر پالیسی کے طور پر شمار کیا جاتا ہے
کہاں
def compute_improved_policy( state_dict: Dict, states: List[str], model_n_steps: int, model_n_logits: int, N_bar: int,
): """Compute the improved policy given the state_dict, the list of states. The improved policy is computed as (N_s_a / N_s_a.sum())^(1/tau) where tau is (log(N_s_a.sum()) / log(N_bar)) if N_s_a.sum() > N_bar else 1. """ policies = torch.zeros(len(states), model_n_steps, model_n_logits) N_bar = torch.tensor(N_bar) for idx, state in enumerate(states): N_s_a = state_dict[state][3] actions = state_dict[state][5] if N_s_a.sum() > N_bar: tau = (torch.log(N_s_a.sum()) / torch.log(N_bar)).item() else: tau = 1 N_s_a = N_s_a ** (1 / tau) improved_policy = N_s_a / N_s_a.sum() for sample_id in range(actions.shape[1]): action_ids = actions[0, sample_id] for step_id, action_id in enumerate(action_ids): policies[idx, step_id, action_id] += improved_policy[ 0, sample_id ] return policies
نوٹ کریں کہ ہمارے نفاذ میں N_s_a ٹینسر سے پالیسی کی گنتی کرنے کے بعد ہمیں اسے اصل ایکشن ٹینسر پر واپس نقشہ بنانا ہوگا۔ درحقیقت، N_s_a صرف ماڈل کی طرف سے نمونے کی گئی کارروائیوں پر غور کرتا ہے، جبکہ حتمی پالیسی میں دریافت نہ کیے گئے اعمال کے لیے بھی امکانات کا ہونا ضروری ہے۔
ChatGPT ٹریننگ الگورتھم کے حوالے سے اختلافات
AlphaTensor is the latest member of the AlphaGo/AlphaZero family of artificial intelligence methods by DeepMind. These methods are based on the Monte Carlo Tree Search (MCTS) algorithm, which has been refined and enhanced by DeepMind to tackle increasingly complex tasks. Another AI system, OpenAI's ChatGPT, which has caused a lot of buzz for its remarkable performance, was trained with a different approach, called Reinforcement Learning with Human Feedback (RLHF).
RLHF ایک عمدہ ٹیوننگ تکنیک ہے جو زبان کے ماڈلز کو تحریری ہدایات کے ایک سیٹ پر عمل کرنے کے لیے استعمال کیا جاتا ہے۔ یہ ماڈل کو ٹھیک کرنے کے لیے انسانی ترجیحات کو انعامی سگنل کے طور پر استعمال کرتا ہے، اس طرح 'انسانی اقدار' کے کچھ وسیع تر تصور کے بجائے زبان کے ماڈل کے طرز عمل کو لوگوں کے مخصوص گروہ کی بیان کردہ ترجیحات کے ساتھ ہم آہنگ کرتا ہے۔
اس کے برعکس، MCTS ایک درخت پر مبنی سرچ الگورتھم ہے جو گیمز میں بہترین چالوں کا تعین کرنے کے لیے استعمال ہوتا ہے۔ یہ ممکنہ چالوں کی نقل کرتا ہے اور ہر اقدام کی اقدار کو ان کے نتائج کی بنیاد پر اپ ڈیٹ کرتا ہے، بہترین اقدام کے انتخاب کی رہنمائی کرتا ہے۔
RLHF انسانی تحریری مظاہروں اور AI ماڈلز کے درمیان انسانی لیبل والے موازنہ سے ڈیٹا اکٹھا کرتا ہے، اور لوگوں کے دیئے گئے گروپ کی ترجیحات کا اندازہ لگانے کے لیے ایک انعامی ماڈل کو تربیت دیتا ہے۔ پھر انعامی ماڈل کا استعمال AI ماڈلز کو ٹھیک کرنے کے لیے کیا جاتا ہے۔ دوسری طرف، MCTS بہترین فیصلے کا تعین کرنے کے لیے نقالی اور تشخیصات کا استعمال کرتا ہے۔
اگرچہ وہ مختلف نقطہ نظر ہیں، RLHF اور MCTS میں بھی مماثلت ہے۔ دونوں مصنوعی ذہانت کی تکنیکیں فیصلہ سازی اور مسئلہ حل کرنے کے طریقے استعمال کرتی ہیں، اور دونوں مختلف اختیارات کو دریافت کرنے اور دستیاب معلومات کی بنیاد پر فیصلے کرنے کے لیے آزمائش اور غلطی کا طریقہ استعمال کرتی ہیں۔ دونوں تکراری عمل بھی ہیں جو وقت کے ساتھ ساتھ مزید معلومات اور تجربہ جمع ہونے کے ساتھ ساتھ بہتر ہوتے ہیں۔
RLHF اور MCTS کے درمیان انتخاب ہاتھ میں کام پر منحصر ہے۔ RLHF مثالی ہے جب ماڈل کی کارکردگی کا جائزہ لینے کے لیے کوئی واضح میٹرک نہیں ہے، جبکہ MCTS گیم جیسے کاموں میں کارگر ثابت ہوا ہے جہاں علم اور مستقبل کی تلاش ماڈل کو ایک اہم فائدہ دیتی ہے۔
الفا ٹینسر ٹریننگ کے لیے کوڈ کی اصلاح
AlphaTensor ٹریننگ الگورتھم کو لاگو کرنے کے لیے تربیت کی رفتار اور میموری کی کھپت کے درمیان کامل سمجھوتہ کرنے کی ضرورت ہوتی ہے۔ جیسا کہ ماڈل سیکشن میں دیکھا گیا ہے، صرف ایکشن ٹوکنائزیشن پر غور کرنے سے بہت ساری میموری محفوظ ہو سکتی ہے، لیکن حد سے زیادہ جارحانہ کارروائی کی جگہ میں کمی درستگی اور سست کارکردگی دونوں کا باعث بن سکتی ہے۔ مؤخر الذکر اس لیے ہوتا ہے کہ ماڈل ڈیکوڈر کے ذریعے تمام ٹوکن ترتیب وار طور پر خود بخود تیار کیے جاتے ہیں۔ لہذا، ایکشن اسپیس پر سوفٹ میکس اب رکاوٹ نہ ہونے کے بعد فی ایکشن ٹوکنز کی تعداد کے ساتھ انفرنس ٹائم لکیری طور پر بڑھتا ہے۔
AlphaTensor ٹریننگ قائم کرتے وقت، اداکاری کے عمل سے نمٹنے میں اہم مشکلات پائی گئیں۔ اگر ٹینسرز کو درست شکل میں ذخیرہ نہیں کیا جاتا ہے تو، MCTS آسانی سے میموری کے استعمال میں بے قابو اضافہ کا سبب بن سکتا ہے۔ دوسری طرف، اگر ہر ایک سمولیشن کے دوران ذخیرہ شدہ ٹینسر کی تعداد بہت زیادہ کم ہو جاتی ہے، تو MCTS مطلوبہ حالتوں کو دوبارہ شمار کرنے میں لامحدود وقت صرف کر سکتا ہے۔
Let's take an example of the game simulation step, where the game is explored by looking at possible future scenarios. For each state, if we don't save the actions generated by the model and we decide to save only the random seed used to sample the actions from the policy, then each time we explore a tree node we would have to recompute the policy and then sample the actions. Clearly, we decided to store the sampled actions to save time and to avoid having to manage model sharing between different processes in the case of MCTS exploration parallelization. However, just saving the actions was not enough to get a sufficiently efficient acting step. In fact, the time for converting the n_steps actions into the (u, v, w) triplet, reducing the game tensor state and creating the new3D tensors from the n_samples actions would easily be a bottleneck for the whole training. Secondly, we didn't want to store all possible future states for each sampled action, as this would have a huge impact on the memory used by the algorithm. Suppose we set n_samples=32, n=7 and N=5, and let's remember that N is the size of the square matrix product we want to reduce and n is the number of previous actions remembered by the model. In this situation, each state tensor would have the form (8, 25, 25, 25), which multiplied by 32 would result in 328252525گراف میں ہر نوڈ کے لیے 4 بائٹس۔ اب، اس بات پر غور کرتے ہوئے کہ توسیعی مرحلے میں ہر تخروپن ایک نیا نوڈ (اور n_sim=200) پیدا کرتا ہے، ہمارے پاس آخری میموری کی کھپت 200 ہوگی۔328252525*4 = 3.2GB صرف پہلے MCTS نوڈ کے لیے۔ بدترین صورت حال میں، ایکٹنگ میکس_رینک نوڈس (جہاں max_rank=150) کو دریافت کرتے ہوئے، اس کے نتیجے میں RAM میموری میں 150 * 3.2GB = 480GB کی کل میموری کی کھپت ہوگی (یا GPU میموری اگر تمام ٹینسر GPU پر محفوظ کیے گئے ہوں) . ہم نے اپنے ورک سٹیشن پر 128 GB RAM اور 48 GB GPU میموری کے ساتھ ٹریننگ چلائی، اس لیے ہمیں میموری کی کھپت کو کم کرنا پڑا۔
Since we didn't want to increase the execution time, we adopted an optimization that exploits the redundancy in the state tensors produced. In fact, the tensors have n-1 previous actions in common, which can then be stored once and not repeated for each stored tensor. This results in a memory reduction of 2/7~28%, meaning that in the worst-case 137GB can be stored. At this point, by simply pruning the unused part of the tree (such as the unselected trajectories) and storing the tensors in CPU memory, we were able to avoid any memory error during training.
OpenAlphaTensor کے اب اوپن سورس ہونے کے ساتھ، مزید ترقی کے کئی دلچسپ راستے کھلتے ہیں۔
ٹارگٹ ہارڈویئر ڈیوائسز پر OpenAlphaTensor کی ٹھیک ٹیوننگ ایک قدرتی پیشرفت ہے۔ یہ بہت مسابقتی کمپیوٹیشنل کارکردگی کی قیادت کرنے کی توقع ہے. میں مختلف ہارڈ ویئر پر OpenAlphaTensor کی کارکردگی کے بارے میں مزید شائع کروں گا۔ GitHub کے. یہ مضمون لکھنے کے وقت، OpenAlphaTensor تربیت سے گزر رہا تھا۔
ایک اور اہم پیش قدمی ریموٹ کمپلیشن کے لیے معاونت ہوگی، جس سے صارفین کو ایج ڈیوائسز کے لیے موزوں الگورتھم بنانے کی اجازت ہوگی۔ یہ OpenAlphaTensor ماڈل کو سرور پر اسٹور کرکے حاصل کیا جاسکتا ہے، جبکہ میٹرکس ضرب الگورتھم کا جائزہ مختلف ہارڈ ویئر پر کیا جاتا ہے۔
تاخیر پر مبنی انعام کی اصلاح کی گنتی کرنے کے لیے مختلف مرتب کرنے والوں کے لیے تعاون بڑھانا بھی اہم ہو سکتا ہے۔ مختلف کمپائلرز دیئے گئے ہارڈ ویئر پر مختلف آپٹمائزڈ الگورتھم کا باعث بن سکتے ہیں۔ مثال کے طور پر، DeepMind پیپر نے TPU اور Nvidia GPUs پر JAX اور XLA کمپائلر کا استعمال کرتے ہوئے امید افزا نتائج دکھائے۔ Nvidia پر NCCL یا CPUs پر LLVM کا استعمال کرتے ہوئے اس کا اندازہ لگانا دلچسپ ہوگا۔
آخر میں، بڑے میٹرکس سائز کو سپورٹ کرنے کے لیے ماڈل اور ٹریننگ الگورتھم کو بڑھانا ایک بڑا کھلا چیلنج ہے۔ فی الحال، OpenAlphaTensor 5 کے زیادہ سے زیادہ میٹرکس سائز کو سپورٹ کرتا ہے، لیکن اس کا اطلاق بڑے میٹرکس ضرب کو 5 سے چھوٹے سائز والے چھوٹے MMs کے گروپوں میں تقسیم کر کے کیا جا سکتا ہے۔ یہ نقطہ نظر سب سے زیادہ ہے، اور کمی کو براہ راست بڑے ٹینسر پر انجام دے کر مکمل ایم ایم نظریاتی طور پر بہتر نتائج کا باعث بن سکتا ہے۔
ڈیاگو فیوری is the CTO of Nebuly AI, a company committed to making AI optimization part of every developer's toolkit.
- SEO سے چلنے والا مواد اور PR کی تقسیم۔ آج ہی بڑھا دیں۔
- پلیٹو بلاک چین۔ Web3 Metaverse Intelligence. علم میں اضافہ۔ یہاں تک رسائی حاصل کریں۔
- ماخذ: https://www.kdnuggets.com/2023/03/first-open-source-implementation-deepmind-alphatensor.html?utm_source=rss&utm_medium=rss&utm_campaign=first-open-source-implementation-of-deepminds-alphatensor
- : ہے
- ][p
- $UP
- 1
- 3d
- 8
- a
- قابلیت
- ہمارے بارے میں
- اوپر
- مطلق
- تیز
- کے مطابق
- اس کے مطابق
- اکاؤنٹ
- درستگی
- حاصل
- حاصل کیا
- عمل
- اعمال
- اصل میں
- شامل کیا
- ایڈیشنل
- ایڈجسٹ
- اپنایا
- آگے بڑھانے کے
- فائدہ
- کے بعد
- ایجنٹ
- مجموعی
- جارحانہ
- AI
- اے آئی سسٹمز
- مقصد ہے
- یلگورتم
- یلگوردمز
- تمام
- اجازت دے رہا ہے
- کی اجازت دیتا ہے
- اکیلے
- پہلے ہی
- متبادل
- کے درمیان
- رقم
- تجزیے
- اور
- ایک اور
- اطلاقی
- نقطہ نظر
- نقطہ نظر
- فن تعمیر
- کیا
- مضمون
- مصنوعی
- مصنوعی ذہانت
- AS
- تفویض
- منسلک
- At
- آٹومیٹڈ
- دستیاب
- گریز
- واپس
- بیک اپ
- کی بنیاد پر
- بنیادی طور پر
- بنیاد
- BE
- کیونکہ
- ہو جاتا ہے
- اس سے پہلے
- کیا جا رہا ہے
- نیچے
- معیار
- BEST
- بہتر
- کے درمیان
- سے پرے
- بورڈ
- بورڈ کھیل
- پابند
- وسیع
- BT
- تعمیر
- تعمیر
- by
- کہا جاتا ہے
- کر سکتے ہیں
- نہیں کر سکتے ہیں
- کیس
- کیونکہ
- وجہ
- کچھ
- چیلنج
- چیلنج
- تبدیل
- چینل
- چیٹ جی پی ٹی
- بچے
- انتخاب
- منتخب کریں
- منتخب کیا
- حوالہ دیا
- واضح
- واضح طور پر
- کوڈ
- جمع کرتا ہے
- جمع
- انجام دیا
- کامن
- کمپنی کے
- مقابلے میں
- مقابلہ
- پیچیدہ
- پیچیدگی
- اجزاء
- پر مشتمل
- سمجھوتہ
- حساب
- کمپیوٹیشنل طاقت
- کمپیوٹنگ
- کمپیوٹنگ
- تصورات
- تصور سے
- شرط
- آپکا اعتماد
- غور کریں
- سمجھا
- پر غور
- سمجھتا ہے
- کھپت
- پر مشتمل ہے
- جاری
- اس کے برعکس
- تبدیل
- کور
- اسی کے مطابق
- مساوی ہے
- سکتا ہے
- مقابلہ
- CPU
- پیدا
- تخلیق
- معیار
- CTO
- موجودہ
- اس وقت
- اعداد و شمار
- معاملہ
- فیصلہ کرنا
- فیصلہ کیا
- فیصلہ
- فیصلہ کرنا
- فیصلے
- گہری
- گہری سیکھنے
- Deepmind
- انحصار کرتا ہے
- بیان کیا
- اس بات کا تعین
- ڈیولپر
- ترقی
- آلہ
- کے الات
- DICT
- مختلف
- مشکلات
- طول و عرض
- طول و عرض
- براہ راست
- دریافت
- دریافت
- بات چیت
- تقسیم
- تقسیم
- نیچے
- چھوڑ
- کے دوران
- e
- ہر ایک
- اس سے قبل
- آسانی سے
- ایج
- موثر
- ہنر
- یا تو
- عنصر
- عناصر
- ایمبیڈڈ
- ختم ہو جاتا ہے
- بہتر
- بہت بڑا
- کافی
- اندراج
- خرابی
- تخمینہ
- اندازے کے مطابق
- Ether (ETH)
- اندازہ
- اندازہ
- کا جائزہ لینے
- اندازہ
- بھی
- ہر کوئی
- مثال کے طور پر
- مثال کے طور پر
- دلچسپ
- پھانسی
- توسیع
- توقع
- تجربہ
- وضاحت
- وضاحت کی
- استحصال
- کی تلاش
- تلاش
- وضاحت کی
- ایکسپلور
- اظہار
- توسیع
- توسیع
- انتہائی
- کافی
- خاندان
- تیز تر
- آراء
- چند
- اعداد و شمار
- فائنل
- تلاش
- پہلا
- فلوٹ
- توجہ مرکوز
- پر عمل کریں
- کے بعد
- فوٹ پرنٹ
- کے لئے
- فارم
- فارمیٹ
- فارمولا
- ملا
- سے
- مکمل
- تقریب
- بنیادی
- مزید
- مزید ترقی
- مستقبل
- کھیل ہی کھیل میں
- کھیل
- پیدا
- پیدا
- پیدا ہوتا ہے
- پیدا کرنے والے
- حاصل
- حاصل کرنے
- دے دو
- دی
- دے
- مقصد
- جاتا ہے
- اچھا
- GPU
- GPUs
- گراف
- عظیم
- گروپ
- گروپ کا
- بڑھتا ہے
- ترقی
- رہنمائی
- ہاتھ
- ہینڈلنگ
- ہوا
- ہوتا ہے
- ہارڈ ویئر
- ہارڈ ویئر ڈیوائس
- ہارڈ ویئر کے آلات
- ہے
- ہونے
- یہاں
- سب سے زیادہ
- افق
- کس طرح
- کیسے
- تاہم
- HTTPS
- بھاری
- انسانی
- i
- میں ہوں گے
- مثالی
- IDX
- تصویر
- اثر
- پر عملدرآمد
- نفاذ
- اہم
- کو بہتر بنانے کے
- بہتر
- in
- اضافہ
- اضافہ
- دن بدن
- آزاد
- انڈکس
- معلومات
- ابتدائی
- ان پٹ
- کے بجائے
- ہدایات
- انٹیلی جنس
- دلچسپ
- اندرونی
- متعارف
- انترجشتھان
- IT
- تکرار
- میں
- خود
- فوٹو
- KDnuggets
- رکھیں
- کلیدی
- علم
- جانا جاتا ہے
- زبان
- بڑے
- بڑے
- آخری
- تاخیر
- تازہ ترین
- پرت
- تہوں
- قیادت
- سیکھا ہے
- سیکھنے
- لنکڈ
- لسٹ
- دیکھو
- تلاش
- بہت
- بنا
- مین
- اہم
- بنا
- بنانا
- انتظام
- مینیجنگ
- بہت سے
- نقشہ
- تعریفیں
- میٹرکس
- معاملہ
- زیادہ سے زیادہ
- مطلب
- بامعنی
- کا مطلب ہے کہ
- رکن
- یاد داشت
- طریقہ
- طریقوں
- میٹرک۔
- لاپتہ
- مرکب
- ماڈل
- ماڈل
- نظر ثانی کی
- ماڈیول
- زیادہ
- زیادہ موثر
- اس کے علاوہ
- سب سے زیادہ
- منتقل
- چالیں
- ضرب
- قدرتی
- فطرت، قدرت
- قریب
- ضروری
- ضرورت ہے
- ضرورت
- منفی
- نیٹ ورک
- عصبی
- نیند نیٹ ورک
- نئی
- اگلے
- ویزا
- نوڈ
- نوڈس
- غیر ماہرین
- تصور
- تعداد
- NVIDIA
- حاصل کی
- of
- تجویز
- on
- ایک
- کھول
- اوپن سورس
- اوپنائی
- آپریشن
- آپریشنز
- زیادہ سے زیادہ
- اصلاح کے
- کی اصلاح کریں
- اصلاح
- آپشنز کے بھی
- اصل
- دیگر
- دوسری صورت میں
- پیداوار
- مجموعی طور پر
- کاغذ.
- کاغذات
- پیرامیٹر
- حصہ
- خاص طور پر
- خاص طور پر
- حصے
- لوگ
- کامل
- کارکردگی
- کارکردگی کا مظاہرہ
- مرحلہ
- ٹکڑے ٹکڑے
- پلاٹا
- افلاطون ڈیٹا انٹیلی جنس
- پلیٹو ڈیٹا
- کھیلیں
- کھلاڑی
- کھیل
- پوائنٹ
- پالیسیاں
- پالیسی
- پوزیشن
- ممکن
- ممکنہ
- طاقت
- عملی
- پریکٹس
- پیشن گوئی
- پیش گوئی
- ترجیحات
- پیش
- پچھلا
- امکان
- شاید
- مسئلہ
- عمل
- عمل
- پیدا
- تیار
- مصنوعات
- بڑھنے
- ترقی
- وعدہ
- مجوزہ
- ممکنہ طور پر
- ثابت
- شائع
- شائع
- RAM
- بے ترتیب
- صفوں
- بلکہ
- پہنچ گئی
- پہنچتا ہے
- حال ہی میں
- کو کم
- کم
- کو کم کرنے
- بہتر
- قابو پانے کی تعلیم
- جاری
- باقی
- باقی
- قابل ذکر
- یاد
- ریموٹ
- بار بار
- نمائندگی
- کی نمائندگی کرتا ہے
- ضرورت
- کی ضرورت ہے
- ذمہ دار
- محدود
- نتیجہ
- نتیجے
- نتائج کی نمائش
- واپسی
- واپسی
- انقلاب
- انعام
- ROW
- rt
- رن
- s
- اسی
- محفوظ کریں
- بچت
- منظر نامے
- منظرنامے
- سکیم
- تلاش کریں
- دوسری
- سیکشن
- بیج
- منتخب
- منتخب
- انتخاب
- SELF
- مقرر
- قائم کرنے
- کئی
- شکل
- اشتراک
- مختصر
- ہونا چاہئے
- دکھائیں
- دکھایا گیا
- شوز
- اشارہ
- اہم
- نمایاں طور پر
- اسی طرح
- مماثلت
- سادہ
- سادگی
- صرف
- تخروپن
- بعد
- صورتحال
- سائز
- سائز
- چھوٹے
- چھوٹے
- سنیپشاٹ
- So
- حل
- حل
- حل کرنا۔
- کچھ
- ماخذ
- خلا
- خالی جگہیں
- مخصوص
- خاص طور پر
- مخصوص
- تیزی
- خرچ
- خرچ کرنا۔
- تقسیم
- چوک میں
- سجا دیئے
- اسٹیج
- معیار
- شروع کریں
- شروع ہوتا ہے
- حالت
- ریاستی آرٹ
- نے کہا
- امریکہ
- کے اعداد و شمار
- مرحلہ
- مراحل
- روکنا
- ذخیرہ
- ذخیرہ
- پردہ
- براہ راست
- کامیاب
- اس طرح
- حمایت
- کی حمایت کرتا ہے
- مصنوعی
- مصنوعی ڈیٹا
- مصنوعی طور پر
- کے نظام
- سسٹمز
- موزوں
- لے لو
- لیتا ہے
- لینے
- ہدف
- ٹاسک
- کاموں
- تکنیک
- ٹرمنل
- شرائط
- کہ
- ۔
- مستقبل
- گراف
- کے بارے میں معلومات
- ریاست
- ان
- ان
- اس طرح
- لہذا
- یہ
- تھرڈ
- تین
- تین جہتی
- کے ذریعے
- وقت
- وقت لگتا
- کرنے کے لئے
- مل کر
- ٹوکن
- ٹوکن بنانا
- ٹوکن
- ٹوکن
- بھی
- ٹول کٹ
- سب سے اوپر
- مشعل
- کل
- روایتی
- ٹرین
- تربیت یافتہ
- ٹریننگ
- ٹرینوں
- پراجیکٹ
- تبدیل
- علاج
- سچ
- سمجھ
- کائنات
- غیر استعمال شدہ
- اپ ڈیٹ کریں
- اپ ڈیٹ
- تازہ ترین معلومات
- اپ ڈیٹ
- اپ گریڈ
- us
- استعمال
- استعمال کی شرائط
- صارفین
- عام طور پر
- قیمت
- اقدار
- مختلف
- ورژن
- ویڈیو
- ویڈیو گیمز
- دورہ
- دورے
- W
- راستہ..
- کیا
- جس
- جبکہ
- بڑے پیمانے پر
- وکیپیڈیا
- گے
- جیت
- ساتھ
- الفاظ
- ورکشاپ
- قابل
- گا
- تحریری طور پر
- لکھا
- X
- زیفیرنیٹ
- صفر