ஜூலியா என்பது மிகஅதிகசுருக்கமான ஒரு இயக்கநேர நிரலாக்க மொழியாகும். இது எந்தவொரு நிரலையும் உருவாக்க ஒரு பொது-நோக்க கணினிமொழியாக இருந்தாலும், இது எண்ணியல் பகுப்பாய்வு , கணக்கீட்டு ஆய்விற்கு மிகவும் பொருத்தமான பல பண்புகளைக் கொண்டுள்ளது.
பைதான்ஆனது 1990 களின் முற்பகுதியில் ஒரு எளிய பொருள் சார்ந்த நிரலாக்க மொழியாக வடிவமைக்கப்பட்டது, ஆனால் அதன் பின்னர் குறிப்பிடத்தக்க அளவில் வளர்ச்சியடைந்துவருகின்றது. இந்த கட்டுரையில் நரம்பியல் பிணையவமைப்புகள், இயந்திர கற்றல் ஆகியவற்றில் இவ்விரண்டு கணினிமொழிகளின் செயல்திறனை ஆழமாகப் ஆய்வு செய்யவிருக்கின்றது.
ஜூலியாவின் கட்டமைப்பு இதனை ஒரு இயக்கநேர நிரலாக்க மொழியில் நிலையளவுருக்களை சார்ந்த பல்லுருப்பு பெறலையும் , அதன் முதன்மை நிரலாக்க மாதிரியாக அனுப்புகின்ற பல நிரலாக்க முன்னுதாரணத்தையும் கொண்டுள்ளது. இது செய்தி அனுப்புகின்ற இடைமுகம் (MPI) அல்லது உள்ளமைக்கப்பட்ட ‘OpenMP-style’ எனும்புரிகளை அல்லது இடைநிலையிலான குறிமுறைவரிகளில்லாமல் C , FORTRAN ஆகிய கணினிமொழிகளின் நூலகங்களை ஒரே நேரத்தில் நேரடியாக அழைக்கின்றவாறு இணையான, விநியோகிக்கப்பட்ட கணினியை அனுமதிக்கிறது. ஜூலியா ஆனது ஒரு சரியான நேரத்தில் ( just-in-time (JIT)) இயந்திரமொழிமாற்றியைப் பயன்படுத்திகொள்கின்றது, ஜூலியாவின் சமூக குழுவானது இதனை ‘just-ahead-of-time’’ (JAOT) என்று குறிப்பிடுகிறது, ஏனெனில் இதனை இயக்கும் முன்பாகவே இயல்புநிலையாக இயந்திரக் குறியீட்டிற்கு எல்லா குறிமுறை வரிகளையும் தொகுக்கிறது.
பைதான் போலல்லாமல், ஜூலியா குறிப்பாக புள்ளிவிவரங்கள், இயந்திர கற்றல் ஆகியவற்றில் பயன்படுத்துவதற்காகவே வடிவமைக்கப்பட்டுள்ளது. ஜூலியாவானது நேரியல் இயற்கணிதம் வழியாக பறந்து செல்ல முடியும், அதே சமயம் பைதான் ஆனது நேரியல் இயற்கணிதம் வழியாகச் செல்லமட்டுமே முடியும். ஏனெனில், இயந்திரக் கற்றலுக்குத் தேவையான அனைத்து அணிகளுக்கும் (matrices) சமன்பாடுகளுக்கும் இடமளிக்கும் வகையில் பைதான் ஒருபோதும் வடிவமைக்கப்படவில்லை. ஆயினும் பைதான் ஆனதுஎந்த வகையிலும் மோசமானதாக இல்லை, இதற்காக NumPy உடன் இணைத்து பயன்படுத்திகொள்ளலாம், ஆனால் ஜூலியா ஆனது, தடைகள் எதுவும் இல்லாத அனுபவத்தின் அடிப்படையில் இந்த வகையான கணித ஆய்வுகளுக்கு ஏற்றவாறு மிகவும் சிறப்பாக வடிவமைக்கப்பட்டுள்ளது. பைத்தானை விட ஜூலியாவின் செயலேற்பி அமைவு Rஎனும் கணினிமொழியைப் போன்றது, இது ஒரு குறிப்பிடத்தக்க கூடுதல் வசதியாகும். ஜூலியாவின் துனையுடன்நேரியல் இயற்கணிதத்தின் பெரும்பகுதியை குறைந்த நேரத்தில் குறைந்த முயற்சியில் முடிக்க முடியும்.
சமீபத்திய ஆண்டுகளில் பைதான் இயந்திர கற்றல் தரவு அறிவியல் துறைகளில் ஆதிக்கம் செலுத்திவருகிறது. ஏனெனில் பைத்தானில் நாம் பயன்படுத்தக்கூடிய பல்வேறு மூன்றாம் தரப்பு நூலகங்கள், இயந்திர கற்றல் குறிமுறைவரிகளை எளிதாக உருவாக்க உதவுகின்றன. பைத்தானின் பல நன்மைகள் இருந்தாலும், – இது ஒரு இயந்திர மொழிமாற்றியுடனான கணினி மொழியாக இருப்பதால் இது மிகமெதுவாக செயல்படுகின்ற ஒரு பெரிய குறைபாடு உள்ளது . தற்போது அதிகஅளவிலான தரவுகளை கையாளுகின்ற சூழலில் நாம் வாழ்ந்து வருகின்றோம், இவ்வாறான அதிகஅளவிலான தரவுகளில் நாம் மிகஅதிக நேரம் பணி செய்ய வேண்டிய நிலை ஏற்படுகின்றது. இந்நிலையில்தான் ஜூலியா கைகொடுக்க வருகின்றது. பெரும்பாலான ஆய்வுப் பணிகள், உயர் சக்தியுடையக் கணினி அல்லது அறிவியல் கணக்கீட்டுத் திறன் போன்ற தலைப்புகளில் இதுவரை ஜூலியாவைப் பற்றி நடந்துள்ளன. ஆனால் ஜூலியா எந்தவொரு சிக்கலான அறிவியல் கணக்கீடுகளிலும் திறமையாக செயல்படுவதோடு மட்டுமல்லாமல் வணிக அடிப்படையிலான சிக்கல்களிலும் எவ்வாறு செயல்படுகின்றது என்பதைப் பற்றி மட்டும் இங்கு விவாதிப்போம், மேலும் இயந்திர கற்றல் நரம்பியல் பிணையவமைப்புகளில் பைத்தானை கொண்டு எவ்வாறு சமாளிக்க முடியும் என்பதையும் காண்போம்.
குறிக்கோளும் பரிசோதனையும்
ஜூலியா எனும் கணினிமொழியானது பைத்தான் எனும் கணினிமொழியைப் போன்றே மிகஎளிமையானது, ஆனால் சி போன்ற தொகுக்கப்பட்ட மொழியாகும். எனவே பைத்தானுடன் ஒப்பிடுகையில் ஜூலியா எவ்வளவு விரைவாக செயல்படுகின்றது என்பதை முதலில் சில எளிய நிரல்களில் இந்த கணினி மொழிகளை பரிசோதித்திடுவோம்., பின்னர் நமமுடைய பரி சோதனையின் முக்கிய மையத்திற்குச் செல்வோம், இது இயந்திரக் கற்றல் ஆழ்கற்றல் ஆகியவற்றை பரிசோதிப்பதற்கானதாகும். ஜூலியா பைதான் ஆகிய இரண்டும் பல நூலகங்களையும் திறமூல தரப்படுத்தல் கருவிகளையும் வழங்குகின்றன. ஜூலியாவில் நேரத்தை தரப்படுத்துவதற்கும் கணக்கிடுவதற்கும், CPUTime, நேர நூலகங்கள் பயன்படுத்தப்ட்டுள்ளது. இதேபோல், பைத்தானுக்கு, நேர தொகுதியைப் பயன்படுத்திகொள்ளப்பட்டுள்லது.
அணிகளை பெருக்குதல்(Matrix multiplication )
நாம் முதலில் எளிய எண்கணித செயலிகளை முயற்சித்திடுவோம், ஆனால் இவை செயல்படும்நேரத்தில் அதிக வித்தியாசத்தை உருவாக்காது என்பதால், அணிகளின் பெருக்குதலில் நேரத்தைச் சரிபார்த்திடுவோம். சீரற்ற மிதக்கும் புள்ளிகளாலான எண்களின் இரண்டு (10 * 10) அணிகளை உருவாக்கி, இவற்றில் புள்ளியினை உருவாக்கிடுவோம். நாம் அறிந்தபடி, பைத்தானில் ஒரு NumPy நூலகம் உள்ளது, இது அணிகள் கோடுகள் ஆகியவற்றுடன் பணிபுரிவதில் பிரபலமானது. இதேபோல், ஜூலியாவில் ஒரு கோடுகளின் இயற்கணித நூலகம் உள்ளது, அது அணிகள் திசையன்களுடன் நன்றாக செயல்படுகிறது. எனவே அணிகளின் பெருக்கலை அந்தந்த நூலகங்களுடனும் பயன்படுத்தாமலும் ஒப்பிட்டுப் பார்த்திடலாம். இந்தக் கட்டுரையில் பயன்படுத்தப்படும் அனைத்து நிரல்களுக்கான மூலக் குறிமுறைவரிகளும் (github.com/mr-nerdster/Julia_Research.gitsee) எனும் இணையதளமுகவரியின் GitHub களஞ்சியத்தில் கிடைக்கிறது. ஜூலியாவில் எழுதப்பட்ட 10×10 அணியின் பெருக்குதல் செய்வதற்கான நிரல் பின்வருமாறு:
@time LinearAlgebra.mul!(c,x,y)
function MM()
x = rand(Float64,(10,10))
y = rand(Float64,(10,10))
c = zeros(10,10)
for i in range(1,10)
for j in range(1,10)
for k in range(1,10)
c[i,j] += x[i,k]*y[k,j]
end
end
end
end
@time MM
0.000001 seconds
MM (generic function with 1 method)
ஜூலியா நூலகத்தைப் பயன்படுத்தி 0.000017 வினாடிகளும், மடக்கிகளைப்(loops). பயன்படுத்தி 0.000001 வினாடிகளும் எடுத்துக்கொள்கின்றது. அதேஅணி பெருக்குதலிற்கான நிரல் கீழே கண்டுள்ளவாறு பைத்தானில் எழுதப்பட்டது. நூலகம் இல்லாததை விட நூலகத்துடன் ஒப்பிடும்போது குறைந்த நேரத்தை எடுத்துகொள்ளும் என்பதை இம்முடிவுகளிலிருந்து காணலாம்.
import numpy as np
import time as t
x = np.random.rand(10,10)
y = np.random.rand(10,10)
start = t.time()
z = np.dot(x, y)
print(“Time = “,t.time()-start)
Time = 0.001316070556640625
import random
import time as t
l = 0
h= 10
cols = 10
rows= 10
choices = list (map(float, range(l,h)))
x = [random.choices (choices , k=cols) for _ in range(rows)]
y = [random.choices (choices , k=cols) for _ in range(rows)]
result = [([0]*cols) for i in range (rows)]
start = t.time()
for i in range(len(x)):
for j in range(len(y[0])):
for k in range(len(result)):
result[i][j] += x[i][k] * y[k][j]
print(result)
print(“Time = “, t.time()-start)
Time = 0.0015912055969238281
பைதான் நூலகத்தைப் பயன்படுத்தி 0.0013 வினாடிகள் மடக்கிகளைப் பயன்படுத்தி 0.0015 வினாடிகள் எடுத்துக்கொள்கின்றது.
நேரியல் தேடல்(Linear search )
அடுத்த பரிசோதனையானது, தோராயமாக உருவாக்கப்பட்ட ஒரு இலட்சம் சீரற்ற எண்களில் நேரியல் தேடலாகும். இதில் forஎனும் மடக்கி, இயக்கி(operator) ஆகிய இரண்டு வழிமுறைகளைப் பயன்படுத்தப்பட்டுள்ளன – . 1 முதல் 1000 வரையிலான முழு எண்களைக் கொண்டு 1000 தேடல்களைச் செய்யப்பட்டன, மேலும் கீழே உள்ள வெளியீட்டில் காண்பதை போல, தரவுத் தொகுப்பில் எத்தனை முழு எண்களைக் காண்கிறோம் என்பதையும் அச்சிடலாம். forஎனும் மடக்கியைப் பயன்படுத்தியையும், IN எனும் இயக்கியையும் பயன்படுத்துவதன் மூலம் நேரத்தின் வெளியீடு பின்வருமாறு இருக்கும. இதில்சராசரி CPU நேரமானது 3 முறை இயக்கி எடுத்து அளக்கப்பட்டது. பின்வரும்நிரல் ஜூலியாவுக்காக எழுதப்பட்டது அதன் முடிவுகள் பின்வருமாறு.
import numpy as np
import time as t
x = np.random.rand(10,10)
y = np.random.rand(10,10)
start = t.time()
z = np.dot(x, y)
print(“Time = “,t.time()-start)
Time = 0.001316070556640625
import random
import time as t
l = 0
h= 10
cols = 10
rows= 10
choices = list (map(float, range(l,h)))
x = [random.choices (choices , k=cols) for _ in range(rows)]
y = [random.choices (choices , k=cols) for _ in range(rows)]
result = [([0]*cols) for i in range (rows)]
start = t.time()
for i in range(len(x)):
for j in range(len(y[0])):
for k in range(len(result)):
result[i][j] += x[i][k] * y[k][j]
print(result)
print(“Time = “, t.time()-start)
Time = 0.0015912055969238281
அதையே பைத்தானுக்காக எழுதப்பட்ட நிரல் அதன்முடிவுகள் பின்வருமாறு:
FOR_SEARCH:
Elapsed CPU time: 16.420260511 seconds
matches: 550
Elapsed CPU time: 16.140975079 seconds
matches: 550
Elapsed CPU time: 16.49639576 seconds
matches: 550
IN:
Elapsed CPU time: 6.446583343 seconds
matches: 550
Elapsed CPU time: 6.216615487 seconds
matches: 550
Elapsed CPU time: 6.296716556 seconds
matches: 550
மேலே கண்ட முடிவுகளிலிருந்து, ஜூலியாவில் மடக்கி, இயக்கி ஆகியவற்றினைப் பயன்படுத்துவதில் நேர வேறுபாடுகள் இல்லை என்பது தெளிவாகிறது. இருப்பினும், பைத்தானில் உள்ள IN எனும் இயக்கியைவிட மடக்கியானது ஏறக்குறைய மூன்று மடங்கு அதிக செயலாக்க நேரத்தை எடுத்துகொள்கின்றது. இங்கே சுவாரசியமான செய்தி என்னவெனில், இரண்டு நிகழ்வுகளிலும், பைத்தானை விட ஜூலியா மிக விரைவாக செயல்படுத்தும் நேரத்தைக் கொண்டுள்ளது என்பதேயாகும்.
நேரியல் பின்னோக்கு(Linear regression)
அடுத்த பரிசோதனைகள் இயந்திர கற்றல் தருக்கபடிமுறைகளில் செய்யப் படு கின்றன. முதலில் மிகவும் பொதுவான எளிமையான இயந்திர கற்றல் தருக்கபடி முறைகளில் ஒன்றில் பணியானது செயற்படுத்தப்பட்டது, அதாவது, ஒரு எளிய தரவுத் தொகுப்புடன் நேரியல் பின்னோக்கு(Linear regression) சரிபார்க்கப்டடது. 237 எண்ணிக்கையிலான தரவு உள்ளீடுகள், இரண்டு நெடுவரிசைகள் [HeadSize, BrainWeight] கொண்ட ‘Head Brain’ எனும் தரவுத் தொகுப்புப் பயன்படுத்தப்பட்டது. இதில், தலையின் அளவைப் பயன்படுத்தி மூளையின் எடையைக் கணக்கிட வேண்டியிருந்தது. எனவே பைதான் ஜூலியா இரண்டிலும் இந்தத் தரவுகளில் எந்த நூலகத்தையும் பயன்படுத்தாமல், புதிதாக ரியல் பின்னோக்கு(Linear regression) செயல்படுத்தப்பட்டது.
Julia:
GC.gc()
@CPUtime begin
linear_reg()
end
elapsed CPU time: 0.000718 seconds
Python:
gc.collect()
start = process_time()
linear_reg()
end = process_time()
print(end-start)
elapsed time: 0.007180344000000005
ஜூலியா , பைதான் ஆகிய இரண்டும் எடுத்தகொண்ட நேரம் மேலே கொடுக்கப் பட்டுள்ளது.
போக்குவரத்து பின்னோக்கு(Logistic regression)
அடுத்து, இருகணினி மொழிகளிலும் உள்ள நூலகங்களைப் பயன்படுத்தி, மிகவும் பொதுவான வகை இயந்திரக் கற்றல் தருக்கபடிமுறை, அதாவது போக்குவரத்து பின்னோக்கு பற்றிய பரிசோதனை மேற்கொள்ளப்பட்டது. பைத்தானைப் பொறுத்தவரை, ஜூலியாவில் GLM நூலகத்தைப் பயன்படுத்தியபோது, பொதுவாகப் பயன்படுத்தப்படும் sklearn எனும் நூலகம் பயன்படுத்தப்பட்டது. 10,000 தரவு உள்ளீடுகளைக் கொண்ட வங்கியின் வாடிக்கையாளர்களைப் பற்றிய தகவலே இதற்கு பயன்படுத்திய தரவுத் தொகுப்பாகும். இதில் இலக்கு மாறி என்பது binary மாறி ஆகும், இது நுகர்வோர் வங்கியை விட்டு வெளியேறினாரா (அவரது அல்லது கணக்கை முடி்த்துவிட்டாரா) அல்லது வாடிக்கையாளராக இருந்தாரா என்பதைக் குறிக்கிறது.
@time log_rec()
0.027746 seconds (3.32 k allocations: 10.947 MiB)
போக்குவரத்தின் பின்னோக்கிற்கு பைதான் எடுக்கும் நேரம் பின்வருமாறு
gc.collect()
start = process_time()
LogReg()
end = process_time()
print(end-start)
Accuracy : 0.8068
0.34901400000000005
நரம்பியல்பிணையங்கள்(Neural networks)
பல்வேறு நிரல்கள் தரவுத் தொகுப்புகளில் இரு கணினிமொழிகளையும் பரசோதித்த பிறகு, அவற்றை நரம்பியல் பிணையங்களில் பரிசோதித்திட, MNIST தரவுத் தொகுப்பு பயன்படுத்தப்பட்டது. இந்தத் தரவுத் தொகுப்பில் பூஜ்ஜியத்திலிருந்து ஒன்பது வரையிலான கையால் வரையப்பட்ட இலக்கங்களின் சாம்பல் அளவிலான படங்கள் உள்ளன. ஒவ்வொரு படமும் 28×28 பிக்சல்கள். ஒவ்வொரு பிக்சல் மதிப்பும் அந்த பிக்சலின் ஒளி அல்லது இருளைக் குறிக்கிறது, மேலும் இந்த மதிப்பு 0 , 255 ஆகியவற்றிற்கு இடைப்பட்ட ஒரு முழு எண் ஆகும். இம்மதிப்பிற்குரிய படத்தில் வரையப்பட்ட இலக்கத்தைக் குறிக்கும் முகவரிசீட்டின் நெடுவரிசையையும் தரவு கொண்டுள்ளது
.
1
MNIST தரவுத் தொகுப்பின் சில உதாரணங்களை படம் 1 காட்டுகிறது.
இரண்டு கணினிமொழிகளும் எடுத்துகொள்ளும் நேரத்தை பரிசோதிக்க எளிய நரம்பியல் பிணையவமைப்பு ஒன்று உருவாக்கப்பட்டது. நமது நரம்பியல் பிணையவமைப்பின் கட்டமைப்பு பின்வருமாறு:
Input —> Hidden layer —> Output
இது உள்ளீட்டு அடுக்கு, மறைக்கப்பட்ட அடுக்கு , வெளியீட்டு அடுக்கு ஆகியவற்றைக் கொண்டுள்ளது. சிக்கல்களைத் தவிர்க்க, தரவுத் தொகுப்பில் எந்த முன் செயலாக்கத்தையும் பயன்படுத்தவில்லை, அது அப்படியே செயல்படுத்தப் பட்டது. இந்த மாதிரியை 40 முறைகளுக்குப் பயிற்றுவிக்கப்பட்டது, அதில் ஜூலியாவிற்கும் பைத்தானுக்கும் இடையிலான நேர வித்தியாசம் சரிபார்க்கப்பட்டது.
2
படம் 2: ஜூலியா நரம்பியல் பிணையவைமைப்பில் 5.76 வினாடிகள் எடுக்கின்றது
ஜூலியாவிற்கு, Flux எனும் நூலகம் நரம்பியல் பிணையவமைப்பை செயல்படுத்த பயன்படுத்தப்பட்டது . பைத்தானுக்கு, Keras எனும்நூலகம் பயன்படுத்தப்பட்டது. நரம்பியல் பிணையவமைப்பில் ஜூலியா எடுத்த நேரத்தை படம் 2 காட்டுகிறது. படம் 3 பைதான் எடுத்த நேரத்தையும், நரம்பியல் பிணையவமைப்பில் மாதிரியின் சில மறு செயல்களையும் காட்டுகிறது.
3.
படம் 3: பைதான் ஒரு நரம்பியல்பிணையவமைப்பில் 110.3 வினாடிகள் எடுத்துகொள்கின்றது
நரம்பியல் பிணையவயமைப்பிற்கு வரும்போது ஜூலியாவிற்கும் பைத்தானுக்கும் இடையே பெரிய நேர வேறுபாடுகள் இருப்பதாக முடிவுகள் காட்டுகின்றன.
அட்டவணை 1 பரிசோதனைகளின் அனைத்து முடிவுகளையும் சுருக்கமாகக் கூறுகிறது, மேலும் ஜூலியா , பைத்தானுக்கு இடையிலான நேர வேறுபாட்டை (சதவீதத்தில்) வழங்குகிறது.
அட்டவணை 1
|
ஆய்வுகள் |
ஜூலியா (நொடிகளில்) |
பைதான் (நொடிகளில்) |
நேரவேறுபாடு (%) |
|
Matrix multiplication (without library) |
0.000001 |
0.0015 |
99.9 |
|
Matrix multiplication (with library) |
0.000017 |
0.0013 |
98.69 |
|
Linear search (using loop ) |
0.42 |
16.4 |
97.43 |
|
Linear search (using IN operator) |
0.43 |
6.2 |
93.06 |
|
Linear regression |
0.000718 |
0.00718 |
90 |
|
Logistic regression |
0.025 |
0.34901 |
92.83 |
|
Neural networks |
5.76 |
110.3 |
94.77 |
மேற்கொண்ட அனைத்து பரிசோதனைகளின் வாயிலாக நிரலின் சிக்கலான தன்மையுடன் , தரவுத் தொகுப்பின் அளவு அதிகரிக்கும் போது, ஜூலியாவிற்கும் பைத்தானுக்கும் இடையிலான செயல்பாட்டின் நேர வேறுபாடு அதிகரிக்கிறது என அறிந்து கொள்ளலாம். இம்முடிவுகளிலிருந்து, இயந்திர கற்றல் ,நரம்பியல் பிணையவமைப்புகளுக்கு ஜூலியா சிறந்த நிரலாக்க மொழி என்று நாம் முடிவு செய்யலாம்.