/** @param stateSetTree */
 public static void printBadLLReason(Tree<StateSet> stateSetTree, SophisticatedLexicon lexicon) {
   System.out.println(stateSetTree.toString());
   boolean lexiconProblem = false;
   List<StateSet> words = stateSetTree.getYield();
   Iterator<StateSet> wordIterator = words.iterator();
   for (StateSet stateSet : stateSetTree.getPreTerminalYield()) {
     String word = wordIterator.next().getWord();
     boolean lexiconProblemHere = true;
     for (int i = 0; i < stateSet.numSubStates(); i++) {
       double score = stateSet.getIScore(i);
       if (!(Double.isInfinite(score) || Double.isNaN(score))) {
         lexiconProblemHere = false;
       }
     }
     if (lexiconProblemHere) {
       System.out.println("LEXICON PROBLEM ON STATE " + stateSet.getState() + " word " + word);
       System.out.println("  word " + lexicon.wordCounter.getCount(stateSet.getWord()));
       for (int i = 0; i < stateSet.numSubStates(); i++) {
         System.out.println("  tag " + lexicon.tagCounter[stateSet.getState()][i]);
         System.out.println(
             "  word/state/sub "
                 + lexicon.wordToTagCounters[stateSet.getState()].get(stateSet.getWord())[i]);
       }
     }
     lexiconProblem = lexiconProblem || lexiconProblemHere;
   }
   if (lexiconProblem) System.out.println("  the likelihood is bad because of the lexicon");
   else System.out.println("  the likelihood is bad because of the grammar");
 }
Example #2
0
 public void run() {
   int count = 0;
   for (Tree<String> t : this) {
     System.out.println(t.toString());
     ++count;
   }
   Logger.i().logs("Number of Trees: %d", count);
 }
 /**
  * This function probably doesn't belong here, but because it should be called after {@link
  * #updateStateSetTrees}, Leon left it here.
  *
  * @param trees Trees which have already had their inside-outside probabilities calculated, as by
  *     {@link #updateStateSetTrees}.
  * @return The log likelihood of the trees.
  */
 public static double logLikelihood(List<Tree<StateSet>> trees, boolean verbose) {
   double likelihood = 0, l = 0;
   for (Tree<StateSet> tree : trees) {
     l = tree.getLabel().getIScore(0);
     if (verbose) System.out.println("LL is " + l + ".");
     if (Double.isInfinite(l) || Double.isNaN(l)) {
       System.out.println("LL is not finite.");
     } else {
       likelihood += l;
     }
   }
   return likelihood;
 }
 /**
  * @param maxGrammar
  * @param maxLexicon
  * @param validationStateSetTrees
  * @return
  */
 public static double calculateLogLikelihood(
     Grammar maxGrammar, Lexicon maxLexicon, StateSetTreeList validationStateSetTrees) {
   ArrayParser parser = new ArrayParser(maxGrammar, maxLexicon);
   int unparsable = 0;
   double maxLikelihood = 0;
   for (Tree<StateSet> stateSetTree : validationStateSetTrees) {
     parser.doInsideScores(stateSetTree, false, false, null); // Only inside scores are needed here
     double ll = stateSetTree.getLabel().getIScore(0);
     ll = Math.log(ll) + (100 * stateSetTree.getLabel().getIScale());
     if (Double.isInfinite(ll) || Double.isNaN(ll)) {
       unparsable++;
       // printBadLLReason(stateSetTree, lexicon);
     } else maxLikelihood += ll; // there are for some reason some sentences that are unparsable
   }
   //		if (unparsable>0) System.out.print("Number of unparsable trees: "+unparsable+".");
   return maxLikelihood;
 }
 private static void formStringBuilder(Tree<String> next) {
   List<String> tokens = next.getTerminalYield();
   for (String token : tokens) {
     builder.append(token);
     builder.append(" ");
   }
   builder.append("\n");
 }
  /**
   * @param previousGrammar
   * @param previousLexicon
   * @param grammar
   * @param lexicon
   * @param trainStateSetTrees
   * @return
   */
  public static double doOneEStep(
      Grammar previousGrammar,
      Lexicon previousLexicon,
      Grammar grammar,
      Lexicon lexicon,
      StateSetTreeList trainStateSetTrees,
      boolean updateOnlyLexicon,
      int unkThreshold) {
    boolean secondHalf = false;
    ArrayParser parser = new ArrayParser(previousGrammar, previousLexicon);
    double trainingLikelihood = 0;
    int n = 0;
    int nTrees = trainStateSetTrees.size();
    for (Tree<StateSet> stateSetTree : trainStateSetTrees) {
      secondHalf = (n++ > nTrees / 2.0);
      boolean noSmoothing = true, debugOutput = false;
      parser.doInsideOutsideScores(stateSetTree, noSmoothing, debugOutput); // E Step
      double ll = stateSetTree.getLabel().getIScore(0);
      ll =
          Math.log(ll)
              + (100 * stateSetTree.getLabel().getIScale()); // System.out.println(stateSetTree);
      if ((Double.isInfinite(ll) || Double.isNaN(ll))) {
        if (VERBOSE) {
          System.out.println("Training sentence " + n + " is given " + ll + " log likelihood!");
          System.out.println(
              "Root iScore "
                  + stateSetTree.getLabel().getIScore(0)
                  + " scale "
                  + stateSetTree.getLabel().getIScale());
        }
      } else {
        lexicon.trainTree(stateSetTree, -1, previousLexicon, secondHalf, noSmoothing, unkThreshold);
        if (!updateOnlyLexicon) grammar.tallyStateSetTree(stateSetTree, previousGrammar); // E Step
        trainingLikelihood += ll; // there are for some reason some sentences that are unparsable
      }
    }
    lexicon.tieRareWordStats(unkThreshold);

    // SSIE
    ((SophisticatedLexicon) lexicon).overwriteWithMaxent();

    return trainingLikelihood;
  }
  private static void createVectorBeanToBeSerialized() {

    vectorBean.setPhi(phiSyn);
    vectorBean.setPsi(psiSyn);
    vectorBean.setPhiSem(phiSem);
    vectorBean.setPsiSem(psiSem);

    vectorBean.setInsideTree(insideTree);
    vectorBean.setLabel(insideTree.getLabel());
    vectorBean.setSyntaxTree(syntaxTree);
    vectorBean.setFootToRoot(foottoroot);
  }
  public static void main(String... args) throws Exception {

    /*
     * The inside and outisde projection matrices I suppose
     */
    Object[] matrices = new Object[2];

    /*
     * Data structure to hold all the sparse vectors
     */
    // ArrayList<SparseVector> phiList = new ArrayList<SparseVector>();
    // ArrayList<SparseVector> psiList = new ArrayList<SparseVector>();

    /*
     * Used to normalize the trees
     */

    PTBTreeNormaliser treeNormalizer = new PTBTreeNormaliser(true);

    /*
     * Getting the feature dictionary path, i.e. the serialized file path.
     * This dictionary will be used to form the feature vectors.
     */
    String featureDictionary = null;

    /*
     * This variable tells the code about the directory path where parse
     * trees are stored from which feature vectors need to be extracted
     * corresponding to all the nodes
     */
    String parsedTreeCorpus = null;

    /*
     * The feature dictionary that needs to be used while extracting
     * features
     */
    featureDictionary = "/disk/scratch/s1444025/worddictionary/worddictionary.ser";
    /*
     * The directory that holds the parse trees that are iterated over to
     * extract the feature vector corresponding to the nodes
     */
    parsedTreeCorpus = "/afs/inf.ed.ac.uk/group/project/vsm.restored/trees";
    /*
     * Necessary to get the appropriate directory structure
     */
    // countMapLoc =
    // "/afs/inf.ed.ac.uk/group/project/vsm/countmapnodesamples/countMap.ser";

    /*
     * Getting the serialised dictionary bean object that contains the
     * inside and outside feature dictionaries which are used to form the
     * feature vectors
     */
    VSMWordDictionaryBean dictionaryBean =
        VSMReadSerialWordDict.readSerializedDictionary(featureDictionary);

    /*
     * Getting the inside and outside feature dictionaries, that are used
     * for forming the feature vectors
     */
    System.out.println("***Getting word dictionary*****");
    Alphabet wordDictionary = dictionaryBean.getWordDictionary();
    System.out.println(wordDictionary);
    // System.out.println(wordDictionary.size());

    dprime = wordDictionary.size();
    d = wordDictionary.size();

    SparseMatrixLil PsiTPsi = new SparseMatrixLil(dprime, dprime);
    SparseMatrixLil PsiTPhi = new SparseMatrixLil(dprime, d);
    SparseMatrixLil PhiTPhi = new SparseMatrixLil(d, d);
    SparseMatrixLil PhiTPsi = new SparseMatrixLil(d, dprime);

    /*
     * The parsed tree corpus from where the feature vectors need to be
     * extracted corresponding to all the nodes
     */
    File[] files =
        new File(parsedTreeCorpus)
            .listFiles(
                new FileFilter() {

                  @Override
                  public boolean accept(File file) {
                    return !file.isHidden();
                  }
                });

    ArrayList<String> filePaths = VSMUtil.getFilePaths(files);

    /*
     * The obect that is used to serialize the feature vector bean. The
     * feature vector bean storing the inside and outside feature vectors
     * corresponding to a particular node in a tree. Each feature vector
     * bean holds the feature vectors for one particular node
     */
    VSMSerializeFeatureVectorBeanWord serializeBean = null;

    /*
     * If we already have a serialized count map object then we would want
     * to start from where we left
     */
    // File fileCountMap = new File(countMapLoc);

    serializeBean = new VSMSerializeFeatureVectorBeanWord();
    // } else {
    // VSMCountMap countMapObj = VSMReadSerialCountMap
    // .readCountMapObj(countMapLoc);
    // System.out.println("inside the count map***");
    // serializeBean = new VSMSerializeFeatureVectorBeanWord(
    // countMapObj.getCountMap());
    // }

    /*
     * Getting the data structure to store all the feature vectors in it, We
     * are taking 200000 samples for a particular non-terminal
     */
    SparseMatrixLil Phi = new SparseMatrixLil(300000, d);
    SparseMatrixLil Psi = new SparseMatrixLil(300000, dprime);

    int count = 0;

    mainloop:
    for (String filePath : filePaths) {

      /*
       * Getting an iterator over the trees in the file
       */
      PennTreeReader treeReader = VSMUtil.getTreeReader(filePath);

      /*
       * Iterating over all the trees
       */
      while (treeReader.hasNext()) {

        /*
         * The syntax tree
         */
        Tree<String> syntaxTree = null;

        /*
         * Unmatched parentheses exception. Does this mean that the
         * BLLIP corpus sometimes does not have correct parse trees?
         * Strange
         */
        try {
          syntaxTree = treeReader.next();
        } catch (RuntimeException e) {
          System.out.println("exception" + e + " ::tree  " + syntaxTree);
        }

        /*
         * Do stuff only if the syntax tree is a valid one
         */
        if (syntaxTree != null) {

          /*
           * Process the syntax tree to remove the top bracket
           */
          syntaxTree = treeNormalizer.process(syntaxTree);

          /*
           * Iterator over the nodes of the tree
           */
          Iterator<Tree<String>> nodeTrees = syntaxTree.iterator();

          /*
           * Sparse Inside and outside feature vectors declared
           */
          no.uib.cipr.matrix.sparse.SparseVector psi = null;
          no.uib.cipr.matrix.sparse.SparseVector phi = null;
          Tree<String> insideTree = null;

          /*
           * Iterating over all the nodes in a particular syntax tree
           */
          while (nodeTrees.hasNext()) {

            /*
             * This is the inside tree for which we want to form a
             * feature vector and store it in the map
             */
            insideTree = nodeTrees.next();

            /*
             * Only do stuff if inside tree is not a leaf
             */
            if (!insideTree.isLeaf() && insideTree.getLabel().equalsIgnoreCase("NNS")) {

              /*
               * Setting the object's properties that are stored
               * in the .ser file
               */
              VSMWordFeatureVectorBean vectorBean = new VSMWordFeatureVectorBean();

              System.out.println(
                  "****Extracting inside and outside feature vectors for node****  "
                      + insideTree.getLabel());

              /*
               * Getting the inside and outside feature vectors
               * corresponding to the partcular node
               */

              psi =
                  new VSMOutsideFeatureVectorWords()
                      .getOutsideFeatureVectorPsi(
                          syntaxTree, insideTree, wordDictionary, vectorBean);
              // psiList.add(psi);

              phi =
                  new VSMInsideFeatureVectorWords()
                      .getInsideFeatureVectorPhi(insideTree, wordDictionary, vectorBean);
              // phiList.add(phi);

              System.out.println("got the sparse vectors*** ");

              /*
               * Inside sparse matrix formation for the particular
               * node.
               */

              /*
               * Do the below operation only if both psi and phi
               * are not null for the given node sample and also
               * if either psi pr phi are different than before
               * for this spample, if both are same then no need
               * to unecessarily fill up Psi and Phi
               */

              if (phi != null && psi != null) {

                System.out.println(count);

                System.out.println("****Filling in the matrices***");

                int[] indicesPhi = phi.getIndex();
                double[] valuesPhi = phi.getData();
                /*
                 * Don't need the phi anymore in this iteration
                 */
                phi = null;
                /*
                 * Putting the inside feature vector into the
                 * inside feature matrix
                 */
                for (int i = 0; i < indicesPhi.length; i++) {
                  Phi.append(count, indicesPhi[i], valuesPhi[i]);
                }
                indicesPhi = null;
                valuesPhi = null;

                /*
                 * Outside sparse matrix formation for the
                 * particular node
                 */
                int[] indicesPsi = psi.getIndex();
                double[] valuesPsi = psi.getData();
                psi = null;

                /*
                 * Putting the outside feature vector into the
                 * outside feature matrix
                 */
                for (int j = 0; j < indicesPsi.length; j++) {
                  Psi.append(count, indicesPsi[j], valuesPsi[j]);
                }
                indicesPsi = null;
                valuesPsi = null;
                System.gc();

                /*
                 * Storing the feature vectors in a bean which
                 * will be serialized for future use
                 */
                vectorBean.setPhi(phi);
                vectorBean.setPsi(psi);
                vectorBean.setInsideTree(insideTree);
                vectorBean.setLabel(insideTree.getLabel());
                vectorBean.setSyntaxTree(syntaxTree);

                /*
                 * Serialize the feature vector bean
                 * corresponding to the particular node. The
                 * feature vector bean contains the sparse
                 * inside and outside feature vectors
                 */
                serializeBean.serializeWordVectorBean(vectorBean);
                System.out.println("***Serialized the feature vector***");

                count++;

                /*
                 * Break when we have 200000 samples
                 */
                if (count == (Psi.rows - 1)) {
                  break mainloop;
                }
              }
            }
          }
        }
      }
    }

    /*
     * Call the CCA function here
     */

    System.out.println("*****Done with matrices formation****");

    /*
     * Just calculating the co-vavriance, assuming that the data is centered
     * and normalized
     */

    System.out.println("***Calculating Covariances****");
    PsiTPsi = Psi.t().mmul(Psi); // d' \times d'
    PsiTPhi = Psi.t().mmul(Phi); // d' \times d
    PhiTPhi = Phi.t().mmul(Phi); // d \times d
    PhiTPsi = Phi.t().mmul(Psi); // d \times d'
    System.out.println("****Done with it***");

    /*
     * Log and square root transform
     */
    PsiTPsi =
        VSMUtil.createJeigenMatrix(transform(VSMUtil.createSparseMatrixMTJFromJeigen(PsiTPsi)));
    PsiTPhi =
        VSMUtil.createJeigenMatrix(transform(VSMUtil.createSparseMatrixMTJFromJeigen(PsiTPhi)));
    PhiTPhi =
        VSMUtil.createJeigenMatrix(transform(VSMUtil.createSparseMatrixMTJFromJeigen(PhiTPhi)));
    PhiTPsi =
        VSMUtil.createJeigenMatrix(transform(VSMUtil.createSparseMatrixMTJFromJeigen(PhiTPsi)));

    /*
     * Writing the co-variance matrices in a text file to see what's going
     * on
     */
    System.out.println("****Writing the Covarinace Matrices to the file***");
    VSMUtil.writeCovarMatrixSem(PsiTPsi, "NNS");
    VSMUtil.writeCovarMatrixSem(PsiTPhi, "NNS");
    VSMUtil.writeCovarMatrixSem(PhiTPhi, "NNS");
    VSMUtil.writeCovarMatrixSem(PhiTPsi, "NNS");
    System.out.println("***Done***");

    /*
     * Done with the Psi and Phi and freeing up some space
     */
    Psi = null;
    Phi = null;
    System.gc();
    /*
     * Getting the the similarity scoressvd template object that has utility
     * methods to do preprocessing before performing CCA
     */
    SVDTemplates1 svdTC = new SVDTemplates1(null);

    /*
     * Function to compute the CCA, passing the covariance matrices to the
     * function
     */
    computeCCA2(
        MatrixFormatConversion.createSparseMatrixMTJFromJeigen(PsiTPhi),
        MatrixFormatConversion.createSparseMatrixMTJFromJeigen(PhiTPsi),
        MatrixFormatConversion.createSparseMatrixMTJFromJeigen(PhiTPhi),
        MatrixFormatConversion.createSparseMatrixMTJFromJeigen(PsiTPsi),
        svdTC,
        null,
        0,
        50,
        "NNS");

    /*
     * Writing the projection matrices out in a file to see what is in there
     */
    matrices = VSMUtil.deserializeCCAVariantsRunSem("NNS");
    VSMUtil.writeEigenDictInsideSemantic(matrices, "NNS", d);
    VSMUtil.writeEigenDictOutsideSem(matrices, "NNS", dprime);
    matrices = null;
    PsiTPhi = null;
    PhiTPhi = null;
    PsiTPsi = null;
    PhiTPsi = null;
    System.gc();

    /*
     * We would also like to serialize the count map. The count map is the
     * data structure that helps us store the .ser files in proper
     * directories with proper names. So, if in future we want to extract
     * feature vectors corresponding to more parse trees, we will start from
     * where we left in the directory structure and file name
     */

    /*
     * Getting the updated count map
     */
    // countMap = VSMSerializeFeatureVectorBean.getCountMap();
    // /*
    // * The object that will be serialized
    // */
    // VSMCountMap countMapObject = new VSMCountMap();
    // countMapObject.setCountMap(countMap);
    //
    // /*
    // * Serialize count map
    // */
    // VSMSerializeCountMap.serializeCountMap(countMapObject);
    // System.out.println("*****count map serialized****");
  }
  public static void main(String... args) throws Exception {

    System.out.println("+++Compiled New++++");

    nonTerminal = VSMUtil.getNonTerminal(args);

    LOGGER = VSMLogger.setup(FeatureVectors.class.getName() + "." + nonTerminal);

    featureDictionary =
        VSMContant.FEATURE_DICTIONARY + nonTerminal.toLowerCase() + "/dictionary.ser";

    wordDictionaryPath = VSMContant.WORD_DICT;

    LOGGER.info("Reading the Feature Dictionary Object");
    dictionaryBean = ReadSerializedDictionary.readSerializedDictionary(featureDictionary, LOGGER);

    LOGGER.info("Reading the word dictionary object");
    wordDictBean = VSMReadSerialWordDict.readSerializedDictionary(wordDictionaryPath);

    outsideFeatureDictionary = dictionaryBean.getOutsideFeatureDictionary();

    insideFeatureDictionary = dictionaryBean.getInsideFeatureDictionary();

    wordDictionary = wordDictBean.getWordDictionary();

    LOGGER.info(
        "Got the syntactic and semantic feature dictionaries, with word dictionary dimensions: "
            + wordDictionary.size());

    treeReader = VSMUtil.getTreeReader(VSMContant.SICK_TRIAL_TREES);

    LOGGER.info("GOT Training Trees File Iterator: " + treeReader);

    int treeCount = 0;

    while (treeReader.hasNext()) {

      getSynaxTree();

      if (syntaxTree != null) {

        treeCount += 1;

        syntaxTree = treeNormalizer.process(syntaxTree);

        constituentsMap = syntaxTree.getConstituents();

        Iterator<Tree<String>> nodeTrees = syntaxTree.iterator();

        while (nodeTrees.hasNext()) {

          insideTree = nodeTrees.next();

          if (!insideTree.isLeaf() && insideTree.getLabel().equalsIgnoreCase(nonTerminal)) {

            createSparseVectors();

            serializeVectorBean(treeCount);

            System.out.println("Serialized the feature vector***");
          }
        }
      }
    }

    LOGGER.info("Done Creating the Sparse Vectors For the Non Terminal: " + nonTerminal);
  }
  @Test
  public void testFeatureVectorSerialization() throws Exception {

    // VSMFeatureMatrixBean matrixBean = VSMReadSerialMatrix
    // .readFeatureMatrix("/Users/sameerkhurana10/Documents/featurematrix/dictionary.ser");
    VSMDictionaryBean matrixBean =
        VSMReadSerialMatrix.readSerializedDictionary(
            "/Users/sameerkhurana10/Documents/featurematrixtest/dictionary.ser");

    ArrayList<Alphabet> updateFilteredDcitionaryOutside = matrixBean.getOutsideFeatureDictionary();
    ArrayList<Alphabet> updatedFilteredDictionaryInside = matrixBean.getInsideFeatureDictionary();

    /*
     * Getting all the tree files
     */
    // File[] files = new File("/Users/sameerkhurana10/blipp_corpus/trees")
    // .listFiles();
    // File[] files = new File("/Users/sameerkhurana10/blipp_corpus/trees")
    // .listFiles();
    File[] files = new File("/Users/sameerkhurana10/blipp_corpus/testtrees").listFiles();

    /*
     * Getting the iterator over all the trees in the file specified by the
     * URI
     */

    VSMSerializeFeatureVectorBean serializeBean = new VSMSerializeFeatureVectorBean();

    Trees.StandardTreeNormalizer obj = new Trees.StandardTreeNormalizer();
    PTBTreeNormaliser treeNormalizer = new PTBTreeNormaliser(true);
    for (File file : files) {
      PennTreeReader treeReader = VSMUtil.getTreeReader(file.getAbsolutePath());
      /*
       * Iterating over all the trees
       */
      while (treeReader.hasNext()) {
        /*
         * Get the tree
         */
        Tree<String> syntaxTree = null;
        /*
         * Unmatched parentheses exception
         */
        try {
          syntaxTree = treeReader.next();
        } catch (RuntimeException e) {
          System.out.println("exception" + e + " ::tree  " + syntaxTree);
        }
        /*
         * Do stuff only if the syntax tree is a valid one
         */
        if (syntaxTree != null) {

          /*
           * Processed syntax tree
           */
          syntaxTree = treeNormalizer.process(syntaxTree);

          Map<Tree<String>, Constituent<String>> constituentsMap = syntaxTree.getConstituents();
          /*
           * Iterator over the nodes of the tree
           */
          Iterator<Tree<String>> nodeTrees = syntaxTree.iterator();
          /*
           * Iterating over all the nodes
           */
          // double[] psi = null;
          // double[] phi = null;
          no.uib.cipr.matrix.sparse.SparseVector psi = null;
          no.uib.cipr.matrix.sparse.SparseVector phi = null;
          Tree<String> insideTree = null;
          while (nodeTrees.hasNext()) {
            /*
             * This is the inside tree for which we want to form a
             * feature vector and store it in the map
             */
            insideTree = nodeTrees.next();
            System.out.println("****Serializing for node  " + insideTree.getLabel());
            /*
             * Setting some static variables for the particular node
             * feature
             */
            VSMUtil.setConstituentLength(constituentsMap.get(insideTree));
            VSMUtil.getNumberOfOutsideWordsLeft(insideTree, constituentsMap, syntaxTree);
            VSMUtil.getNumberOfOutsideWordsRight(insideTree, constituentsMap, syntaxTree);

            /*
             * Creating the footoroot path for outside feature
             * extraction
             */
            Stack<Tree<String>> foottoroot = new Stack<Tree<String>>();
            foottoroot =
                VSMUtil.updateFoottorootPath(foottoroot, syntaxTree, insideTree, constituentsMap);

            /*
             * Only do stuff if inside tree is not a leaf
             */
            if (!insideTree.isLeaf()) {

              /*
               * Setting the object's properties that are stored
               * in the .ser file
               */
              VSMFeatureVectorBean vectorBean = new VSMFeatureVectorBean();

              // System.out.println(":::::::" + insideTree);
              /*
               * Getting the inside feature vector phi
               */
              psi =
                  new VSMOutsideFeatureVector()
                      .getOutsideFeatureVectorPsi(
                          foottoroot, updateFilteredDcitionaryOutside, vectorBean);
              System.out.println("got the outside feature vector** " + psi);
              phi =
                  new VSMInsideFeatureVector()
                      .getInsideFeatureVectorPhi(
                          insideTree, updatedFilteredDictionaryInside, vectorBean);
              System.out.println("got the outside feature vector*** " + phi);

              /*
               * THe inside feature vector //
               */
              vectorBean.setPhi(phi);
              /*
               * // * The outside feature vector //
               */
              vectorBean.setPsi(psi);
              // /*
              // * The inside tree from which the inside feature
              // vector
              // * is extracted
              // */
              vectorBean.setInsideTree(insideTree);
              // /*
              // * The label of the node for which the inside and
              // * outside feature vectors are extracted
              // */
              vectorBean.setLabel(insideTree.getLabel());
              // /*
              // * The tree from which the inside and outside
              // feature
              // * vectors are extracted
              // */
              vectorBean.setSyntaxTree(syntaxTree);
              // /*
              // * Setting the outside constituent trees from
              // which
              // the
              // * outside feature vector is extracted
              // */
              vectorBean.setFootToRoot(foottoroot);
              // /*
              // * Read the count map from the file, if it not
              // null
              // then
              // * call the other constructor, otherwise call the
              // empty
              // * constructor
              // */
              // // String fileURI =
              // //
              // "/Users/sameerkhurana10/Documents/serialization/countMap.ser";
              // // File file = new File(fileURI);
              // // if (!file.exists()) {
              // // VSMSerializeFeatureVectorBean serializeBean =
              // new
              // // VSMSerializeFeatureVectorBean();
              // // serializeBean.serializePhiBean(vectorBean);
              // // System.out.println("****does not exist***");
              // // } else {
              // // LinkedHashMap<String, Integer> countMap =
              // // VSMReadSerialCountMap
              // // .readCountMapObj(fileURI).getCountMap();
              // // VSMSerializeFeatureVectorBean serializeBean =
              // new
              // // VSMSerializeFeatureVectorBean(
              // // countMap);
              System.out.println("****heer here****" + vectorBean.getInsideFeatureVectorDim());
              System.out.println(vectorBean.getInsideTreeFeatureList());
              serializeBean.serializeVectorBean(vectorBean);
              System.out.println("****heer here****" + vectorBean.getInsideFeatureVectorDim());
              System.out.println(vectorBean.getInsideTreeFeatureList());
              System.out.println("Serialized the feature vector***");
              // // }
              //
              // //
              // outsideFeatureMatrix.put(insideTree.getLabel(),
              // psi);
              // }
              // }
              // }
              // }
              //

            }
          }
        }
      }
    }

    // /*
    // * Serialize the count map
    // */
    LinkedHashMap<String, Integer> countMap = VSMSerializeFeatureVectorBean.getCountMap();
    // /*
    // * The object that will be serialized
    // */
    VSMCountMap countMapObject = new VSMCountMap();
    countMapObject.setCountMap(countMap);
    // /*
    // * Serialize count Map
    // */
    VSMSerializeCountMap.serializeCountMap(countMapObject);
    System.out.println("count map serialized");
    // /*
    // * Test the serialized object, read the object
    // */
    LinkedHashMap<String, Integer> countMapRetireved =
        VSMReadSerialCountMap.readCountMapObj(
                "/Users/sameerkhurana10/Documents/serialization/countMap.ser")
            .getCountMap();
    System.out.println(countMapRetireved);
  }