Отрывок из 1-ой лекции нового сезона AI Product Engineer

0:00 We will essentially be both the product and the engineer. And I think that we, as developers, for example, need to lie around more, get involved in the product, and, conversely, as product managers, get involved more in development. And I know many experienced developers who are frustrated by this aspect. And personally, my productivity, eh, it increased, well, according to my feelings, three times. we can write and check quickly, God knows how, but we will definitely talk about it. There is an area of knowledge that I don’t even know that I don’t know, you know, right? But LLM has it. Resarch is conducted in order to

0:46 understand why LLM, or rather, not why, but how LLM comes to the output it comes to. And today we start the second season, AI Product Engineer. A course that started out as experimental. And what I realized while we were leading the first season was that it was transforming as things went along, because a lot of new things were appearing. And so don't be surprised if some new things come up

1:31 as part of the program as we go along, because, well, I'm trying to keep it as current as possible. For example, when we started the previous course, uh, during the, uh, course, the infrastructure appeared to do coding, agent code. These are agents who write the code themselves. And to make them from a box of lamps. And I initially had a course, well, this lesson was made, that we ourselves raise there docker, the agent writes the code, we execute in docker, uh, everything is clean there, secure and so on. Ah, but, well, that requires a lot of movement. And then both Anthropopic and

2:18 Open AI are releasing the ability to actually launch, well, write, uh, agents that run code in their containers, in their dockers, and so on. And I understand that, well, I need to redo this lesson on the fly. And in the end I show two options. So don't be surprised if some things are added. And the second thing is that as we go along , if suddenly you have some new topics that you are interested in, so that we can look at them, if I see that most people are interested in them, then I will adapt this material or within the framework of our Office Hours format, within the Office Hour format I will tell you how,

3:05 well, how to do something, a little bit of the logic and structure of the course. I understand that many have read the program, but I will outline a little, so to speak, what was not said in the program and in between. The most important thing, and this is probably the biggest theoretical part that will be for the entire course, is to clearly understand the difference between the two approaches to programming, because they will be like a trail of these differences between these two approaches in different topics. Ah, and today we’ll talk about a specific example, we’ll look at the difference between the two types of

3:52 systems. And then, when we, well, let's say, put on other layers, you will feel and see when we actually combine both approaches, both approaches. We won’t say that that’s all there is to it, we need to switch completely to probabilistic programming. I'll explain what it is today, and sort of forget about determinism. No, you will see that in our systems we combine these two paradigms. And often each has its pros and cons, obviously, and one compensates for the shortcomings of the other. And my goal is to show different

4:38 paradigms, as it were, and how they complement each other . Once we have sorted this out, then within the framework of the DZ you will create an end-to-end project. Let me say right away that it is not necessary to take this particular project. If you want, you can take your own project and do it. I saw that some of you wrote in the intro that you want to finish your part there or figure it out. Here. with pleasure and I highly recommend taking on your project. Yes, of course, some topics may not exactly fit into your project, but globally we will have an end-to-end project where we will

5:23 create an AI product manager. That is, we will, uh, try to solve a number of problems that a good product manager in a digital product company really does. And we will look at how we could replace it, how we could automate some parts of its work thanks to illa. And there, first, we will try to automate the interview with the casto. And today we will try to, uh, automate the processing of product feedback. Well, for some it might be reviews in Appstore, for others it might be supportportfeedbk, for others it might be some other

6:09 form of feedback, how to automate it, then how to make virtual userboards, and so on. you'll see us start to push more and more, uh, aspects of what a product manager does into automation. Because I see that, ah, it’s not for nothing that our course is called AI Product Enger. We will, in essence, be both a product and an engineer. And you will see that some topics will be much closer to engineering, some will be much closer to product. That's where the second, uh , meeting is, it will be more about, uh, product, but automation of this aspect. Next, uh, we will

6:55 build agents, well, or more precisely, multi-agent systems. And there are several central components that they have. And we will, in fact, build, uh, these components, how agents sense the environment, how they, uh, make decisions about what to do, and how they do it, and what ready-made tools there are to implement, well, uh, important components for such systems. And, of course, what are the architectural patterns for designing multi-agent systems, the pros and cons of these architectures and, accordingly, where to

7:44 apply them. a huge part, today you will feel it, in general, the design of such systems is due to the probabilistic nature of programming with LLM, when the same input can give a different output. We have to build a different system for measuring the quality of such systems. And if you are sure that there is TDD, yes, Test Driven Development, then I see that such D or EDP evaluation driven development appears. We will learn what evaluation is, how to design

8:31 quality measurement metrics, how to optimize the development of promts, pipelines, and so on in accordance with these metrics. Because it seems to me that without this and without this skill and this practice you will not understand what is happening with the LM Powered system. Well, the last thing here will be a little flexible, these are special topics. For example, initially we didn’t include Voice agents, but the guys asked us to, and we’ll do it. Secondly, I see that there is a high probability that soon there

9:16 will be, well, I kind of understand, I don’t know the future, but I feel that it will be . Agency stores will appear and the issue of communication between agents developed by different teams will arise. with each other and, uh, protocols appear, uh, of communication between agents. Ah, and we'll actually look at the main protocols. Well , essentially there are two of them for now. Ah, but there are initiatives, yes, IBM has A2A. Here they propose their protocol. So these two are key. We will talk more about AA . I think he has a

10:03 better situation in terms of support, but we'll see. My opinion is that this year we will see whether Open AI or Google will have an Appstore for agents. Actually, here are roughly [music] topics and this end-to-end project that I was talking about, where we will create an AI product manager, who, actually, what will he do? It will automatically process feedback on the product in different forms, i.e. text, video, screenshot, attached, and so on. will automate the resarch of this, well, well, for example, roughly

10:49 speaking, it will classify whether it is a bug or a feature. If it's a bug, then check if we have a duplicate in our issue management backdoor system. If not, then start it. If this is a feature, then it will do something like deep resarch. How does this feature work for competitors and do they even have one? And, accordingly, ultimately formulate how this feature should be done. Well, and there you will see that I simply do not include this, that it will definitely happen, but I understand that the next small step is that she will start not only creating these features, these tasks, but also developing them,

11:34 or, let's say, developing them by 60-70%. And then, ah, we still need to collect analytics. This is the entire pipeline that we will do during our homework. Well, thanks to this, we will learn how to work with multimodal data, design multi-agent systems, provide their communication and, accordingly, use different external IPs for this. So, what is this new, uh, programming paradigm? How is it different? what kind of limitations or features does it impose on our development, how does development change because of this

12:20 , how do different disciplines change within the development. Well, I really, like, liked it as an intro, and we will use this article. An article Tim Rely wrote about the end of programming. Well, with a question mark. And if in short his main idea is that this is not the end of programming, this is the end of programming, but in the form in which we know it, in the sense that the systems there are powered by LLM, they are different. Well, in order to interact with them,

13:07 current programmers will need to retrain. and it will be much easier for a new programmer to enter this type of this programming paradigm . he even compares it there with, uh, with how when the platform block like Wordpress appeared, how much it opened up the world of creative writing in, well, how would you say in the world of, well, how would you call it, fiction and non-fiction. And he sees the same thing, that tools, uh, based, firstly, on and helping to code, uh, based on LLM and

13:54 in general the integration of LLM as a backend, uh, backend in quotes or as a brain for your products, for our products, this is a completely different type of interaction. Well, that’s essentially what our entire course is about. Very cool article. We will even analyze it today as part of lifecoding. But the main point is that we are simply moving, rising one level of abstraction higher. This will increase the number of developers in general, in his opinion, and I am closer to his opinion than that programmers will no longer be needed. But because of this abstraction, that we rise to another level of abstraction, I believe that we need,

14:42 as, for example, developers, to lie down more, get involved in the product and, conversely, as product managers, get involved more in development. There is a popular opinion now that development is shifting to the right. To the right, in the sense of closer to the customer. That is, people who are closer to the customer, they begin to be programmed. That is, roughly speaking, classically, if a product manager has not programmed, then he begins to program. But in this, I believe, there is a second point, that the developers themselves are moving to the right, that is, they are becoming closer to the users. And therefore, ah, as if all

15:29 development is shifting to the right, in my opinion, but always when we start talking about this, the term wipe coding comes up. I think you are familiar with this feeling that you seem to wipe code very quickly, but then debug it all for quite a long time. And why does this happen? And how does the specifics of the work of such probabilistic systems affect the problems that we then have to debug using vibedebugging? This is exactly what we are going to talk about.

16:15 And I think that global coding is, let's say, a tool that allows us to code. This is a huge help and acceleration in increasing productivity. I hope you have already felt it there or will feel it there as part of the course. But secondly, if they are not properly instructed, not properly controlled, not properly set up Guard Rails, then we can get a debug that will be a Nightmare for all of us. OK. What is the key, so to speak, difference between deterministic and

17:02 probabilistic systems? There is a great post on this topic, and we will be exploring some of the ideas in that post throughout the course. And in Hamel, he's known in narrow circles, uh, as the guy who helps design AI Powered, LLM Powered products. And he has a very cool point that, having done a lot of consulting projects in this regard, it is generally necessary to start projects in which LLM will be used with the question: “How will we measure that this really works?” This is the very same Driven Development that we will talk about in depth

17:48 at the fourth meeting. So why is it so important for us to be able to measure these systems? This is what needs to be sorted out. So, let's globally understand the terms there and try some coding examples. Actually, deterministic systems. I can very clearly describe the sequence of steps for transforming some input. And, uh, what's cool is that no matter how many times I launch, uh, this pipeline, it always has the same inputs, and if I don't change the pipeline, it will give me the same

18:35 output, which is cool with a system like this. It is stable, predictable, it is, a, it is easy to measure, the quality of such a system, a, because, well, the deterministic outc, is there the same input to issue. That is, I can, ah, easily, mm, let's say , check whether it gives the outcam that I expect. And the most important thing is that I can easily audit it, yes, or debug it. That is, I can see at what stage what is happening, what transformation or logic to track down, well, right down to each point and quite precisely, yes,

19:24 precisely correct the part that I want. Probabilistic systems, they are very good at, let's say , solving problems where the input that we receive may be in a form that is difficult to, well , let's say, determine. Well, for example, often it is, well, understanding the text, that is, when we do not just need to find some words in a sentence, but when we need to

20:09 understand the meaning of these words and, accordingly, do some processing with them . And I can make mistakes in words. That is, in this regard, it is very adaptive and can handle such cases well. But the only problem is that each time it can give a different output for the same input. This is actually a huge problem. It forces us to think differently about such systems, to measure them differently. An entire valuation driven development was invented for this. But the main point is that we, as developers, are not used to such systems. We are used to it, and I know many

20:55 experienced developers who are frustrated by this aspect. And I think that this is largely because we are used to programming systems that are deterministic, and easy to track, easy to manage. The system seems to be completely under control, and this creates enormous difficulties for probabilistic people. Let's go less, well, let's move on to lifecoding and just figure it out, let's try to feel the problem we're talking about, a, feel it using an example, and then we'll do a zumaa and try to formulate in more detail the fundamental difference between the two types of a systems, a,

21:43 and, accordingly, summarize what the paradigm shift is and why we, what we need to do, a, so that we can somehow at least manage or understand how to manage probabilistic systems. To do this, we will take the following problem. We have this text. We will take the text of the article as a different one about the end of programming as we know it. What should we learn to do? There is often a task in a product when you receive feedback and you need to somehow, uh, categorize it, understand from it what is a bug, what is a

22:31 feature, what is just praise, let's say, or just some kind of non-productive, let's say , unproductive feedback. Well, they're just arguing there. And, uh, and when you have, for example, thousands of reviews, uh, coming in per week, it’s clear that it’s impossible to do this with a person. And we need to build some kind of pipeline within the framework of our end-to-end project of an AI product manager, who would analyze all this feedback, summarize it, categorize it, and we would understand what our users think about our product. A very simple task that any

23:17 product manager must perform and which takes, well, if it is actually done, a very large amount of time from the product manager . So we want to automate it, so we want to implement this task, the task of understanding the text, while the text form is in feedback about our product. And we will try to solve this problem in two ways within the framework of the lacoding task . And before we start, I'm going to ask you to tell me what you think the pros and cons of each approach are before we even start, uh, coding this problem and, uh, seeing the results. So, ah, two

24:05 approaches. First, we try to code without using LLM. We will use one of the popular libraries NLTK. And we will try to process this feedback in a deterministic manner for the purpose of understanding what users think about us. And, uh, I'll explain how this library works. But the overall idea is to search for specific words in the feedback and guess what kind of feedback it is. Well, let's say, and if there are a lot of words

24:50 cool, then this is probably positive feedback. Or if there are a lot of words with, ah, fu, a lot of reviews with the word login, well, probably we have some, well, this group of reviews is related to login and so on and so forth . The second approach is precisely probabilistic. That is, we will take the LMA and say: "Lam, you give us the summation yourself, and look at all the feedback, categorize it and tell us what our user thinks." Here are two fundamentally different systems in terms of approach. I want to show you how I use clotд. Eh, and it seems to me

25:40 that this personally increased my productivity, uh, well , according to my feelings, three times. I may, of course, exaggerate there, because I am essentially a techno-optimist, but I will try to show you as we go along how it all happens. And accordingly, mm, I am ready to recommend this product with both hands for use. If I don’t have any super preferences by ID, then I do have them by this one. Let's check it with an example. And look how we will try to implement this system . That is, we don’t want to write the code ourselves, which we need

26:27 to compare these two paradigms on this task. So I just want to, uh, make uh, well, so that the CD-code would write all this code for me and, accordingly, we would solve this problem. the task of writing two types of text summation, deterministic and abstract, and, accordingly, would look at and compare them with each other. So, how I'm going to do this, I actually just took a screenshot of this, uh, process, uh, I'll immediately submit this screenshot

27:18 to the boat code. And I tell them, actually, review screenshot and help me develop a system that compares. Can you speak Russian? First of all, it’s just easier for me to say it faster in English. Secondly, elmki are better, in fact, in my opinion, and when you instruct them in English, they do the tasks. Therefore, I will do it in English, but in principle it can be done in Russian. Actually, let him look at the screenshot, of this system. And, in fact, his task is to write and compare these two approaches.

28:09 Ah, well, actually, which article do we want to examine, right? That is, look at the screenshot, develop for me a system that compares these two approaches based on the task of text summarization of this article. I'm asking you this problem. And, accordingly, in general, for now you will notice that at the beginning I will write prompts very stupidly, and then, well, you will see that they will be a little more elaborate, yes,

28:55 longer. But I just want to show in general how it is, and that super-large barriers to entry are not needed for this. And in parallel I will comment on some aspects. Why? Because I think the code as an implementation of the AI agent is very well done. and some UX solutions that are there, I think I will draw your attention to them, because when we do homework and generally analyze agents, we can take some ideas from the cloudcode. Here's the first thing that's done well, I think, is, look, well, it's clear that I

29:41 launched the code in a separate folder, there's lesson one in edu AI Product Engineer 2. And, but the screenshot, well, on my Mac system it's in another part, there's Temporary Folder, and that's why it asks for permission to read the file from there. So what the agent actually does, in my opinion, is it gives me a sense of transparency about what it's going to do, and it gives me two levels of autonomy. Yes, here we see, a, the first level of autonomy is to allow him once, because I see that he just wants to read the text from the temporary folder. And,

30:27 accordingly, I have a second option - to give him the ability to read everything from this folder within the framework of this session always. And thirdly, it is clear that he did not understand what to do at all. And I generally want him to do this very often the third option is needed when you accidentally pressed Enter, but did not finish writing or a new thought came to your head. Well, I'll give him full access and say: "Calmly read this temporary folder. Even if he releases RM in it, I wo n't be too upset." Here. Well, and, accordingly, it is clear that he is now considering developing this system for us. And what do we

31:17 see in wipecoding? You've probably noticed that if LLM writes a plan for itself and writes this plan into some file, an MD file, for example, then it doesn't lose context and remembers what needs to be done. We see exactly this kind of, uh, situation, when she presented a plan and said: “I need to put together, well, tasks there.” And as these tasks are completed, it will, so to speak, put check marks in the completed files. Well, okay. And the next one is a continuation of the same thought about levels of control. She says, "Can I

32:05 create a file here?" I say: "Yes, within the framework of this session, calmly write whatever you want in this folder." And, accordingly, he has practically already written the code. Let's look at this code for now. Oh, and he's finishing up there for now. Let's see what he actually plans to do. Well, the main thing that happens here is text summarization. What do we see? Well, okay, he's there Init, he tells him, who knows NLTK and the library, he needs to download the dictionary of terms, just, uh, which

32:51 we talked about, and then use it. And then, accordingly, he downloads all this from us, and he wants to download an article with beautiful. That's okay. And so, in fact, he wants two main methods. This is sumorization. We see that he uses NLTK there precisely to build the so-called sentence score. For those who don’t know how LTK works, in essence, it’s something like this. All the words that are popular and that are in this, uh, text are taken. And, uh, all the sentences in the source text

33:38 are evaluated by the occurrence of words in this in this sentence. That is, roughly speaking, if in this sentence there is a word 1 2 3 4 out of all four possible, then these are the highest. is cleared of all prepositions and unnecessary little words. In short, accordingly, it turns out that each sentence has some kind of sorrow. And, uh, the summation is just, uh, the most popular sentences in the source text, you know, right? That is, it takes, uh, text, counts the words in different sentences, and the sentences that are the most popular, it counts, if I

34:25 put the most popular sentences in the summarization according to the occurrence of words in them, this will be a cool summarization. And now we will see how cool this summation is. And then, ah, about well, probalistic - this is LLM. Here he wants to use this Google. I just saw. And, accordingly, we will sort of remake it into Open AI. He wants to use GM. We will now convert it to Open AI. And then, ah, he even, you see, decided to put together some kind of dashboard. Now we'll see. And, actually, a file to run

35:11 all this from the console. Actually, okay, good. Wants to create, run executable, make scriptrit. Okay, there is readmi. That's basically all I said. Well, as I said, I don’t like that he uses this, well, he made some report on what, in fact, he got. I like that Google Understands, I could immediately write normal instructions. And let's say we take

35:57 GPT 41 as a model for this. OK. Well, actually, now he will replace us and we will see what we get. Let's see what libraries he has here . Well, that's to be expected. This is expected. Well, it's because he wants, uh, this gradio interest. That is, he, apparently, even has a web interface somewhere, maybe he even decided to make this dashboard , yes, he decided to make a web interface through Gradiok. So far, from the point of view of, uh, here are our forecasts that we

36:44 talked about, and what do we have from this point of view, and then in terms of content, that is, well, it is obvious that, as we correctly said, uh, the speed of execution, uh, of the task is fundamentally different. That is, we see that there is half a second versus 5 seconds of execution on this piece of text, yes, the text could have been much larger, and then we would have had completely different ones . If we, if we now, yes, I ca n’t, it’s very difficult for me to ask a complete question and even if I say in the instructions, well, I’ll say that make the sumary 200

37:30 words, it can give me 203, it can make 197, and that means I have a pipeline that waits for this summarization and somehow transforms something with it and so on, or it has to do an additional check for the number of words, because I can’t be sure that it will definitely give me 200 words. And because of this, I might break some downstream pipeline, and it will turn out completely wrong. But for NLTK to work, it needs to download a dictionary, and therefore, in fact, this, well, let's summarize the results,

38:21 let's see in general what we got in terms of content. Let's see what you see? And what difference do you see in the way the extractive approach looks Versus the probabilistic LLM based? Well, by the way, you see, I told him 4.1, he took the tubo because he thinks that 4.1 doesn’t exist yet, and I obviously have to repeat to him that, hey, it already exists and can replace it. Well, or I can actually change it myself with my own hands. But what do we

39:07 see? This is what summation looks like in an extractive, well, deterministic approach. And this is what it looks like for the probabilistic one. What is the fundamental difference? Look, actually, because, uh, the deterministic way, again, it just picks out specific sentences from the source text. That is, I can find these sentences in the article itself, but here, well, I can’t, uh, find this fa, that is, look, from the point of view, that’s absolutely right, Yulia, that is, the text was completely reworked. I

39:55 can't hard-code the source text from the summary. No way. That is, just imagine that I need to make a QA system that does eation. How right did LLM do it? did she make something up in this formulation without obviously reading this and this and this and how can I compare if she completely reworked it I can’t control I can’t somehow compare I need a completely different one imagine who was there maybe

40:40 deeply involved if assurance was written there test. How would you write a test for the second method? Do you agree? This is, well, that is, a very non-trivial task. We will talk with you about how to write tests for such probabilistic models; probabilistic tests are needed. Well, I will show you that other LLMs can act as evaitors, but this creates a new problem. And who evicts the evaitor? Yes, if we take LLM, then it will actually be worse. What if LM herself comes up with the text, and another

41:26 LM who checks her might also do it incorrectly. And the question arises: who checks the final LLM if we use LLM as an eator? And it really feels like we can write quickly. There's no way to check it, but we 'll definitely talk about it. I can take it and really test it, audit it, to prove that nothing happened, but was made up. And accordingly, if we look at the similarity score of the first sari sumary and the second, we see that the first one is much closer to the original. Well, because these are just ripped out sentences. But the question is, do

42:13 these sentences describe the meaning of the article? That is, how likely is it that a text that, well, a sentence that has the most, well, occurrence of words in a sentence describes well the essence of this text content. about reading and scoring. He probably does it by the length of the sentence . And since the MCA wrote, well, we didn’t give additional instructions on this topic, but, well, one long summary, then perhaps the readability of the second one is higher, because it’s short sentences, and not this long narrative, a, which we received.

43:01 Well, and probably the last thing that I can interpret, that is, I can listen to the text, that is, I can understand how I managed to choose these sentences. Why these particular sentences? Because I can change the words, this approach, I can change the words and so on and so forth. But, of course, this sum that we got, this is generally, in short, a very, uh, some kind of strange excerpt, yes, actually, uh, so let me try to summarize, what I'm actually getting at, this is

43:46 all that we have, if we start comparing these two approaches structurally, then we will see, in principle, what kind of observations, yes, that we have a deterministic method, there are specific sentences, it sorts by Wordфquency much faster, but what if it often happens that the sentences that were chosen, they actually repeat each other, because it looks for words that are included in the sentence as much as possible and, accordingly, these sentences can repeat themselves and not give a new meaning, and some part of

44:32 the meaning has disappeared altogether. And ideally, the article should be broken up into some pieces, well, for example, according to the formatting that the author did, yes, because he has headings. and within the headings, search, make a summary for each section of the article and then, according to the sumri sari, make it as if for the entire article. We understand, yes, the idea. Well, and, accordingly, it is clear that it is more expensive in the case of LLM, but the result is better. Let's look at it from the point of view of principles, yes, and let's translate this into specifics, that the output, as we have already

45:18 said, is completely determined, and we can inspect and change how it, as an input, turns into an output. We don't have any random home. Everything is quite structured and deterministic with us. Therefore we get predictable execution. If there is predictable execution, then we can do predictable tests. And for us, all logic is based on rules. Anyone can look at these rules at any time and change them. I will say right away that in some industries, if this rule is not followed, the rule that the logic of decision-making can be taken

46:05 and read, then such systems are prohibited altogether. Well, for example, in the banking industry, well, I don’t know, for example, like in Russia, in the USA, let’s say, it is prohibited and in Europe, uh, it is prohibited to make decisions about issuing a loan, uh, with probabilistic systems precisely because of this aspect, that it is impossible to audit by what principle [music] the model made the decision that someone should be given a loan, and someone should not. Why is this necessary? Well, this is for anti-discrimination.

46:53 Here is my global point, that we seem to be talking about some programming paradigms and so on, but business, uh, rules impose restrictions on us, which parts of pipelines we can generally make probabilistic systems, and which we do not have the right to, seeing the pros and cons of each of the systems. And just about explainability, when, when, well, as I said, this is, for example, regulated environments or where the cost of error is very high, and, for example, driving a car, and where I believe that the number of

47:40 inputs, excuse me, inputs that can come into the system, it is more or less finite, that is, predictable. A, that is, conditionally, look, that’s why anti-spam systems are most often made on a probabilistic basis, and not on a deterministic basis, because who remembers how spam began, at first all the rules were deterministic. And what's the problem with deterministic rules, that as soon as, uh, well, it turns into an arms race, and these rules or reverse engineering is done

48:26 through the submission of different, well, inputs and monitoring the outcome, well, the result of the check, and, reverse engineering is done, the rules by which a spam filter is made. And, accordingly, then ways to circumvent these rules are invented. Well, for example, here's a classic way to bypass, a, the deterministic rule for spam - this is text, change the text in words, a, Latin and Cyrillic characters, for example, or, a, for example, replace the letter O with a zero. And from the point of view of a deterministic system, if this

49:13 rule, well, was not included in the reference book, yes, then, well, for example, it will not understand that some word there is simply replaced by a zero, but the person will read it and understand. And you and I know this test, when you can remove all the vowels from a sentence and a person will still understand the sentence. Actually, it is precisely these systems, where the input is variable, that are better solved by probabilistic systems. But where there is low variability, they are ideal for deterministic systems. Well, where we have clear rules or someone who is an expert can formulate them.

50:00 Here is an interesting drink that you will feel what I will do. In general, a classic product manager, well, within the framework of our end-to-end project. And the classic product manager, it seems like he is supposed to know the business area very well. Well, if it’s a custom development, then it’s a business analyst who interviews customers and formulates requirements. But, ah, what do I see? And this business expert, product manager or business analyst, they are an important part of the system, because they formulate these requirements, they have these

50:46 rules, they have this knowledge. But what's happening with the paradigm shift is that, in my opinion, a significant portion of, uh, domain knowledge, it's on the Internet. And therefore, LMs out of the box, if they are correctly programmed, can formulate and apply these rules. And because of this, I think that developers are starting to need less and less product managers, or, let's call it that, those who know the business area, because it often turns out that the knowledge that

51:33 was on the Internet on this topic is even cooler than the knowledge of a product manager. Here is my personal case, when I had a direct insight, uh, a hard one on this topic. Previously, I had a paradigm that a good developer should understand the business area, he should immerse himself in it. Here I was conducting Strateggy Talks. I tried to make sure that the whole company knew why we were doing things, knew the terminology, uh, how things work, how the economics of an airline are built, and so on and so forth . But now I'm starting to completely reconsider this point,

52:18 because I will still know worse than LM. And I need to direct my focus to other aspects, including aspects that we will be examining in this course . This is how to protect, how to properly debug these systems, how to protect them from errors thanks to this probabilistic system and so on. And therefore, it becomes clear to me that those who formulated the rules, they can fade into the background. Actually, the case is like this. I'm designing a system that evaluates and qualifies leads for one of our customers to see which US visa is best for them

53:05 . There are several classes of visas. Well, in order to, uh, have the opportunity to stay and work in the USA. And, uh, one of the points is how much your salary is, well, above, roughly speaking, the average. And so, well, I’m writing this qualification system and decided to write it completely in a different paradigm. In a paradigm where LLM formulates all these rules itself, I will simply rush through it. And she even formulates a plan for how she will search for data on I give it to her, we will try all this. I give her

53:51 access to Google, Google search as a tool, and I tell her that my task there is to check how suitable a given candidate is for this type of visa. Think about what information you need, plan it, write a plan and then implement this plan with the tools that are available to you. And Google, Yumilyan is just like an example, in short, it’s not fundamental. Well, what happened? In general, yes, and I read her plan, yes, in short, and thinking about the plan. Rizanik, we will try this too . And I read this text, she

54:36 says there: “Okay, this candidate, he works as some kind of speaker at a Swiss institute, and I need to evaluate how much his salary is above average.” Well, in general, if he works in a Swiss institute, it is public, well, it is like a public institute or like a state, in short, an institute. But in fact, the salaries of all employees of Swiss, in short, state universities, are published in such and such a register. Therefore, I need to go to this registry and take this salary from there. and compare it

55:22 with the average for Switzerland. And at that moment I realize that I cannot know. Here. That is, first of all, I didn’t even think to think that it was possible to find a public database of Swiss salaries. Secondly, I don’t even know that they are in the public domain . Do you understand? There is an area of knowledge that I don’t even know that I don’t know, you know, right? But it does have it. And I understand that in order to hire such a product, who will know everything, but such conventions, it is either very expensive, or such people do not

56:08 exist. And now look at how disadvantageous it is for us to compete in this aspect. And this, well, with LMs. My point is that the rules that are being formulated, and I will actively call for this, many need to be transferred to lm, because it gives her tools. update these rules, because then you can endlessly improve your product with each new release. This is what Sam was talking about, right? He said that you

56:53 should design your systems in such a way that each new version of the model, as if it simply by default makes your product cooler. And even just when the LM is updated and the knowledge of cats time is shifted, it will improve for you if you base the rules you use on the knowledge base, you understand, right? And so you sort of stand on a wave, and the wave itself carries you. The probabilistic key point is that it learns from the data. And whoever made traditional ML systems, in principle, probabilistic systems - this is also an ML system. The only point is that we needed to collect a lot of data

57:41 so that it could normally, well, perform the task that it has. Well, for example, the classification task is classified . What did they add to this? that there is no need to provide a lot of data, because it is already, uh, trained on a large data corpus, but it is necessary to provide those very F shot one shot examples, so that, roughly speaking, the lamp can be directed to which part of this huge data corpus that it contains, to find the most necessary one, in order to correctly understand the examples. And so that you don’t need to feed hundreds of thousands of lines

58:26 to teach the model to qualify, for example, the emotional coloring of sentences. And here it is clear, as someone correctly wrote, for probilistic systems you need probilistic tests. It is true that the measurement of the result becomes different. That is, roughly speaking, you formulate the quality of the system approximately in such a way that in 95% of cases Accuracy is not less than, and not in the form that there should not be a single critical error. Well, here is a classic test plan, which is done in

59:12 classical programming. Well, and, accordingly, I just gave the example of spam, and I said that when you have a situation of an arms race and when the variability of inputs is very high and it evolves over time, then it is better to make probabilistic systems that learn as they go, because such systems, well, turn out to be more flexible and adaptable for the future. Well, and of course, when we need to generate text, generate artifacts, that is, text, and not

1:00:00 just analyze it, it is very difficult to create content using deterministic systems. So if you think about Generative AI, like the space was named because the key idea is that these systems are good at generating content. And because traditional LL systems did classification tasks very well, let's say, aa, but content generation is already the era of LOLm. Well, just on one, as if on one table, in one table, a comparison of approaches and when to use them. This is how someone correctly said that you don’t need to

1:00:46 choose, you need to combine, that when our logic is clear, we can easily describe all the rules, then we take the deterministic one. When the logic is unknown or unknown to us, we don’t have the competence for it, we can give it to the lm side and transfer these execution rules to it. And output has also talked about this many times. And, actually, what is better suited for Ambigс systems, what is low tribity? In this regard, well, active resarch is carried out in the so-called

1:01:32 XAI, that is, explainable AI. In general, this, and resarch is conducted in order to understand why LLM, or rather, not why, but how LLM comes to the output to which it comes. Now the researchers can't understand. This is needed for two purposes. Firstly, for explainability, for auditability, and so on. But secondly, for control. This whole safety, and the alignment AI system is a mechanical interpretability, that is, the ability to mechanically show what this part of the LMK gives this

1:02:17 output. And that's why if I click here, I'll get guaranteed such and such an output, because, as I said, se doesn't even help. That is, it reduces this time, but it does not completely solve the problem, namely, reproducibility. And just explainable AI is a direction of research that has not yet been decided. Well, from the performance we have already seen with you an example that deterministic systems work much faster and are more stable in terms of issuance, that domain expertise is needed to formulate rules, but simply data or examples of the same Zero Shot, View Shot, but these examples have become much

1:03:03 less necessary with the advent of LLM. Oh, and about support, if we talk about systems as deterministic, then there, in essence, support is a change, or the addition of rules, and in a probabilistic system it is retraining, or, through prompts, where fшot, zero shot, or through, in fact, retraining of the LLM itself, well, the model on new data and for many systems. Why are we going to talk about Mory when we’re discussing agents? Because I think Emory is a hack to retrain

1:03:52 Lamky cheaply and quickly. Let's call it that. We understand, right? In short, we have agents who, on behalf of our customer, find his potential clients, knock on his doors, and, in fact, bring in new clients. And when they knock on Linten's door and write messages, the potential client can answer. And we do not allow LN to respond to this customer automatically. We do what is called a human loop. And we will be with you, when we talk about control systems and the LM systems, we will talk about Human Enzop. And you will implement Human Enzop within the framework of the DZ.

1:04:40 So we implemented such a scenario that when the response comes from Let me show you quickly. Basically, an agent arrives at the Investigative Committee when a potential client has responded. Here is Anna Jane Rheims, a potential client of our client. And the agent sent, uh, a message to her, uh, some sequence of messages. Ah, and here she answered. And what's happening with us? We lmka, which has a shot of ezmple, fshot of ezly, how to respond to answers, offers an answer in slack, but gives two buttons like approve and edit.

1:05:27 Accordingly, we measure how many edits are made and what changes are made in the edit. And then we return this as Shot example in the LM prompt. Thus, it turns out that as the system works, it learns to do its job better and better, well, in this case, to offer, well, an auto-response to this manager. And the manager is still in control. And so, as the trust in the system increases, remember, when with the deck code. But at first I read every action that he tells me, that's when the first and

1:06:13 second day, but then I realized that in general he speaks and within some frameworks I am ready for him, but, for example, within the framework of the working dir he does it automatically and does not bother me every time when he wants to create a new file or use a new library. So what I'm getting at is that in order to maintain systems that are, so to speak, probabilistic, we need to implement a feedback system and learn from newly incoming data. But in this, from a business point of view, there is still protection of your product from competition. That is, roughly speaking, what is called data Flywel,

1:07:00 that the more, uh, as if with your product is used, the more e-cases you learn, the more e-cases you submit to, roughly speaking, to prompts, the better your system works. And then, when you come to a new customer and show him these edge cases, he’s shocked, how do you, uh, know this, and you show your expertise. In fact, it is your users who create this expertise. Well , it’s just that the essence of our tests is changing , that this is not inp. Here are those who remember, those who work with this, here are test scenarios, test cases, yes, this is a very deterministic input/output in classical systems. Here we need to

1:07:46 calculate probabilities, essentially. Well, it is difficult to audit and certify probabilistic systems when it is possible to do it much better odithermically. But in general, what I would like you to do is again something of an absolutely recommendatory nature, that is, if you want to do it, you want to, but if not, you can remake it for your system, for your project. we will have GitHub, and where will I put all the code, here, which was generated today, and I’ll upload it. You will be able to upload your homework there, if you want, absolutely this one, and I will comment on them. Accordingly, what needs to be

1:08:32 done? We need to make an agent. I understand that you may not know yet what an agent is. And in this regard, since you have cursors, cloudcodes, and so on, I will first have you try to do this, and then we will figure out how to design agents. But try to make an agent that, actually, a, in two ways a interprets the reviews that you have, and in two ways generates a report, and, and as a framework on which, a, you do this, choose one of the frameworks, a, which we will try in different

1:09:21 This is the only one, let me add another one . This is Google, so it's fair. Google Ads Agent Development Kit. In general, you can take any of these four and write one agent on it, which will take either from the online system of reviews, or simply from a text file, and make a report on them, as an AI would do, or rather, a human product manager. A, that is, he analyzes all the reviews and says: “So, over the past period, people mostly write about this, complain about this, and ask for this.” And in the following homework assignments we will

1:10:06 do more according to this pipeline. For now, here is an agent who, using two approaches, analyzes reviews of your product or of the data set that I will give you. And, accordingly, this is homework, the main goal of this homework, and, firstly, to try one agency framework without any guideline of mine yet, that is, from the start, roughly speaking, and here is that pipeline, and, during which we will create an AI product manager, start implementing it. The first step in this pipeline is to analyze, uh,

1:10:52 reviews or feedback on your product, because this is something that a product manager should, a good product manager should do regularly, but it takes a lot of time for them without such systems . I hope it's conceptually clear. If I wanted you to walk away from this whole meeting with one thought , that depending on the business problem, ah, we'll have a combination of deterministic and probabilistic approaches. And often the deterministic approach will compensate for the shortcomings of the probilistic one and vice versa. And when we

1:11:37 design this table, why I did it , when we design systems, we must decide in advance which components we will make probabilistic, which deterministic, and depending on those criteria we will make this decision, the criteria of speed, cost, interpretability, and so on and so forth . And of course, a lot of the speed and cost points are starting to shift due to the emergence of, uh, smaller models, uh, or due to the general trend of cost reduction, uh, LLM, that we're seeing. M.