supo

The environment allows for separation of the useful good ones from the "only in it for the cash" ex-investment banking types ^_^

Open-source k8s cluster for serving a wide catalog of small language models across search, OCR & data processing.

by that same logic, why would you not strive to push all the signals you have available into the ANN search? sure, some will have reduced resolution vs using a heavy reranker, but surely the optimal solution is to use the same signals in both stages and just add resolution in the second stage? the more they are aligned, the fewer candidates you need -> better latency & lower cost.

one thing to remember is that bm25 is purely in the domain of text - the moment any other signal enters in the picture (and it ~always does in sufficiently important systems), bm25 alone can literally have 0 recall.

Here is a quick overview, doesn't really explain the deep details though: https://www.youtube.com/watch?v=ikYsr6nvbdE

Basically think mixture of experts, but each expert is an encoder with it's own input tokenization/feature engineering part and then there is some machinery to parametrize these encoders based on natural language queries and stitch their outputs together to form unified vectors for objects in the index and the queries coming in.

Given that the whole framework is Apache 2.0, you can also check https://github.com/superlinked/superlinked and the docs: https://docs.superlinked.com/ https://docs.superlinked.com/concepts/overview

We have some proprietary tech besides that - mainly embedding models for things like location and then executors for the Superlinked DAG that help you run it on GPU-accelerated Spark and something analogous to that for streaming workloads - those proprietary things are how we make money, we call it Superlinked Cloud.

This article focuses on ways to make "pre-fetching" more accurate, reducing or eliminating the need for reranking to improve latency/cost but also sometimes quality - for example if you use a text cross-encoder to rerank your structured objects, you'll find that those rerankers don't actually understand much of the numbers, locations and other data like that.

If this was a solved problem, every e-com website would already run some variant of https://arxiv.org/pdf/2209.07663 for all their shopping surfaces and some version of "deep research" on every search query. They don't, so the problem isn't solved. And a big part of the problem is still the integration of behavioral, structured and unstructured signals into the underlying retrieval of products and content - which is what the article is about.

Also, the company is doing fine, not sure where that last sentence came from ^_^

It allows faster experimentation because you can't do things like partial embedding updates and reasonable schema migrations on your vector search index - if you could, you'd experiment in retrieval... and with better retrieval you don't have to move 100s or 1000s of candidates from a database and pay a ton for a ranker inference on every query (not even mentioning the latency impact of that).

If you could wave a magic wand and push all the ranking signals into retrieval and that index would be fast to update and not that expensive to operate - you would do that and you would delete all your reranking systems, wouldn't you?

We are mostly focused on natural language search in e-commerce/marketplace/travel settings right now. There we have a production deployment that drove $15M of incremental revenue through personalization of a shopping feed for a fashion e-commerce business. Happy to share more if you are interested, feel free to email me at daniel@superlinked.com!

We focus on text, images, numerical, categorical and timestamp-properties for the objects you vectorize with Superlinked. The performance will depend on which models you chose to use with the framework, your queries etc. Happy to elaborate if you could describe your use-case :-)

Supported VDBs: Currently MongoDB, Redis Search and Qdrant https://docs.superlinked.com/run-in-production/index-1

As you say, AstraDB also offers vector search (you can see it at https://superlinked.com/vector-db-comparison) but we haven't built the integration with them yet. We focus on fewer but higher quality integrations in general. Do you like AstraDB? Any advantages vs competition that you care about?

In terms of the plan you mentioned Astra+Redis - you don't have to do that, you can just use redis for both key-value store and vector search.

A table comparing the features available with different vector databases. The project is open-source and developed by a community of practitioners with points of contact from the different vector databases to validate.

And you decided to not work remotely and 10x your income instantly, because you'd miss your office and colleagues. Got it!

Any apps that can benefit from social interactions. A good example is DuoLingo. They built a social+ product for learning languages, have 50m MAUs and $250M revenue!! There are thousands of other learning apps, but DuoLingo is by far the best one out there.

The removal of barriers favors those who can take advantage of the newly acquired access and information.

Your life reflects this capacity as much as the environment that let it manifest itself:)

Nice formalization, this has been rattling around in my head for a long time it's good to see numbers put on it!

A short piece of satire on the dangers of deploying ML/AI into production.

Hi, I co-founded a company that works on a similar idea, just from a slightly different perspective (focus on storytelling, not so much the aggregation): http://memoarc.com/

We should hang out :-)

Saying that you are intelligent is just so cringe-worthy. If you want to make a point about yourself give two small examples of what you've achieved and let the reader form an opinion.

I'm sorry for not making it more obvious, but each bullet point in the list ends with a link.

Nice, thanks! I wish there was a cleaned up repository of datasets like these, in a unified format, directly accessible to a public MapReduce engine like Elastic at AWS.

Some of that must be a California thing. In an European office of one of the mentioned companies, most people almost always eat lunch with their team in a canteen and plenty people do 3-4 day long weekends to go on trips all the time (+ normal 1-2 week long vacations of course). Yes, sometimes I go online during my vacation or when travelling during the weekend to perhaps look at emails or do some simple work, but that is because I'm motivated - nobody is making me do it.

Depends on the randomness of the paths. With URLs coming from a limited set of websites - yes, there would be some savings.

With a set of random strings, for alphabet with 64 chars, there are 16M different 4 character prefixes, so the savings from overlapping prefixes for 128char long strings is likely less than 3%.

Ah, in that case it goes straight to set<string> for me :-) I think that in practice you want to do that but then drop in a few asserts to check whether things are not getting out of control once you forgot about this decision.

Sure, but it can blow up faster than you think. Say you have 100k URL strings, up to 128 chars each, with 64 allowed characters in alphabet.

- storing this at byte per char = 12.8MB

- storing this in a basic trie = 12.8 * 64 = 820MB

- storing this in the TST = 12.8 * 3 = 38MB

You went to Stanford and have never seen a Trie in highschool? There are a few highschools in Bratislava, Slovakia that teach basic data structures in their Intro to programming courses.

With a basic Trie, you always have this problem of how to keep the pointers at each node. Naively, you can:

1) Keep an array of size equal to the alphabet size, indexed by the characters, holding pointers to successive nodes.

- but this blows the memory to O(N * alphabet_size) where N is the input size

2) Keep a linked list of pairs (character, pointer).

- but this blows the lookup time to O(word_length * alphabet_size)

3) Keep something like an STL map<character, pointer>.

- still suboptimal complexity of O(word_length * log alphabet_size) + it complicates the code + it dramatically increases the constant time per operation

Or you research a bit more and actually learn a way to properly implement a trie, called a Ternary Search Tree: http://en.wikipedia.org/wiki/Ternary_search_tree

Well, there is already a stranger going over your email to show ads in your client no? ;-)

There is more: 4. Leave the country with her!