juxtaposicion

Chrisemoody.com

Nice work. I’ve also tinkered on unit pricing! I worked on Popgot.com, which is similar but for the US and tracks non-perishable staples

Got it, thanks! Yeah, so it makes sense that any age-bucketing like this would have a similar effect

I'm not sure I understand. Your model shows that different group buckets (eg 20-24yo vs 25-29yo) peak at different years (in your figure, 2022 vs 2024) despite being driven by the same dynamics. Is that expected? I (naively?) expected the same groups to rise, fall and have peaks at the same times.

Yeah, agree most daily purchases are humdrum and shouldn’t command all of my attention.

Incidentally, my last project is about buying by unit price. Shameless plug, but for vitmain D the best price per serving here (https://popgot.com/vitamin-d3)

The LLMs are in fact quite expensive! We run dozen of LLM calls across thousands of products. That's thousands to tens of thousands of calls per search query. The idea is we've got to find the best & the cheapest, and I have spared no expense in doing so. (Plus we have GCP credits.)

Eventually products will overlap between search queries, so we can serve fast and low latency results that have been pre-processed by LLMs. That will be near zero cost. And of course LLM prices will continue to drop quickly.

We monetize via affiliate fees -- you buy something off that list, and we get 1-4% back at no cost to you.

thanks! let me know if y'all have any feedback :)

I had to look at that carefully, but I think that "save you $57.65 on 33 fl oz" is both technically and meaningfully correct. It compares our best choice to the most popular choice -- we use the product with the most ratings as a proxy for that. Nizoral 2-in-1 has a crazy 100k reviews, but it is in fact almost 20x more expensive per fluid ounce! And it is the most popular product@

If you hover the text it explains the logic (you can see that in this screenshot https://imgur.com/a/hO7fiWR). But to replay the logic here:

Equate 2 in 1 Dandruff Shampoo 28.2oz is 21¢/fl oz (for 33 fl oz it costs $6.99) is the Popgot choice.

But the most popular (e.g. most reviewed) product is "Nizoral 2-in-1 Anti-Dandruff Shampoo" and that costs a whopping $1.96/fl oz (33 fl oz it costs $64.63)

So yes, the most popular anti-dandruff shampoo (which I used to use, until I saw this shampoo list https://popgot.com/shampoo?attributes=scalp_concern%3Adandru...) is literally 20x more expensive, so you can do a lot better by picking alternatives at the top of that list.

Not sure why you didn't see toilet paper, but it is right here: https://popgot.com/toilet-paper

That’s pretty interesting. I’ve using Airtable’s “field agents” for a similar use case, but would love to use this instead. Does it automatically cache values? (Don’t want to pay for repeat prompts just because one input cell updated)

I’m building Popgot (https://popgot.com): compare unit prices (per oz/sheet/lb) across Costco, Walmart, Target, and Amazon. We normalize fuzzy sizes (“family,” “mega,” multipacks) so you see the actually cheapest option for staples.

New: a deep research mode that, on demand, crawls thousands of product pages and uses visual LLMs to read label photos (ingredients, counts, square footage) when the text is messy. First run takes ~60–90s, then it’s cached.

A good torture test: 20×25×1 MERV 13 home air filters—listings mix single/4/6/12-packs and vague claims (“3-month,” “allergen defense”), which wreck per-unit comparisons. I’d love feedback on misses (coupons/Subscribe & Save/region), categories to add, and to collaborate with a grocery-list app, budgeting tool, or anyone in the frugal/deals space. chris@popgot.com

My pleasure! Happy you could use it as much as I do. Anyway we can chat in person? I'd love to make more stuff for you. chris@<our site>.com

Yeah, I agree. It is a pain to search product by product instead of sticking to one store. Also popgot.com can only do what's online & shipped to you -- so really just the non-perishables / daily essentials that are not fresh groceries. But even when limited to consumables I save ~$100/mo by basically buying by unit price.

Uploading a receipt to see how much you can save... that's a good idea. I think I can find your email via your personal site. Can I email you when we have a prototype ready?

Ah, hell yeah! My buddy on this project has been itching to add sweetmarias.com ... he just needed this as an excuse.

So yeah, we'll add it. If you shoot me an email (or post it here?) to chris @ <our site>.com I'll send you a link when it's done. Should take a day or two.

I'm so glad you like it!

We have historical price tracking in the database, but haven't exposed it as a product yet. What do you have in mind / what would you use it for?

Glad you guys mentioned Costco -- I happen to have written a blog post on exactly that: https://popgot.com/blog/retailer-comparison Surprisingly, Costco does not win most of the time, and especially if you are not brand loyal. Costco has famously low-margins, but it turns out that when you sort by price-per-unit they're ok, but not great.

@mynameisash I'm curious what you learned... maybe I can help more people learn that using Popgot data.

I’m working on Popgot (https://popgot.com), a tool that tracks unit prices (cost per ounce, sheet, pound) across Costco, Walmart, Target, and Amazon. It normalizes confusing listings (“family size”, “mega pack”, etc.) to surface the actual cheapest option for daily essentials.

On top of that, it uses a lightweight AI model to read product descriptions and filter based on things like ingredients (e.g., flagging peanut butter with BPA by checking every photograph of the plastic or avoiding palm oil by reading the nutrition facts) or brand lists (e.g., only showing WSAVA-compliant dog foods). Still reviewing results manually to catch bad extractions.

Started this to replace a spreadsheet I was keeping for bulk purchases. Slowly adding more automation like alerting on price drops or restocking when under a threshold.

It’s interesting to see how differentiable logic/binary circuits can be made cheap at inference time.

But what about the theoretical expressiveness of logic circuits vs baselines like MLPs? (And then of course compared to CNNs and other kernels.) Are logic circuits roughly equivalent in terms of memory and compute being used? For my use case, I don’t care about making inference cheaper (eg the benefit logical circuits brings). But I do care about the recursion in space and time (the benefit from CAs). Would your experiments work if you still had a CA, but used dumb MLPs?

Right the hope was to go further. E.g. if the input is:

```

class Classification(BaseModel):

    color: Literal['red', 'blue', 'green']

then the output type would be:

```

class ClassificationWithLogProbs(BaseModel):

    color: Dict[Literal['red', 'blue', 'green'], float]

Don't take this too literally; I'm not convinced that this is the right way to do it. But it would provide structure and scores without dealing with a mess of complex JSON.

This looks great; very useful for (example) ranking outputs by confidence so you can do human reviews of the not-confident ones.

Any chance we can get Pydantic support?

Like other comments, I was also initially surprised. But I think the gains are both real and easy to understand where the improvements are coming from.

Under the hood Reflection 70B seems to be a Llama-3.1 finetune that encourages the model to add <think>, <reflection> and <output> tokens and corresponding phases. This is an evolution of Chain-of-Thought's "think step by step" -- but instead of being a prompting technique, this fine-tune bakes examples of these phases more directly into the model. So the model starts with an initial draft and 'reflects' on it before issuing a final output.

The extra effort spent on tokens, which effectively let the model 'think more' appears to let it defeat prompts which other strong models (4o, 3.5 Sonnet) appear to fumble. So for example, when asked "which is greater 9.11 or 9.9" the Reflection 70b model initially gets the wrong answer, then <reflects> on it, then spits the right output.

Personally, the comparison to Claude and 4o doesn't quite seem apples-to-apples. If you were to have 4o/Claude take multiple rounds to review and reflect on their initial drafts, would we see similar gains? I suspect they would improve massively as well.

Oh, thanks! I added my email to my profile. Look forward to replying to your note!

We're building that spreadsheet as a product. I'd love to show you. I'd message you a private link to a prototype but you have no contact info on your profile. If you are interested, can you email or DM me using my profile info?

For a "small" dataset of 50M and 0.5TB in size with 20 results get around 50-100ms.

I'd love to know the answer here too!

I've ran a few tests on pg and retrieving 100 random indices from a billion-scale table -- without vectors, just a vanilla table with an int64 primary key -- easily took 700ms on beefy GCP instances. And that was without a vector index.

Entirely possibly my take was too cursory, would love to know what latencies you're getting bryan0!

Disk retrieval is definitely slower. In-memory retrieval typically can be ~1ms or less, whereas disk retrieval on a fast network drive is 50-100ms. But frankly, for any use case I can think of 50ms of latency is good enough. The best part is that the cost is driven by disk not ram, which means instead of $50k/month for ~TB of RAM you're talking about $1k/mo for a fast NVMe on a fast link. That's 50x cheaper, because disks are 50x cheaper. $50k/mo for an extra 50ms latency is a pretty clear easy tradeoff.

We’re also building billion-scale pipeline for indexing embeddings. Like the author, most of our pain has been scaling. If you only had to do millions, this whole pipeline would be a 100 LoC. but billions? Our system is at 20k LoC and growing.

The biggest surprise to me here is using Weavite at the scale of billions — my understanding was that this would require tremendous memory requirements (of order a TB in RAM) which are prohibitively expensive (10-50k/m for that much memory).

Instead, we’ve been using Lance, which stores its vector index on disk instead of in memory.

We use Lance extensively at my startup. This blog post (previously on HN) details nicely why: https://thedataquarry.com/posts/vector-db-4/ but essentially it’s because Lance is a “just a file” in the same way SQLite is a “just a file” which makes it embedded and serverless and straightforward to use locally or in a deployment.

What’re the techniques that’ll get this to run on a single GPU?

It is exciting that you could train a CLIP-style model from scratch with only 4M datapoints. But if you’ve got that data, why not fine tune a pretrained model with your 4M points? It seems likely to outperform the from-scratch method.

How does this compare to Quickwit or other Tantivy-powered engines?