Sergio Lopez Montolio

Just finished reading a whitepaper on open-source LLMs and their understanding of the Spanish language! 🌍 It’s so important to ensure AI is built, tested, and trained with diverse data to uplift all communities—no one should be left behind or unintentionally harmed. Let's push for inclusive tech that benefits everyone! 🤖💡 https://lnkd.in/gRz4AiHD #AI #InclusiveTech #DiversityInAI #LLM #OpenSource

17

3 comentarios

Yossi Matias made a good point by comparing learning mathematics to learning coding. Learning basic disciplines is as important as ever. To add to his points, we still need to learn mathematics even after the invention of calculators and computers. Similarly, we still need to learn coding alongside GenAI. Otherwise, how can we be sure that the code is correct? https://lnkd.in/gmtyDc75

8

How do you measure progress in AI? One Llama at a time! We dropped new models today at 8B, 70B, and 405B sizes, with longer context (128k), more languages, and better benchmark numbers across the board. Check out the Llama 3 research paper (https://llama.meta.com/) — the most detailed and transparent publication to date on what it takes to build a state-of-the-art general purpose AI model, ready to be plugged in or adapted to thousands of use cases by AI practitioners and the open source community. And if you know an expert in AI evaluation, send them my way! Measuring progress to AGI only gets more fun from here!

90

3 comentarios

Yesterday I was wrong and did not notice it. Today I stand corrected! I did not realize that the struggle of AI music to generate consistent song structures (intro, chorus, verse, pre-chorus, bridge, outro) is still a big challenge. It is not. Suno is now generating fairly consistent songs. In other words: We are currently witnessing the sixth-finger phenomenon to leave the stage. I guess it is safe to assume that it is only a matter of months (not years) until it is very hard to tell AI-generated and human-produced music apart. https://lnkd.in/ddyyyq8X

7

6 comentarios

The original video was the best explanation of RAG vs. fine tuning that I had seen, so looking forward to reading this update.

7

Mystic is looking for more clients; it's a team with a lot of smart people with varied talents, covering Python, Javascript, the JVM, deployments, architecture, and more. We've yet to see a problem for which we can't imagine a solution, that I know of. Keep us in mind, would you? And I am finding the "rewrite with AI" button on Linkedin vaguely hilarious. It's almost tempting to try it out just to see how much better it could do at such a simple message... in fact, gosh, let's try it on ChatGPT: "At Mystic, we specialize in solving complex challenges with a team of talented professionals across various domains, including Python, JavaScript, JVM, deployments, and architecture. We pride ourselves on our ability to imagine and implement innovative solutions for any problem that comes our way. If you're looking for a reliable partner to tackle your toughest projects, we'd love to collaborate. Keep Mystic in mind for your future needs!" ... not bad, and adding it dilutes THIS message, but that's okay.

8

Testing new AI models with #ollama in a small laptop. https://lnkd.in/deNkm9xT results are pretty different, lots of testing has to be done before adopting one of them.

1

I still meet so many folks who are convinced that chatbots powered by Large Language Models (LLMs) are going to leave traditional systems completley in the dust. And on the surface, that sounds pretty convincing! But let’s be real—every bit of magic has its price 💰. LLMs are non-deterministic by nature, which means they bring both creativity and endless possibilities, but also a fair share of inconsistency, quality concerns, and potential risks—especially in crucial sectors like #retail, #healthcare, and #education. When we’re designing conversational flows, chatbots, virtual agents, or customer experiences, keeping that human touch should be mandatory🤝! Generative AI has definitely created a buzz, but it comes with its own challenges. To create chatbots that genuinely help users solve problems or complete transactions, we need to dive deep into the principles of conversational AI. My take? We’ve got to find the sweet spot between creativity and sticking to best practices in conversation design 🎨✨. Right now, #GenAI is being used to analyze content, generate responses for agents, and even manage conversation flows, which really cuts down on development time and boosts the overall quality of agents—especially when it comes to understanding what users want 🙌. But let’s not ignore the difficulties ahead, LLMs learn from tons of data, but that info can get outdated pretty quickly, leaving AI chatbots in the lurch about important details on products or services. This can lead to inaccurate responses, and we definitely don’t want to lose our users' trust! 🚫 Retrieval-Augmented Generation (#RAG) has become a game-changer that takes all the info a company has—like structured databases and unstructured stuff like PDFs or chat transcripts—and transforms it into a neat format stored in a knowledge library. This makes it super easy for the generative AI system to access and retrieve relevant info quickly! 🔍💡 While LLMs cover a lot of ground, their open-ended nature can sometimes miss the mark when it comes to specific issues, like reporting an issue. So, when designing user interactions, we need to balance #variety with #clarity to help folks solve problems and complete transactions easily 🚀😊.

55

1 comentario

Black Forest Labs open-sourced FLUX, a 12B parameter text to image on par with Midjourney! ‚Schnell’ is a faster distilled version: https://lnkd.in/dXmw5fi5 Yet another awesome model made in Europe coming from a team of former Stability.ai and Runway.ai GenAI Pro‘s. Their largest model remains API-access only which is a good thing: Europe is much better in building AI than many think but we need to learn how to better monetize AI if we want to stay in the race.

5

We must consider the premise that moving on completely from the GenAI craze is not only a legitimate position, but maybe the smartest one. The theoretical minor benefits this technology provides dwarfs in comparison to the risks, both theoretical and concrete.

2

Arg! After thousands of lines of code cannibalizing the LLVM support library I’ve run into a fundamental design flaw in my approach. Too technical to talk about. Let’s just say I’ve created a set of cyclic dependencies where a depends on b which depends on c which depends on a. It’s because I made a fundamental change to how the library works (which makes it much easier to use when it has to work on different platforms like MacOS and iPads, and is the main reason I went down this path rather than trying to use the library as is) while trying to stick very close to the original structure and design. Not gonna fly. So either I throw out all that work and give up the ease of use - not happening - or I step back and rethink the big picture design elements. And despite the frustration I am loving digging into this library. Usually. By the way this is pretty much what programming is all about - running into obstacles and figuring out how to overcome them. We call it Software Architecture, but it’s not at all like building cathedrals.

6

5 comentarios

So I became fascinated by C++ coroutines late last week, and have spent a good portion of the weekend figuring out how they work. The TL;DR of my discoveries so far is that C++20 coroutines: 1) follow the best and the worst of C++ practices, and 2) are a really clever way to decouple stackless functions from their execution model. For (1), well, it's C++. No crisp & clean syntax, lots of weird compilation errors, and even weirder runtime errors. I hated them with passion for the first several hours. But then they grew on me, because the flip side is also true. The flip side is backwards compatibility and "only pay for what you use". And introducing a totally new concept — the stackless execution model, effectively, [proto-] green threads — into a mature and complex language is one hell of a pain! For (2), I do believe it's a genius solution for the language to separate stackless functions from their execution model. And C++20 did exactly that. There is literally no event loop in C++20! The claim (as I understand it) is that a tiny microcontroller may want to use C++20 coroutines, and the authors of the Standard are very explicit about not constraining possible runtimes. All that C++20 coroutines do is introduce stackless functions into the language as first-class citizens. And yes, stackless immediately implies resumable. So it is one step about the most-clever-possible syntactic sugar over `setjmp()`. Full one step. But not a millimeter more than this one step. Whether you "execute" your coroutines in a dedicated single-threaded event loop, or a thread-pool-based event loop, or by individual steps via some timer event or even a network packet — that is entirely your call. The stackless functions are there, `co_await` (as well as `co_yield` and `co_return`) is there, no callback hell is needed, and all the RAII and scoped initialization/ownership model is fully intact. Now, I'm still elbows deep in my experiments, but here's the first big LinkedIn-worthy question. Why don't we write our C++20 [unit] tests as corourines? Say, you want to limit some test to five seconds. And fail it as "timed out" within these five seconds. Before coroutines, doing this without instrumenting the very code of the test involved `fork()`-ing the process, effectively relying on the operating system's primitives to ensure proper resource deallocation. With C++20 coroutines, as long as the slow test is slow on non-blocking I/O (i.e. not in an infinite loop, but on something that `co_await`-s stuff), it is possible to time-box each individual test to some five seconds very much organically. Because a coroutine frame, unlike a stack frame, can be `.destroy()`-ed safely and cleanly. So, are we doing it yet? If no, why not? If yes, what would be some next-gen `gtest` to look into? Also, I'll be writing some code and blog posts on C++20 coroutines soon. If you are reading this text and are an expert, DM me pls — I'd love to pick your brain!

19

4 comentarios

The next generation of LLMs will arrive later this year. As a reference, Llama 3 by Meta was trained on 25.000 H100’s. Also, of course training started at 4:20 https://lnkd.in/dyYZqz5n)

10

It's not just AI Girlfriends! (sorry Joaquin) 🤖 👧 The Gen AI industry is undergoing a major (and rapid) shift from using proprietary models in production towards open source models. This is true in a general sense and it's even more pronounced w/ fine-tuned models. The bottom line: Tech companies are wary of building their castle on someone else's land 🏰 Do you prefer to build w/? Open source or OpenAI?

4

1 comentario

Llama 3.1 has demonstrated one more time that open source is the way to go. Still doubtful? Give it a try using distilabel. 1️⃣ pip install distilabel 2️⃣ Select your favorite LLM 3️⃣ Test it with your own prompts And if you like, build with it!

28

2 comentarios