docs: def _build_graph(self, vocab, initial_embedding_dict):
          """Builds the computatation graph.
  
          Parameters
          ------------
          vocab : Iterable
          initial_embedding_dict : dict
          """
          # Constants
          self.ones = tf.ones([self.n_words, 1])
  
          # Parameters:
          if initial_embedding_dict is None:
              # Ordinary GloVe
              self.W = self._weight_init(self.n_words, self.n, 'W')
              self.C = self._weight_init(self.n_words, self.n, 'C')
          else:
              # This is the case where we have values to use as a
              # "warm start":
              self.n = len(next(iter(initial_embedding_dict.values())))
              W = randmatrix(len(vocab), self.n)
              C = randmatrix(len(vocab), self.n)
              self.original_embedding = np.zeros((len(vocab), self.n))
              self.has_embedding = np.zeros(len(vocab))
              for i, w in enumerate(vocab):
                  if w in initial_embedding_dict:
                      self.has_embedding[i] = 1.0
                      embedding = np.array(initial_embedding_dict[w])
                      self.original_embedding[i] = embedding
                      # Divide the original embedding into W and C,
                      # plus some noise to break the symmetry that would
                      # otherwise cause both gradient updates to be
                      # identical.
                      W[i] = 0.5 * embedding + noise(self.n)
                      C[i] = 0.5 * embedding + noise(self.n)
              self.W = tf.Variable(W, name='W', dtype=tf.float32)
              self.C = tf.Variable(C, name='C', dtype=tf.float32)
              self.original_embedding = tf.constant(self.original_embedding,
                                                    dtype=tf.float32)
              self.has_embedding = tf.constant(self.has_embedding,
                                               dtype=tf.float32)
              # This is for testing. It differs from
              # `self.original_embedding` only in that it includes the
              # random noise we added above to break the symmetry.
              self.G_start = W + C
  
          self.bw = self._weight_init(self.n_words, 1, 'bw')
          self.bc = self._weight_init(self.n_words, 1, 'bc')
  
          self.model = tf.tensordot(self.W, tf.transpose(self.C), axes=1) + \
                       tf.tensordot(self.bw, tf.transpose(self.ones), axes=1) + \
                       tf.tensordot(self.ones, tf.transpose(self.bc), axes=1)