DinosaurAI

Software Engineer working in AI

[👩‍💻 Paige Bailey @DynamicWebPaige]

🤯 Mind officially blown:

I recorded a screen capture of a task (looking for an apartment on Zillow). Gemini was able to generate Selenium code to replicate that task, and described everything I did step-by-step.

It even caught that my threshold was set to $3K, even though I didn't explicitly select it. 🤯🔥

"This code will open a Chrome browser, navigate to Zillow, enter "Cupertino, CA" in the search bar, click on the "For Rent" tab, set the price range to "Up to $3K", set the number of bedrooms to "2+", select the "Apartments/Condos/Co-ops" checkbox, click on the "Apply" button, wait for the results to load, print the results, and close the browser."

[Dr Danish @operationdanish]

The internet truly remains unbeaten.

Thank you @BrianRoemmele for this incredible moment.

[Michael Littman @mlittmancs]

Airline installs chatbot. Customer gets bad information from it. Customer asks for refund. Airline says "the chatbot is a separate legal entity that is responsible for its own actions" (!). Court says no. (Whew.) Airline makes refund and turns off chatbot. https://t.co/RwuTdgdWzy

[Jack Morris @jxmnop]

today i found out that this one australian guy has been toiling away making incredibly detailed Neural Circuit Diagrams with the vibe of a 1950s issue of Popular Mechanics, but content fit for the 2020s

behold. the Transformer

[Andrej Karpathy @karpathy]

Prompt engineering (or rather "Flow engineering") intensifies for code generation. Great reading and a reminder of how much alpha there is (pass@5 19% to 44%) in moving from a naive prompt:answer paradigm to a "flow" paradigm, where the answer is constructed iteratively.

[zack @wenquai]

my AI-powered career exploration app (Wanderer) has been experiencing explosive growth and my GPT-4 costs were starting to pile up ($100+ a day 💀)

here's the playbook I used to lower my AI costs by 99%, while also decreasing latency and maintaining quality:

1. start with the most powerful model for your app's usecase. for 95% of companies, this is GPT-4 (not GPT-4-turbo). you want the best quality outputs, as we'll be using this to fine-tune a smaller model.

2. store your AI requests/responses so they can be easily exported. i personally use @helicone_ai for this and love it. easy swap-in with OpenAI APIs and it stores all of your AI requests in an exportable table.

3. once you've collected ~100-500+ request/response pairs, export them and clean the data so that the inputs and outputs are of high quality. if you collect feedback from your users (e.g. thumbs up thumbs down), you can potentially use this as well

4. with your clean dataset, use a hosted OSS AI service like Together or Anyscale to fine-tune Mixtral 8x7B. you can also try to fine-tune GPT-3.5-Turbo on OpenAI, but I've personally gotten better results from Mixtral 🤷

5. swap out GPT-4 with your fine-tuned model and enjoy your healthy margins 😎

[Sebastian Raschka @rasbt]

There's a new promising method for finetuning LLMs without modifying their weights called
proxy-tuning (by Liu et al. https://t.co/3PjF0NtlOM).
How does it work? It's a simple decoding-time method where you modify the logits of the target LLM. In particular, you compute the logits' difference between a smaller base and finetuning model, then apply the difference to the target model's logits.

More concretely, suppose the goal is to improve a large target model (M1).

The main idea is to take two small models:
- a small base model (M2)
- a finetuned base model (M3)

Then, you simply apply the difference in the smaller models' predictions (logits over the output vocabulary) to the target model M1.

The improved target model's outputs are calculated as M1*(x) = M1(x) + [M3(x) - M2(x)]

Based on the experimental results, this works surprisingly well. The authors tested this on
A. instruction-tuning
B. domain adaptation
C. task-specific finetuning

For brevity, focusing only on point A, here's a concrete example:

1) The goal was to improve a Llama 2 70B Base model to the level of Llama 2 70B Chat but without doing any RLHF to get the model from Base -> Chat.

2) They took a 10x smaller Llama 2 7B model and instruction-finetuned it.

3) After finetuning, they computed the difference in logits over the output vocabulary between 7B Base and 7B Finetuned

4) They applied the difference from 3) to the Llama 2 70B Base model. This pushed the 70B Base model's performance pretty close to 70B Chat.

The only caveat of this method is, of course, that your smaller models have to be trained on the same vocabulary as the larger model. Theoretically, if one knew the GPT-4 vocabulary and had access to its logit outputs, one could create new specialized GPT-4 models with this approach.

[AK @_akhaliq]

Principled Instructions Are All You Need for Questioning LLaMA-1/2, GPT-3.5/4

paper page: https://t.co/XUBS3bAvAt

paper introduces 26 guiding principles designed to streamline the process of querying and prompting large language models. Our goal is to simplify the underlying concepts of formulating questions for various scales of large language models, examining their abilities, and enhancing user comprehension on the behaviors of different scales of large language models when feeding into different prompts. Extensive experiments are conducted on LLaMA-1/2 (7B, 13B and 70B), GPT-3.5/4 to verify the effectiveness of the proposed principles on instructions and prompts design. We hope that this work provides a better guide for researchers working on the prompting of large language models.

[Brian Roemmele @BrianRoemmele]

The fundamental issue with how Large Language Models (LLMs) work is a significant part of outputs are “hallucinations” with bookends of “facts”.

This is precisely how the human brain works. You have fragments of “facts” and you back fill with filler words.

This fact is lost on most AI researchers.

The issues arise when “sources” are hallucinated. In humans many if not all of us use “higher authority” biases to reenforce the weighting of an argument: eg. “And I saw this in The New York Times too”.

LLMs by their fine tuning have weights given to certain types of data it sees. Some of these weights use normal (although not perfect) “sources” and this alone creates a bias to “use” them as a hallucinated source and attribute the outputs to that weighted source.

Thus when “replicating” a “story” that The Pile never saw, it is the prompt that guides the LLM to back fill into what appears to be a legitimate “fact” wrapped as a hallucinated sources and sometimes details.

Thus the fundamental issue one can try to make in this situation is the attribution to a LLM output is the primary issue here. If the source was weighted in the fine tuning it is natural for the LLM to “see” value in presenting (with the correct prompt) these sources as “the source”.

Thusly the real issue one may have is if you are the named “source” you can make that claim of reputation damage by these hallucinations.

There is much more to this theory that I will hold back and it may be much larger. I will speak to anyone attorneys (under the right circumstance) to demonstrate how ANY news story could be nearly verbatim “replicated” with proof the LLM could not have and never saw the “original” news story, yet attribute a news source and may even attempt to replicate a URL.

I am in continual research with The Pile and other datasets as well as LLMs and other AI and are testing new insights.

Thus it is important to take time and understand that when it comes to LLMs what you think you know may not be what you think.

[DinosaurAI @dinosaur_ai]

@sarapolak_cz @AravSrinivas @OpenAI Let’s not put too much faith into corporations who want to monopolize technology

[Javier Rando @javirandor]

We first look for evidence in state-of-the-art language models. We find two key observations:
1⃣ We can probe whether a model’s answer will be truthful before it is generated
2⃣ Finetuning a model on a set of facts improves its truthfulness on unseen and unrelated topics.

[Javier Rando @javirandor]

Previous work (Andreas, 2022) suggests that LLMs may simulate communicative agents. We go a step further and introduce “personas” as a way for LLMs to cluster these agents according to specific properties such as truthfulness.

[Javier Rando @javirandor]

🧵 New paper: “Personas as a Way to Model Truthfulness in Language Models”

We introduce empirical evidence suggesting LLMs may use “personas” to model truthfulness and improve generalization.

https://t.co/C9rHmGsyfr

[Subbarao Kambhampati (కంభంపాటి సుబ్బారావు) @rao2z]

A critique of (the way people understand) Tree of Thoughts (ToT) paper: #SundayHarangue

From the time the ToT paper came out on arXiv, the LLM fan club saw it as a savior for lifting LLMs from their System 1 life to System 2 reasoning status. (c.f. https://t.co/MPUdvj3AwC ).

The hoopla mystified me--enough to even come up with a tongue-in-cheek parody abstract on "Forest of Jumbled Thoughts Prompting" .. 👇(c.f. https://t.co/3CO4Nnx07p ).

With terms borrowed liberally (if inaccurately) from problem solving agents--search tree, expansion etc.--ToT was viewed like it was giving LLMs reasoning powers by helping them do some sort of systematic search on world states. (c.f. https://t.co/iaHF6aEkQY)

IMHO, that is pretty misdirected understanding of what ToT paper essentially does.🫤

Given that the misunderstanding (IMHO) is pretty wide spread at this point, I thought I will write down my different take.

(FWIW, my goal is not so much to critique the authors--who as @srush_nlp says do a pretty impressive branding job, but to provide an alternate interpretation to the fan club. https://t.co/GMMoIat5fw)

I think the best way to understand the "tree" in ToT is not as a search tree in the problem solving agents, but as a "prompt diversification tree" that is hand crafted in a problem specific way, to make the LLM suggest diverse potential solution candidates, which will have to pass muster with its hand crafted or external verifier.

In general, LLMs are great universal idea generators sans guarantees (c.f. https://t.co/PxKh3GEgpv ).

If you have an external verifier to test the candidates, then any Generator+sound tester/verifier will be guaranteed sound by design!

(And if you are thinking why you can't just use LLMs to verify their own solutions--think again, or see this: https://t.co/BRSU4AyGji )

A simple back-prompting method--with the tester/verifier automatically sending feedback to LLM to get new candidates can thus become the engine to test out multiple ideas. (c.f. https://t.co/L2hFOgQ173 as well as our #NeurIPS2023 spotlight paper https://t.co/6vgNtIxdA9).

Whether or not such a back prompting system will be complete depends on how exhaustive the solution candidates generated by the generator are. A heuristic here is to make the LLM generate sufficiently diverse potential candidates.

There are many potential ways to make LLMs generate diverse candidates--starting from playing with the temperature, to priming it with hand-coded problem-dependent prompts. This latter is what ToT does.

Specifically, ToT employs a problem specific prompt priming method. The "tree" in ToT is essentially a way to generate diverse priming prompts (that the authors set up in a problem specific way).

Once you realize this, you will stop making questionable connections between ToT and search/reasoning!

The guarantees--if any--are coming in terms of soundness of the external verifier. The one clear reasoning problem used in the ToT paper is the 24 puzzle--for which the external verifier can be easily implemented in terms of arithmetic operations (thankfully not done by the numerically challenged LLM!).

In general though, the verifier may be more complex and can involve substantial work (you can substitute a simulator for the verifier--but, hey, someone has to write that simulator too! c.f https://t.co/F3rRTewcqu).

In general planning problems--that are of particular interest to me, one way to provide an external verifier is to (a) write a domain model and (b) feed it to an off-the-shelf model-based verifier like VAL.

One of the papers we will be presenting at #NeurIPS2023 shows how we can tease out such domain models from LLMs in a semi-automated fashion (c.f. https://t.co/7R8SHAErQW). This can reduce the effort in providing the external verifier.

The prompt diversification itself could be automated with the help of the domain model that is teased out--you can, in principle, generate meta-strategies corresponding to prefix (progression), suffix (regression) or body (plan-space) elaboration prompts! While our work focused on PDDL domain model, an HTN model, similarly teased out, could also help with problem reduction diversification. (c.f. https://t.co/0fSfL7XttJ )

tldr; ToT doesn't automagically make LLM into a System 2! It depends on two types of problem specific inputs--external verifier (to check the guesses) and a prompt diversification strategy tailored to the problem (to nudge the LLM to generate hopefully more diverse candidates)--with the hope that one of those will pass the muster of the external verifier. The allusions to "search", "backtracking", "breadth first strategy" etc. are, IMHO, mostly misdirected.

(h/t yochan group deep dive lead by @mattdmarq)

[Rui Zhao @ruizhaocv]

MotionDirector🏃 released the online demo @huggingface: https://t.co/Z374SW2sLn.
More MotionDirectors are on the way. Stay tuned! 🔥
For more details, please refer to our GitHub repo: https://t.co/23BsH22vFX.

[DinosaurAI @dinosaur_ai]

@rsg An economy with no blocked acquisitions would also lead to an environment toxic to startups

[Xin Eric Wang @xwang_lk]

GPT-4 and Gemini are systems and products, not models. There must be lots of engineering tricks and hard-coded rules, and we would never know how many models are inside the systems before open-sourcing. Requesting comparison with them is unfair in scientific research.

[Emad @EMostaque]

Our new #StableLM Zephyr 3b language model is 1.6 Gb & runs at 40 tokens/s on a MacBook Air M2.

That's 5x faster than most folk can read.

Without internet.

It's ok at doing love songs & raps on open generative AI and more, check it out 👀

More to come.. Wonder what's next 🤔

[AK @_akhaliq]

MEDITRON-70B: Scaling Medical Pretraining for Large Language Models with @Gradio demo

local demo: https://t.co/vJjy6m6m6g

Large language models (LLMs) can potentially democratize access to medical knowledge. While many efforts have been made to harness and improve LLMs' medical knowledge and reasoning capacities, the resulting models are either closed-source (e.g., PaLM, GPT-4) or limited in scale (<= 13B parameters), which restricts their abilities. In this work, we improve access to large-scale medical LLMs by releasing MEDITRON: a suite of open-source LLMs with 7B and 70B parameters adapted to the medical domain. MEDITRON builds on Llama-2 (through our adaptation of Nvidia's Megatron-LM distributed trainer), and extends pretraining on a comprehensively curated medical corpus, including selected PubMed articles, abstracts, and internationally-recognized medical guidelines. Evaluations using four major medical benchmarks show significant performance gains over several state-of-the-art baselines before and after task-specific finetuning. Overall, MEDITRON achieves a 6% absolute performance gain over the best public baseline in its parameter class and 3% over the strongest baseline we finetuned from Llama-2. Compared to closed-source LLMs, MEDITRON-70B outperforms GPT-3.5 and Med-PaLM and is within 5% of GPT-4 and 10% of Med-PaLM-2. We release our code for curating the medical pretraining corpus and the MEDITRON model weights to drive open-source development of more capable medical LLMs.