ਵਰਤੇ ਜਾ ਰਹੇ ਇੱਕ ਟ੍ਰਾਂਸਫਾਰਮਰ ਦਾ ਇੱਕ ਪਾਈਟੋਰਕ ਸੰਸਕਰਣ ਵੇਖੋ'] ", 'ਵਰਤੇ ਜਾ ਰਹੇ ਇੱਕ ਟ੍ਰਾਂਸਫਾਰਮਰ ਦਾ ਇੱਕ ਪਾਈਟੋਰਕ ਸੰਸਕਰਣ ਵੇਖੋ', ' [\'ਵਰਤੋਂ ਵਿੱਚ ਇੱਕ ਟ੍ਰਾਂਸਫਾਰਮਰ ਦਾ ਇੱਕ ਪਾਈਟੋਰਚ ਸੰਸਕਰਣ ਵੇਖੋ\', "ਇੱਥੇ ਪਾਈਟੋਰਚ ਵਿੱਚ ਇੱਕ ਸਧਾਰਨ ਟ੍ਰਾਂਸਫਾਰਮਰ ਲਾਗੂ ਕਰਨ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n\\n" \'ਪਾਈਥਨ\\ਨਿਮਪੋਰਟਟਾਰਚ\\ਨਿੰਪੋਰਟ torch.nn ਨੂੰ nn\\n ਤੋਂ torch.utils.data ਇੰਪੋਰਟ ਡੇਟਾਸੇਟ, ਡਾਟਾਲੋਡਰ\\n\\n ਕਲਾਸ ਟ੍ਰਾਂਸਫਾਰਮਰ (nn.Module): \\n ਡਿਫ _ _ ਇਨਿਟ _ (ਸੈਲਫ, ਇੰਪੁੱਟ _ ਸਾਈਜ਼,ਆਉਟਪੁੱਟ _ ਸਾਈਜ਼, ਨੰਮ _ ਹੈੱਡ, ਡਰਾਪਆਉਟ = 0.1): \\n ਸੁਪਰ (ਟ੍ਰਾਂਸਫਾਰਮਰ, ਸੈਲਫ). _ _ init _ () \\n self.encoder = nn.MultiHeadAttention (ਇੰਪੁੱਟ _ ਸਾਈਜ਼, ਆਉਟਪੁੱਟ _ ਸਾਈਜ਼,num _ ਹੇਡਸ) \\n self.encoder.to (torch.device (\'cuda\')) \\n self.encoder.weight.data.uniform_ (-1,1) \\n self.encoder.bias.data.uniform_ (-1,1) \\n self.decoder= nn.MultiHeadAttention (ਆਉਟਪੁੱਟ _ ਸਾਈਜ਼, ਇੰਪੁੱਟ _ ਸਾਈਜ਼, ਨੰਮ _ ਹੈੱਡ) \\n self.decoder.to (torch.device (\'ਕੁਡਾ\')) \\n self.decoder.weight.data.uniform_ (-1,1) \\nself.decoder.bias.data.uniform_ (-1,1) \\n self.fc = nn.Linear (ਇੰਪੁੱਟ _ ਸਾਈਜ਼, ਆਉਟਪੁੱਟ _ ਸਾਈਜ਼) \\n self.fc.to (torch.device (\'ਕੁਡਾ\')) \\nself.fc.weight.data.uniform_ (-1,1) \\n self.fc.bias.data.uniform_ (-1,1) \\n self.dropout = nn.Dropout (ਡਰਾਪਆਉਟ) \\n\\n ਡਿਫ ਫਾਰਵਰਡ (ਸੈਲਫ, x): \\nh =self.encoder (x) \\nh = self.dropout (h) \\nh = self.decoder (h) \\nh = torch.sigmoid (self.fc (h) \\n ਰਿਟਰਨ h\\n \'\\n\\n ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਸਧਾਰਨ ਪਰਿਭਾਸ਼ਾ ਦਿੰਦੇ ਹਾਂ।ਟ੍ਰਾਂਸਫਾਰਮਰ ਮਾਡਲ ਜੋ ਇੱਕ ਪਾਈਟੋਰਚ \'torch.Tensor\' ਵਿੱਚ ਇੰਪੁੱਟ ਅਕਾਰ \'ਇੰਪੁੱਟ _ ਸਾਈਜ਼\' ਲੈਂਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਪਾਈਟੋਰਚ \'torch.Tensor\' ਅਕਾਰ \'ਆਉਟਪੁੱਟ _ ਸਾਈਜ਼\' ਦਾ ਆਉਟਪੁੱਟ ਦਿੰਦਾ ਹੈ।ਟ੍ਰਾਂਸਫਾਰਮਰ ਵਿੱਚ ਇੱਕ ਇੰਕੋਡਰ ਅਤੇ ਇੱਕ ਡੀਕੋਡਰ ਹੁੰਦਾ ਹੈ, ਜੋ ਦੋਵੇਂ ਮਲਟੀ-ਹੈੱਡ ਧਿਆਨ ਪਰਤਾਂ ਹੁੰਦੀਆਂ ਹਨ। ਇੰਕੋਡਰ ਅਤੇ ਡੀਕੋਡਰ ਦੋਵੇਂ ਇਸ ਵਿੱਚ ਲਪੇਟੇ ਹੁੰਦੇ ਹਨ।\'nn.Module\', \'ਡ੍ਰੌਪਆਊਟ ਦੀ ਵਰਤੋਂ ਕਿਉਂ ਕੀਤੀ ਜਾ ਰਹੀ ਹੈ? ਇਹ ਕਿਸ ਕਾਗਜ਼ ਤੋਂ ਹੈ?\' ', 'ਵਰਤੇ ਜਾ ਰਹੇ ਇੱਕ ਟ੍ਰਾਂਸਫਾਰਮਰ ਦਾ ਇੱਕ ਪਾਈਟੋਰਕ ਸੰਸਕਰਣ ਵੇਖੋ', ' [\'ਵਰਤੋਂ ਵਿੱਚ ਇੱਕ ਟ੍ਰਾਂਸਫਾਰਮਰ ਦਾ ਇੱਕ ਪਾਈਟੋਰਚ ਸੰਸਕਰਣ ਵੇਖੋ\', "ਇੱਥੇ ਪਾਈਟੋਰਚ ਵਿੱਚ ਇੱਕ ਸਧਾਰਨ ਟ੍ਰਾਂਸਫਾਰਮਰ ਲਾਗੂ ਕਰਨ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n\\n" \'ਪਾਈਥਨ\\ਨਿਮਪੋਰਟਟਾਰਚ\\ਨਿੰਪੋਰਟ torch.nn ਨੂੰ nn\\n ਤੋਂ torch.utils.data ਇੰਪੋਰਟ ਡੇਟਾਸੇਟ, ਡਾਟਾਲੋਡਰ\\n\\n ਕਲਾਸ ਟ੍ਰਾਂਸਫਾਰਮਰ (nn.Module): \\n ਡਿਫ _ _ ਇਨਿਟ _ (ਸੈਲਫ, ਇੰਪੁੱਟ _ ਸਾਈਜ਼,ਆਉਟਪੁੱਟ _ ਸਾਈਜ਼, ਨੰਮ _ ਹੈੱਡ, ਡਰਾਪਆਉਟ = 0.1): \\n ਸੁਪਰ (ਟ੍ਰਾਂਸਫਾਰਮਰ, ਸੈਲਫ). _ _ init _ () \\n self.encoder = nn.MultiHeadAttention (ਇੰਪੁੱਟ _ ਸਾਈਜ਼, ਆਉਟਪੁੱਟ _ ਸਾਈਜ਼,num _ ਹੇਡਸ) \\n self.encoder.to (torch.device (\'cuda\')) \\n self.encoder.weight.data.uniform_ (-1,1) \\n self.encoder.bias.data.uniform_ (-1,1) \\n self.decoder= nn.MultiHeadAttention (ਆਉਟਪੁੱਟ _ ਸਾਈਜ਼, ਇੰਪੁੱਟ _ ਸਾਈਜ਼, ਨੰਮ _ ਹੈੱਡ) \\n self.decoder.to (torch.device (\'ਕੁਡਾ\')) \\n self.decoder.weight.data.uniform_ (-1,1) \\nself.decoder.bias.data.uniform_ (-1,1) \\n self.fc = nn.Linear (ਇੰਪੁੱਟ _ ਸਾਈਜ਼, ਆਉਟਪੁੱਟ _ ਸਾਈਜ਼) \\n self.fc.to (torch.device (\'ਕੁਡਾ\')) \\nself.fc.weight.data.uniform_ (-1,1) \\n self.fc.bias.data.uniform_ (-1,1) \\n self.dropout = nn.Dropout (ਡਰਾਪਆਉਟ) \\n\\n ਡਿਫ ਫਾਰਵਰਡ (ਸੈਲਫ, x): \\nh =self.encoder (x) \\nh = self.dropout (h) \\nh = self.decoder (h) \\nh = torch.sigmoid (self.fc (h) \\n ਰਿਟਰਨ h\\n \'\\n\\n ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਸਧਾਰਨ ਪਰਿਭਾਸ਼ਾ ਦਿੰਦੇ ਹਾਂ।ਟ੍ਰਾਂਸਫਾਰਮਰ ਮਾਡਲ ਜੋ ਇੱਕ ਪਾਈਟੋਰਚ \'torch.Tensor\' ਵਿੱਚ ਇੰਪੁੱਟ ਅਕਾਰ \'ਇੰਪੁੱਟ _ ਸਾਈਜ਼\' ਲੈਂਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਪਾਈਟੋਰਚ \'torch.Tensor\' ਅਕਾਰ \'ਆਉਟਪੁੱਟ _ ਸਾਈਜ਼\' ਦਾ ਆਉਟਪੁੱਟ ਦਿੰਦਾ ਹੈ।ਟ੍ਰਾਂਸਫਾਰਮਰ ਵਿੱਚ ਇੱਕ ਇੰਕੋਡਰ ਅਤੇ ਇੱਕ ਡੀਕੋਡਰ ਹੁੰਦਾ ਹੈ, ਜੋ ਦੋਵੇਂ ਮਲਟੀ-ਹੈੱਡ ਧਿਆਨ ਪਰਤਾਂ ਹੁੰਦੀਆਂ ਹਨ। ਇੰਕੋਡਰ ਅਤੇ ਡੀਕੋਡਰ ਦੋਵੇਂ ਇਸ ਵਿੱਚ ਲਪੇਟੇ ਹੁੰਦੇ ਹਨ।\'nn.Module\', \'ਵਰਤੋਂ ਵਿੱਚ ਛੱਡਣਾ ਕਿਉਂ ਹੈ? ਇਹ ਕਿਸ ਕਾਗਜ਼ ਤੋਂ ਹੈ?\', \'ਛੱਡਣਾ ਇੱਕ ਨਿਯਮਤ ਕਰਨ ਦੀ ਤਕਨੀਕ ਹੈ ਜੋ ਬੇਤਰਤੀਬੇ ਤੌਰ\' ਤੇ ਕੁੱਝ ਮੁੱਲਾਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦੀ ਹੈਸਿਖਲਾਈ ਦੌਰਾਨ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਵਿੱਚ ਲੁਕੀਆਂ ਇਕਾਈਆਂ ਜ਼ੀਰੋ ਹੋ ਜਾਂਦੀਆਂ ਹਨ। ਇਸ ਦਾ ਇਕਾਈਆਂ ਦਰਮਿਆਨ ਸਹਿ-ਅਨੁਕੂਲਤਾ ਨੂੰ ਘਟਾਉਣ ਦਾ ਪ੍ਰਭਾਵ ਹੁੰਦਾ ਹੈ, ਜੋ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ।ਓਵਰਫਿਟਿੰਗ ਨੂੰ ਰੋਕਣਾ ਅਤੇ ਸਰਵ ਸਧਾਰਨਕਰਨ ਵਿੱਚ ਸੁਧਾਰ ਕਰਨਾ। \\n ਸਕੂਲ ਛੱਡਣ ਦੇ ਪਿੱਛੇ ਦਾ ਵਿਚਾਰ ਇਹ ਹੈ ਕਿ ਬੇਤਰਤੀਬੇ ਤੌਰ \'ਤੇ ਕੁੱਝ ਇਕਾਈਆਂ ਨੂੰ ਜ਼ੀਰੋ\' ਤੇ ਸੈੱਟ ਕਰਕੇ, ਅਸੀਂ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਹਾਂ।ਨੈੱਟਵਰਕ ਦੀ ਸਮਰੱਥਾ ਨੂੰ ਘਟਾਉਣਾ, ਜੋ ਇਸ ਨੂੰ ਵਧੇਰੇ ਮਜ਼ਬੂਤ ਅਤੇ ਸਥਿਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਸਿੱਖਣ ਲਈ ਮਜਬੂਰ ਕਰਦਾ ਹੈ। \\n ਸਕੂਲ ਛੱਡਣ ਦੀ ਨਿਯਮਤ ਕਰਨ ਦੀ ਤਕਨੀਕ ਸੀ"ਡ੍ਰੌਪਆਊਟਃ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਨੂੰ ਓਵਰਫਿਟਿੰਗ ਤੋਂ ਰੋਕਣ ਦਾ ਇੱਕ ਸਧਾਰਨ ਤਰੀਕਾ" ਪੇਪਰ ਵਿੱਚ ਨਾਮ _ 1, ਨਾਮ _ 2, ਨਾਮ _ 3 ਅਤੇ ਨਾਮ _ 4 ਦੁਆਰਾ ਪੇਸ਼ ਕੀਤਾ ਗਿਆ।2013 ਵਿੱਚ ਜਰਨਲ ਆਫ਼ ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਰਿਸਰਚ ਵਿੱਚ ਪ੍ਰਕਾਸ਼ਿਤ \',\' ਹਾਂ ਪਰ ਇੱਕ ਟ੍ਰਾਂਸਫਾਰਮਰ ਵਿੱਚ ਸਕੂਲ ਛੱਡਣ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ ਹੈ? \' ', 'ਵਰਤੇ ਜਾ ਰਹੇ ਇੱਕ ਟ੍ਰਾਂਸਫਾਰਮਰ ਦਾ ਇੱਕ ਪਾਈਟੋਰਕ ਸੰਸਕਰਣ ਵੇਖੋ', ' [\'ਵਰਤੋਂ ਵਿੱਚ ਇੱਕ ਟ੍ਰਾਂਸਫਾਰਮਰ ਦਾ ਇੱਕ ਪਾਈਟੋਰਚ ਸੰਸਕਰਣ ਵੇਖੋ\', "ਇੱਥੇ ਪਾਈਟੋਰਚ ਵਿੱਚ ਇੱਕ ਸਧਾਰਨ ਟ੍ਰਾਂਸਫਾਰਮਰ ਲਾਗੂ ਕਰਨ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n\\n" \'ਪਾਈਥਨ\\ਨਿਮਪੋਰਟਟਾਰਚ\\ਨਿੰਪੋਰਟ torch.nn ਨੂੰ nn\\n ਤੋਂ torch.utils.data ਇੰਪੋਰਟ ਡੇਟਾਸੇਟ, ਡਾਟਾਲੋਡਰ\\n\\n ਕਲਾਸ ਟ੍ਰਾਂਸਫਾਰਮਰ (nn.Module): \\n ਡਿਫ _ _ ਇਨਿਟ _ (ਸੈਲਫ, ਇੰਪੁੱਟ _ ਸਾਈਜ਼,ਆਉਟਪੁੱਟ _ ਸਾਈਜ਼, ਨੰਮ _ ਹੈੱਡ, ਡਰਾਪਆਉਟ = 0.1): \\n ਸੁਪਰ (ਟ੍ਰਾਂਸਫਾਰਮਰ, ਸੈਲਫ). _ _ init _ () \\n self.encoder = nn.MultiHeadAttention (ਇੰਪੁੱਟ _ ਸਾਈਜ਼, ਆਉਟਪੁੱਟ _ ਸਾਈਜ਼,num _ ਹੇਡਸ) \\n self.encoder.to (torch.device (\'cuda\')) \\n self.encoder.weight.data.uniform_ (-1,1) \\n self.encoder.bias.data.uniform_ (-1,1) \\n self.decoder= nn.MultiHeadAttention (ਆਉਟਪੁੱਟ _ ਸਾਈਜ਼, ਇੰਪੁੱਟ _ ਸਾਈਜ਼, ਨੰਮ _ ਹੈੱਡ) \\n self.decoder.to (torch.device (\'ਕੁਡਾ\')) \\n self.decoder.weight.data.uniform_ (-1,1) \\nself.decoder.bias.data.uniform_ (-1,1) \\n self.fc = nn.Linear (ਇੰਪੁੱਟ _ ਸਾਈਜ਼, ਆਉਟਪੁੱਟ _ ਸਾਈਜ਼) \\n self.fc.to (torch.device (\'ਕੁਡਾ\')) \\nself.fc.weight.data.uniform_ (-1,1) \\n self.fc.bias.data.uniform_ (-1,1) \\n self.dropout = nn.Dropout (ਡਰਾਪਆਉਟ) \\n\\n ਡਿਫ ਫਾਰਵਰਡ (ਸੈਲਫ, x): \\nh =self.encoder (x) \\nh = self.dropout (h) \\nh = self.decoder (h) \\nh = torch.sigmoid (self.fc (h) \\n ਰਿਟਰਨ h\\n \'\\n\\n ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਸਧਾਰਨ ਪਰਿਭਾਸ਼ਾ ਦਿੰਦੇ ਹਾਂ।ਟ੍ਰਾਂਸਫਾਰਮਰ ਮਾਡਲ ਜੋ ਇੱਕ ਪਾਈਟੋਰਚ \'torch.Tensor\' ਵਿੱਚ ਇੰਪੁੱਟ ਅਕਾਰ \'ਇੰਪੁੱਟ _ ਸਾਈਜ਼\' ਲੈਂਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਪਾਈਟੋਰਚ \'torch.Tensor\' ਅਕਾਰ \'ਆਉਟਪੁੱਟ _ ਸਾਈਜ਼\' ਦਾ ਆਉਟਪੁੱਟ ਦਿੰਦਾ ਹੈ।ਟ੍ਰਾਂਸਫਾਰਮਰ ਵਿੱਚ ਇੱਕ ਇੰਕੋਡਰ ਅਤੇ ਇੱਕ ਡੀਕੋਡਰ ਹੁੰਦਾ ਹੈ, ਜੋ ਦੋਵੇਂ ਮਲਟੀ-ਹੈੱਡ ਧਿਆਨ ਪਰਤਾਂ ਹੁੰਦੀਆਂ ਹਨ। ਇੰਕੋਡਰ ਅਤੇ ਡੀਕੋਡਰ ਦੋਵੇਂ ਇਸ ਵਿੱਚ ਲਪੇਟੇ ਹੁੰਦੇ ਹਨ।\'nn.Module\', \'ਵਰਤੋਂ ਵਿੱਚ ਛੱਡਣਾ ਕਿਉਂ ਹੈ? ਇਹ ਕਿਸ ਕਾਗਜ਼ ਤੋਂ ਹੈ?\', \'ਛੱਡਣਾ ਇੱਕ ਨਿਯਮਤ ਕਰਨ ਦੀ ਤਕਨੀਕ ਹੈ ਜੋ ਬੇਤਰਤੀਬੇ ਤੌਰ\' ਤੇ ਕੁੱਝ ਮੁੱਲਾਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦੀ ਹੈਸਿਖਲਾਈ ਦੌਰਾਨ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਵਿੱਚ ਲੁਕੀਆਂ ਇਕਾਈਆਂ ਜ਼ੀਰੋ ਹੋ ਜਾਂਦੀਆਂ ਹਨ। ਇਸ ਦਾ ਇਕਾਈਆਂ ਦਰਮਿਆਨ ਸਹਿ-ਅਨੁਕੂਲਤਾ ਨੂੰ ਘਟਾਉਣ ਦਾ ਪ੍ਰਭਾਵ ਹੁੰਦਾ ਹੈ, ਜੋ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ।ਓਵਰਫਿਟਿੰਗ ਨੂੰ ਰੋਕਣਾ ਅਤੇ ਸਰਵ ਸਧਾਰਨਕਰਨ ਵਿੱਚ ਸੁਧਾਰ ਕਰਨਾ। \\n ਸਕੂਲ ਛੱਡਣ ਦੇ ਪਿੱਛੇ ਦਾ ਵਿਚਾਰ ਇਹ ਹੈ ਕਿ ਬੇਤਰਤੀਬੇ ਤੌਰ \'ਤੇ ਕੁੱਝ ਇਕਾਈਆਂ ਨੂੰ ਜ਼ੀਰੋ\' ਤੇ ਸੈੱਟ ਕਰਕੇ, ਅਸੀਂ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਹਾਂ।ਨੈੱਟਵਰਕ ਦੀ ਸਮਰੱਥਾ ਨੂੰ ਘਟਾਉਣਾ, ਜੋ ਇਸ ਨੂੰ ਵਧੇਰੇ ਮਜ਼ਬੂਤ ਅਤੇ ਸਥਿਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਸਿੱਖਣ ਲਈ ਮਜਬੂਰ ਕਰਦਾ ਹੈ। \\n ਸਕੂਲ ਛੱਡਣ ਦੀ ਨਿਯਮਤ ਕਰਨ ਦੀ ਤਕਨੀਕ ਸੀ"ਡ੍ਰੌਪਆਊਟਃ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਨੂੰ ਓਵਰਫਿਟਿੰਗ ਤੋਂ ਰੋਕਣ ਦਾ ਇੱਕ ਸਧਾਰਨ ਤਰੀਕਾ" ਪੇਪਰ ਵਿੱਚ ਨਾਮ _ 1, ਨਾਮ _ 2, ਨਾਮ _ 3 ਅਤੇ ਨਾਮ _ 4 ਦੁਆਰਾ ਪੇਸ਼ ਕੀਤਾ ਗਿਆ।2013 ਵਿੱਚ ਜਰਨਲ ਆਫ਼ ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਰਿਸਰਚ ਵਿੱਚ ਪ੍ਰਕਾਸ਼ਿਤ \',\' ਹਾਂ ਪਰ ਇੱਕ ਟ੍ਰਾਂਸਫਾਰਮਰ ਵਿੱਚ ਸਕੂਲ ਛੱਡਣ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ ਹੈ? \',\' ਇਹ ਸਹੀ ਹੈ, ਸਕੂਲ ਛੱਡਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ।ਇੱਕ ਟ੍ਰਾਂਸਫਾਰਮਰ ਮਾਡਲ ਵਿੱਚ ਇਸ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ ਹੈ। ਅਸਲ ਵਿੱਚ, ਡਰਾਪਆਉਟ ਇੱਕ ਟ੍ਰਾਂਸਫਾਰਮਰ ਵਿੱਚ ਨੁਕਸਾਨਦੇਹ ਹੋ ਸਕਦਾ ਹੈ ਕਿਉਂਕਿ ਇਹ ਬੇਤਰਤੀਬੇ ਤੌਰ ਉੱਤੇ ਲੁਕੀਆਂ ਇਕਾਈਆਂ ਦੇ ਕੁੱਝ ਮੁੱਲਾਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈਜ਼ੀਰੋ, ਜਿਸ ਨਾਲ ਜਾਣਕਾਰੀ ਦਾ ਨੁਕਸਾਨ ਹੋ ਸਕਦਾ ਹੈ ਅਤੇ ਕਾਰਗੁਜ਼ਾਰੀ ਵਿੱਚ ਗਿਰਾਵਟ ਆ ਸਕਦੀ ਹੈ। \\nਟ੍ਰਾਂਸਫਾਰਮਰ ਸਕੂਲ ਛੱਡਣ ਦੀ ਬਜਾਏ ਸਵੈ-ਧਿਆਨ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨਓਵਰਫਿਟਿੰਗ ਨੂੰ ਰੋਕਣਾ ਅਤੇ ਆਮਕਰਨ ਵਿੱਚ ਸੁਧਾਰ ਕਰਨਾ। ਸਵੈ-ਧਿਆਨ ਵਿਧੀ ਮਾਡਲ ਨੂੰ ਇੰਪੁੱਟ ਦੀ ਨੁਮਾਇੰਦਗੀ ਸਿੱਖਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ ਜੋ ਮਜ਼ਬੂਤ ਹੈ।ਅਤੇ ਇੰਪੁੱਟ ਦੇ ਵੱਖ-ਵੱਖ ਹਿੱਸਿਆਂ ਲਈ ਨਿਰੰਤਰ, ਜੋ ਓਵਰਫਿਟਿੰਗ ਨੂੰ ਰੋਕਣ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਦਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਟ੍ਰਾਂਸਫਾਰਮਰ ਆਰਕੀਟੈਕਚਰ ਵਿੱਚ ਆਪਣੇ ਆਪ ਵਿੱਚ ਇੱਕ ਬਿਲਟ-ਇਨ ਹੁੰਦਾ ਹੈ।ਸਮਰੱਥਾ-ਨਿਯੰਤਰਣ ਵਿਧੀ, ਜੋ ਮਾਡਲ ਵਿੱਚ ਮਾਪਦੰਡਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਸੀਮਤ ਕਰਦੀ ਹੈ ਅਤੇ ਓਵਰਫਿਟਿੰਗ ਨੂੰ ਰੋਕਣ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਦੀ ਹੈ। \',\' ਇਹ ਸਮਰੱਥਾ ਨਿਯੰਤਰਣ ਕੀ ਹੈ?ਵਿਧੀ? \'] ', 'ਵਰਤੇ ਜਾ ਰਹੇ ਇੱਕ ਟ੍ਰਾਂਸਫਾਰਮਰ ਦਾ ਇੱਕ ਪਾਈਟੋਰਕ ਸੰਸਕਰਣ ਵੇਖੋ', ' [\'ਵਰਤੋਂ ਵਿੱਚ ਇੱਕ ਟ੍ਰਾਂਸਫਾਰਮਰ ਦਾ ਇੱਕ ਪਾਈਟੋਰਚ ਸੰਸਕਰਣ ਵੇਖੋ\', "ਇੱਥੇ ਪਾਈਟੋਰਚ ਵਿੱਚ ਇੱਕ ਸਧਾਰਨ ਟ੍ਰਾਂਸਫਾਰਮਰ ਲਾਗੂ ਕਰਨ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n\\n" \'ਪਾਈਥਨ\\ਨਿਮਪੋਰਟਟਾਰਚ\\ਨਿੰਪੋਰਟ torch.nn ਨੂੰ nn\\n ਤੋਂ torch.utils.data ਇੰਪੋਰਟ ਡੇਟਾਸੇਟ, ਡਾਟਾਲੋਡਰ\\n\\n ਕਲਾਸ ਟ੍ਰਾਂਸਫਾਰਮਰ (nn.Module): \\n ਡਿਫ _ _ ਇਨਿਟ _ (ਸੈਲਫ, ਇੰਪੁੱਟ _ ਸਾਈਜ਼,ਆਉਟਪੁੱਟ _ ਸਾਈਜ਼, ਨੰਮ _ ਹੈੱਡ, ਡਰਾਪਆਉਟ = 0.1): \\n ਸੁਪਰ (ਟ੍ਰਾਂਸਫਾਰਮਰ, ਸੈਲਫ). _ _ init _ () \\n self.encoder = nn.MultiHeadAttention (ਇੰਪੁੱਟ _ ਸਾਈਜ਼, ਆਉਟਪੁੱਟ _ ਸਾਈਜ਼,num _ ਹੇਡਸ) \\n self.encoder.to (torch.device (\'cuda\')) \\n self.encoder.weight.data.uniform_ (-1,1) \\n self.encoder.bias.data.uniform_ (-1,1) \\n self.decoder= nn.MultiHeadAttention (ਆਉਟਪੁੱਟ _ ਸਾਈਜ਼, ਇੰਪੁੱਟ _ ਸਾਈਜ਼, ਨੰਮ _ ਹੈੱਡ) \\n self.decoder.to (torch.device (\'ਕੁਡਾ\')) \\n self.decoder.weight.data.uniform_ (-1,1) \\nself.decoder.bias.data.uniform_ (-1,1) \\n self.fc = nn.Linear (ਇੰਪੁੱਟ _ ਸਾਈਜ਼, ਆਉਟਪੁੱਟ _ ਸਾਈਜ਼) \\n self.fc.to (torch.device (\'ਕੁਡਾ\')) \\nself.fc.weight.data.uniform_ (-1,1) \\n self.fc.bias.data.uniform_ (-1,1) \\n self.dropout = nn.Dropout (ਡਰਾਪਆਉਟ) \\n\\n ਡਿਫ ਫਾਰਵਰਡ (ਸੈਲਫ, x): \\nh =self.encoder (x) \\nh = self.dropout (h) \\nh = self.decoder (h) \\nh = torch.sigmoid (self.fc (h) \\n ਰਿਟਰਨ h\\n \'\\n\\n ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਸਧਾਰਨ ਪਰਿਭਾਸ਼ਾ ਦਿੰਦੇ ਹਾਂ।ਟ੍ਰਾਂਸਫਾਰਮਰ ਮਾਡਲ ਜੋ ਇੱਕ ਪਾਈਟੋਰਚ \'torch.Tensor\' ਵਿੱਚ ਇੰਪੁੱਟ ਅਕਾਰ \'ਇੰਪੁੱਟ _ ਸਾਈਜ਼\' ਲੈਂਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਪਾਈਟੋਰਚ \'torch.Tensor\' ਅਕਾਰ \'ਆਉਟਪੁੱਟ _ ਸਾਈਜ਼\' ਦਾ ਆਉਟਪੁੱਟ ਦਿੰਦਾ ਹੈ।ਟ੍ਰਾਂਸਫਾਰਮਰ ਵਿੱਚ ਇੱਕ ਇੰਕੋਡਰ ਅਤੇ ਇੱਕ ਡੀਕੋਡਰ ਹੁੰਦਾ ਹੈ, ਜੋ ਦੋਵੇਂ ਮਲਟੀ-ਹੈੱਡ ਧਿਆਨ ਪਰਤਾਂ ਹੁੰਦੀਆਂ ਹਨ। ਇੰਕੋਡਰ ਅਤੇ ਡੀਕੋਡਰ ਦੋਵੇਂ ਇਸ ਵਿੱਚ ਲਪੇਟੇ ਹੁੰਦੇ ਹਨ।\'nn.Module\', \'ਵਰਤੋਂ ਵਿੱਚ ਛੱਡਣਾ ਕਿਉਂ ਹੈ? ਇਹ ਕਿਸ ਕਾਗਜ਼ ਤੋਂ ਹੈ?\', \'ਛੱਡਣਾ ਇੱਕ ਨਿਯਮਤ ਕਰਨ ਦੀ ਤਕਨੀਕ ਹੈ ਜੋ ਬੇਤਰਤੀਬੇ ਤੌਰ\' ਤੇ ਕੁੱਝ ਮੁੱਲਾਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦੀ ਹੈਸਿਖਲਾਈ ਦੌਰਾਨ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਵਿੱਚ ਲੁਕੀਆਂ ਇਕਾਈਆਂ ਜ਼ੀਰੋ ਹੋ ਜਾਂਦੀਆਂ ਹਨ। ਇਸ ਦਾ ਇਕਾਈਆਂ ਦਰਮਿਆਨ ਸਹਿ-ਅਨੁਕੂਲਤਾ ਨੂੰ ਘਟਾਉਣ ਦਾ ਪ੍ਰਭਾਵ ਹੁੰਦਾ ਹੈ, ਜੋ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ।ਓਵਰਫਿਟਿੰਗ ਨੂੰ ਰੋਕਣਾ ਅਤੇ ਸਰਵ ਸਧਾਰਨਕਰਨ ਵਿੱਚ ਸੁਧਾਰ ਕਰਨਾ। \\n ਸਕੂਲ ਛੱਡਣ ਦੇ ਪਿੱਛੇ ਦਾ ਵਿਚਾਰ ਇਹ ਹੈ ਕਿ ਬੇਤਰਤੀਬੇ ਤੌਰ \'ਤੇ ਕੁੱਝ ਇਕਾਈਆਂ ਨੂੰ ਜ਼ੀਰੋ\' ਤੇ ਸੈੱਟ ਕਰਕੇ, ਅਸੀਂ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਹਾਂ।ਨੈੱਟਵਰਕ ਦੀ ਸਮਰੱਥਾ ਨੂੰ ਘਟਾਉਣਾ, ਜੋ ਇਸ ਨੂੰ ਵਧੇਰੇ ਮਜ਼ਬੂਤ ਅਤੇ ਸਥਿਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਸਿੱਖਣ ਲਈ ਮਜਬੂਰ ਕਰਦਾ ਹੈ। \\n ਸਕੂਲ ਛੱਡਣ ਦੀ ਨਿਯਮਤ ਕਰਨ ਦੀ ਤਕਨੀਕ ਸੀ"ਡ੍ਰੌਪਆਊਟਃ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਨੂੰ ਓਵਰਫਿਟਿੰਗ ਤੋਂ ਰੋਕਣ ਦਾ ਇੱਕ ਸਧਾਰਨ ਤਰੀਕਾ" ਪੇਪਰ ਵਿੱਚ ਨਾਮ _ 1, ਨਾਮ _ 2, ਨਾਮ _ 3 ਅਤੇ ਨਾਮ _ 4 ਦੁਆਰਾ ਪੇਸ਼ ਕੀਤਾ ਗਿਆ।2013 ਵਿੱਚ ਜਰਨਲ ਆਫ਼ ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਰਿਸਰਚ ਵਿੱਚ ਪ੍ਰਕਾਸ਼ਿਤ \',\' ਹਾਂ ਪਰ ਇੱਕ ਟ੍ਰਾਂਸਫਾਰਮਰ ਵਿੱਚ ਸਕੂਲ ਛੱਡਣ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ ਹੈ? \',\' ਇਹ ਸਹੀ ਹੈ, ਸਕੂਲ ਛੱਡਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ।ਇੱਕ ਟ੍ਰਾਂਸਫਾਰਮਰ ਮਾਡਲ ਵਿੱਚ ਇਸ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ ਹੈ। ਅਸਲ ਵਿੱਚ, ਡਰਾਪਆਉਟ ਇੱਕ ਟ੍ਰਾਂਸਫਾਰਮਰ ਵਿੱਚ ਨੁਕਸਾਨਦੇਹ ਹੋ ਸਕਦਾ ਹੈ ਕਿਉਂਕਿ ਇਹ ਬੇਤਰਤੀਬੇ ਤੌਰ ਉੱਤੇ ਲੁਕੀਆਂ ਇਕਾਈਆਂ ਦੇ ਕੁੱਝ ਮੁੱਲਾਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈਜ਼ੀਰੋ, ਜਿਸ ਨਾਲ ਜਾਣਕਾਰੀ ਦਾ ਨੁਕਸਾਨ ਹੋ ਸਕਦਾ ਹੈ ਅਤੇ ਕਾਰਗੁਜ਼ਾਰੀ ਵਿੱਚ ਗਿਰਾਵਟ ਆ ਸਕਦੀ ਹੈ। \\nਟ੍ਰਾਂਸਫਾਰਮਰ ਸਕੂਲ ਛੱਡਣ ਦੀ ਬਜਾਏ ਸਵੈ-ਧਿਆਨ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨਓਵਰਫਿਟਿੰਗ ਨੂੰ ਰੋਕਣਾ ਅਤੇ ਆਮਕਰਨ ਵਿੱਚ ਸੁਧਾਰ ਕਰਨਾ। ਸਵੈ-ਧਿਆਨ ਵਿਧੀ ਮਾਡਲ ਨੂੰ ਇੰਪੁੱਟ ਦੀ ਨੁਮਾਇੰਦਗੀ ਸਿੱਖਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ ਜੋ ਮਜ਼ਬੂਤ ਹੈ।ਅਤੇ ਇੰਪੁੱਟ ਦੇ ਵੱਖ-ਵੱਖ ਹਿੱਸਿਆਂ ਵਿੱਚ ਨਿਰੰਤਰ, ਜੋ ਓਵਰਫਿਟਿੰਗ ਨੂੰ ਰੋਕਣ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਦਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਟ੍ਰਾਂਸਫਾਰਮਰ ਆਰਕੀਟੈਕਚਰ ਵਿੱਚ ਆਪਣੇ ਆਪ ਵਿੱਚ ਇੱਕ ਬਿਲਟ-ਇਨ ਹੁੰਦਾ ਹੈ।ਸਮਰੱਥਾ-ਨਿਯੰਤਰਣ ਵਿਧੀ, ਜੋ ਮਾਡਲ ਵਿੱਚ ਮਾਪਦੰਡਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਸੀਮਤ ਕਰਦੀ ਹੈ ਅਤੇ ਓਵਰਫਿਟਿੰਗ ਨੂੰ ਰੋਕਣ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਦੀ ਹੈ। \',\' ਇਹ ਸਮਰੱਥਾ ਨਿਯੰਤਰਣ ਕੀ ਹੈ?\',\' ਟ੍ਰਾਂਸਫਾਰਮਰ ਆਰਕੀਟੈਕਚਰ ਵਿੱਚ, ਸਮਰੱਥਾ-ਨਿਯੰਤਰਣ ਵਿਧੀ ਨੂੰ ਮਲਟੀ-ਹੈੱਡ ਸਵੈ-ਧਿਆਨ ਦੀ ਵਰਤੋਂ ਦੁਆਰਾ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇਰੇਖਿਕ ਪਰਤਾਂ। \\n ਮਲਟੀ-ਹੈੱਡ ਸਵੈ-ਧਿਆਨ ਵਿਧੀ ਮਾਡਲ ਨੂੰ ਇੰਪੁੱਟ ਦੇ ਵੱਖ-ਵੱਖ ਪਹਿਲੂਆਂ ਨੂੰ ਸਿੱਖਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ, ਜੋ ਓਵਰਫਿਟਿੰਗ ਨੂੰ ਰੋਕਣ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਦੀ ਹੈ।ਸਵੈ-ਧਿਆਨ ਵਿਧੀ ਦਾ ਹਰੇਕ ਮੁਖੀ ਇਨਪੁਟ ਦੀ ਇੱਕ ਵੱਖਰੀ ਨੁਮਾਇੰਦਗੀ ਸਿੱਖਦਾ ਹੈ, ਜੋ ਇਸ ਦੀ ਵਧੇਰੇ ਵਿਆਪਕ ਸਮਝ ਨੂੰ ਹਾਸਲ ਕਰਨ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਦਾ ਹੈ।ਇੰਪੁੱਟ। \\n ਟ੍ਰਾਂਸਫਾਰਮਰ ਆਰਕੀਟੈਕਚਰ ਵਿੱਚ ਰੇਖਿਕ ਪਰਤਾਂ ਸਵੈ-ਧਿਆਨ ਵਿਧੀ ਦੇ ਆਉਟਪੁੱਟ ਨੂੰ ਇੱਕ ਵਿੱਚ ਪ੍ਰੋਜੈਕਟ ਕਰਨ ਦਾ ਇੱਕ ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦੀਆਂ ਹਨਘੱਟ-ਅਯਾਮੀ ਸਪੇਸ। ਇਹ ਅਨੁਮਾਨ ਮਾਡਲ ਵਿੱਚ ਮਾਪਦੰਡਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣ ਅਤੇ ਮਾਡਲ ਦੀ ਸਮਰੱਥਾ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ।ਰੇਖਿਕ ਪਰਤਾਂ ਵਿੱਚ ਮਾਪਦੰਡਾਂ ਨੂੰ ਰੇਖਿਕ ਪਰਤਾਂ ਦੇ ਆਕਾਰ ਨੂੰ ਅਨੁਕੂਲ ਕਰਕੇ ਨਿਯੰਤਰਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਜਿਸ ਨੂੰ ਸਮਰੱਥਾ ਨਿਯੰਤਰਣ ਦੇ ਇੱਕ ਰੂਪ ਵਜੋਂ ਦੇਖਿਆ ਜਾ ਸਕਦਾ ਹੈ। \\nByਇਸ ਤਰੀਕੇ ਨਾਲ ਮਾਡਲ ਦੀ ਸਮਰੱਥਾ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਦੇ ਹੋਏ, ਟ੍ਰਾਂਸਫਾਰਮਰ ਆਰਕੀਟੈਕਚਰ ਪ੍ਰਗਟਾਵੇ ਦੀ ਸ਼ਕਤੀ ਅਤੇ ਵਿਚਕਾਰ ਇੱਕ ਚੰਗਾ ਸੰਤੁਲਨ ਪ੍ਰਾਪਤ ਕਰਨ ਦੇ ਯੋਗ ਹੁੰਦਾ ਹੈ।ਸਰਵ ਸਧਾਰਨਕਰਨ। \',\' ਜ਼ੀਰੋ ਕਾਨਵ ਦੀ ਵਿਆਖਿਆ ਕਰੋ \'] ', 'ਵਰਤੇ ਜਾ ਰਹੇ ਇੱਕ ਟ੍ਰਾਂਸਫਾਰਮਰ ਦਾ ਇੱਕ ਪਾਈਟੋਰਕ ਸੰਸਕਰਣ ਵੇਖੋ', ' [\'ਵਰਤੋਂ ਵਿੱਚ ਇੱਕ ਟ੍ਰਾਂਸਫਾਰਮਰ ਦਾ ਇੱਕ ਪਾਈਟੋਰਚ ਸੰਸਕਰਣ ਵੇਖੋ\', "ਇੱਥੇ ਪਾਈਟੋਰਚ ਵਿੱਚ ਇੱਕ ਸਧਾਰਨ ਟ੍ਰਾਂਸਫਾਰਮਰ ਲਾਗੂ ਕਰਨ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਹੈਃ \\n\\n" \'ਪਾਈਥਨ\\ਨਿਮਪੋਰਟਟਾਰਚ\\ਨਿੰਪੋਰਟ torch.nn ਨੂੰ nn\\n ਤੋਂ torch.utils.data ਇੰਪੋਰਟ ਡੇਟਾਸੇਟ, ਡਾਟਾਲੋਡਰ\\n\\n ਕਲਾਸ ਟ੍ਰਾਂਸਫਾਰਮਰ (nn.Module): \\n ਡਿਫ _ _ ਇਨਿਟ _ (ਸੈਲਫ, ਇੰਪੁੱਟ _ ਸਾਈਜ਼,ਆਉਟਪੁੱਟ _ ਸਾਈਜ਼, ਨੰਮ _ ਹੈੱਡ, ਡਰਾਪਆਉਟ = 0.1): \\n ਸੁਪਰ (ਟ੍ਰਾਂਸਫਾਰਮਰ, ਸੈਲਫ). _ _ init _ () \\n self.encoder = nn.MultiHeadAttention (ਇੰਪੁੱਟ _ ਸਾਈਜ਼, ਆਉਟਪੁੱਟ _ ਸਾਈਜ਼,num _ ਹੇਡਸ) \\n self.encoder.to (torch.device (\'cuda\')) \\n self.encoder.weight.data.uniform_ (-1,1) \\n self.encoder.bias.data.uniform_ (-1,1) \\n self.decoder= nn.MultiHeadAttention (ਆਉਟਪੁੱਟ _ ਸਾਈਜ਼, ਇੰਪੁੱਟ _ ਸਾਈਜ਼, ਨੰਮ _ ਹੈੱਡ) \\n self.decoder.to (torch.device (\'ਕੁਡਾ\')) \\n self.decoder.weight.data.uniform_ (-1,1) \\nself.decoder.bias.data.uniform_ (-1,1) \\n self.fc = nn.Linear (ਇੰਪੁੱਟ _ ਸਾਈਜ਼, ਆਉਟਪੁੱਟ _ ਸਾਈਜ਼) \\n self.fc.to (torch.device (\'ਕੁਡਾ\')) \\nself.fc.weight.data.uniform_ (-1,1) \\n self.fc.bias.data.uniform_ (-1,1) \\n self.dropout = nn.Dropout (ਡਰਾਪਆਉਟ) \\n\\n ਡਿਫ ਫਾਰਵਰਡ (ਸੈਲਫ, x): \\nh =self.encoder (x) \\nh = self.dropout (h) \\nh = self.decoder (h) \\nh = torch.sigmoid (self.fc (h) \\n ਰਿਟਰਨ h\\n \'\\n\\n ਇਸ ਉਦਾਹਰਣ ਵਿੱਚ, ਅਸੀਂ ਇੱਕ ਸਧਾਰਨ ਪਰਿਭਾਸ਼ਾ ਦਿੰਦੇ ਹਾਂ।ਟ੍ਰਾਂਸਫਾਰਮਰ ਮਾਡਲ ਜੋ ਇੱਕ ਪਾਈਟੋਰਚ \'torch.Tensor\' ਵਿੱਚ ਇੰਪੁੱਟ ਅਕਾਰ \'ਇੰਪੁੱਟ _ ਸਾਈਜ਼\' ਲੈਂਦਾ ਹੈ, ਅਤੇ ਇੱਕ ਪਾਈਟੋਰਚ \'torch.Tensor\' ਅਕਾਰ \'ਆਉਟਪੁੱਟ _ ਸਾਈਜ਼\' ਦਾ ਆਉਟਪੁੱਟ ਦਿੰਦਾ ਹੈ।ਟ੍ਰਾਂਸਫਾਰਮਰ ਵਿੱਚ ਇੱਕ ਇੰਕੋਡਰ ਅਤੇ ਇੱਕ ਡੀਕੋਡਰ ਹੁੰਦਾ ਹੈ, ਜੋ ਦੋਵੇਂ ਮਲਟੀ-ਹੈੱਡ ਧਿਆਨ ਪਰਤਾਂ ਹੁੰਦੀਆਂ ਹਨ। ਇੰਕੋਡਰ ਅਤੇ ਡੀਕੋਡਰ ਦੋਵੇਂ ਇਸ ਵਿੱਚ ਲਪੇਟੇ ਹੁੰਦੇ ਹਨ।\'nn.Module\', \'ਵਰਤੋਂ ਵਿੱਚ ਛੱਡਣਾ ਕਿਉਂ ਹੈ? ਇਹ ਕਿਸ ਕਾਗਜ਼ ਤੋਂ ਹੈ?\', \'ਛੱਡਣਾ ਇੱਕ ਨਿਯਮਤ ਕਰਨ ਦੀ ਤਕਨੀਕ ਹੈ ਜੋ ਬੇਤਰਤੀਬੇ ਤੌਰ\' ਤੇ ਕੁੱਝ ਮੁੱਲਾਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦੀ ਹੈਸਿਖਲਾਈ ਦੌਰਾਨ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਵਿੱਚ ਲੁਕੀਆਂ ਇਕਾਈਆਂ ਜ਼ੀਰੋ ਹੋ ਜਾਂਦੀਆਂ ਹਨ। ਇਸ ਦਾ ਇਕਾਈਆਂ ਦਰਮਿਆਨ ਸਹਿ-ਅਨੁਕੂਲਤਾ ਨੂੰ ਘਟਾਉਣ ਦਾ ਪ੍ਰਭਾਵ ਹੁੰਦਾ ਹੈ, ਜੋ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ।ਓਵਰਫਿਟਿੰਗ ਨੂੰ ਰੋਕਣਾ ਅਤੇ ਸਰਵ ਸਧਾਰਨਕਰਨ ਵਿੱਚ ਸੁਧਾਰ ਕਰਨਾ। \\n ਸਕੂਲ ਛੱਡਣ ਦੇ ਪਿੱਛੇ ਦਾ ਵਿਚਾਰ ਇਹ ਹੈ ਕਿ ਬੇਤਰਤੀਬੇ ਤੌਰ \'ਤੇ ਕੁੱਝ ਇਕਾਈਆਂ ਨੂੰ ਜ਼ੀਰੋ\' ਤੇ ਸੈੱਟ ਕਰਕੇ, ਅਸੀਂ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਹਾਂ।ਨੈੱਟਵਰਕ ਦੀ ਸਮਰੱਥਾ ਨੂੰ ਘਟਾਉਣਾ, ਜੋ ਇਸ ਨੂੰ ਵਧੇਰੇ ਮਜ਼ਬੂਤ ਅਤੇ ਸਥਿਰ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਸਿੱਖਣ ਲਈ ਮਜਬੂਰ ਕਰਦਾ ਹੈ। \\n ਸਕੂਲ ਛੱਡਣ ਦੀ ਨਿਯਮਤ ਕਰਨ ਦੀ ਤਕਨੀਕ ਸੀ"ਡ੍ਰੌਪਆਊਟਃ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਨੂੰ ਓਵਰਫਿਟਿੰਗ ਤੋਂ ਰੋਕਣ ਦਾ ਇੱਕ ਸਧਾਰਨ ਤਰੀਕਾ" ਪੇਪਰ ਵਿੱਚ ਨਾਮ _ 1, ਨਾਮ _ 2, ਨਾਮ _ 3 ਅਤੇ ਨਾਮ _ 4 ਦੁਆਰਾ ਪੇਸ਼ ਕੀਤਾ ਗਿਆ।2013 ਵਿੱਚ ਜਰਨਲ ਆਫ਼ ਮਸ਼ੀਨ ਲਰਨਿੰਗ ਰਿਸਰਚ ਵਿੱਚ ਪ੍ਰਕਾਸ਼ਿਤ \',\' ਹਾਂ ਪਰ ਇੱਕ ਟ੍ਰਾਂਸਫਾਰਮਰ ਵਿੱਚ ਸਕੂਲ ਛੱਡਣ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ ਹੈ? \',\' ਇਹ ਸਹੀ ਹੈ, ਸਕੂਲ ਛੱਡਣ ਦੀ ਜ਼ਰੂਰਤ ਹੈ।ਇੱਕ ਟ੍ਰਾਂਸਫਾਰਮਰ ਮਾਡਲ ਵਿੱਚ ਇਸ ਦੀ ਜ਼ਰੂਰਤ ਨਹੀਂ ਹੈ। ਅਸਲ ਵਿੱਚ, ਡਰਾਪਆਉਟ ਇੱਕ ਟ੍ਰਾਂਸਫਾਰਮਰ ਵਿੱਚ ਨੁਕਸਾਨਦੇਹ ਹੋ ਸਕਦਾ ਹੈ ਕਿਉਂਕਿ ਇਹ ਬੇਤਰਤੀਬੇ ਤੌਰ ਉੱਤੇ ਲੁਕੀਆਂ ਇਕਾਈਆਂ ਦੇ ਕੁੱਝ ਮੁੱਲਾਂ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈਜ਼ੀਰੋ, ਜਿਸ ਨਾਲ ਜਾਣਕਾਰੀ ਦਾ ਨੁਕਸਾਨ ਹੋ ਸਕਦਾ ਹੈ ਅਤੇ ਕਾਰਗੁਜ਼ਾਰੀ ਵਿੱਚ ਗਿਰਾਵਟ ਆ ਸਕਦੀ ਹੈ। \\nਟ੍ਰਾਂਸਫਾਰਮਰ ਸਕੂਲ ਛੱਡਣ ਦੀ ਬਜਾਏ ਸਵੈ-ਧਿਆਨ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨਓਵਰਫਿਟਿੰਗ ਨੂੰ ਰੋਕਣਾ ਅਤੇ ਆਮਕਰਨ ਵਿੱਚ ਸੁਧਾਰ ਕਰਨਾ। ਸਵੈ-ਧਿਆਨ ਵਿਧੀ ਮਾਡਲ ਨੂੰ ਇੰਪੁੱਟ ਦੀ ਨੁਮਾਇੰਦਗੀ ਸਿੱਖਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ ਜੋ ਮਜ਼ਬੂਤ ਹੈ।ਅਤੇ ਇੰਪੁੱਟ ਦੇ ਵੱਖ-ਵੱਖ ਹਿੱਸਿਆਂ ਵਿੱਚ ਨਿਰੰਤਰ, ਜੋ ਓਵਰਫਿਟਿੰਗ ਨੂੰ ਰੋਕਣ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਦਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਟ੍ਰਾਂਸਫਾਰਮਰ ਆਰਕੀਟੈਕਚਰ ਵਿੱਚ ਆਪਣੇ ਆਪ ਵਿੱਚ ਇੱਕ ਬਿਲਟ-ਇਨ ਹੁੰਦਾ ਹੈ।ਸਮਰੱਥਾ-ਨਿਯੰਤਰਣ ਵਿਧੀ, ਜੋ ਮਾਡਲ ਵਿੱਚ ਮਾਪਦੰਡਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਸੀਮਤ ਕਰਦੀ ਹੈ ਅਤੇ ਓਵਰਫਿਟਿੰਗ ਨੂੰ ਰੋਕਣ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਦੀ ਹੈ। \',\' ਇਹ ਸਮਰੱਥਾ ਨਿਯੰਤਰਣ ਕੀ ਹੈ?\',\' ਟ੍ਰਾਂਸਫਾਰਮਰ ਆਰਕੀਟੈਕਚਰ ਵਿੱਚ, ਸਮਰੱਥਾ-ਨਿਯੰਤਰਣ ਵਿਧੀ ਨੂੰ ਮਲਟੀ-ਹੈੱਡ ਸਵੈ-ਧਿਆਨ ਦੀ ਵਰਤੋਂ ਦੁਆਰਾ ਲਾਗੂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇਰੇਖਿਕ ਪਰਤਾਂ। \\n ਮਲਟੀ-ਹੈੱਡ ਸਵੈ-ਧਿਆਨ ਵਿਧੀ ਮਾਡਲ ਨੂੰ ਇੰਪੁੱਟ ਦੇ ਵੱਖ-ਵੱਖ ਪਹਿਲੂਆਂ ਨੂੰ ਸਿੱਖਣ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ, ਜੋ ਓਵਰਫਿਟਿੰਗ ਨੂੰ ਰੋਕਣ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਦੀ ਹੈ।ਸਵੈ-ਧਿਆਨ ਵਿਧੀ ਦਾ ਹਰੇਕ ਮੁਖੀ ਇਨਪੁਟ ਦੀ ਇੱਕ ਵੱਖਰੀ ਨੁਮਾਇੰਦਗੀ ਸਿੱਖਦਾ ਹੈ, ਜੋ ਇਸ ਦੀ ਵਧੇਰੇ ਵਿਆਪਕ ਸਮਝ ਨੂੰ ਹਾਸਲ ਕਰਨ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਦਾ ਹੈ।ਇੰਪੁੱਟ। \\n ਟ੍ਰਾਂਸਫਾਰਮਰ ਆਰਕੀਟੈਕਚਰ ਵਿੱਚ ਰੇਖਿਕ ਪਰਤਾਂ ਸਵੈ-ਧਿਆਨ ਵਿਧੀ ਦੇ ਆਉਟਪੁੱਟ ਨੂੰ ਇੱਕ ਵਿੱਚ ਪ੍ਰੋਜੈਕਟ ਕਰਨ ਦਾ ਇੱਕ ਤਰੀਕਾ ਪ੍ਰਦਾਨ ਕਰਦੀਆਂ ਹਨਘੱਟ-ਅਯਾਮੀ ਸਪੇਸ। ਇਹ ਅਨੁਮਾਨ ਮਾਡਲ ਵਿੱਚ ਮਾਪਦੰਡਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਘਟਾਉਣ ਅਤੇ ਮਾਡਲ ਦੀ ਸਮਰੱਥਾ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਵਿੱਚ ਮਦਦ ਕਰਦਾ ਹੈ।ਰੇਖਿਕ ਪਰਤਾਂ ਵਿੱਚ ਮਾਪਦੰਡਾਂ ਨੂੰ ਰੇਖਿਕ ਪਰਤਾਂ ਦੇ ਆਕਾਰ ਨੂੰ ਅਨੁਕੂਲ ਕਰਕੇ ਨਿਯੰਤਰਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ, ਜਿਸ ਨੂੰ ਸਮਰੱਥਾ ਨਿਯੰਤਰਣ ਦੇ ਇੱਕ ਰੂਪ ਵਜੋਂ ਦੇਖਿਆ ਜਾ ਸਕਦਾ ਹੈ। \\nByਇਸ ਤਰੀਕੇ ਨਾਲ ਮਾਡਲ ਦੀ ਸਮਰੱਥਾ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਦੇ ਹੋਏ, ਟ੍ਰਾਂਸਫਾਰਮਰ ਆਰਕੀਟੈਕਚਰ ਪ੍ਰਗਟਾਵੇ ਦੀ ਸ਼ਕਤੀ ਅਤੇ ਵਿਚਕਾਰ ਇੱਕ ਚੰਗਾ ਸੰਤੁਲਨ ਪ੍ਰਾਪਤ ਕਰਨ ਦੇ ਯੋਗ ਹੁੰਦਾ ਹੈ।\',\' ਜ਼ੀਰੋ ਕਨਵੋਲਿਊਸ਼ਨ ਦੀ ਵਿਆਖਿਆ ਕਰੋ \',\' ਜ਼ੀਰੋ ਕਨਵੋਲਿਊਸ਼ਨ, ਜਿਸ ਨੂੰ ਜ਼ੀਰੋ ਪੈਡਿੰਗ ਵੀ ਕਿਹਾ ਜਾਂਦਾ ਹੈ, ਇੱਕ ਤਕਨੀਕ ਹੈ ਜੋ ਡੂੰਘੀ ਸਿਖਲਾਈ ਵਿੱਚ ਵਰਤੀ ਜਾਂਦੀ ਹੈ ਤਾਂ ਜੋ ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕੀਤਾ ਜਾ ਸਕੇ ਕਿਇੰਪੁੱਟ ਡੇਟਾ ਦੇ ਮਾਪ ਇੱਕ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਵਿੱਚ ਕਨਵੋਲਿਊਸ਼ਨਲ ਪਰਤਾਂ ਦੀਆਂ ਜ਼ਰੂਰਤਾਂ ਦੇ ਅਨੁਕੂਲ ਹੁੰਦੇ ਹਨ। \\n ਨਿਊਰਲ ਵਿੱਚ ਕਨਵੋਲਿਊਸ਼ਨਲ ਪਰਤਾਂਨੈੱਟਵਰਕ ਨੂੰ ਇੱਕ ਨਿਸ਼ਚਿਤ ਅਕਾਰ ਅਤੇ ਸ਼ਕਲ ਲਈ ਇੰਪੁੱਟ ਡੇਟਾ ਦੀ ਲੋਡ਼ ਹੁੰਦੀ ਹੈ, ਜਿਸ ਵਿੱਚ ਚੈਨਲਾਂ ਦੀ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਗਿਣਤੀ ਹੁੰਦੀ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਇੱਕ ਚਿੱਤਰ ਵਿੱਚ ਇੱਕ ਕਨਵੋਲਿਊਸ਼ਨਲ ਪਰਤ।ਵਰਗੀਕਰਣ ਮਾਡਲ ਲਈ ਆਮ ਤੌਰ ਉੱਤੇ 3 ਰੰਗ ਚੈਨਲਾਂ (ਆਰ, ਜੀ, ਬੀ) ਦੇ ਨਾਲ 28x28 ਅਕਾਰ ਦੇ ਇੰਪੁੱਟ ਚਿੱਤਰਾਂ ਦੀ ਜ਼ਰੂਰਤ ਹੁੰਦੀ ਹੈ। ਜੇਕਰ ਇੰਪੁੱਟ ਚਿੱਤਰ ਦਾ ਆਕਾਰ 28x28 ਨਹੀਂ ਹੈ, ਤਾਂਇੰਪੁੱਟ ਡੇਟਾ ਦੇ ਮਾਪ ਨੂੰ ਪਰਤ ਦੀਆਂ ਜ਼ਰੂਰਤਾਂ ਦੇ ਅਨੁਕੂਲ ਬਣਾਉਣ ਲਈ ਪਰਤ ਨੂੰ ਜ਼ੀਰੋ ਨਾਲ ਪੈਡਿੰਗ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਹੋਏਗੀ। \\n ਜ਼ੀਰੋ ਪੈਡਿੰਗ ਤਕਨੀਕਇੰਪੁੱਟ ਡੇਟਾ ਦੀਆਂ ਸਰਹੱਦਾਂ ਵਿੱਚ ਜ਼ੀਰੋ ਜੋਡ਼ਨਾ ਸ਼ਾਮਲ ਹੈ ਜਦੋਂ ਤੱਕ ਇਹ ਲੋਡ਼ੀਂਦੇ ਅਕਾਰ ਤੱਕ ਨਹੀਂ ਪਹੁੰਚਦਾ। ਉਦਾਹਰਣ ਲਈ, ਜੇ ਇੰਪੁੱਟ ਚਿੱਤਰ ਦਾ ਆਕਾਰ 20x20 ਹੈ, ਤਾਂ ਪਰਤਇਸ ਨੂੰ 28x28 ਬਣਾਉਣ ਲਈ ਜ਼ੀਰੋ ਨਾਲ ਪੈੱਡ ਕੀਤਾ ਜਾਵੇਗਾ। ਇਹ ਸੁਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਇਨਪੁੱਟ ਦੇ ਹਰ ਹਿੱਸੇ ਲਈ ਕੰਵੋਲਿਊਸ਼ਨਲ ਪਰਤ ਢੁਕਵੀਂ ਫਿਲਟਰ ਨੂੰ ਲਾਗੂ ਕਰ ਸਕਦੀ ਹੈ।ਡਾਟਾ, ਬਿਨਾਂ ਕਿਸੇ ਜਾਣਕਾਰੀ ਨੂੰ ਗੁਆਏ। \\nZero ਕਨਵੋਲਿਊਸ਼ਨ ਡੂੰਘੀ ਸਿਖਲਾਈ ਵਿੱਚ ਇੱਕ ਸਧਾਰਨ ਅਤੇ ਵਿਆਪਕ ਤੌਰ ਉੱਤੇ ਵਰਤੀ ਜਾਣ ਵਾਲੀ ਤਕਨੀਕ ਹੈ, ਅਤੇ ਅਕਸਰ ਇਸਦੇ ਨਾਲ ਜੋਡ਼ ਕੇ ਵਰਤੀ ਜਾਂਦੀ ਹੈ।ਹੋਰ ਤਕਨੀਕਾਂ ਜਿਵੇਂ ਕਿ ਨਾਮ _ 5 ਪੂਲਿੰਗ ਅਤੇ ਔਸਤ ਪੂਲਿੰਗ। \',\' ਕੀ ਬਿਹਤਰ ਨਤੀਜੇ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਡੇਟਾਸੇਟ ਚਾਲਾਂ ਹਨ \'] ', 'ਵਰਤੇ ਜਾ ਰਹੇ ਇੱਕ ਟ੍ਰਾਂਸਫਾਰਮਰ ਦਾ ਇੱਕ ਪਾਈਟੋਰਕ ਸੰਸਕਰਣ ਵੇਖੋ \n ']