PyTorch അടിസ്ഥാനങ്ങൾ: മോഡലുകൾ നിർമ്മിക്കുകയും ട്രെയിൻ ചെയ്യുകയും ചെയ്യൽ

PyTorch ഡിഫോൾട്ടായി eager execution ഉപയോഗിക്കുന്നു: ടെൻസറുകൾ Python ഓപ്പറേഷനുകളിലൂടെ ഒഴുകുന്നു, നിങ്ങൾക്ക് സാധാരണ ഡേറ്റ പോലെ പ്രിന്റ് ചെയ്യാനും, സ്ലൈസ് ചെയ്യാനും, ഡീബഗ് ചെയ്യാനും കഴിയും. ഫിനാൻസിൽ ഇത് പ്രധാനമാണ്, ജോലിയുടെ പകുതിയും അലങ്കോലമായ ഫീച്ചർ പാനലുകൾ പുനർരൂപകൽപ്പന ചെയ്യുന്നതും, മോഡലിന് നൽകുന്ന ടെൻസറിലേക്ക് look-ahead ഒന്നും കടന്നുകൂടിയിട്ടില്ല എന്ന് പരിശോധിക്കുന്നതും ആയതിനാൽ.

പഴയ "ഒരു സ്റ്റാറ്റിക് ഗ്രാഫ് ബിൽഡ് ചെയ്യുക, പിന്നെ ഒരു സെഷൻ റൺ ചെയ്യുക" വർക്ക്ഫ്ലോയുമായി ഇത് താരതമ്യം ചെയ്യുക. ഗവേഷകർ ഇപ്പോഴും ഡിപ്ലോയ്മെന്റിനായി മോഡലുകൾ എക്സ്പോർട്ട് ചെയ്യുന്നു, എന്നാൽ ദിവസേനയുള്ള ജോലി ഉടനടിയുള്ളതിന്റെ ഗുണം അനുഭവിക്കുന്നു: ഒരു ലെയർ മാറ്റുക, ഒരു സെൽ വീണ്ടും റൺ ചെയ്യുക, activation-കൾ പരിശോധിക്കുക.

ഒരു ടെൻസർ ഒരു മൾട്ടിഡൈമെൻഷണൽ അറേയാണ്; requires_grad=True നിങ്ങൾ ഡെറിവേറ്റിവുകൾ ആഗ്രഹിക്കുന്ന ലീഫുകൾ അടയാളപ്പെടുത്തുന്നു. Autograd ഒരു ബാക്ക്‌വേഡ് ഗ്രാഫ് ബിൽഡ് ചെയ്യാൻ ഓപ്പറേഷനുകൾ റെക്കോർഡ് ചെയ്യുന്നു, അതിനാൽ loss.backward() പാരാമീറ്ററുകളിൽ .grad പോപ്പുലേറ്റ് ചെയ്യുന്നു.

import torch
x = torch.randn(32, 10, requires_grad=True)
w = torch.randn(10, 1, requires_grad=True)
y = (x @ w).mean()
y.backward()
print(w.grad.shape)

ലഭ്യമാകുമ്പോൾ ടെൻസറുകൾ cuda-യിലോ mps-ലോ സ്ഥാപിക്കുക; ഓരോ സ്റ്റെപ്പിലും ചെറിയ ടെൻസറുകൾ അബദ്ധത്തിൽ അങ്ങോട്ടും ഇങ്ങോട്ടും നീക്കാതിരിക്കാൻ ഡിവൈസ് പ്ലേസ്മെന്റ് സ്ഥിരമായി നിലനിർത്തുക.

nn.Module subclass ചെയ്യുക, __init__-ൽ ലെയറുകൾ നിർവചിക്കുക, forward-ൽ അവയെ ബന്ധിപ്പിക്കുക. Registration, പാരാമീറ്ററുകൾ ഓപ്റ്റിമൈസറുകൾക്കായി model.parameters()-ൽ പ്രത്യക്ഷപ്പെടുന്നത് ഉറപ്പാക്കുന്നു.

import torch.nn as nn

class MLP(nn.Module):
    def __init__(self, n):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(n, 64), nn.ReLU(), nn.Linear(64, 1)
        )
    def forward(self, x):
        return self.net(x)

സീക്വൻസ് മോഡലുകൾക്ക്, nn.LSTM-ഉം nn.TransformerEncoder ലെയറുകളും സാധാരണമാണ്; ടാബുലാർ alpha-ക്ക്, MLP-കളും gradient boosting-ഉം ഇപ്പോഴും മത്സരിക്കുന്നു — ട്രെൻഡ് അനുസരിച്ചല്ല, validation ഡിസിപ്ലിൻ അനുസരിച്ച് തിരഞ്ഞെടുക്കുക.

ട്രെയിനിംഗ് മനഃപൂർവം ആവർത്തനപരമാണ്: forward, loss, zero grad, backward, step. അധിക കാര്യങ്ങൾ പ്രധാനമാണ്: model.train() vs model.eval() dropout-ഉം batch norm-ഉം ടോഗിൾ ചെയ്യുന്നു; torch.no_grad() മെമ്മറി സേവ് ചെയ്യാൻ validation-നെ പൊതിയുന്നു.

ഫീച്ചറുകളും ലേബലുകളും ബോധ്യമാക്കാൻ Dataset subclass ചെയ്യുക; ബാച്ചിംഗിനായി DataLoader-ൽ പൊതിയുക. ക്രോണോളജിക്കൽ ഡേറ്റയ്ക്ക്, സാധാരണയായി validation-ൽ shuffle=False നിലനിർത്തുക, തുടർച്ചയായ വിൻഡോകൾ സ്ലൈസ് ചെയ്യുകയാണെങ്കിൽ ട്രെയിനിംഗിലും പലപ്പോഴും — അല്ലെങ്കിൽ നിങ്ങൾ സമയത്തിലുടനീളം വിവരങ്ങൾ പരത്തുന്നു.

നിങ്ങൾ GaiaEx-ൽ നിന്നോ സമാന ഫീഡുകളിൽ നിന്നോ ടിക്ക് ഡേറ്റയിൽ ട്രെയിൻ ചെയ്യുകയാണെങ്കിൽ, ബാറുകൾ ഒരൊറ്റ ക്ലോക്കിലേക്ക് അലൈൻ ചെയ്യുക, മിസ്സിംഗ് പ്രിന്റുകൾ വ്യക്തമായി കൈകാര്യം ചെയ്യുക, മോഡൽ ചെക്ക്പോയിന്റിനൊപ്പം നിങ്ങളുടെ ഫീച്ചർ കോഡ് വേർഷൻ ചെയ്യുക.

ലോ-ലേറ്റൻസി ഇൻഫറൻസിന്, ടീമുകൾ പലപ്പോഴും മോഡൽ trace ചെയ്യുകയോ script ചെയ്യുകയോ ചെയ്യുന്നു, തുടർന്ന് ഒരു C++ റണ്ടൈമിലോ ഒരു സൈഡ്‌കാർ സർവീസിലോ റൺ ചെയ്യുന്നു. ട്രെയിനിംഗ് എൻവയോൺമെന്റ് (ലൈബ്രറി വേർഷനുകൾ) നിങ്ങൾ എക്സ്പോർട്ട് ചെയ്യാൻ ഉപയോഗിച്ചതിനൊപ്പം പിൻ ചെയ്ത് നിലനിർത്തുക.

PyTorch Lightning-ഉം സമാന ഫ്രെയിംവർക്കുകളും മൾട്ടി-GPU ട്രെയിനിംഗിനും ലോഗിംഗിനും ബോയിലർപ്ലേറ്റ് കുറയ്ക്കുന്നു; അവ ശ്രദ്ധാപൂർവമായ ഫീച്ചർ ഡിസൈനിന് പകരമല്ല. ട്രേഡിംഗിലെ എഡ്ജ് സാധാരണയായി വരുന്നത് ഡേറ്റ ഹൈജീനിൽ നിന്നും regime awareness-ൽ നിന്നുമാണ്, കുറച്ചുകൂടി മികച്ച ഒരു ഒപ്റ്റിമൈസറിൽ നിന്നല്ല.