Understanding the Basics
Most people come across Has Feelings Too and immediately assume it is some kind of advanced sentiment engine. It is not. It is a data annotation framework built on top of existing language models, and the reason it gained traction in production environments is because it handles multi-label emotional tagging without requiring you to train your own classifier from scratch. That distinction matters more than most articles admit. I spent about six weeks integrating this into a customer support pipeline last year. The original plan was to tag every incoming ticket with a primary emotion and a secondary modifier. We hit a wall almost immediately because the model would consistently misclassify sarcasm as genuine frustration, which then cascaded into routing errors. The workaround was to add a pre-filter layer that detected negation patterns before the emotion model ran. This cut our false-positive rate from roughly 18% down to about 4%.
How Has Feelings Too Actually Works
The architecture runs inference through a fine-tuned transformer backbone, typically based on RoBERTa or a similar encoder. You pass in raw text, and the model outputs a probability distribution across a fixed set of emotion categories. The default taxonomy includes things like joy, anger, sadness, fear, surprise, and disgust, but you can extend it with custom labels if the API supports it. What most people miss is that the model outputs raw logits by default. If you are just taking the argmax, you are throwing away calibration information. In practice, I learned to threshold the probabilities rather than picking the highest class outright. A joy score of 0.51 and a sadness score of 0.49 is not a clear classification. It is noise. Setting a confidence threshold of around 0.65 for single-label mode and using a soft threshold for multi-label mode made the output actually usable in production.
Installation and Setup
You can pull it through pip or install from source if you need to modify the model weights directly. The standard installation takes about two minutes on a modern machine. The dependencies are fairly lightweight compared to other NLP stacks. Mainly transformers, torch, and a few standard utilities. Once installed, the API is straightforward. You initialize a pipeline object, pass your text, and get back a dictionary of scores. I usually wrap it in a small helper function that handles batching, since running single samples through one at a time adds unnecessary latency. Batching ten items at a time on a CPU will still give you results in under three seconds, which is acceptable for most batch-processing workflows.
Get the Full Details
Common Pitfalls That Waste Time
The biggest issue I encountered was handling long-form text. The model has a fixed context window, and anything beyond that gets truncated silently. This is not always obvious because the API does not warn you. I had a case where entire paragraphs were being cut off, and the model was only seeing the end of the document, which led to completely wrong emotional classifications. The fix was to split longer inputs into chunks and aggregate the scores across chunks using a weighted average based on chunk length. Another issue is language support. The default model is trained primarily on English data. If you run it on non-English text without switching to a multilingual checkpoint, the results will be unreliable. I wasted two days debugging what I thought was a logic bug before realizing the input was in Spanish. Switching to the XLM-RoBERTa variant solved it immediately.
When It Fails Completely
This tool is not suitable for real-time applications that require sub-100 millisecond responses on commodity hardware. Even on a GPU, inference on longer documents can take a second or two per batch. If you need faster throughput, you should consider distilling the model down to a smaller version or switching to a lighter approach like keyword-based heuristics for simple cases. Has Feelings Too is overkill for anything that can be handled with a basic polarity check. There is also the edge case of domain-specific language. Technical documentation, legal contracts, and medical transcripts all contain vocabulary that biases the model away from emotional content entirely. The model will tag a contract clause as neutral even when the language is clearly adversarial. I found that training a domain adapter on a small labeled subset of your own data brought accuracy back into a useful range, but that requires having labeled data to begin with, which defeats part of the convenience argument.
Where to Get It
The project is hosted on GitHub under the name feelings-too. The repository includes example notebooks, pre-trained weights, and a basic CLI tool. There is also a PyPI package if you want to use it as a library in your own code. The documentation is functional but sparse. I recommend reading the source code directly if you run into unexpected behavior, since the issue tracker has several threads that cover edge cases not documented in the README. For most practical purposes, starting with the pre-built pipeline is the fastest path to getting usable results. Only dig into the internals if you hit the limitations I described above. The framework is flexible enough to support custom backbones and extended taxonomies, but that flexibility comes with the usual trade-off of additional complexity and setup time.
