Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.apache.ctakes.temporal.eval;
  
  import java.io.File;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 import  org.cleartk.eval.AnnotationStatistics;
 import  org.cleartk.ml.jar.JarClassifierBuilder;
 import  org.cleartk.ml.liblinear.LibLinearStringOutcomeDataWriter;
 import  org.cleartk.ml.tksvmlight.model.CompositeKernel.ComboOperator;
 import  org.cleartk.util.ViewUriUtil;
 
 
  
   static interface CoreferenceOptions extends TempRelOptions{
     @Option
     public String getOutputDirectory();
     
     @Option
     public boolean getUseTmp();
     
   }
   
   public static float COREF_DOWNSAMPLE = 0.5f;
       1.0, 1.0, "linear", ComboOperator.SUM, 0.1, 0.5);  // (0.3, 0.4 for tklibsvm)
 
   public static void main(String[] argsthrows Exception {
     CoreferenceOptions options = CliFactory.parseArguments(CoreferenceOptions.classargs);
 
     List<IntegerpatientSets = options.getPatients().getList();
     List<IntegertrainItems = getTrainItems(options);
     List<IntegertestItems = getTestItems(options);
 
     ParameterSettings params = ;
     File workingDir = new File("target/eval/temporal-relations/coreference");
     if(!workingDir.exists()) workingDir.mkdirs();
     if(options.getUseTmp()){
       File tempModelDir = File.createTempFile("temporal"nullworkingDir);
       tempModelDir.delete();
       tempModelDir.mkdir();
      workingDir = tempModelDir;
    }
        workingDir,
        options.getRawTextDirectory(),
        options.getXMLDirectory(),
        options.getXMLFormat(),
        options.getXMIDirectory(),
        options.getTreebankDirectory(),
        options.getCoreferenceDirectory(),
        options.getPrintErrors(),
        options.getPrintFormattedRelations(),
        params,
        options.getKernelParams(),
        options.getOutputDirectory());
    eval.prepareXMIsFor(patientSets);
    params.stats = eval.trainAndTest(trainItemstestItems);//training);//
    //      System.err.println(options.getKernelParams() == null ? params : options.getKernelParams());
    ..println(params.stats);
    if(options.getUseTmp()){
      FileUtils.deleteRecursive(workingDir);
    }
  }
  
  private String outputDirectory;
  
  public EvaluationOfEventCoreference(File baseDirectory,
      File rawTextDirectoryFile xmlDirectory,
      File xmiDirectoryFile treebankDirectoryFile coreferenceDirectoryboolean printErrors,
      boolean printRelationsParameterSettings paramsString cmdParamsString outputDirectory) {
    super(baseDirectoryrawTextDirectoryxmlDirectoryxmlFormatxmiDirectory,
        treebankDirectorycoreferenceDirectoryprintErrorsprintRelationsparams);
    this. = outputDirectory;
    this. = cmdParams == null ? null : cmdParams.split(" ");
  }
  protected void train(CollectionReader collectionReaderFile directory)
      throws Exception {
    AggregateBuilder aggregateBuilder = this.getPreprocessorAggregateBuilder();
    aggregateBuilder.add(AnalysisEngineFactory.createEngineDescription(DocumentIDPrinter.class));
    aggregateBuilder.add(AnalysisEngineFactory.createEngineDescription(ParagraphAnnotator.class));
    aggregateBuilder.add(AnalysisEngineFactory.createEngineDescription(ParagraphVectorAnnotator.class));
    aggregateBuilder.add(CopyFromGold.getDescription(Markable.classCoreferenceRelation.classCollectionTextRelation.class));
    aggregateBuilder.add(EventCoreferenceAnnotator.createDataWriterDescription(
//        TKSVMlightStringOutcomeDataWriter.class,
        LibLinearStringOutcomeDataWriter.class,
        directory,
        ));
    // create gold chains for writing out which we can then use for our scoring tool
//    aggregateBuilder.add(AnalysisEngineFactory.createEngineDescription(CoreferenceChainScoringOutput.class,
//        CoreferenceChainScoringOutput.PARAM_OUTPUT_DIR,
//        this.outputDirectory + "train"));
    SimplePipeline.runPipeline(collectionReaderaggregateBuilder.createAggregate());
    String[] optArray;
    if(this. == null){
      ArrayList<StringsvmOptions = new ArrayList<>();
      svmOptions.add("-c"); svmOptions.add(""+.);        // svm cost
      svmOptions.add("-t"); svmOptions.add(""+.); // kernel index 
      svmOptions.add("-d"); svmOptions.add("3");                      // degree parameter for polynomial
      svmOptions.add("-g"); svmOptions.add(""+.);
        svmOptions.add("-S"); svmOptions.add(""+.);   // second kernel index (similar to -t) for composite kernel
        String comboFlag = (. == ComboOperator.SUM ? "+" : . == ComboOperator.PRODUCT ? "*" : . == ComboOperator.TREE_ONLY ? "T" : "V");
        svmOptions.add("-C"); svmOptions.add(comboFlag);
        svmOptions.add("-L"); svmOptions.add(""+.);
        svmOptions.add("-T"); svmOptions.add(""+.);
        svmOptions.add("-N"); svmOptions.add("3");   // normalize trees and features
      }
      optArray = svmOptions.toArray(new String[]{});
    }else{
      optArray = this.;
      for(int i = 0; i < optArray.lengthi+=2){
        optArray[i] = "-" + optArray[i];
      }
    }
    JarClassifierBuilder.trainAndPackage(directoryoptArray);
  }
  protected AnnotationStatistics<Stringtest(
      CollectionReader collectionReaderFile directorythrows Exception {
    AggregateBuilder aggregateBuilder = this.getPreprocessorAggregateBuilder();
    aggregateBuilder.add(AnalysisEngineFactory.createEngineDescription(DocumentIDPrinter.class));
    aggregateBuilder.add(AnalysisEngineFactory.createEngineDescription(ParagraphAnnotator.class));
    aggregateBuilder.add(AnalysisEngineFactory.createEngineDescription(ParagraphVectorAnnotator.class));
    aggregateBuilder.add(CopyFromGold.getDescription(Markable.class));
    aggregateBuilder.add(AnalysisEngineFactory.createEngineDescription(CoreferenceChainScoringOutput.class,
        this. + "gold.chains",
        true));
    aggregateBuilder.add(EventCoreferenceAnnotator.createAnnotatorDescription(directory));
    aggregateBuilder.add(CoreferenceChainAnnotator.createAnnotatorDescription());
    aggregateBuilder.add(AnalysisEngineFactory.createEngineDescription(CoreferenceChainScoringOutput.class,
        this. + "system.chains"));
      public HashableArguments apply(CoreferenceRelation relation) {
        return new HashableArguments(relation);
      }
    };
      public String apply(CoreferenceRelation relation){
        return "Coreference";
      }
    };
    AnnotationStatistics<Stringstats = new AnnotationStatistics<>();
    for(Iterator<JCascasIter =new JCasIterator(collectionReaderaggregateBuilder.createAggregate()); casIter.hasNext();){
      JCas jCas = casIter.next();
      JCas goldView = jCas.getView();
      JCas systemView = jCas.getView(.);
      Collection<CoreferenceRelationgoldRelations = JCasUtil.select(
          goldView,
          CoreferenceRelation.class);
      Collection<CoreferenceRelationsystemRelations = JCasUtil.select(
          systemView,
          CoreferenceRelation.class);
      stats.add(goldRelationssystemRelationsgetSpangetOutcome);
      if(this.){
        Map<HashableArgumentsBinaryTextRelationgoldMap = Maps.newHashMap();
        for (BinaryTextRelation relation : goldRelations) {
          goldMap.put(new HashableArguments(relation), relation);
        }
        Map<HashableArgumentsBinaryTextRelationsystemMap = Maps.newHashMap();
        for (BinaryTextRelation relation : systemRelations) {
          systemMap.put(new HashableArguments(relation), relation);
        }
        Set<HashableArgumentsall = Sets.union(goldMap.keySet(), systemMap.keySet());
        List<HashableArgumentssorted = Lists.newArrayList(all);
        Collections.sort(sorted);
        for (HashableArguments key : sorted) {
          BinaryTextRelation goldRelation = goldMap.get(key);
          BinaryTextRelation systemRelation = systemMap.get(key);
          if (goldRelation == null) {
            ..println("System added: " + formatRelation(systemRelation));
          } else if (systemRelation == null) {
            ..println("System dropped: " + formatRelation(goldRelation));
          } else if (!systemRelation.getCategory().equals(goldRelation.getCategory())) {
            String label = systemRelation.getCategory();
            ..printf("System labeled %s for %s\n"labelformatRelation(goldRelation));
          } else{
            ..println("Nailed it! " + formatRelation(systemRelation));
          }
        }
      }
    }
    return stats;
  }
    public static final String PARAM_OUTPUT_FILENAME = "OutputDirectory";
        name = ,
        mandatory = true,
        description = "Directory to write output"
        )
    private String outputFilename;
    private PrintWriter out = null;
    
    public static final String PARAM_USE_GOLD_CHAINS = "UseGoldChains";
        name = ,
        mandatory = false,
        description = "Whether to use gold chains for writing output"
        )
    private boolean useGoldChains = false;
    
    @Override
    public void initialize(final UimaContext contextthrows ResourceInitializationException{
      super.initialize(context);
      
      try {
         = new PrintWriter();
      } catch (FileNotFoundException e) {
        e.printStackTrace();
        throw new ResourceInitializationException(e);
      }
    }
    
    @Override
    public void process(JCas jCasthrows AnalysisEngineProcessException {
      File filename = new File(ViewUriUtil.getURI(jCas));
      JCas chainsCas = null;
      try {
         chainsCas = jCas.getView() : jCas;
      } catch (CASException e) {
        e.printStackTrace();
        throw new AnalysisEngineProcessException(e);
      }
      int chainNum = 1;
      HashMap<AnnotationIntegerent2chain = new HashMap<>();
      if(..println("Gold chains:");
      else ..println("System chains:");
      for(CollectionTextRelation chain : JCasUtil.select(chainsCasCollectionTextRelation.class)){
        FSList members = chain.getMembers();
        while(members instanceof NonEmptyFSList){
          Annotation mention = (Annotation) ((NonEmptyFSListmembers).getHead();
          ent2chain.put(mentionchainNum);
          members = ((NonEmptyFSList)members).getTail();
          ..print("Mention: " + mention.getCoveredText());
          ..print(" (" + mention.getBegin() + ", " + mention.getEnd() + ")");
          ..print("  ----->    ");
        }
        ..println();
        chainNum++;
      }
      
      .println("#begin document " + filename.getPath());
      List<BaseTokentokens = new ArrayList<>(JCasUtil.select(jCasBaseToken.class));
      Stack<IntegerendStack = new Stack<>();
      for(int i = 0; i < tokens.size(); i++){
        BaseToken token = tokens.get(i);
        List<Markablemarkables = new ArrayList<>(JCasUtil.selectCovering(chainsCasMarkable.classtoken.getBegin(), token.getEnd()));
        List<IntegerstartMention = new ArrayList<>();
        Multiset<IntegerendMention = HashMultiset.create();
        List<IntegerwholeMention = new ArrayList<>();
        
        for(Annotation markable : markables){
          if(ent2chain.containsKey(markable)){
            if(markable.getBegin() == token.getBegin()){
              if(markable.getEnd() == token.getEnd()){
                wholeMention.add(ent2chain.get(markable));
              }else{
                startMention.add(ent2chain.get(markable));
              }
            }else if(markable.getEnd() <= token.getEnd()){
              if(endMention.contains(ent2chain.get(markable))){
                ..println("There is a duplicate element -- should be handled by multiset");
              }
              if(markable.getEnd() < token.getEnd()){
                ..println("There is a markable that ends in the middle of a token!");
              }
              endMention.add(ent2chain.get(markable));
            }
          }
        }
        .print(i+1);
        .print('\t');
        StringBuffer buff = new StringBuffer();
        while(endStack.size() > 0 && endMention.contains(endStack.peek())){
          int ind = endStack.pop();
          buff.append(ind);
          buff.append(')');
          buff.append('|');
          endMention.remove(ind);
        }
        for(int ind : wholeMention){
          buff.append('(');
          buff.append(ind);
          buff.append(')');
          buff.append('|');
        }
        for(int ind : startMention){
          buff.append('(');
          buff.append(ind);
          buff.append('|');
          endStack.push(ind);
        }
//        for(int ind : endMention){
//          buff.append(ind);
//          buff.append(')');
//          buff.append('|');
//        }
        if(buff.length() > 0){
          .println(buff.substring(0,  buff.length()-1));
        }else{
          .println("_");
        }
      }
      .println("#end document " + filename.getPath());
      .println();
    }
  }
  
  public static class AnnotationComparator implements Comparator<Annotation> {
    @Override
    public int compare(Annotation o1Annotation o2) {
      if(o1.getBegin() < o2.getBegin()){
        return -1;
      }else if(o1.getBegin() == o2.getBegin() && o1.getEnd() < o2.getEnd()){
        return -1;
      }else if(o1.getBegin() == o2.getBegin() && o1.getEnd() > o2.getEnd()){
        return 1;
      }else if(o2.getBegin() < o1.getBegin()){
        return 1;
      }else{
        return 0;
      }
    }
  }
  public static class DocumentIDPrinter extends org.apache.uima.fit.component.JCasAnnotator_ImplBase {
    static Logger logger = Logger.getLogger(DocumentIDPrinter.class);
    @Override
    public void process(JCas jCasthrows AnalysisEngineProcessException {
      String docId = DocumentIDAnnotationUtil.getDocumentID(jCas);
      if(docId == null){
        docId = new File(ViewUriUtil.getURI(jCas)).getName();
      }
      .info(String.format("Processing %s\n"docId));
    }
    
  }
  
  public static class ParagraphAnnotator extends org.apache.uima.fit.component.JCasAnnotator_ImplBase {
    @Override
    public void process(JCas jcasthrows AnalysisEngineProcessException {
      List<BaseTokentokens = new ArrayList<>(JCasUtil.select(jcasBaseToken.class));
      BaseToken lastToken = null;
      int parStart = 0;
      
      for(int i = 0; i < tokens.size(); i++){
        BaseToken token = tokens.get(i);
        if(parStart == i && token instanceof NewlineToken){
          // we've just created a pargraph ending but there were multiple newlines -- don't want to start the
          // new paragraph until we are past the newlines -- increment the parStart index and move forward
          parStart++;
        }else if(lastToken != null && token instanceof NewlineToken){
          Paragraph par = new Paragraph(jcastokens.get(parStart).getBegin(), lastToken.getEnd());
          par.addToIndexes();
          parStart = i+1;
        }
        lastToken = token;
      }
      
    }
    
  }
  
    WordEmbeddings words = null;
    @Override
    public void initialize(final UimaContext contextthrows ResourceInitializationException{
      try {
         = WordVectorReader.getEmbeddings(FileLocator.getAsStream("org/apache/ctakes/coreference/distsem/mimic_vectors.txt"));
      } catch (IOException e) {
        e.printStackTrace();
        throw new ResourceInitializationException(e);
      }
    }
    
    @Override
    public void process(JCas jcasthrows AnalysisEngineProcessException {
      List<Paragraphpars = new ArrayList<>(JCasUtil.select(jcasParagraph.class));
      FSArray parVecs = new FSArray(jcaspars.size());
      for(int parNum = 0; parNum < pars.size(); parNum++){
        Paragraph par = pars.get(parNum);
        float[] parVec = new float[.getDimensionality()];
        List<BaseTokentokens = JCasUtil.selectCovered(BaseToken.classpar);
        for(int i = 0; i < tokens.size(); i++){
          BaseToken token = tokens.get(i);
          if(token instanceof WordToken){
            String word = token.getCoveredText().toLowerCase();
            if(.containsKey(word)){
              WordVector wv = .getVector(word);
              for(int j = 0; j < parVec.lengthj++){
                parVec[j] += wv.getValue(j);
              }
            }          
          }
        }
        normalize(parVec);
        FloatArray vec = new FloatArray(jcas.getDimensionality());
        vec.copyFromArray(parVec, 0, 0, parVec.length);
        vec.addToIndexes();
        parVecs.set(parNumvec);
      }
      parVecs.addToIndexes();
    }
    private static final void normalize(float[] vec) {
      double sum = 0.0;
      for(int i = 0; i < vec.lengthi++){
        sum += (vec[i]*vec[i]);
      }
      sum = Math.sqrt(sum);
      for(int i = 0; i < vec.lengthi++){
        vec[i] /= sum;
      }
    }
  }
New to GrepCode? Check out our FAQ X