CNN இன் முழுமையாக இணைக்கப்பட்ட லேயரில் ஒரு முனையை எவ்வாறு தீர்மானிப்பது

சிஎன்என்களில் முழுமையாக இணைக்கப்பட்ட அடுக்குகளை நீக்குதல்

கன்வல்யூஷனல் நியூரல் நெட்வொர்க்கில் (சிஎன்என்) முழுமையாக இணைக்கப்பட்ட (எஃப்சி) லேயரின் செயல்பாட்டைப் புரிந்துகொள்வது ஒரு மர்மத்தை அவிழ்ப்பது போல் உணரலாம். பலருக்கு, சிக்கலானது கணக்கீடு செயல்பாட்டில் உள்ளது மற்றும் மறைக்கப்பட்ட அடுக்கில் ஒரு முனை எவ்வாறு பெறப்படுகிறது. பாரம்பரிய செயற்கை நரம்பியல் நெட்வொர்க்குகள் (ANNகள்) போலல்லாமல், CNN களில் உள்ள FC அடுக்கு நுணுக்கங்களைக் கொண்டுள்ளது, அவை பெரும்பாலும் பயிற்சிகளில் விவரிக்கப்படாது. இதைப் பற்றி நீங்கள் குழப்பமடைந்தால், நீங்கள் தனியாக இல்லை!

பல ஆதாரங்கள் இந்தத் தலைப்பைப் பயன்படுத்துகின்றன, கற்றவர்களுக்கு தெளிவான வழிகாட்டுதல் இல்லாமல் போய்விடுகிறது. பயிற்சிகள் பெரும்பாலும் முழுமையடையாத விளக்கங்களை மறுசுழற்சி செய்கின்றன, மேலும் தெளிவைத் தேடுபவர்களின் விரக்தியைச் சேர்க்கின்றன. நீங்கள் மீண்டும் மீண்டும் பதில்களைத் தேடுவதைக் கண்டறிந்தால், நீங்கள் சரியான இடத்தில் உள்ளீர்கள். 🧩

இந்த வழிகாட்டியில், FC லேயரின் மறைக்கப்பட்ட அடுக்கிலிருந்து ஒற்றை முனையைக் கணக்கிடுவதில் கவனம் செலுத்துவோம். ஒரு முனைக்கான பொறிமுறையை நீங்கள் புரிந்துகொண்டவுடன், மீதமுள்ளவற்றைச் சமாளிக்க நீங்கள் தயாராக இருப்பீர்கள். இந்த செயல்முறையை தெளிவான, செயல்படக்கூடிய படிகளாகப் பிரிப்பதன் மூலம், எந்த FC லேயர் கணக்கீட்டிலும் செல்ல நம்பிக்கையைப் பெறுவீர்கள்.

தொடர்புடைய எடுத்துக்காட்டுகள் மற்றும் நேரடியான வரைபடத்தைப் பயன்படுத்தி, FC லேயரில் உள்ளீடுகளிலிருந்து வெளியீடுகளுக்கான பாதையை ஒளிரச் செய்வோம். குழப்பத்திற்கு குட்பை சொல்லுங்கள், புரிதலுக்கு வணக்கம் - உள்ளே நுழைவோம்! 🚀

கட்டளை	பயன்பாட்டின் உதாரணம்
np.dot()	இரண்டு வரிசைகளுக்கு இடையே புள்ளி தயாரிப்பைச் செய்கிறது. முழுமையாக இணைக்கப்பட்ட அடுக்கில் ஒரு முனைக்கான உள்ளீடுகள் மற்றும் எடைகளின் எடையுள்ள தொகையைக் கணக்கிட இங்கே பயன்படுத்தப்படுகிறது.
np.maximum()	கணக்கிடப்பட்ட வெளியீடு மற்றும் பூஜ்ஜியத்திற்கு இடையே உள்ள அதிகபட்ச மதிப்பைத் தேர்ந்தெடுப்பதன் மூலம் ReLU செயல்படுத்தும் செயல்பாட்டைப் பயன்படுத்துகிறது.
torch.tensor()	PyTorch இல் ஒரு டென்சரை உருவாக்குகிறது. ஆழமான கற்றல் கட்டமைப்பில் தரவு பிரதிநிதித்துவத்திற்கான அடிப்படை கட்டுமான தொகுதிகள் டென்சர்கள் ஆகும்.
torch.matmul()	பைடார்ச்சில் மேட்ரிக்ஸ் பெருக்கலைச் செய்கிறது. உள்ளீடுகள் மற்றும் எடைகளுக்கு இடையே உள்ள புள்ளி உற்பத்தியைக் கணக்கிடப் பயன்படுகிறது.
torch.nn.functional.relu()	PyTorch இல் ReLU செயல்படுத்தும் செயல்பாட்டைப் பயன்படுத்துகிறது, டென்சரில் உள்ள அனைத்து எதிர்மறை மதிப்புகளையும் பூஜ்ஜியமாக அமைக்கிறது.
np.testing.assert_array_almost_equal()	ஒரு குறிப்பிட்ட சகிப்புத்தன்மைக்குள் சமத்துவத்திற்காக உறுப்பு வாரியாக இரண்டு அணிவரிசைகளை ஒப்பிடுகிறது. எண் செயல்பாடுகளில் வெளியீட்டின் சரியான தன்மையை சோதிக்க பயனுள்ளதாக இருக்கும்.
unittest.TestCase	சோதனை நிகழ்வுகளை உருவாக்குவதற்கான யூனிடெஸ்ட் தொகுதியில் அடிப்படை வகுப்பு. பைத்தானில் அலகு சோதனைகளை கட்டமைக்கவும் ஒழுங்கமைக்கவும் பயன்படுகிறது.
np.array()	NumPy இல் ஒரு வரிசையை உருவாக்குகிறது. முழுமையாக இணைக்கப்பட்ட அடுக்கு கணக்கீடுகளில் உள்ளீடுகள், எடைகள் மற்றும் சார்புகளைக் குறிக்க வரிசைகள் பயன்படுத்தப்படுகின்றன.
torch.matmul()	நரம்பியல் நெட்வொர்க்குகளில் வெளியீடுகளைக் கணக்கிடுவதற்கு முக்கியமான மேட்ரிக்ஸ் பெருக்கத்திற்கான PyTorch இன் செயல்பாடு.
unittest.main()	ஸ்கிரிப்ட்டில் வரையறுக்கப்பட்ட அனைத்து சோதனை நிகழ்வுகளையும் இயக்குகிறது. செயல்படுத்தப்பட்ட தீர்வுகளின் துல்லியம் மற்றும் நம்பகத்தன்மையை சரிபார்க்க இன்றியமையாதது.

முழுமையாக இணைக்கப்பட்ட அடுக்கு கணக்கீடுகளை உடைத்தல்

வழங்கப்பட்டுள்ள ஸ்கிரிப்ட்கள், ஒரு முனையில் எப்படி ஒரு முனையை நீக்குவதை நோக்கமாகக் கொண்டுள்ளது CNN இன் அடுக்கு முந்தைய லேயரில் இருந்து தரவை செயலாக்குகிறது. இந்த அடுக்குகள் எடையுள்ள இணைப்புகள் மற்றும் சார்புகளைப் பயன்படுத்தி ஒவ்வொரு உள்ளீட்டையும் ஒவ்வொரு முனையுடனும் இணைக்கின்றன, அவை பட வகைப்பாடு போன்ற பணிகளுக்கு அவசியமானவை. முதல் ஸ்கிரிப்ட் ஒற்றை முனையைப் பயன்படுத்தி வெளியீட்டைக் கணக்கிடுகிறது . உள்ளீட்டு மதிப்புகளை அவற்றின் தொடர்புடைய எடைகளுடன் பெருக்கி, சார்புகளைச் சேர்ப்பதன் மூலம், முனை வெளியீடு பெறப்படுகிறது. இந்த வெளியீடு பின்னர் ஒரு செயல்படுத்தும் செயல்பாட்டின் மூலம் அனுப்பப்படுகிறது (எ.கா., ReLU) நேரியல் அல்லாத தன்மையை அறிமுகப்படுத்துகிறது. எடுத்துக்காட்டாக, ஒரு படத்தின் பிக்சல் மதிப்புகளை உள்ளீடுகளாக கற்பனை செய்து பாருங்கள்; எடைகள் படத்திலிருந்து அர்த்தமுள்ள அம்சங்களைப் பிரித்தெடுக்கும் கற்றறிந்த வடிப்பான்களைக் குறிக்கலாம். 🖼️

இரண்டாவது ஸ்கிரிப்ட் பல முனைகளுக்கான கணக்கீட்டை பொதுமைப்படுத்துகிறது. இது மேட்ரிக்ஸ் பெருக்கத்தைப் பயன்படுத்துகிறது, அங்கு எடைகள் 2டி மேட்ரிக்ஸாகவும் உள்ளீடுகள் வெக்டராகவும் குறிப்பிடப்படுகின்றன. இந்த திறமையான அணுகுமுறை அடுக்கில் உள்ள அனைத்து முனைகளுக்கும் ஒரே நேரத்தில் கணக்கீடு செய்ய அனுமதிக்கிறது. சார்புகளைச் சேர்த்து, ReLU செயல்படுத்தும் செயல்பாட்டைப் பயன்படுத்துவதன் மூலம், லேயரின் இறுதி வெளியீடுகள் உருவாக்கப்படுகின்றன. இந்த முறை மிகவும் அளவிடக்கூடியது மற்றும் நவீன ஆழ்ந்த கற்றல் கட்டமைப்பில் ஒரு முக்கிய செயல்பாடாகும். உதாரணமாக, முகம் அடையாளம் காணும் அமைப்பில், கண்டறியப்பட்ட வடிவம் மனித முகத்தை ஒத்திருக்கிறதா என்பதைத் தீர்மானிக்க இந்த செயல்முறை உதவும். 😊

போன்ற ஆழமான கற்றல் நூலகங்களுடன் பணிபுரிபவர்களுக்கு , மூன்றாவது ஸ்கிரிப்ட் அதே கணக்கீடுகளை அடைய டென்சர்கள் மற்றும் உள்ளமைக்கப்பட்ட செயல்பாடுகளை எவ்வாறு பயன்படுத்துவது என்பதை விளக்குகிறது. PyTorch இன் நெகிழ்வுத்தன்மை மற்றும் உள்ளமைக்கப்பட்ட மேம்படுத்தல்கள் நரம்பியல் நெட்வொர்க்குகளை உருவாக்குவதற்கும் பயிற்சி செய்வதற்கும் சிறந்ததாக அமைகிறது. உள்ளீடுகள், எடைகள் மற்றும் சார்புகளை டென்சர்களாக வரையறுப்பது மற்றும் மேட்ரிக்ஸ் பெருக்கத்தை எவ்வாறு செய்வது என்பதை ஸ்கிரிப்ட் காட்டுகிறது. செயல்பாடு. வனவிலங்கு புகைப்படங்களில் விலங்குகளை அடையாளம் காண்பது போன்ற பெரிய தரவுத்தொகுப்புகளில் CNN களுக்கு பயிற்சி அளிப்பதற்கான இறுதி முதல் இறுதி வரையிலான பைப்லைன்களை உருவாக்க இது மிகவும் பயனுள்ளதாக இருக்கும்.

இறுதியாக, யூனிட் சோதனைகள் ஸ்கிரிப்ட் பல்வேறு நிபந்தனைகளின் கீழ் அனைத்து செயலாக்கங்களும் சரியாக வேலை செய்வதை உறுதி செய்கிறது. பயன்படுத்தி நூலகம், கணக்கீடுகளின் எண்ணியல் துல்லியத்தை சரிபார்க்கிறது மற்றும் வெளியீடுகள் எதிர்பார்த்த முடிவுகளை சந்திக்கின்றன என்பதை உறுதிப்படுத்துகிறது. பிழைத்திருத்தம் செய்வதற்கும் நம்பகத்தன்மையை உறுதி செய்வதற்கும் இந்தப் படி முக்கியமானது, குறிப்பாக மருத்துவப் படப் பகுப்பாய்வு போன்ற நிஜ உலகப் பயன்பாடுகளில் CNNகளைப் பயன்படுத்தும்போது. இந்த ஸ்கிரிப்டுகள் மற்றும் விளக்கங்கள் மூலம், CNNகளில் FC லேயர்களை நம்பிக்கையுடன் புரிந்துகொள்வதற்கும் செயல்படுத்துவதற்கும் இப்போது தெளிவான பாதை உங்களுக்கு உள்ளது. 🚀

# Import necessary library
import numpy as np
# Define inputs to the fully connected layer (e.g., from previous convolutional layers)
inputs = np.array([0.5, 0.8, 0.2])  # Example inputs
# Define weights for the first node in the hidden layer
weights_node1 = np.array([0.4, 0.7, 0.3])
# Define bias for the first node
bias_node1 = 0.1
# Calculate the output for node 1
node1_output = np.dot(inputs, weights_node1) + bias_node1
# Apply an activation function (e.g., ReLU)
node1_output = max(0, node1_output)
# Print the result
print(f"Output of Node 1: {node1_output}")

# Import necessary library
import numpy as np
# Define inputs to the fully connected layer
inputs = np.array([0.5, 0.8, 0.2])
# Define weights matrix (rows: nodes, columns: inputs)
weights = np.array([[0.4, 0.7, 0.3],  # Node 1
                    [0.2, 0.9, 0.5]]) # Node 2
# Define bias for each node
biases = np.array([0.1, 0.2])
# Calculate outputs for all nodes
outputs = np.dot(weights, inputs) + biases
# Apply activation function (e.g., ReLU)
outputs = np.maximum(0, outputs)
# Print the results
print(f"Outputs of Hidden Layer: {outputs}")

# Import PyTorch
import torch
# Define inputs as a tensor
inputs = torch.tensor([0.5, 0.8, 0.2])
# Define weights and biases
weights = torch.tensor([[0.4, 0.7, 0.3],  # Node 1
                          [0.2, 0.9, 0.5]]) # Node 2
biases = torch.tensor([0.1, 0.2])
# Calculate outputs
outputs = torch.matmul(weights, inputs) + biases
# Apply ReLU activation
outputs = torch.nn.functional.relu(outputs)
# Print results
print(f"Outputs of Hidden Layer: {outputs}")

# Import unittest library
import unittest
# Define the test case class
class TestNodeCalculation(unittest.TestCase):
    def test_single_node(self):
        inputs = np.array([0.5, 0.8, 0.2])
        weights_node1 = np.array([0.4, 0.7, 0.3])
        bias_node1 = 0.1
        expected_output = max(0, np.dot(inputs, weights_node1) + bias_node1)
        self.assertEqual(expected_output, 0.86)
    def test_multiple_nodes(self):
        inputs = np.array([0.5, 0.8, 0.2])
        weights = np.array([[0.4, 0.7, 0.3],
                            [0.2, 0.9, 0.5]])
        biases = np.array([0.1, 0.2])
        expected_outputs = np.maximum(0, np.dot(weights, inputs) + biases)
        np.testing.assert_array_almost_equal(expected_outputs, np.array([0.86, 0.98]))
# Run the tests
if __name__ == "__main__":
    unittest.main()

சிஎன்என்களில் முழுமையாக இணைக்கப்பட்ட அடுக்குகளின் முக்கியத்துவத்தை அவிழ்த்தல்

முழுமையாக இணைக்கப்பட்ட (எஃப்சி) அடுக்குகள் கன்வல்யூஷனல் லேயர்களில் இருந்து பிரித்தெடுக்கப்பட்ட அம்சங்களை இறுதிக் கணிப்புகளாக மாற்றுவதில் முக்கியப் பங்கு வகிக்கின்றன. ஒவ்வொரு உள்ளீட்டையும் ஒவ்வொரு வெளியீட்டிலும் இணைப்பதன் மூலம் அவை செயல்படுகின்றன, கற்றறிந்த அம்சங்களின் அடர்த்தியான மேப்பிங்கை வழங்குகின்றன. ஸ்பேஷியல் படிநிலைகளில் கவனம் செலுத்தும் கன்வல்யூஷனல் லேயர்களைப் போலல்லாமல், ஒரு படத்தில் உள்ள பொருட்களை அடையாளம் காண்பது போன்ற முடிவுகளை எடுக்க FC லேயர்கள் இந்தத் தகவலை ஒருங்கிணைக்கின்றன. உதாரணமாக, ஒரு சுய-ஓட்டுநர் காரின் பட அங்கீகார அமைப்பில், கண்டறியப்பட்ட பொருள் பாதசாரியா அல்லது தெரு அடையாளமா என்பதை FC லேயர் தீர்மானிக்கலாம். 🚗

FC அடுக்குகளை வேறுபடுத்தும் ஒரு அம்சம், பயிற்சியின் போது கற்றுக்கொண்ட வடிவங்களைப் பொதுமைப்படுத்தும் திறன் ஆகும். காணப்படாத தரவைக் கையாளும் போது இந்த சொத்து முக்கியமானது. அடுக்கில் உள்ள ஒவ்வொரு முனையும் எடைகள் மற்றும் சார்புகளின் தனித்துவமான கலவையைக் குறிக்கிறது, இது குறிப்பிட்ட வடிவங்கள் அல்லது வகுப்புகளை அங்கீகரிப்பதில் நிபுணத்துவம் பெற உதவுகிறது. இதனால்தான் FC அடுக்குகளின் அமைப்பு ஒட்டுமொத்த மாதிரியின் துல்லியத்தை அடிக்கடி தீர்மானிக்கிறது. எடுத்துக்காட்டாக, கையால் எழுதப்பட்ட இலக்க அங்கீகார மாதிரியில், எஃப்சி அடுக்கு பிக்சல் வடிவங்களை எண் கணிப்புகளாக (0-9) ஒருங்கிணைக்கிறது. ✍️

FC அடுக்குகள் அவற்றின் அடர்த்தியான இணைப்புகளின் காரணமாக கணக்கீட்டு ரீதியாக விலை உயர்ந்ததாக இருந்தாலும், விரிவான வகைப்பாடு தேவைப்படும் பணிகளுக்கு அவை இன்றியமையாததாக இருக்கும். டிராப்அவுட் போன்ற நவீன நுட்பங்கள், அதிகப்படியான பொருத்தத்தைத் தடுப்பதன் மூலம் அவற்றின் செயல்திறனை மேம்படுத்த பயன்படுத்தப்படுகின்றன. பயிற்சியின் போது செயலில் உள்ள முனைகளின் எண்ணிக்கையைக் குறைப்பதன் மூலம், எஃப்சி லேயர் வலுவான அம்சங்களைக் கற்றுக்கொள்வதை உறுதிசெய்கிறது, இது முக அங்கீகாரம் மற்றும் மருத்துவப் படக் கண்டறிதல் போன்ற பயன்பாடுகளில் இன்றியமையாததாக ஆக்குகிறது.

1. சிஎன்என்களில் முழுமையாக இணைக்கப்பட்ட லேயரின் முக்கிய செயல்பாடு என்ன?
2. FC அடுக்கு அனைத்து உள்ளீடுகளையும் வெளியீடுகளுடன் இணைக்கிறது, இறுதி கணிப்புகளுக்கான அம்சங்களை ஒருங்கிணைக்கிறது. அம்ச வரைபடங்களை செயல்படக்கூடிய முடிவுகளாக மாற்றுவதற்கு இது முக்கியமானது.
3. எஃப்சி லேயர்களில் எடைகள் மற்றும் சார்புகள் எவ்வாறு தொடங்கப்படுகின்றன?
4. எடைகள் பெரும்பாலும் தோராயமாக துவக்கப்படுகின்றன அல்லது சேவியர் துவக்கம் போன்ற நுட்பங்களைப் பயன்படுத்துகின்றன, அதே சமயம் சார்புகள் பொதுவாக எளிமைக்காக பூஜ்ஜியத்தில் தொடங்கும்.
5. ReLU செயல்படுத்தல் FC லேயர் செயல்திறனை எவ்வாறு மேம்படுத்துகிறது?
6. எதிர்மறை வெளியீடுகளை பூஜ்ஜியமாக அமைப்பதன் மூலம் ReLU நேரியல் அல்லாத தன்மையைப் பயன்படுத்துகிறது. இது சாய்வு மறைந்து போவதைத் தடுக்கிறது, மாடல் வேகமாக ஒன்றிணைகிறது.
7. டிராப்அவுட்டை FC லேயர்களுக்குப் பயன்படுத்த முடியுமா?
8. ஆம், டிராப்அவுட் ஆனது பயிற்சியின் போது முனைகளைத் தோராயமாக முடக்குகிறது, மாதிரி பொதுமைப்படுத்தலை மேம்படுத்துகிறது மற்றும் அதிகப்படியான பொருத்துதலைக் குறைக்கிறது.
9. எஃப்சி லேயர்களை மாற்றும் அடுக்குகளிலிருந்து வேறுபடுத்துவது எது?
10. கன்வல்யூஷனல் லேயர்ஸ் ஸ்பேஷியல் அம்சங்களை பிரித்தெடுக்கும் போது, ​​எஃப்சி லேயர்கள் இந்த அம்சங்களை வகைப்படுத்துவதற்காக அடர்த்தியான வடிவத்தில் ஒருங்கிணைக்கின்றன.

முழுமையாக இணைக்கப்பட்ட அடுக்கு, கற்றறிந்த அம்சங்களை செயல்படக்கூடிய கணிப்புகளாக ஒருங்கிணைக்கிறது, இது நரம்பியல் நெட்வொர்க்குகளில் இறுதி முடிவெடுக்கும் படியாக செயல்படுகிறது. ஒவ்வொரு முனையும் எவ்வாறு கணக்கிடப்படுகிறது என்பதைப் புரிந்துகொள்வதன் மூலம், ஆப்ஜெக்ட் கண்டறிதல் மற்றும் வகைப்பாடு போன்ற பணிகளுக்கு CNN கட்டமைப்புகளை வடிவமைத்து மேம்படுத்துவதில் பயனர்கள் நம்பிக்கையைப் பெறுகின்றனர்.

தன்னாட்சி வாகனங்களில் பட அங்கீகாரம் அல்லது முக அடையாளம் போன்ற நடைமுறை எடுத்துக்காட்டுகள், FC அடுக்குகளின் முக்கியத்துவத்தை வெளிப்படுத்துகின்றன. சரியான அணுகுமுறையுடன், தேர்வுமுறை முறைகளை இணைத்துக்கொள்வது, பார்க்காத தரவுகளுடன் நன்கு பொருந்தக்கூடிய வலுவான மற்றும் துல்லியமான மாதிரிகளை உறுதி செய்கிறது. இந்த கருத்தின் தேர்ச்சியானது செயற்கை நுண்ணறிவுக்கான ஆழமான ஆய்வைத் திறக்கிறது. 😊