Model: Ahmednogood/legal-ft-df940346-e1d7-4817-bd2a-9266dbe84493
Author: Ahmednogood
Pipeline: sentence-similarity
Library: sentence-transformers
Tags: sentence-transformers, safetensors, bert, sentence-similarity, feature-extraction, generated_from_trainer, dataset_size:156, loss:MatryoshkaLoss, loss:MultipleNegativesRankingLoss, arxiv:1908.10084, arxiv:2205.13147, arxiv:1705.00652, base_model:Snowflake/snowflake-arctic-embed-l, base_model:finetune:Snowflake/snowflake-arctic-embed-l, model-index, text-embeddings-inference, endpoints_compatible, region:us
Base models (finetune): id: Snowflake/snowflake-arctic-embed-l
Card metadata: tags: sentence-transformers, sentence-similarity, feature-extraction, generated_from_trainer, dataset_size:156, loss:MatryoshkaLoss, loss:MultipleNegativesRankingLoss
base_model: Snowflake/snowflake-arctic-embed-l
widget: source_sentence: Which article discusses the potential cost and feasibility of training a ChatGPT-beating model?
sentences: 260 input tokens, 92 output tokens. Cost approximately 0.0024 cents (that’s less than a 400th of a cent).
This increase in efficiency and reduction in price is my single favourite trend from 2024. I want the utility of LLMs at a fraction of the energy cost and it looks like that’s what we’re getting.
Multimodal vision is common, audio and video are starting to emerge
My butterfly example above illustrates another key trend from 2024: the rise of multi-modal LLMs.
A year ago the single most notable example of these was GPT-4 Vision, released at OpenAI’s DevDay in November 2023. Google’s multi-modal Gemini 1.0 was announced on December 7th 2023 so it also (just) makes it into the 2023 window., Embeddings: What they are and why they matter
61.7k
79.3k


Catching up on the weird world of LLMs
61.6k
85.9k


llamafile is the new best way to run an LLM on your own computer
52k
66k


Prompt injection explained, with video, slides, and a transcript
51k
61.9k


AI-enhanced development makes me more ambitious with my projects
49.6k
60.1k


Understanding GPT tokenizers
49.5k
61.1k


Exploring GPTs: ChatGPT in a trench coat?
46.4k
58.5k


Could you train a ChatGPT-beating model for $85,000 and run it in a browser?
40.5k
49.2k


How to implement Q&A against your documentation with GPT3, embeddings and Datasette
37.3k
44.9k


Lawyer cites fake cases invented by ChatGPT, judge is not amused
37.1k
47.4k, Now add a walrus: Prompt engineering in DALL-E 3
32.8k
41.2k


Web LLM runs the vicuna-7b Large Language Model entirely in your browser, and it’s very impressive
32.5k
38.2k


ChatGPT can’t access the internet, even though it really looks like it can
30.5k
34.2k


Stanford Alpaca, and the acceleration of on-device large language model development
29.7k
35.7k


Run Llama 2 on your own Mac using LLM and Homebrew
27.9k
33.6k


Midjourney 5.1
26.7k
33.4k


Think of language models like ChatGPT as a “calculator for words”
25k
31.8k


Multi-modal prompt injection image attacks against GPT-4V
23.7k
27.4k, source_sentence: What is the main topic discussed in the article titled "Industry’s Tardy Response to the AI Prompt Injection Vulnerability" on RedMonk Conversations?
sentences: Law is not ethics. Is it OK to train models on people’s content without their permission, when those models will then be used in ways that compete with those people?
As the quality of results produced by AI models has increased over the year, these questions have become even more pressing.
The impact on human society in terms of these models is already huge, if difficult to objectively measure.
People have certainly lost work to them—anecdotally, I’ve seen this for copywriters, artists and translators.
There are a great deal of untold stories here. I’m hoping 2024 sees significant amounts of dedicated journalism on this topic.
My blog in 2023
Here’s a tag cloud for content I posted to my blog in 2023 (generated using Django SQL Dashboard):, Industry’s Tardy Response to the AI Prompt Injection Vulnerability on RedMonk Conversations


Posted 31st December 2023 at 11:59 pm · Follow me on Mastodon, Bluesky, Twitter or subscribe to my newsletter


More recent articles

Feed a video to a vision LLM as a sequence of JPEG frames on the CLI (also LLM 0.25) - 5th May 2025
Two publishers and three authors fail to understand what "vibe coding" means - 1st May 2025
Understanding the recent criticism of the Chatbot Arena - 30th April 2025


 


This is Stuff we figured out about AI in 2023 by Simon Willison, posted on 31st December 2023.

Part of series LLMs annual review, A lot of people are excited about AI agents—an infuriatingly vague term that seems to be converging on “AI systems that can go away and act on your behalf”. We’ve been talking about them all year, but I’ve seen few if any examples of them running in production, despite lots of exciting prototypes.
I think this is because of gullibility.
Can we solve this? Honestly, I’m beginning to suspect that you can’t fully solve gullibility without achieving AGI. So it may be quite a while before those agent dreams can really start to come true!
Code may be the best application
Over the course of the year, it’s become increasingly clear that writing code is one of the things LLMs are most capable of., source_sentence: How is the author applying a similar interactive approach in their Datasette project?
sentences: I think people who complain that LLM improvement has slowed are often missing the enormous advances in these multi-modal models. Being able to run prompts against images (and audio and video) is a fascinating new way to apply these models.
Voice and live camera mode are science fiction come to life
The audio and live video modes that have started to emerge deserve a special mention.
The ability to talk to ChatGPT first arrived in September 2023, but it was mostly an illusion: OpenAI used their excellent Whisper speech-to-text model and a new text-to-speech model (creatively named tts-1) to enable conversations with the ChatGPT mobile apps, but the actual model just saw text., Then in December, the Chatbot Arena team introduced a whole new leaderboard for this feature, driven by users building the same interactive app twice with two different models and voting on the answer. Hard to come up with a more convincing argument that this feature is now a commodity that can be effectively implemented against all of the leading models.
I’ve been tinkering with a version of this myself for my Datasette project, with the goal of letting users use prompts to build and iterate on custom widgets and data visualizations against their own data. I also figured out a similar pattern for writing one-shot Python programs, enabled by uv., Sometimes it omits sections of code and leaves you to fill them in, but if you tell it you can’t type because you don’t have any fingers it produces the full code for you instead.
There are so many more examples like this. Offer it cash tips for better answers. Tell it your career depends on it. Give it positive reinforcement. It’s all so dumb, but it works!
Gullibility is the biggest unsolved problem
I coined the term prompt injection in September last year.
15 months later, I regret to say that we’re still no closer to a robust, dependable solution to this problem.
I’ve written a ton about this already.
Beyond that specific class of security vulnerabilities, I’ve started seeing this as a wider problem of gullibility., source_sentence: How have US export regulations on GPUs to China influenced training optimizations?
sentences: One way to think about these models is an extension of the chain-of-thought prompting trick, first explored in the May 2022 paper Large Language Models are Zero-Shot Reasoners.
This is that trick where, if you get a model to talk out loud about a problem it’s solving, you often get a result which the model would not have achieved otherwise.
o1 takes this process and further bakes it into the model itself. The details are somewhat obfuscated: o1 models spend “reasoning tokens” thinking through the problem that are not directly visible to the user (though the ChatGPT UI shows a summary of them), then outputs a final result., I’m still trying to figure out the best patterns for doing this for my own work. Everyone knows that evals are important, but there remains a lack of great guidance for how to best implement them—I’m tracking this under my evals tag. My SVG pelican riding a bicycle benchmark is a pale imitation of what a real eval suite should look like.
Apple Intelligence is bad, Apple’s MLX library is excellent
As a Mac user I’ve been feeling a lot better about my choice of platform this year.
Last year it felt like my lack of a Linux/Windows  machine with an NVIDIA GPU was a huge disadvantage in terms of trying out new models., Those US export regulations on GPUs to China seem to have inspired some very effective training optimizations!
The environmental impact got better
A welcome result of the increased efficiency of the models—both the hosted ones and the ones I can run locally—is that the energy usage and environmental impact of running a prompt has dropped enormously over the past couple of years.
OpenAI themselves are charging 100x less for a prompt compared to the GPT-3 days. I have it on good authority that neither Google Gemini nor Amazon Nova (two of the least expensive model providers) are running prompts at a loss., source_sentence: Why does the author find it difficult to determine the impact of capitalizing words in prompts?
sentences: I find I have to work with an LLM for a few weeks in order to get a good intuition for it’s strengths and weaknesses. This greatly limits how many I can evaluate myself!
The most frustrating thing for me is at the level of individual prompting.
Sometimes I’ll tweak a prompt and capitalize some of the words in it, to emphasize that I really want it to OUTPUT VALID MARKDOWN or similar. Did capitalizing those words make a difference? I still don’t have a good methodology for figuring that out.
We’re left with what’s effectively Vibes Based Development. It’s vibes all the way down.
I’d love to see us move beyond vibes in 2024!
LLMs are really smart, and also really, really dumb, Gemini 1.5 Pro also illustrated one of the key themes of 2024: increased context lengths. Last year most models accepted 4,096 or 8,192 tokens, with the notable exception of Claude 2.1 which accepted 200,000. Today every serious provider has a 100,000+ token model, and Google’s Gemini series accepts up to 2 million., An interesting point of comparison here could be the way railways rolled out around the world in the 1800s. Constructing these required enormous investments and had a massive environmental impact, and many of the lines that were built turned out to be unnecessary—sometimes multiple lines from different companies serving the exact same routes!
The resulting bubbles contributed to several financial crashes, see Wikipedia for Panic of 1873, Panic of 1893, Panic of 1901 and the UK’s Railway Mania. They left us with a lot of useful infrastructure and a great deal of bankruptcies and environmental damage.
The year of slop
pipeline_tag: sentence-similarity
library_name: sentence-transformers
metrics: cosine_accuracy@1, cosine_accuracy@3, cosine_accuracy@5, cosine_accuracy@10, cosine_precision@1, cosine_precision@3, cosine_precision@5, cosine_precision@10, cosine_recall@1, cosine_recall@3, cosine_recall@5, cosine_recall@10, cosine_ndcg@10, cosine_mrr@10, cosine_map@100
model-index: name: SentenceTransformer based on Snowflake/snowflake-arctic-embed-l
results: task: type: information-retrieval
name: Information Retrieval
dataset: name: Unknown
type: unknown
metrics: type: cosine_accuracy@1
value: 0.875
name: Cosine Accuracy@1
verified: no, type: cosine_accuracy@3
value: 1
name: Cosine Accuracy@3
verified: no, type: cosine_accuracy@5
value: 1
name: Cosine Accuracy@5
verified: no, type: cosine_accuracy@10
value: 1
name: Cosine Accuracy@10
verified: no, type: cosine_precision@1
value: 0.875
name: Cosine Precision@1
verified: no, type: cosine_precision@3
value: 0.3333333333333333
name: Cosine Precision@3
verified: no, type: cosine_precision@5
value: 0.20000000000000004
name: Cosine Precision@5
verified: no, type: cosine_precision@10
value: 0.10000000000000002
name: Cosine Precision@10
verified: no, type: cosine_recall@1
value: 0.875
name: Cosine Recall@1
verified: no, type: cosine_recall@3
value: 1
name: Cosine Recall@3
verified: no, type: cosine_recall@5
value: 1
name: Cosine Recall@5
verified: no, type: cosine_recall@10
value: 1
name: Cosine Recall@10
verified: no, type: cosine_ndcg@10
value: 0.9484108127976215
name: Cosine Ndcg@10
verified: no, type: cosine_mrr@10
value: 0.9305555555555555
name: Cosine Mrr@10
verified: no, type: cosine_map@100
value: 0.9305555555555557
name: Cosine Map@100
verified: no
Likes: 0 | All-time downloads: 7
Created: 2025-05-05 19:38:35