pos[index++] = tokenAnnotation.getFeatureValueAsString( mPosFeature);
private String getFeatureValueCovering(CAS aCas, AnnotationFS aToken, Type aType, Feature aFeature) { List<AnnotationFS> annotations = CasUtil.selectCovered(aType, aToken); if (annotations.isEmpty()) { return PAD; } String value = annotations.get(0).getFeatureValueAsString(aFeature); return isNoneBlank(value) ? value : PAD; }
private void processChunk(CAS tcas, AnnotationFS chunk) { String chunkTag = chunk.getFeatureValueAsString(mChunkTagFeature); FSIndex<AnnotationFS> tokenIndex = tcas.getAnnotationIndex(mTokenType); ContainingConstraint containingConstraint = new ContainingConstraint(chunk); Iterator<AnnotationFS> tokenIterator = tcas.createFilteredIterator(tokenIndex.iterator(), containingConstraint); List<String> tokens = new ArrayList<String>(); List<String> tags = new ArrayList<String>();; List<String> chunkTags = new ArrayList<String>();; while (tokenIterator.hasNext()) { AnnotationFS tokenAnnotation = tokenIterator.next(); tokens.add(tokenAnnotation.getCoveredText().trim()); tags.add(tokenAnnotation.getFeatureValueAsString(mPOSFeature)); chunkTags.add(chunkTag); } mChunkSamples.add(new ChunkSample(tokens, tags, chunkTags)); }
private void process(CAS tcas, AnnotationFS sentence) { FSIndex<AnnotationFS> allTokens = tcas.getAnnotationIndex(mTokenType); ContainingConstraint containingConstraint = new ContainingConstraint(sentence); List<String> tokens = new ArrayList<String>(); List<String> tags = new ArrayList<String>(); Iterator<AnnotationFS> containingTokens = tcas.createFilteredIterator( allTokens.iterator(), containingConstraint); while (containingTokens.hasNext()) { AnnotationFS tokenAnnotation = (AnnotationFS) containingTokens.next(); String tag = tokenAnnotation.getFeatureValueAsString(mPOSFeature); tokens.add(tokenAnnotation.getCoveredText().trim()); tags.add(tag); } mPOSSamples.add(new POSSample(tokens, tags)); }
/** * Construct the label text used in the brat user interface. */ public static String getBratLabelText(TypeAdapter aAdapter, AnnotationFS aFs, List<AnnotationFeature> aFeatures) { StringBuilder bratLabelText = new StringBuilder(); for (AnnotationFeature feature : aFeatures) { if (!(feature.isEnabled()) && !(feature.isVisible())) { continue; } Feature labelFeature = aFs.getType().getFeatureByBaseName(feature.getName()); if (bratLabelText.length() > 0) { bratLabelText.append(TypeAdapter.FEATURE_SEPARATOR); } bratLabelText.append(StringUtils.defaultString(aFs .getFeatureValueAsString(labelFeature))); } if (bratLabelText.length() > 0) { return bratLabelText.toString(); } else { // If there are no label features at all, then use the layer UI name return "(" + aAdapter.getLayer().getUiName() + ")"; } }
private List<Annotation> extractAnnotations(List<CAS> aCasses) { List<Annotation> annotations = new ArrayList<>(); for (CAS cas : aCasses) { Type annotationType = CasUtil.getType(cas, layerName); Feature labelFeature = annotationType.getFeatureByBaseName(featureName); for (AnnotationFS ann : CasUtil.select(cas, annotationType)) { String label = ann.getFeatureValueAsString(labelFeature); annotations.add(new Annotation(label, ann.getBegin(), ann.getEnd())); } } return annotations; } // end::extractAnnotations[]
private static List<String> getAnnotation(TypeAdapter aAdapter, Sentence aSentence, AnnotationFeature aFeature) { CAS cas = aSentence.getCAS(); Type type = getType(cas, aAdapter.getAnnotationTypeName()); List<String> annotations = new ArrayList<>(); for (Token token : selectCovered(Token.class, aSentence)) { List<AnnotationFS> tokenLevelAnnotations = selectCovered(type, token); if (tokenLevelAnnotations.size() > 0) { AnnotationFS anno = tokenLevelAnnotations.get(0); Feature labelFeature = anno.getType().getFeatureByBaseName(aFeature.getName()); annotations.add(anno.getFeatureValueAsString(labelFeature)); } else { annotations.add(NILL); } } return annotations; } }
private static List<String> getAnnotation(TypeAdapter aAdapter, Sentence aSentence, AnnotationFeature aFeature) { CAS cas = aSentence.getCAS(); Type type = getType(cas, aAdapter.getAnnotationTypeName()); List<String> annotations = new ArrayList<>(); for (Token token : selectCovered(Token.class, aSentence)) { List<AnnotationFS> tokenLevelAnnotations = selectCovered(type, token); if (tokenLevelAnnotations.size() > 0) { AnnotationFS anno = tokenLevelAnnotations.get(0); Feature labelFeature = anno.getType().getFeatureByBaseName(aFeature.getName()); annotations.add(anno.getFeatureValueAsString(labelFeature)); } else { annotations.add(NILL); } } return annotations; } }
private Optional<AnnotationFS> getMatchingAnnotation(CAS aCas, LearningRecord aRecord) { Type type = CasUtil.getType(aCas, alStateModel.getObject().getLayer().getName()); Feature feature = type.getFeatureByBaseName(aRecord.getAnnotationFeature().getName()); return selectAt(aCas, type, aRecord.getOffsetCharacterBegin(), aRecord.getOffsetCharacterEnd()).stream() .filter(fs -> aRecord.getAnnotation().equals(fs.getFeatureValueAsString(feature))) .findFirst(); }
private Optional<AnnotationFS> getMatchingAnnotation(CAS aCas, LearningRecord aRecord) { Type type = CasUtil.getType(aCas, alStateModel.getObject().getLayer().getName()); Feature feature = type.getFeatureByBaseName(aRecord.getAnnotationFeature().getName()); return selectAt(aCas, type, aRecord.getOffsetCharacterBegin(), aRecord.getOffsetCharacterEnd()).stream() .filter(fs -> aRecord.getAnnotation().equals(fs.getFeatureValueAsString(feature))) .findFirst(); }
public void process(JCas jCas) { CAS cas = jCas.getCas(); Type type = CasUtil.getAnnotationType(cas, typeName); Iterator<AnnotationFS> iter = CasUtil.iterator(cas, type); AnnotationFS anno = null; int i = 0; while (iter.hasNext() && i <= ind) { anno = iter.next(); } pass = true; if (anno == null) pass = false; Feature fObj = type.getFeatureByBaseName(featureName); if (fObj == null) pass = false; else { String value = anno.getFeatureValueAsString(fObj); if (!value.equals(featureValue)) pass = false; } if (begin > -1 && end > -1) { if (anno.getBegin() != begin || anno.getEnd() != end) pass = false; } } }
@Override public List<String> getAnnotation(JCas aJcas, AnnotationFeature aFeature, int begin, int end) { Type type = getType(aJcas.getCas(), getAnnotationTypeName()); List<String> annotations = new ArrayList<String>(); for (AnnotationFS fs : selectCovered(aJcas.getCas(), type, begin, end)) { Feature labelFeature = fs.getType().getFeatureByBaseName(aFeature.getName()); annotations.add(fs.getFeatureValueAsString(labelFeature)); } return annotations; }
/** * @param cas * @param type * @param feature * @return feature value of the first annotation of given type from given * CAS. E.g., it is useful to get document metadata values. If there * is no such annotation method will return null. */ public static String getStringValue(CAS cas, Type type, Feature feature) { AnnotationIndex<AnnotationFS> metaIdx = cas.getAnnotationIndex(type); if (metaIdx.size() > 0) { AnnotationFS meta = metaIdx.iterator().next(); return meta.getFeatureValueAsString(feature); } else { return null; } }
public static Map<Integer, String> getMultipleAnnotation( AnnotationSchemaService aAnnotationService, Sentence sentence, AnnotationFeature aFeature) throws CASException { SpanAdapter adapter = (SpanAdapter) aAnnotationService.getAdapter(aFeature.getLayer()); Map<Integer, String> multAnno = new HashMap<>(); Type type = getType(sentence.getCAS(), adapter.getAnnotationTypeName()); for (AnnotationFS fs : selectCovered(type, sentence)) { boolean isBegin = true; Feature labelFeature = fs.getType().getFeatureByBaseName(aFeature.getName()); for (Token token : selectCovered(Token.class, fs)) { if (multAnno.get(getAddr(token)) == null) { if (isBegin) { multAnno.put(getAddr(token), "B-" + fs.getFeatureValueAsString(labelFeature)); isBegin = false; } else { multAnno.put(getAddr(token), "I-" + fs.getFeatureValueAsString(labelFeature)); } } } } return multAnno; }
public Map<Integer, String> getMultipleAnnotation(Sentence sentence, AnnotationFeature aFeature) throws CASException { Map<Integer, String> multAnno = new HashMap<Integer, String>(); Type type = getType(sentence.getCAS(), getAnnotationTypeName()); for (AnnotationFS fs : selectCovered(sentence.getCAS(), type, sentence.getBegin(), sentence.getEnd())) { boolean isBegin = true; Feature labelFeature = fs.getType().getFeatureByBaseName(aFeature.getName()); for (Token token : selectCovered(sentence.getCAS().getJCas(), Token.class, fs.getBegin(), fs.getEnd())) { if (multAnno.get(token.getAddress()) == null) { if (isBegin) { multAnno.put(token.getAddress(), "B-" + fs.getFeatureValueAsString(labelFeature)); isBegin = false; } else { multAnno.put(token.getAddress(), "I-" + fs.getFeatureValueAsString(labelFeature)); } } } } return multAnno; }
@Override public void train(RecommenderContext aContext, List<CAS> aCasses) { Trie<DictEntry> dict = new Trie<>(); for (CAS cas : aCasses) { Type annotationType = getType(cas, layerName); Feature labelFeature = annotationType.getFeatureByBaseName(featureName); for (AnnotationFS ann : select(cas, annotationType)) { learn(dict, ann.getCoveredText(), ann.getFeatureValueAsString(labelFeature)); } } aContext.put(KEY_MODEL, dict); aContext.markAsReadyForPrediction(); log.debug("Learned dictionary model with {} entries", dict.size()); }
@Override public void train(RecommenderContext aContext, List<CAS> aCasses) { Trie<DictEntry> dict = new Trie<>(); for (CAS cas : aCasses) { Type annotationType = getType(cas, layerName); Feature labelFeature = annotationType.getFeatureByBaseName(featureName); for (AnnotationFS ann : select(cas, annotationType)) { learn(dict, ann.getCoveredText(), ann.getFeatureValueAsString(labelFeature)); } } aContext.put(KEY_MODEL, dict); aContext.markAsReadyForPrediction(); log.debug("Learned dictionary model with {} entries", dict.size()); }
@Override public void delete(JCas aJCas, AnnotationFeature aFeature, int aBegin, int aEnd, String aValue) { Type type = CasUtil.getType(aJCas.getCas(), getAnnotationTypeName()); Feature feature = type.getFeatureByBaseName(aFeature.getName()); for (AnnotationFS fs : CasUtil.selectCovered(aJCas.getCas(), type, aBegin, aEnd)) { if (fs.getBegin() == aBegin && fs.getEnd() == aEnd) { if (fs.getFeatureValueAsString(feature).equals(aValue)) { delete(aJCas, ((FeatureStructureImpl) fs).getAddress()); } } } }
private void copyFeatures(AnnotationFS oldFS, FeatureStructure newFS, CAS cas) { List<?> features = oldFS.getType().getFeatures(); Type newType = newFS.getType(); for (Object object : features) { Feature feature = (Feature) object; String shortName = feature.getShortName(); Feature newFeature = newType.getFeatureByBaseName(shortName); if (newFeature != null) { if (feature.getRange().isPrimitive()) { String value = oldFS.getFeatureValueAsString(feature); newFS.setFeatureValueFromString(newFeature, value); } else { FeatureStructure value = oldFS.getFeatureValue(feature); newFS.setFeatureValue(newFeature, value); } } } }
private void copyFeatures(AnnotationFS oldFS, FeatureStructure newFS, CAS cas) { List<?> features = oldFS.getType().getFeatures(); Type newType = newFS.getType(); for (Object object : features) { Feature feature = (Feature) object; String shortName = feature.getShortName(); Feature newFeature = newType.getFeatureByBaseName(shortName); if (newFeature != null) { if (feature.getRange().isPrimitive()) { String value = oldFS.getFeatureValueAsString(newFeature); newFS.setFeatureValueFromString(newFeature, value); } else { FeatureStructure value = oldFS.getFeatureValue(feature); newFS.setFeatureValue(newFeature, value); } } } }