code: def parse_sparse(filename, vocab_filename):
      """
      Parse a file that's in libSVM format. In libSVM format each line of the text
      file represents a document in bag of words format:
  
      num_unique_words_in_doc word_id:count another_id:count
  
      The word_ids have 0-based indexing, i.e. 0 corresponds to the first
      word in the vocab filename.
  
      Parameters
      ----------
      filename : str
          The name of the file to parse.
  
      vocab_filename : str
          A list of words that are used for this data set.
  
      Returns
      -------
      out : SArray
          Each element represents a document in bag-of-words format.
  
      Examples
      --------
      If we have two documents:
      1. "It was the best of times, it was the worst of times"
      2. "It was the age of wisdom, it was the age of foolishness"
  
      Then the vocabulary file might contain the unique words, with a word
      on each line, in the following order:
      it, was, the, best, of, times, worst, age, wisdom, foolishness
  
      In this case, the file in libSVM format would have two lines:
      7 0:2 1:2 2:2 3:1 4:2 5:1 6:1
      7 0:2 1:2 2:2 7:2 8:1 9:1 10:1
  
      The following command will parse the above two files into an SArray
      of type dict.
  
      >>> file = 'https://static.turi.com/datasets/text/ap.dat'
      >>> vocab = 'https://static.turi.com/datasets/text/ap.vocab.txt'
      >>> docs = turicreate.text_analytics.parse_sparse(file, vocab)
      """
      vocab = _turicreate.SFrame.read_csv(vocab_filename, header=None)[
          "X1"
      ]
      vocab = list(vocab)
  
      docs = _turicreate.SFrame.read_csv(filename, header=None)
  
      # Remove first word
      docs = docs["X1"].apply(lambda x: x.split(" ")[1:])
  
      # Helper function that checks whether we get too large a word id
      def get_word(word_id):
          assert int(word_id) < len(
              vocab
          ), "Text data contains integers that are larger than the \
                   size of the provided vocabulary."
          return vocab[word_id]
  
      def make_dict(pairs):
          pairs = [z.split(":") for z in pairs]
          ret = {}
          for k, v in pairs:
              ret[get_word(int(k))] = int(v)
          return ret
  
      # Split word_id and count and make into a dictionary
      docs = docs.apply(lambda x: make_dict(x))
  
      return docs
  
imports: from __future__ import print_function
  from __future__ import division
  from __future__ import absolute_import
  import turicreate
  from turicreate import SArray
  from turicreate import SFrame
  from turicreate.toolkits._internal_utils import _raise_error_if_not_sarray
  import random
  import six
  import turicreate.toolkits._feature_engineering
label_desc: Use image node_id 7 for calling a global function with example usage: parse_sparse(filename, vocab_filename) and returns: docs, vocab, ret