sentencetotree.java

无监督的句法学习系统

                    newTree=baseService.widthSearch2(aTreatNode);
                    break;
                }

            }
             if(newTree.getLeftNode()!=null||newTree.getRightNode()!=null)
              allTreatNode.add(newTree);
        }
        this.setTreatNodeList(allTreatNode);
        return allTreatNode;
    }
   public List<PreTreatSentence> getTestSentence(String fileName) throws IOException {
        PreTreatText preTreatText=preTreatService.readTrainingText(fileName);
        List<PreTreatSentence> preTreatSentenceList=preTreatText.getPreTreatText();
       List<PreTreatSentence> rightPreTreatSentenceList=new ArrayList<PreTreatSentence>();
        List<TreatNode> allTreatNode=new  ArrayList<TreatNode>();
        int index=0;
        for(int i=0;i<preTreatSentenceList.size();i++){
            PreTreatSentence sentence=preTreatSentenceList.get(i);
            List<PreTreatNode>  nodeList=sentence.getPreTreatNodeList();
            SentenceCell sentenceCell=getOneTree(nodeList);
            List<NodesCell> cellList=sentenceCell.getCellList();
            TreatNode aTreatNode=new TreatNode();
            TreatNode newTree=new TreatNode();
            for(int j=0;j<cellList.size();j++){
                NodesCell aNodesCell=cellList.get(j);
                if(aNodesCell.getNodeList().size()>0){
                    aTreatNode=aNodesCell.getNodeList().get(0);
                    if(aTreatNode.getLeftNode()==null&&aTreatNode.getRightNode()==null)
                           System.out.println(index++);
                    newTree=baseService.widthSearch2(aTreatNode);
                    break;
                }
            }
             if(newTree.getLeftNode()!=null||newTree.getRightNode()!=null){
                rightPreTreatSentenceList.add(sentence);
             }
        }
        return rightPreTreatSentenceList;
    } */
    public List<TreatNode> getOneTree( List<PreTreatNode>  nodeList){
          List<TreatNode> initNodeList=new ArrayList<TreatNode>();
          for(int i=0;i<nodeList.size();i++){
              TreatNode treatNode=new  TreatNode();
              treatNode.setState("^");
              treatNode.setLeftNode(null);
              treatNode.setRightNode(null);
              treatNode.setPreTreatNode(nodeList.get(i));
              treatNode.setTreatNodeLenghth(1);
              initNodeList.add(treatNode);
            }
         List<SentenceCell> sentenceList=new ArrayList<SentenceCell>();
          SentenceCell sentenceCell=new SentenceCell();
          sentenceCell.setWordLong(1);
          List<NodesCell>  nodesCellList=new ArrayList();
          for(int i=0;i<initNodeList.size();i++){
              NodesCell nodesCell=new NodesCell();
              List<TreatNode> oneWordnodeList=new ArrayList<TreatNode>();
              TreatNode newTreatNode=treatService.makeNodeUseOneNode(initNodeList.get(i),1);
              oneWordnodeList=this.addList(oneWordnodeList,newTreatNode,1);
              if(oneWordnodeList!=null){
              nodesCell.setNodeList(oneWordnodeList);
              nodesCell.setCellNumber(1);
              nodesCellList.add(nodesCell);
              }
          }
         sentenceCell.setCellList(nodesCellList);
         sentenceList.add(sentenceCell);
         SentenceCell oldSentenceCell=new SentenceCell();
         for(int i=2;i<=initNodeList.size();i++){
              SentenceCell newSentenceCell=new SentenceCell();
              newSentenceCell.setWordLong(i);
              List<int[]> spiltlength=baseService.split(i);
              List<NodesCell> nowNodesCellList=new ArrayList<NodesCell>();
             
             for(int j=0;j<spiltlength.size();j++){
                 int[] spilt=spiltlength.get(j);
                 int index=0;
                 while(index<nodeList.size()){
                     List<PreTreatNode> priorListLog=new ArrayList<PreTreatNode>();
                     List<PreTreatNode> rearListLog=new ArrayList<PreTreatNode>();
                     int v=index;
                     if(index+spilt[0]<=nodeList.size()&&index+i<=nodeList.size()){
                     for(;v<index+spilt[0];v++)
                        priorListLog.add(nodeList.get(v));                   
                     for(;v<index+i;v++)
                        rearListLog.add(nodeList.get(v));
                     NodesCell priorList=this.getListNodeByNeighbour(sentenceList,spilt[0],priorListLog);
                     NodesCell rearList=this.getListNodeByNeighbour(sentenceList,spilt[1],rearListLog);
                     if(priorList!=null&&rearList!=null){
                         NodesCell makeOne= this.getMergeNodes(priorList,rearList,i,initNodeList.size(),spilt[0],spilt[1],i,nodeList);
                       makeOne.setCellNumber(i);
                     if(makeOne.getNodeList().size()>0)
                      nowNodesCellList.add(makeOne);
                     }
                     }
                     index=index+1;
                 }
              //   List<NodesCell> priorList= this.getListNodes(sentenceList,spilt[0]);
             //    List<NodesCell> rearList= this.getListNodes(sentenceList,spilt[1]);

                  /*for(int n=0;n<initNodeList.size();n++){
                      if(n+i<=initNodeList.size()){
                        if(n<priorList.size()){
                      NodesCell priorNodes=priorList.get(n);
                      if((n+priorNodes.getCellNumber())<rearList.size()){
                      NodesCell rearNodes=rearList.get(n+priorNodes.getCellNumber());
                       NodesCell priorNodes1=(NodesCell)priorNodes.clone();
                      NodesCell priorNodes2=(NodesCell)rearNodes.clone();
                      NodesCell makeOne= this.getMergeNodes(priorNodes1,priorNodes2,i,initNodeList.size(),spilt[0],spilt[1],i,nodeList);
                       makeOne.setCellNumber(i);
                    //  if(makeOne.getNodeList().size()>0)
                      nowNodesCellList.add(makeOne);
                       }
                      }
                      }
                 } */
             }

             newSentenceCell.setCellList(nowNodesCellList);
             sentenceList.add(newSentenceCell);
         }
        SentenceCell lastSenCell=sentenceList.get(sentenceList.size()-1);
        List<NodesCell> lasCellList=new ArrayList<NodesCell>();
        List<TreatNode> lastTreatNodeList=new ArrayList<TreatNode>();
        for(int i=0;i<lastSenCell.getCellList().size();i++){
             NodesCell nodesCell=lastSenCell.getCellList().get(i);
             List<TreatNode> oneTreatNode=nodesCell.getNodeList();
             for(int j=0;j<oneTreatNode.size();j++)
                 lastTreatNodeList.add(oneTreatNode.get(j));
        }
        return  lastTreatNodeList;
       // return sentenceList.get(sentenceList.size()-1);
    }

    public NodesCell getListNodeByNeighbour(List<SentenceCell> sentenceList,int length,List<PreTreatNode> priorListLog){
         List<NodesCell> cellList= this.getListNodes( sentenceList,length);
        for(int i=0;i<cellList.size();i++){
            NodesCell cell=cellList.get(i);
            List<TreatNode> treatNodeList=cell.getNodeList();
            for(int j=0;j<treatNodeList.size();j++){
                TreatNode one=treatNodeList.get(j);
                List<PreTreatNode> listNode=one.getContainNodes();
                boolean isOk=true;
                for(int v=0;v<priorListLog.size();v++){
                    if(!listNode.contains(priorListLog.get(v))){
                        isOk=false;
                        break;
                    }
                }
                if(isOk==true)
                  return cell;
            }
        }
        return null;
    }
    public NodesCell getMergeNodes(NodesCell one,NodesCell two,int nowLength,int length,int prior,int rear,int wordLength,List<PreTreatNode>  nodeList){
        List<TreatNode> newNodeslist=new  ArrayList<TreatNode>();
        Set<TreatNode> oldNodeslist=new HashSet<TreatNode>();
        List<TreatNode> priortreatNodeList=one.getNodeList();
        List<TreatNode> rearTreatNodeList=two.getNodeList();
        for(int i=0;i<one.getNodeList().size();i++){
            for(int j=0;j<two.getNodeList().size();j++){
                TreatNode aNode=(TreatNode)priortreatNodeList.get(i).clone();
                TreatNode bNode=(TreatNode)rearTreatNodeList.get(j).clone();
             //  if(isNeigbour(aNode,bNode,nodeList)==true){
                TreatNode newTreatNode=null;
                 if(aNode.getState().equals(">")&&bNode.getState().equals("~")){
               // if(bNode.getPreTreatNode().getParentNode()==aNode.getPreTreatNode()&&aNode.getState().equals(">")&&bNode.getState().equals("~")){
                      newTreatNode=treatService.makeNode(aNode,bNode,wordLength);
                }
                else if(bNode.getState().equals("<>")&&aNode.getState().equals("~")){
               // else if(aNode.getPreTreatNode().getParentNode()==bNode.getPreTreatNode()&&bNode.getState().equals("<>")&&aNode.getState().equals("~")){
                      newTreatNode=treatService.makeNode(aNode,bNode,wordLength);
                }
              /* if(bNode.getState().equals(">")&&aNode.getState().equals("~")){
                   newTreatNode=treatService.makeNode(bNode,aNode,wordLength);
                }
                else if(aNode.getState().equals("<>")&&bNode.getState().equals("~")){
                   newTreatNode=treatService.makeNode(bNode,aNode,wordLength);
                } */
                if(newTreatNode!=null){
                    oldNodeslist.add(newTreatNode);                  
                }
               /* if(prior==rear){
                   TreatNode newTreatNode2=treatService.makeNode(bNode,aNode);
                    if(newTreatNode2!=null){
                    oldNodeslist.add(newTreatNode2);
                }
                }*/
              //  }
            }
        }
        List<TreatNode> tempTreatNodeList=new  ArrayList<TreatNode>();
        Iterator<TreatNode> iter=oldNodeslist.iterator();
         for(int i=0;i<oldNodeslist.size();i++){
             TreatNode root=iter.next();
             tempTreatNodeList.add(root);
         }
        if(nowLength<length){
        for(int j=0;j<tempTreatNodeList.size();j++)
            newNodeslist=this.addList(newNodeslist,tempTreatNodeList.get(j),wordLength);
        }
        else{
            for(int j=0;j<tempTreatNodeList.size();j++)
             newNodeslist=this.addOneNode(newNodeslist,tempTreatNodeList.get(j),wordLength);
        }
        NodesCell newNodesCell=new NodesCell();
        newNodesCell.setNodeList(newNodeslist);
        return newNodesCell;
    }
    public List<NodesCell> getListNodes( List<SentenceCell> sentenceList,int length){
        List<NodesCell>  listAll=new ArrayList<NodesCell>();
        for(int i=0;i<sentenceList.size();i++){
             SentenceCell aSentenceCell=sentenceList.get(i);
             if(aSentenceCell.getWordLong()==length){
               return  aSentenceCell.getCellList();
             }
        }
        return listAll;
    }
    public List<TreatNode> addList(List<TreatNode> nowList,TreatNode nowNode,int length){
         nowList.add(nowNode); 
         TreatNode treatNode=treatService.makeNodeUseOneNode(nowNode,length);
         if(treatNode!=null){
             nowList.add(treatNode);
             TreatNode treatNode2=treatService.makeNodeUseOneNode(treatNode,length);
             if(treatNode2!=null){
                 nowList.add(treatNode2);
                  TreatNode treatNode3=treatService.makeNodeUseOneNode(treatNode2,length);
                 if(treatNode3==null)
                   return nowList;
                 else
                   return null;
             }
             else
                 return nowList;
         }
          return nowList;
    }
    public List<TreatNode> addOneNode(List<TreatNode> nowList,TreatNode nowNode,int length){
       //  nowList.add(nowNode);
         TreatNode treatNode=treatService.makeNodeUseOneNode(nowNode,length);
         if(treatNode!=null){
            // nowList.add(treatNode);
             TreatNode treatNode2=treatService.makeNodeUseOneNode(treatNode,length);
             if(treatNode2!=null){
                 nowList.add(treatNode2);
                  TreatNode treatNode3=treatService.makeNodeUseOneNode(treatNode2,length);
                 if(treatNode3==null)
                   return nowList;
                 else
                   return null;
             }
             else{
                 nowList.add(treatNode);
                 return nowList;
             }
         }
          return nowList;
    }


    public int getSentenceNumber() {
        return sentenceNumber;
    }

    public void setSentenceNumber(int sentenceNumber) {
        this.sentenceNumber = sentenceNumber;
    }

    public List<PreTreatSentence> getPreTreatSenList() {
        return preTreatSenList;
    }

    public void setPreTreatSenList(List<PreTreatSentence> preTreatSenList) {
        this.preTreatSenList = preTreatSenList;
    }

    public List<TreatNode> getTreatNodeList() {
        return treatNodeList;
    }

    public void setTreatNodeList(List<TreatNode> treatNodeList) {
        this.treatNodeList = treatNodeList;
    }

    public List<RuleScore> getRuleScoreList() {
        return ruleScoreList;
    }

    public void setRuleScoreList(List<RuleScore> ruleScoreList) {
        this.ruleScoreList = ruleScoreList;
    }
}