PyTorch-ஐப் பயன்படுத்தி, மிக எளிமையான நரம்பியல் மொழி மாதிரியான ‘character-level bigram‘ எனும் ஒன்று புதிதாக உருவாக்கப்பட்டுள்ளது. இதில் மொழிமாற்றிகள்(transformers), கவணஈர்ப்பு (attention) அல்லது சிக்கலான சுருக்க முறைகள் (abstractions) ஆகிய எதுவும் இல்லை. வெறும் 79 எழுத்துகள், ஒரு எண்ணிக்கை அணி (counting matrix) , பன்மபெயரளவுமாதிரி(multinomial sampling) ஆகியன மட்டுமே இதில் உள்ளன. இந்நிலையில் bigram மாதிரி என்றால் என்ன? எனும் கேள்வி நம்மனதில் எழும் நிற்க.
ஒரு bigram மாதிரி என்பது , தற்போதைய எழுத்தை அடிப்படையாகக் கொண்டு மட்டுமே அடுத்த எழுத்தைக் கணிப்புசெய்கிறது. அவ்வளவுதான். இதில் ஆயிரக்கணக்கானஅடையாளவில்லைகளைக்(token) கொண்ட சூழல் சாளரம் (context window) எதுவும் இல்லை — “கொடுக்கப்பட்ட எழுத்தான X-க்கு அடுத்து வரக்கூடிய மிகவும் சாத்தியமான எழுத்து எது?” என்பது மட்டுமே கேள்வி. மொழியின் மாதிரியாக்கத்தில் இது ‘Hello World’ என்பதை போன்ற மிகவும் அடிப்படையானத் தொடக்க நிலை போன்றதுஆகும்.
செயல்படுத்தும் முறை
படிமுறை1:மூல உரையிலிருந்து (Raw Text) → எழுத்துகளின் தொகுப்பினை (Character Vocabulary) உருவாக்குதல்– அதற்கான குறிமுறைவரிகள் பின்வருமாறு
with open(“Oz.txt”, ‘r’, encoding=’utf-8′) as f:
text = f.read()
chars = sorted(set(text))
print(len(chars)) # 79 unique characters
79 தனித்துவமான எழுத்துகள்: இதில் எழுத்துகள் (a-z, A-Z), எண்கள், நிறுத்தற்குறிகள், இடைவெளிகள் ,புதிய வரிக் குறியீடுகள் ஆகியவை அடங்கும். GPT-4-இன் சுமார் 100K அடையாளவில்லையை(token) BPE தொகுப்புடன் ஒப்பிடும்போது இது மிகச் சிறிய தொகுப்பாகும்.
படிமுறை 2: எழுத்துருவினை மறைகுறியாக்கம் (Character Encoding) செய்தல்
string_to_int = {ch: i for i, ch in enumerate(chars)}
int_to_string = {i: ch for i, ch in enumerate(chars)}
encoder = lambda s: [string_to_int[c] for c in s]
decoder = lambda l: ”.join([int_to_string[i] for i in l])
data = torch.tensor(encoder(text), dtype=torch.long)
print(data.shape) # torch.Size([231881])
ஒவ்வொரு எழுத்தும் 0 முதல் 78 வரையிலான ஒரு முழு எண்ணுடன் இணைக்கப்படுகிறது. “The Wonderful Wizard of Oz” எனும்நூலின் முழு உரையும் 231,881 உறுப்புகளைக் கொண்ட ஒரு tensor ஆக மாறுகிறது.
படிமுறை 3: பயிற்சி/ தரவினைப் பிரித்தல் (Train/Val Split)
n = int(0.8 * len(data))
train_data = data[:n]
val_data = data[n:]
இது வழக்கமான 80/20 எனும் தரவுபிரித்தல் முறையாகும். இது எளிமையானதும் பயனுள்ளதுமாகும்.
படிமுறை 4: உள்ளீட்டு–இரட்டையான இலக்குகள் (Input-Target Pairs)
அடுத்த அடையாளவில்லையைக்(token) கணிப்பதற்கு, நமக்கு (உள்ளீடு, இலக்கு) ஆகிய இரட்டைகள் தேவைப்படுகின்றன; இதில் உள்ளீட்டுத் தொடரைத் தொடர்ந்து வரும் அடுத்த எழுத்தே இலக்காக அமைகிறது:
block_size = 8
x = train_data[:block_size]
y = train_data[1:block_size+1]
for t in range(block_size):
context = x[:t+1]
target = y[t]
print(f”when input is {context} the target: {target}”)
# when input is tensor([0]) the target: 0
# when input is tensor([0, 0]) the target: 43
# when input is tensor([0, 0, 43]) the target: 67
# …
இதுவே ‘autoregressive’ எனும் மொழி மாதிரியாக்கத்தின் முக்கிய வடிவமாகும்: ஒரு தொடர் கொடுக்கப்பட்டால், அடுத்து என்ன வரும் என்பதைக் கணிப்பதே இதன் செயல்பாடுஆகும். GPT முதல் LLaMA , Mistral வரையிலான நவீன LLM-கள் அனைத்தும் இதே அடிப்படை அணுகு முறையையே பயன்படுத்துகின்றன. இவற்றிற்கு இடையிலான ஒரே வேறுபாடு யாதெனில் அளவுகோல் (scale) மட்டுமேயாகும்.
படிமுறை 5: GPU , CPUஆகியவற்றின் செயல்திறன் ஒப்பீடு (Benchmark)
உண்மையான ‘bigram probability matrix ‘ஐ உருவாக்குவதற்கு முன், CUDA-வில் PyTorch-இன் அணிப் பெருக்கல் (matrix multiplication) , CPU-வில் NumPy-இன் செயல்பாடு ஆகியவற்றை ஒப்பிட்டு சரிபார்த்திடுக:
torch_rand1 = torch.rand(100, 100, 100, 100).to(device)
torch_rand2 = torch.rand(100, 100, 100, 100).to(device)
# CUDA: 0.017 வினாடிகள்
# NumPy CPU: 0.134 வினாடிகள்
GPU-வில் 8 மடங்கு வேக அதிகரிப்பு — சீரற்ற அணிப் பெருக்கலுக்குக் கூட. பெரிய அளவில் வன்பொருள் முடுக்கம் என்பது தவிர்க்க முடியாதது.
அடுத்து என்ன?
ஒரு Bigram மாதிரி என்பது வெறும் தொடக்கம்தான். அடுத்த கட்டம் ஒரு உட்பொதிக்கப்பட்ட அடுக்கைச் சேர்ப்பதுஆகும், பின்னர் ஒரு மொழிமாற்றி தொகுதியைச் சேர்ப்பது, அதன்பின் அளவை அதிகரிப்பது. ஆனால் இவைகளை அடிப்படைக் கொள்கைகளிலிருந்து உருவாக்கிடுக — சிக்கலான தன்மையைச் சேர்ப்பதற்கு முன் அடித்தளத்தைப் புரிந்துகொள்க.
முக்கியக் குறிப்புகள் :மொழி மாதிரியாக்கம் என்பது எண்ணுவதில் தொடங்குகிறது — Bigram probability matrix என்பது இயல்பாக்கப்பட்ட எண்ணிக்கைகளேயாகும்.