Recapping here: Our first train was on 4,000 images from the MaskFactory dataset alone. This improved some benchmarks but regressed on others. We took this as a sign of narrow datasets causing unintended specialization.

In our next run, we assembled 26.1K images from 10 different datasets. We capped the amount of images that could come from one source, to prevent a single type of example from dominating. This composite set covered several cases like crowded scenes, camouflage, high-res subjects, fine objects like hair, blurred backgrounds, etc. We then shuffled everything together and trained FeyNoBg.

> what is the subject?

FeyNoBg is an "automatic" model. It automatically detects foreground elements and segments the image. Most of the time, this includes all foreground elements. As you can see in the freekick example (https://drive.google.com/file/d/1MZkAGLwbhNVOZ0Oi7XvpCfSEu9Q...), the model output includes the ball, Messi, and the Liverpool defenders. In your example, FeyNoBg will segment around the person plus the couch.

> I only want the person [including props]

The alternative to automatic models are prompt models and those serve the exact use case you're describing. These allow you to specify the foreground element to include. Everything else is removed. That's the next step for FeyNoBg, converting it from an automatic to a prompt model. Now, answering your question:

> How does it stack up against Adobe's model?

We're better on automatic background removal. Support for selecting a subset of foreground elements is coming soon

We've released projects under the MIT license before, most notably https://github.com/feyninc/chonkie. While we're not trying to directly monetize on this work, credit goes a long way and helps in other operations.

Recently, attributed usage is shrinking. To be clear, this is not a shrinkage in actual use of our software, just how many people acknowledge that they rely on it.

cc-by-nc is a protection against that. We've been very honest about our work being on top of BiRefNet as we want to extend the original creators the same courtesy. I have no issues if individuals fork/finetune/or otherwise build on top of any open source projects we release, irrespective of license. At minimum, we want acknowledgment if a company chooses to use our software in production.

All I ask is you make a PR to https://github.com/feyninc/nobg with your results. We'd love to see what you make, contribute in any way we can, and share onwards.

https://github.com/feyninc/nobg/issues

Today, we’re releasing FeyNoBg, an automatic background removal model. Alongside it, we're open-sourcing NoBg, the Python library we built to train and run it.

Try the model here: https://huggingface.co/spaces/feyninc/feynobg. Check out the library here: https://github.com/feyninc/nobg

Some sample outputs:

(1) Soccer Freekick: https://drive.google.com/file/d/1MZkAGLwbhNVOZ0Oi7XvpCfSEu9Q...

(2) Hair in wind: https://drive.google.com/file/d/1Odc2m0XMVH9uZtvI_KjaRbXzhLL...

(3) Bicycle with visible spokes: https://drive.google.com/file/d/1h99ahjfrtS1MFQJJgiKE2fuM3HZ...

(4) Live Demo video: https://youtu.be/b1heHPvY8BM

Background removal separates an image's subject from its surrounding. We've all tried it at some point. Often it is to reuse the subject in a different artifact. Nowadays, it is common to make chat stickers out of it. It is one of the most common but under-appreciated uses of AI. It is also surprisingly complex. Models can be easily confused by camouflage, motion blur, or fine structures like hair.

The task requires two skills. First, a model has to identify the foreground. Second, it has to trace the foreground’s boundary and estimate an opacity value for each pixel. Generally, these skills are taught with different datasets. That creates a failure point. A poor training mix can improve one skill at the expense of the other. We saw this in our controlled evaluation. A training run with just the MaskFactory dataset improved on the CAMO benchmark but regressed on DIS5K.

For FeyNoBg, we took an interpretability-first approach to training. We first studied how BiRefNet’s stages contribute to finding the foreground and reconstructing its boundary. We discovered that the third stage of it's feature extractor holds a lot of information. Both localization and boundary reconstruction depend heavily on the feature map produced here.

This led us to expand this stage from 18 to 24 blocks while preserving the pre-trained weights. We then trained FeyNoBg on 26.1K diverse examples assembled from 10 datasets. The goal was to improve foreground identification and boundary precision without sacrificing either one.

Across eight benchmarks, FeyNoBg achieves the best published score on four and comes within 2% of the leader on the rest.

Building FeyNoBg also exposed a tooling problem. Image matting models are usually released as isolated repositories with incompatible preprocessing, training, and evaluation code. We built NoBg to solve this. NoBg puts these workflows behind one Python interface. It supports BiRefNet today, with more architectures coming. We hope you build something exciting with it!

Happy to answer any questions!

Comments URL: https://news.ycombinator.com/item?id=49072462

Points: 93

# Comments: 22

HF Space: https://huggingface.co/spaces/feyninc/pulpie

Pulpie will return all main content on a page as HTML/Markdown. I’m not sure I fully understand “which one this is good at?”. perhaps you can try the model on hugging face and let me know if the results look good?

https://huggingface.co/spaces/feyninc/pulpie

We haven't run a targeted eval against SEO spam yet. However, with Pulpie, each block gets labeled by what the text actually says rather than what the tags look like. Wrapping boilerplate in semantic tags fools rule based extractors precisely because they judge structure. Pulpie doesn't. The closest benchmark we have for this is the WebMainBench difficulty split, where pulpie-orange-small holds 0.813 on the hard subset. For comparison, trafilatura scores a 0.526.

For quantization, we haven't benchmarked INT8 or FP8. Everything in the post ran on L4 and A100. That said, I expect it to go well for a few reasons. It's a single forward pass over the page, so the workload is compute bound rather than bandwidth bound, which is why the L4 held up so well against the A100 and why cheaper cards should degrade gracefully. At 210M params the small model is roughly 420MB in FP16 and half that in INT8. So it fits on any consumer GPU with room to spare. Also, one pass classification tends to survive 8 bit quantization better than autoregressive generation since there is no error accumulation across decode steps.

We match SOTA extraction quality while being 20x cheaper. Cleaning 1 billion webpages costs $7,900 with Pulpie versus $159,000 with Dripper, the current leading extractor.

The gains come from architecture. Today's leading extractors are decoders that generate output one token at a time. Each step reads the full model from memory to produce a single token. Conversely, Pulpie models are encoders. They run one forward pass over the full input HTML and label each block as boilerplate or content. As a result, Pulpie is compute-bound while decoders are memory-bound. Cheaper GPUs have relatively more compute than memory bandwidth. This makes Pulpie easy to run optimally.

Here's Pulpie and Dripper cleaning the same pages side by side: https://www.youtube.com/watch?v=ibd-tIiQECo. You can try a side-by-side comparison yourself: https://huggingface.co/spaces/feyninc/pulpie

Our motivation for Pulpie came from building a deep research harness. Every search API returns noisy content that contains ads, nav elements, and sidebars. In one instance, an ad for "Gemini on Pixel" slipped into our search results, got passed into LLM context, and ended up in the final answer served to the user. Pretty embarrassing moment for us but it helped us realize how bad data kills model intelligence. We built Pulpie to get clean data for cheap.

All models are open source on Hugging Face. You can read about our training process and how to use Pulpie here: https://usefeyn.com/blog/pulpie-pareto-optimal-models-for-cl...

Happy to answer any questions!

Comments URL: https://news.ycombinator.com/item?id=48806575

Points: 106

# Comments: 26

Unclean data is harmful to model intelligence. In pre training, it pollutes data the model learns from. At inference, it confuses a model.

We built Pulpie to make clean data available for cheap. The blog goes over our process. Happy to answer any questions

Comments URL: https://news.ycombinator.com/item?id=48748093

Points: 1

# Comments: 0

We've found that maximizing chunk size gives the best retrieval performance and is easier to maintain since you don't have to customize chunking strategy per document type.

The upper limit for chunk size is set by your embedding model. After a certain size, encoding becomes too lossy and performance degrades.

There is a downside: blindly splitting into large chunks may cut a sentence or word off mid-way. We handle this by splitting at delimiters and adding overlap to cover abbreviations and other edge cases.

But as the number of files to ingest grows, chunking speed does become a bottleneck. We want faster everything (chunking, embedding, retrieval) but chunking was the first piece we tackled. Memchunk is the fastest we could build.