CS5542 Big Data Analytics and App Lab Assignment #1 Report Zakari, Abdulmuhaymin (29)

This is a lab assignment report for generating captions of a dataset using the Show and Tell model. Main(): Taking input files from the project profiles. These files are the model, the captions file, and the input images.

1. Disclaimer: This program is inspired directly by the codes that were given in CS5542 (UMKC Class) By Ms. Mayanka Shekar, and on it we're trying to improve and develop!

5. #required libraries
6. from future import absolute_import
7. from future import division
8. from future import print_function
10. import nltk
11. import nltk.translate.gleu_score as gleu
12. import numpy
13. import os
14. try:
15. nltk.data.find('tokenizers/punkt')
16. except LookupError:
17. nltk.download('punkt')
18. import nltk
20. try:
21. nltk.data.find('tokenizers/punkt')
22. except LookupError:
23. nltk.download('punkt')
24. from nltk.translate.bleu_score import sentence_bleu
26. import logging
27. import math
29. import tensorflow as tf
31. from main.caption_generator import CaptionGenerator
32. from main.model import ShowAndTellModel
33. from main.vocabulary import Vocabulary
35. FLAGS = tf.flags.FLAGS

36. setting input files and model location

37. tf.flags.DEFINE_string("model_path", "..\show-and-tell.pb", "Model path")
38. tf.flags.DEFINE_string("vocab_file", "..\word_counts.txt", "vocabularies.")
39. tf.flags.DEFINE_string("input_files", r"..\in3.jpg", "input")
41. logging.basicConfig(level=logging.INFO)
43. logger = logging.getLogger(name)
46. def main(_):

47. model = ShowAndTellModel(FLAGS.model_path)
    

48. vocab = Vocabulary(FLAGS.vocab_file)
    

49. filenames = _load_filenames()
    

50. can1 = "a table with different kinds of food"
    

51. candidate=can1.split()
    

52. generator = CaptionGenerator(model, vocab)
    

53. for filename in filenames:
    

54.     with tf.gfile.GFile(filename, "rb") as f:
    

55.         image = f.read()
    

56.     captions = generator.beam_search(image)
    

57.     print("Captions: ")
    

58.     for i, caption in enumerate(captions):
    

59.         sentence = [vocab.id_to_token(w) for w in caption.sentence[1:-1]]
    

60.         sentence = " ".join(sentence)
    

61.         temp = "  %d) %s (p=%f)" % (i+1, sentence, math.exp(caption.logprob))
    

62.         print(temp)
    

63.         comp = [sentence.split()]
    

64.         # Calculating The Blue Score
    

65.         print('Blue cumulative 1-gram: %f' % sentence_bleu(comp, candidate, weights=(1, 0, 0, 0)))
    

66.         print('Blue cumulative 2-gram: %f' % sentence_bleu(comp, candidate, weights=(0.5, 0.5, 0, 0)))
    

67.         # Glue Score
    

68.         G = gleu.sentence_gleu(comp, candidate, min_len=1, max_len=2)
    

69.         print("Glue score for this sentence: {}".format(G))
    

73. def _load_filenames():

74. filenames = []
    

75. for file_pattern in FLAGS.input_files.split(","):
    

76.     filenames.extend(tf.gfile.Glob(file_pattern))
    

77. logger.info("Running caption generation on %d files matching %s",
    

78.             len(filenames), FLAGS.input_files)
    

79. return filenames
    

82. if name == "main":

83. tf.app.run()
    

The model file:

1. import logging
2. import os
4. import tensorflow as tf
7. class ShowAndTellModel(object):

8.  def __init__(self, model_path):
   

9.      self._model_path = model_path
   

10.     self.logger = logging.getLogger(__name__)
    

12.     self._load_model(model_path)
    

13.     self._sess = tf.Session(graph=tf.get_default_graph())
    

15. def _load_model(self, frozen_graph_path):
    

18.     model_exp = os.path.expanduser(frozen_graph_path)
    

19.     if os.path.isfile(model_exp):
    

20.         self.logger.info('Loading model filename: %s' % model_exp)
    

21.         with tf.gfile.FastGFile(model_exp, 'rb') as f:
    

22.             graph_def = tf.GraphDef()
    

23.             graph_def.ParseFromString(f.read())
    

24.             tf.import_graph_def(graph_def, name='')
    

25.     else:
    

26.         raise RuntimeError("Missing model file at path: {}".format(frozen_graph_path))
    

28. def feed_image(self, encoded_image):
    

29.     initial_state = self._sess.run(fetches="lstm/initial_state:0",
    

30.                                    feed_dict={"image_feed:0": encoded_image})
    

31.     return initial_state
    

33. def inference_step(self, input_feed, state_feed):
    

34.     softmax_output, state_output = self._sess.run(
    

35.         fetches=["softmax:0", "lstm/state:0"],
    

36.         feed_dict={
    

37.             "input_feed:0": input_feed,
    

38.             "lstm/state_feed:0": state_feed,
    

39.         })
    

40.     return softmax_output, state_output, None
    

vocabulary.py

1. from future import absolute_import
2. from future import division
3. from future import print_function
5. import logging
6. import os
9. class Vocabulary(object):

12. def __init__(self,
    

13.              vocab_file_path,
    

14.              start_token="<S>",
    

15.              end_token="</S>",
    

16.              unk_token="<UNK>"):
    

18.     self.logger = logging.getLogger(__name__)
    

19.     if not os.path.exists(vocab_file_path):
    

20.         self.logger.exception("Vocab file %s not found.", vocab_file_path)
    

21.         raise RuntimeError
    

22.     self.logger.info("Initializing vocabulary from file: %s", vocab_file_path)
    

24.     with open(vocab_file_path, mode="r") as f:
    

25.         reverse_vocab = list(f.readlines())
    

26.     reverse_vocab = [line.split()[0] for line in reverse_vocab]
    

27.     assert start_token in reverse_vocab
    

28.     assert end_token in reverse_vocab
    

29.     if unk_token not in reverse_vocab:
    

30.         reverse_vocab.append(unk_token)
    

31.     vocab = dict([(x, y) for (y, x) in enumerate(reverse_vocab)])
    

33.     self.logger.info("Created vocabulary with %d words" % len(vocab))
    

35.     self.vocab = vocab
    

36.     self.reverse_vocab = reverse_vocab
    

38.     self.start_id = vocab[start_token]
    

39.     self.end_id = vocab[end_token]
    

40.     self.unk_id = vocab[unk_token]
    

42. def token_to_id(self, token_id):
    

43.     if token_id in self.vocab:
    

44.         return self.vocab[token_id]
    

45.     else:
    

46.         return self.unk_id
    

48. def id_to_token(self, token_id):
    

49.     if token_id >= len(self.reverse_vocab):
    

50.         return self.reverse_vocab[self.unk_id]
    

51.     else:
    

52.         return self.reverse_vocab[token_id]
    

screenshots: