Hey atalnarayan,

In general the approach you are taking seems to be on the right track, but your question is a bit general for a discussion here. Let me point you to some relevant material:

1. Finding video game titles with sense2vec: https://www.youtube.com/watch?v=EoYHbUHr0fM
2. Detailed example about using the entity ruler to find museum names: https://www.youtube.com/watch?v=Ds18bQAzygo.
3. Rather than the EntityRuler we recommend using the SpanRuler in the future: https://spacy.io/api/spanruler
4. Using dependency tree for extracting information: https://www.youtube.com/watch?v=BoyLPiXXEYA&t=429s.
5. For more in-depth information about entity extraction I recommend this Chapter: https://web.stanford.edu/~jurafsky/slp3/8.pdf
6. For practical examples for machine learning based named entity recognition with spacy you can checkout the relevant projects here: https://github.com/explosion/projects.

Both of your questions can be answered in a similar way. Both the named entity recognition and part-of-speech tagging pipelines use machine learning models. Such models will make mistakes and these mistakes are hard for us to correct in general, because models are not a deterministic set of rules. The accuracy of a model depends on several factors, including:

• The size of the training data;
• the quality of the training data;
• the size of the model.

Taking your named entity recognition example, the en_core_web_sm model is (as the name suggests) a small model. It uses a relatively small convolutional network, but also does not use static embeddings that are pretrained on a large corpus. Since the model is relatively limited, the model may have picked up patterns like: words that are capitalized are typically names, except if they occur at the beginning of the sentence (since all sentence-initial words are capitalized). This may be the reason that it fails to annotate your example correctly. However, if you use the en_core_web_lg model instead, you will see that that model will return the correct annotation:

('Dumbledore', 'PERSON')

You'd have to dive deeper to understand why it works in this case. But en_core_web_lg is a larger model that uses pretrained word embeddings. So, it may e.g. be the case that Dumbledore occurs in the set of word embeddings and the vector is similar to other names, allowing the model to extrapolate that since the vector of _ Dumbledore_ is similar to that of names it has seen in the training data that Dumbledore must also be a name.

Similar reasoning applies to your second question, the models are a trade-off between size, speed and accuracy. Also in this case en_core_web_lg does predicts 'VERB' consistently as the tag for finished.

So what does this mean in practice? First, models make mistakes. Second, if the error rate is not acceptable, you may want to look at larger models (such as md/lg/trf); or if you are working in a very specific domain, annotating more training data. Finally, do not underestimate the power of a set of rules. If you are working in a particular domain, say processing Harry Potter novels, you could get a lot of milage out of making a small set of rules to recognize names since it is a finite set (using e.g. the attribute ruler).