{"id":1638,"date":"2025-02-04T07:02:59","date_gmt":"2025-02-04T07:02:59","guid":{"rendered":"https:\/\/mailitics.com\/index.php\/2025\/02\/04\/show-and-tell-e1a1142456e2\/"},"modified":"2025-02-04T07:02:59","modified_gmt":"2025-02-04T07:02:59","slug":"show-and-tell-e1a1142456e2","status":"publish","type":"post","link":"https:\/\/mailitics.com\/index.php\/2025\/02\/04\/show-and-tell-e1a1142456e2\/","title":{"rendered":"Show and Tell"},"content":{"rendered":"

Show and Tell
\n \t

\n
<\/BR>
\n
\n \t

\n
<\/BR><\/p>\n

\n
\"Photo
Photo by St\u00e5le Grut<\/a> on Unsplash<\/a><\/figcaption><\/figure>\n

Introduction<\/h2>\n

Natural Language Processing and Computer Vision<\/a> used to be two completely different fields. Well, at least back when I started to learn machine learning and deep learning, I feel like there are multiple paths to follow, and each of them, including NLP and Computer Vision, directs me to a completely different world. Over time, we can now observe that AI becomes more and more advanced, with the intersection between multiple fields of study getting more common, including the two I just mentioned.<\/p>\n

Today, many language models have capability to generate images based on the given prompt. That\u2019s one example of the bridge between NLP and Computer Vision. But I guess I\u2019ll save it for my upcoming article as it is a bit more complex. Instead, in this article I am going to discuss the simpler one: image captioning. As the name suggests, this is essentially a technique where a specific model accepts an image and returns a text that describes the input image.<\/p>\n

One of the earliest papers in this topic is the one titled “Show and Tell: A Neural Image Caption Generator<\/em>” written by Vinyals et al. back in 2015 [1]. In this article, I will focus on implementing the Deep Learning<\/a> model proposed in the paper using PyTorch. Note that I won\u2019t actually demonstrate the training process here as that\u2019s a topic on its own. Let me know in the comments if you want a separate tutorial on that.<\/p>\n

\n

Image Captioning Framework<\/h2>\n

Generally speaking, image captioning can be done by combining two types of models: the one specialized to process images and another one capable of processing sequences. I believe you already know what kind of models work best for the two tasks \u2013 yes, you\u2019re right, those are CNN and RNN, respectively. The idea here is that the CNN is utilized to encode the input image (hence this part is called encoder<\/em>), whereas the RNN is used for generating a sequence of words based on the features encoded by the CNN (hence the RNN part is called decoder<\/em>).<\/p>\n

It is discussed in the paper that the authors attempted to do so using GoogLeNet (a.k.a., Inception V1) for the encoder and LSTM for the decoder. In fact, the use of GoogLeNet is not explicitly mentioned, yet based on the illustration provided in the paper it seems like the architecture used in the encoder is adopted from the original GoogLeNet paper [2]. The figure below shows what the proposed architecture looks like.<\/p>\n

\"Figure
Figure 1. The image captioning model proposed in [1], where the encoder part (the leftmost block) implements the GoogLeNet model [2].<\/figcaption><\/figure>\n

Talking more specifically about the connection between the encoder and the decoder, there are several methods available for connecting the two, namely init-inject<\/em>, pre-inject<\/em>, par-inject<\/em> and merge<\/em>, as mentioned in [3]. In the case of the Show and Tell<\/em> paper, authors used pre-inject<\/em>, a method where the features extracted by the encoder are perceived as the 0th word in the caption. Later in the inference phase, we expect the decoder to generate a caption based solely on these image features.<\/p>\n

\"Figure
Figure 2. The four methods possible to be used to connect the encoder and the decoder part of an image captioning model [3]. In our case we are going to use the pre-inject<\/em> method (b).<\/figcaption><\/figure>\n

As we already understood the theory behind the image captioning model, we can now jump into the code!<\/p>\n

\n

Implementation<\/h1>\n

I\u2019ll break the implementation part into three sections: the Encoder, the Decoder, and the combination of the two. Before we actually get into them, we need to import the modules and initialize the required parameters in advance. Look at the Codeblock 1 below to see the modules I use.<\/p>\n

# Codeblock 1\nimport torch  #(1)\nimport torch.nn as nn  #(2)\nimport torchvision.models as models  #(3)\nfrom torchvision.models import GoogLeNet_Weights  #(4)<\/code><\/pre>\n
Let\u2019s break down these imports quickly: the line marked with #(1)<\/code> is used for basic operations, line #(2)<\/code> is for initializing neural network layers, line #(3)<\/code> is for loading various deep learning models, and #(4)<\/code> is the pretrained weights for the GoogLeNet model.<\/p>\n
Talking about the parameter configuration, EMBED_DIM<\/code> and LSTM_HIDDEN_DIM<\/code> are the only two parameters mentioned in the paper, which are both set to 512 as shown at line #(1)<\/code> and #(2)<\/code> in the Codeblock 2 below. The EMBED_DIM<\/code> variable essentially indicates the feature vector size representing a single token in the caption. In this case, we can simply think of a single token as an individual word. Meanwhile, LSTM_HIDDEN_DIM<\/code> is a variable representing the hidden state size inside the LSTM cell. This paper does not mention how many times this RNN-based layer is repeated, but based on the diagram in Figure 1, it seems like it only implements a single LSTM cell. Thus, at line #(3)<\/code> I set the NUM_LSTM_LAYERS<\/code> variable to 1.<\/p>\n
# Codeblock 2\nEMBED_DIM       = 512    #(1)\nLSTM_HIDDEN_DIM = 512    #(2)\nNUM_LSTM_LAYERS = 1      #(3)\n\nIMAGE_SIZE      = 224    #(4)\nIN_CHANNELS     = 3      #(5)\n\nSEQ_LENGTH      = 30     #(6)\nVOCAB_SIZE      = 10000  #(7)\n\nBATCH_SIZE      = 1<\/code><\/pre>\n
The next two parameters are related to the input image, namely IMAGE_SIZE<\/code> (#(4)<\/code>) and IN_CHANNELS<\/code> (#(5)<\/code>). Since we are about to use GoogLeNet for the encoder, we need to match it with its original input shape (3\u00d7224\u00d7224). Not only for the image, but we also need to configure the parameters for the caption. Here we assume that the caption length is no more than 30 words (#(6)<\/code>) and the number of unique words in the dictionary is 10000 (#(7)<\/code>). Lastly, the BATCH_SIZE<\/code> parameter is used because by default PyTorch processes tensors in a batch. Just to make things simple, the number of image-caption pair within a single batch is set to 1.<\/p>\n
GoogLeNet Encoder<\/h3>\n
It is actually possible to use any kind of CNN-based model for the encoder. I found on the internet that [4] uses DenseNet, [5] uses Inception V3, and [6] utilizes ResNet for the similar tasks. However, since my goal is to reproduce the model proposed in the paper as closely as possible, I am using the pretrained GoogLeNet model instead. Before we get into the encoder implementation, let\u2019s see what the GoogLeNet architecture looks like using the following code.<\/p>\n
# Codeblock 3\nmodels.googlenet()<\/code><\/pre>\n
The resulting output is very long as it lists literally all layers inside the architecture. Here I truncate the output since I only want you to focus on the last layer (the fc<\/code> layer marked with #(1)<\/code> in the Codeblock 3 Output below). You can see that this linear layer maps a feature vector of size 1024 into 1000. Normally, in a standard image classification task, each of these 1000 neurons corresponds to a specific class. So, for example, if you want to perform a 5-class classification task, you would need to modify this layer such that it projects the outputs to 5 neurons only. In our case, we need to make this layer produce a feature vector of length 512 (EMBED_DIM<\/code>). With this, the input image will later be represented as a 512-dimensional vector after being processed by the GoogLeNet model. This feature vector size will exactly match with the token embedding dimension, allowing it to be treated as a part of our word sequence.<\/p>\n
# Codeblock 3 Output\nGoogLeNet(\n  (conv1): BasicConv2d(\n    (conv): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n    (bn): BatchNorm2d(64, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)\n  )\n  (maxpool1): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=True)\n  (conv2): BasicConv2d(\n    (conv): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n    (bn): BatchNorm2d(64, eps=0.001, momentum=0.1, affine=True, track_running_stats=True)\n  )\n\n  .\n  .\n  .\n  .\n\n  (avgpool): AdaptiveAvgPool2d(output_size=(1, 1))\n  (dropout): Dropout(p=0.2, inplace=False)\n  (fc): Linear(in_features=1024, out_features=1000, bias=True)  #(1)\n)<\/code><\/pre>\n
Now let\u2019s actually load and modify the GoogLeNet model, which I do in the InceptionEncoder<\/code> class below.<\/p>\n
# Codeblock 4a\nclass InceptionEncoder(nn.Module):\n    def __init__(self, fine_tune):  #(1)\n        super().__init__()\n        self.googlenet = models.googlenet(weights=GoogLeNet_Weights.IMAGENET1K_V1)  #(2)\n        self.googlenet.fc = nn.Linear(in_features=self.googlenet.fc.in_features,  #(3)\n                                      out_features=EMBED_DIM)  #(4)\n\n        if fine_tune == True:       #(5)\n            for param in self.googlenet.parameters():\n                param.requires_grad = True\n        else:\n            for param in self.googlenet.parameters():\n                param.requires_grad = False\n\n        for param in self.googlenet.fc.parameters():\n            param.requires_grad = True<\/code><\/pre>\n
The first thing we do in the above code is to load the model using models.googlenet()<\/code>. It is mentioned in the paper that the model is already pretrained on the ImageNet dataset. Thus, we need to pass GoogLeNet_Weights.IMAGENET1K_V1<\/code> into the weights<\/code> parameter, as shown at line #(2)<\/code> in Codeblock 4a. Next, at line #(3)<\/code> we access the classification head through the fc<\/code> attribute, where we replace the existing linear layer with a new one having the output dimension of 512 (EMBED_DIM<\/code>) (#(4)<\/code>). Since this GoogLeNet model is already trained, we don\u2019t need to train it from scratch. Instead, we can either perform fine-tuning<\/em> or transfer learning<\/em> in order to adapt it to the image captioning task.<\/p>\n
In case you\u2019re not yet familiar with the two terms, fine-tuning<\/em> is a method where we update the weights of the entire model. On the other hand, transfer learning<\/em> is a technique where we only update the weights of the layers we replaced (in this case it\u2019s the last fully-connected layer), while setting the weights of the existing layers non-trainable. To do so, I implement a flag named fine_tune<\/code> at line #(1)<\/code> which will let the model to perform fine-tuning whenever it is set to True<\/code> (#(5)<\/code>).<\/p>\n
The forward()<\/code> method is pretty straightforward since what we do here is simply passing the input image through the modified GoogLeNet model. See the Codeblock 4b below for the details. Additionally, here I also print out the tensor dimension before and after processing so that you can better understand how the InceptionEncoder<\/code> model works.<\/p>\n
# Codeblock 4b\n    def forward(self, images):\n        print(f'originalt: {images.size()}')\n        features = self.googlenet(images)\n        print(f'after googlenett: {features.size()}')\n\n        return features<\/code><\/pre>\n
To test whether our decoder works properly, we can pass a dummy tensor of size 1\u00d73\u00d7224\u00d7224 through the network as demonstrated in Codeblock 5. This tensor dimension simulates a single RGB image of size 224\u00d7224. You can see in the resulting output that our image now becomes a single-dimensional feature vector with the length of 512.<\/p>\n
# Codeblock 5\ninception_encoder = InceptionEncoder(fine_tune=True)\n\nimages = torch.randn(BATCH_SIZE, IN_CHANNELS, IMAGE_SIZE, IMAGE_SIZE)\nfeatures = inception_encoder(images)<\/code><\/pre>\n
# Codeblock 5 Output\noriginal         : torch.Size([1, 3, 224, 224])\nafter googlenet  : torch.Size([1, 512])<\/code><\/pre>\n
LSTM Decoder<\/h3>\n
As we have successfully implemented the encoder, now that we are going to create the LSTM decoder, which I demonstrate in Codeblock 6a and 6b. What we need to do first is to initialize the required layers, namely an embedding layer (#(1)<\/code>), the LSTM layer itself (#(2)<\/code>), and a standard linear layer (#(3)<\/code>). The first one (nn.Embedding<\/code>) is responsible for mapping every single token into a 512 (EMBED_DIM<\/code>)-dimensional vector. Meanwhile, the LSTM layer is going to generate a sequence of embedded tokens, where each of these tokens will be mapped into a 10000 (VOCAB_SIZE<\/code>)-dimensional vector by the linear layer. Later on, the values contained in this vector will represent the likelihood of each word in the dictionary being chosen.<\/p>\n
# Codeblock 6a\nclass LSTMDecoder(nn.Module):\n    def __init__(self):\n        super().__init__()\n\n        #(1)\n        self.embedding = nn.Embedding(num_embeddings=VOCAB_SIZE,\n                                      embedding_dim=EMBED_DIM)\n        #(2)\n        self.lstm = nn.LSTM(input_size=EMBED_DIM, \n                            hidden_size=LSTM_HIDDEN_DIM, \n                            num_layers=NUM_LSTM_LAYERS, \n                            batch_first=True)\n        #(3)        \n        self.linear = nn.Linear(in_features=LSTM_HIDDEN_DIM, \n                                out_features=VOCAB_SIZE)<\/code><\/pre>\n
Next, let\u2019s define the flow of the network using the following code.<\/p>\n
# Codeblock 6b\n    def forward(self, features, captions):                 #(1)\n        print(f'features originalt: {features.size()}')\n        features = features.unsqueeze(1)                   #(2)\n        print(f\"after unsqueezett: {features.shape}\")\n\n        print(f'captions originalt: {captions.size()}')\n        captions = self.embedding(captions)                #(3)\n        print(f\"after embeddingtt: {captions.shape}\")\n\n        captions = torch.cat([features, captions], dim=1)  #(4)\n        print(f\"after concattt: {captions.shape}\")\n\n        captions, _ = self.lstm(captions)                  #(5)\n        print(f\"after lstmtt: {captions.shape}\")\n\n        captions = self.linear(captions)                   #(6)\n        print(f\"after lineartt: {captions.shape}\")\n\n        return captions<\/code><\/pre>\n
You can see in the above code that the forward()<\/code> method of the LSTMDecoder<\/code> class accepts two inputs: features<\/code> and captions<\/code>, where the former is the image that has been processed by the InceptionEncoder<\/code>, while the latter is the caption of the corresponding image serving as the ground truth (#(1)<\/code>). The idea here is that we are going to perform pre-inject<\/em> operation by prepending the features<\/code> tensor into captions<\/code> using the code at line #(4)<\/code>. However, keep in mind that we need to adjust the shape of both tensors beforehand. To do so, we have to insert a single dimension at the 1st axis of the image features (#(2)<\/code>). Meanwhile, the shape of the captions<\/code> tensor will align with our requirement right after being processed by the embedding layer (#(3)<\/code>). As the features<\/code> and captions<\/code> have been concatenated, we then pass this tensor through the LSTM layer (#(5)<\/code>) before it is eventually processed by the linear layer (#(6)<\/code>). Look at the testing code below to better understand the flow of the two tensors.<\/p>\n
# Codeblock 7\nlstm_decoder = LSTMDecoder()\n\nfeatures = torch.randn(BATCH_SIZE, EMBED_DIM)  #(1)\ncaptions = torch.randint(0, VOCAB_SIZE, (BATCH_SIZE, SEQ_LENGTH))  #(2)\n\ncaptions = lstm_decoder(features, captions)<\/code><\/pre>\n
In Codeblock 7, I assume that features<\/code> is a dummy tensor that represents the output of the InceptionEncoder<\/code> model (#(1)<\/code>). Meanwhile, captions<\/code> is the tensor representing a sequence of tokenized words, where in this case I initialize it as random numbers ranging between 0 to 10000 (VOCAB_SIZE<\/code>) with the length of 30 (SEQ_LENGTH<\/code>) (#(2)<\/code>).<\/p>\n
We can see in the output below that the features tensor initially has the dimension of 1\u00d7512 (#(1)<\/code>). This tensor shape changed to 1\u00d71\u00d7512 after being processed with the unsqueeze()<\/code> operation (#(2)<\/code>). The additional dimension in the middle (1) allows the tensor to be treated as a feature vector corresponding to a single timestep, which is necessary for compatibility with the LSTM layer. To the captions<\/code> tensor, its shape changed from 1\u00d730 (#(3)<\/code>) to 1\u00d730\u00d7512 (#(4)<\/code>), indicating that every single word is now represented as a 512-dimensional vector.<\/p>\n
# Codeblock 7 Output\nfeatures original : torch.Size([1, 512])       #(1)\nafter unsqueeze   : torch.Size([1, 1, 512])    #(2)\ncaptions original : torch.Size([1, 30])        #(3)\nafter embedding   : torch.Size([1, 30, 512])   #(4)\nafter concat      : torch.Size([1, 31, 512])   #(5)\nafter lstm        : torch.Size([1, 31, 512])   #(6)\nafter linear      : torch.Size([1, 31, 10000]) #(7)<\/code><\/pre>\n
After pre-inject<\/em> operation is performed, our tensor is now having the dimension of 1\u00d731\u00d7512, where the features<\/code> tensor becomes the token at the 0th timestep in the sequence (#(5)<\/code>). See the following figure to better illustrate this idea.<\/p>\n
\"Figure
Figure 3. What the resulting tensor looks like after the pre-injection operation. [3].<\/figcaption><\/figure>\n
Next, we pass the tensor through the LSTM layer, which in this particular case the output tensor dimension remains the same. However, it is important to note that the tensor shapes at line #(5)<\/code> and #(6)<\/code> in the above output are actually specified by different parameters. The dimensions appear to match here because EMBED_DIM<\/code> and LSTM_HIDDEN_DIM<\/code> were both set to 512. Normally, if we use a different value for LSTM_HIDDEN_DIM<\/code>, then the output dimension is going to be different as well. Finally, we projected each of the 31 token embeddings to a vector of size 10000, which will later contain the probability of every possible token being predicted (#(7)<\/code>).<\/p>\n
GoogLeNet Encoder + LSTM Decoder<\/h3>\n
At this point, we have successfully created both the encoder and the decoder parts of the image captioning model. What I am going to do next is to combine them together in the ShowAndTell<\/code> class below.<\/p>\n
# Codeblock 8a\nclass ShowAndTell(nn.Module):\n    def __init__(self):\n        super().__init__()\n        self.encoder = InceptionEncoder(fine_tune=True)  #(1)\n        self.decoder = LSTMDecoder()     #(2)\n\n    def forward(self, images, captions):\n        features = self.encoder(images)  #(3)\n        print(f\"after encodert: {features.shape}\")\n\n        captions = self.decoder(features, captions)      #(4)\n        print(f\"after decodert: {captions.shape}\")\n\n        return captions<\/code><\/pre>\n
I think the above code is pretty straightforward. In the __init__()<\/code> method, we only need to initialize the InceptionEncoder<\/code> as well as the LSTMDecoder<\/code> models (#(1)<\/code> and #(2)<\/code>). Here I assume that we are about to perform fine-tuning rather than transfer learning, so I set the fine_tune<\/code> parameter to True<\/code>. Theoretically speaking, fine-tuning is better than transfer learning if you have a relatively large dataset since it works by re-adjusting the weights of the entire model. However, if your dataset is rather small, you should go with transfer learning instead \u2013 but that\u2019s just the theory. It\u2019s definitely a good idea to experiment with both options to see which works best in your case.<\/p>\n
Still with the above codeblock, we configure the forward()<\/code> method to accept image-caption pairs as input. With this configuration, we basically design this method such that it can only be used for training purpose. Here we initially process the raw image with the GoogLeNet inside the encoder block (#(3)<\/code>). Afterwards, we pass the extracted features as well as the tokenized captions into the decoder block and let it produce another token sequence (#(4)<\/code>). In the actual training, this caption output will then be compared with the ground truth to compute the error. This error value is going to be used to compute gradients through backpropagation, which determines how the weights in the network are updated.<\/p>\n
It is important to know that we cannot use the forward()<\/code> method to perform inference, so we need a separate one for that. In this case, I am going to implement the code specifically to perform inference in the generate()<\/code> method below.<\/p>\n
# Codeblock 8b\n    def generate(self, images):  #(1)\n        features = self.encoder(images)              #(2)\n        print(f\"after encodertt: {features.shape}n\")\n\n        words = []  #(3)\n        for i in range(SEQ_LENGTH):                  #(4)\n            print(f\"iteration #{i}\")\n            features = features.unsqueeze(1)\n            print(f\"after unsqueezett: {features.shape}\")\n\n            features, _ = self.decoder.lstm(features)\n            print(f\"after lstmtt: {features.shape}\")\n\n            features = features.squeeze(1)           #(5)\n            print(f\"after squeezett: {features.shape}\")\n\n            probs = self.decoder.linear(features)    #(6)\n            print(f\"after lineartt: {probs.shape}\")\n\n            _, word = probs.max(dim=1)  #(7)\n            print(f\"after maxtt: {word.shape}\")\n\n            words.append(word.item())  #(8)\n\n            if word == 1:  #(9)\n                break\n\n            features = self.decoder.embedding(word)  #(10)\n            print(f\"after embeddingtt: {features.shape}n\")\n\n        return words       #(11)<\/code><\/pre>\n
Instead of taking two inputs like the previous one, the generate()<\/code> method takes raw image as the only input (#(1)<\/code>). Since we want the features extracted from the image to be the initial input token, we first need to process the raw input image with the encoder block prior to actually generating the subsequent tokens (#(2)<\/code>). Next, we allocate an empty list for storing the token sequence to be produced later (#(3)<\/code>). The tokens themselves are generated one by one, so we wrap the entire process inside a for<\/code> loop, which is going to stop iterating once it reaches at most 30 (SEQ_LENGTH<\/code>) words (#(4)<\/code>).<\/p>\n
The steps done inside the loop is algorithmically similar to the ones we discussed earlier. However, since the LSTM cell here generates a single token at a time, the process requires the tensor to be treated a bit differently from the one passed through the forward()<\/code> method of the LSTMDecoder<\/code> class back in Codeblock 6b. The first difference you might notice is the squeeze()<\/code> operation (#(5)<\/code>), which is basically just a technical step to be done such that the subsequent layer does the linear projection correctly (#(6)<\/code>). Then, we take the index of the feature vector having the highest value, which corresponds to the token most likely to come next (#(7)<\/code>), and append it to the list we allocated earlier (#(8)<\/code>). The loop is going to break whenever the predicted index is a stop token<\/em>, which in this case I assume that this token is at the 1st index of the probs<\/code> vector. Otherwise, if the model does not find the stop token<\/em>, then it is going to convert the last predicted word into its 512 (EMBED_DIM<\/code>)-dimensional vector (#(10)<\/code>), allowing it to be used as the input features for the next iteration. Lastly, the generated word sequence will be returned once the loop is completed (#(11)<\/code>).<\/p>\n
We are going to simulate the forward pass for the training phase using the Codeblock 9 below. Here I pass two tensors through the show_and_tell<\/code> model (#(1)<\/code>), each representing a raw image of size 3\u00d7224\u00d7224 (#(2)<\/code>) and a sequence of tokenized words (#(3)<\/code>). Based on the resulting output, we found that our model works properly as the two input tensors successfully passed through the InceptionEncoder<\/code> and the LSTMDecoder<\/code> part of the network.<\/p>\n
# Codeblock 9\nshow_and_tell = ShowAndTell()  #(1)\n\nimages = torch.randn(BATCH_SIZE, IN_CHANNELS, IMAGE_SIZE, IMAGE_SIZE)  #(2)\ncaptions = torch.randint(0, VOCAB_SIZE, (BATCH_SIZE, SEQ_LENGTH))      #(3)\n\ncaptions = show_and_tell(images, captions)<\/code><\/pre>\n
# Codeblock 9 Output\nafter encoder : torch.Size([1, 512])\nafter decoder : torch.Size([1, 31, 10000])<\/code><\/pre>\n
Now, let\u2019s assume that our show_and_tell<\/code> model is already trained on an image captioning dataset, and thus ready to be used for inference. Look at the Codeblock 10 below to see how I do it. Here we set the model to eval()<\/code> mode (#(1)<\/code>), initialize the input image (#(2)<\/code>), and pass it through the model using the generate()<\/code> method (#(3)<\/code>).<\/p>\n
# Codeblock 10\nshow_and_tell.eval()  #(1)\n\nimages = torch.randn(BATCH_SIZE, IN_CHANNELS, IMAGE_SIZE, IMAGE_SIZE)  #(2)\n\nwith torch.no_grad():\n    generated_tokens = show_and_tell.generate(images)  #(3)<\/code><\/pre>\n
The flow of the tensor can be seen in the output below. Here I truncate the resulting outputs because it only shows the same token generation process 30 times.<\/p>\n
# Codeblock 10 Output\nafter encoder    : torch.Size([1, 512])\n\niteration #0\nafter unsqueeze  : torch.Size([1, 1, 512])\nafter lstm       : torch.Size([1, 1, 512])\nafter squeeze    : torch.Size([1, 512])\nafter linear     : torch.Size([1, 10000])\nafter max        : torch.Size([1])\nafter embedding  : torch.Size([1, 512])\n\niteration #1\nafter unsqueeze  : torch.Size([1, 1, 512])\nafter lstm       : torch.Size([1, 1, 512])\nafter squeeze    : torch.Size([1, 512])\nafter linear     : torch.Size([1, 10000])\nafter max        : torch.Size([1])\nafter embedding  : torch.Size([1, 512])\n\n.\n.\n.\n.<\/code><\/pre>\n
To see what the resulting caption looks like, we can just print out the generated_tokens<\/code> list as shown below. Keep in mind that this sequence is still in the form of tokenized words. Later, in the post-processing stage, we will need to convert them back to the words corresponding to these numbers.<\/p>\n
# Codeblock 11\ngenerated_tokens<\/code><\/pre>\n
# Codeblock 11 Output\n[5627,\n 3906,\n 2370,\n 2299,\n 4952,\n 9933,\n 402,\n 7775,\n 602,\n 4414,\n 8667,\n 6774,\n 9345,\n 8750,\n 3680,\n 4458,\n 1677,\n 5998,\n 8572,\n 9556,\n 7347,\n 6780,\n 9672,\n 2596,\n 9218,\n 1880,\n 4396,\n 6168,\n 7999,\n 454]<\/code><\/pre>\n
\n
Ending<\/h2>\n
With the above output, we\u2019ve reached the end of our discussion on image captioning. Over time, many other researchers attempted to make improvements to accomplish this task. So, I think in the upcoming article I will discuss the state-of-the-art method on this topic.<\/p>\n
Thanks for reading, I hope you learn something new today!<\/p>\n
_By the way you can also find the code used in this article here<\/a>._<\/p>\n
\n
References<\/h2>\n
[1] Oriol Vinyals et al. Show and Tell: A Neural Image Caption Generator. Arxiv. https:\/\/arxiv.org\/pdf\/1411.4555<\/a> [Accessed November 13, 2024].<\/p>\n
[2] Christian Szegedy et al. Going Deeper with Convolutions. Arxiv. https:\/\/arxiv.org\/pdf\/1409.4842<\/a> [Accessed November 13, 2024].<\/p>\n
[3] Marc Tanti et al. Where to put the Image in an Image Caption Generator. Arxiv. https:\/\/arxiv.org\/pdf\/1703.09137<\/a> [Accessed November 13, 2024].<\/p>\n
[4] Stepan Ulyanin<\/a>. Captioning Images with CNN and RNN, using PyTorch. Medium. https:\/\/medium.com\/@stepanulyanin\/captioning-images-with-pytorch-bc592e5fd1a3<\/a> [Accessed November 16, 2024].<\/p>\n
[5] Saketh Kotamraju<\/a>. How to Build an Image-Captioning Model in Pytorch. Towards Data Science. https:\/\/towardsdatascience.com\/how-to-build-an-image-captioning-model-in-pytorch-29b9d8fe2f8c<\/a> [Accessed November 16, 2024].<\/p>\n
[6] Code with Aarohi. Image Captioning using CNN and RNN | Image Captioning using Deep Learning. YouTube. https:\/\/www.youtube.com\/watch?v=htNmFL2BG34<\/a> [Accessed November 16, 2024].<\/p>\n
The post Show and Tell<\/a> appeared first on Towards Data Science<\/a>.<\/p>\n<\/div>\n
 \t

\n 
<\/BR>
\n    Muhammad Ardi
\n \t

\n
<\/BR>
\nGo to original source<\/a>
\n \t

\n 
<\/BR><\/p>\n","protected":false},"excerpt":{"rendered":"
Show and Tell Photo by St\u00e5le Grut on Unsplash Introduction Natural Language Processing and Computer Vision used to be two completely different fields. Well, at least back when I started to learn machine learning and deep learning, I feel like there are multiple paths to follow, and each of them, including NLP and Computer Vision, […]<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[62,69,221,88,166,260],"tags":[845,548,1621],"class_list":["post-1638","post","type-post","status-publish","format-standard","hentry","category-aimldsaimlds","category-artificial-intelligence","category-computer-vision","category-deep-learning","category-hands-on-tutorials","category-nlp","tag-image","tag-more","tag-two"],"_links":{"self":[{"href":"https:\/\/mailitics.com\/index.php\/wp-json\/wp\/v2\/posts\/1638"}],"collection":[{"href":"https:\/\/mailitics.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/mailitics.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/mailitics.com\/index.php\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/mailitics.com\/index.php\/wp-json\/wp\/v2\/comments?post=1638"}],"version-history":[{"count":0,"href":"https:\/\/mailitics.com\/index.php\/wp-json\/wp\/v2\/posts\/1638\/revisions"}],"wp:attachment":[{"href":"https:\/\/mailitics.com\/index.php\/wp-json\/wp\/v2\/media?parent=1638"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/mailitics.com\/index.php\/wp-json\/wp\/v2\/categories?post=1638"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/mailitics.com\/index.php\/wp-json\/wp\/v2\/tags?post=1638"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}