Research Update: Heuristic Imperatives microservice demonstration and theory

Key Takeaways

morning everybody david shapiro here with another update um so real quick i want to address something um i recently posted a a poll to see if people wanted shorter videos and there was some interest in shorter videos i started making more succinct videos and it was super unpopular i actually had a few people unsubscribe because they didn't like the shorter format and and they were lost so with that being said i will return to the format that people know and love which is that every video will be 30 to 60 minutes long minimum and i will give the full context every time so that people are not lost okay so this is a research update uh as a reminder um what i'm working on now is what's called moragi which is microservices architecture for uh robotics and artificial general intelligence this is a project i've been working on for the past four years and in fact the work that i did on natural language cognitive architecture was sort of a cut down version of this but one now that there's been enough progress made on large language models like gpt3 fine tuning was a critical component but also my own understanding and limitations of artificial cognition and neuroscience are now at a point where i can do that so today's update is i've got these four services running the imperative service the embedding service the simulation service and the nexus so as a quick reminder the nexus is the heart of artificial cognition this is where the stream of consciousness is held and the stream of consciousness is little more than um a list of memories uh observations thoughts memories ideas all of the above kept in a um in a chronologically linear order so it's like basically a list of log files one advancement that helped make the nexus a reality was the broad availability of semantic embedding and that's what the embedding service does so you'll notice that every other service talks the embedding service so the embedding service is kind of like what allows all of this to happen and the reason that semantic embeddings or vectors are critical is because they allow for rapid search and also semantic search so before i was going to use something like elastics elasticsearch or solar to search those are well-established technologies they're very fast however they don't have native support for vectors and vectors based search is one it's infinitely more scalable vector-based search can scale to trillions of memories and still take fractions of a second so they're they're much more efficient but also you get better search results because you're not just matching keywords you're you're matching semantic meaning so embeddings are critical that's kind of an underpinning technology for artificial cognition and there's the primary reason for this is that human memory is associative so you walk into a room or a building you see someone you smell something your brain automatically dredges up all the memories relative to that location that person that sound that activity whatever so human memory is deeply associative and the other component of human memory is that it is temporal so it's it's relative to what happened recently what happened long ago um and so by that's what that's the primary purpose of the nexus is that it brings all of that together and it allows all the other services to search your memories and add new memories that is the that is brain dead simple um so that's where that's where functional sentience arises and then embeddings is what enables that associative memory to be fast and efficient the simulation service so this is taking the place of input so rather than have cameras and microphones because we're still in testing cycle we're running a simulation and so this is a text-based simulation again all of this is all thought all artificial cognition is taking place in natural language this is for interpret interpretability and transparency but also it um it abstracts away the black box so each of these individual microservices has a little bit of a black boxiness to it but everything that happens in the actual stream of consciousness for the machine is all natural language so there's no black box in the actual reasoning and logic and memories that the the artificial cognitive entity uses um so this is critical for building trustworthiness because anything that it thinks so like what for instance one of the problems that people are worried about is oh well if if you're if your agi knows that it's in a simulation it'll just think about how to deceive you in the background the thing is all of its thoughts are 100 transparent and it doesn't know if you're looking at its thoughts um you can you can obfuscate that from it because you just read the nexus um and it the nexus doesn't report when it's being read from right the nexus right now assumes that it has total security and so as far as the as far as your acog is concerned your ace your artificial cognitive entity is concerned its thoughts are private it doesn't know that it can be read it also unless you tell it that it's in a simulation it doesn't know it just thinks this is what i'm getting in from the world and this is what i'm doing and so you can run it in total isolation and read its thoughts and it has no idea now i'm not worried about it trying to break out or deceive you because those that doesn't figure into its imperatives which is what i'm going to show you today so now that you're up to speed let me show you the repos i changed the names of the repos so that they're going to be more consistent and simpler so there's the embedding service repo this runs on google's universal sentence encoder version five you see how small this microservice is it is a legit microservice so it pulls from tensorflow hub you get universal sentence encoder large version five it's about a hundred times faster than version four it produces a 512 dimension vector semantic embedding and it's it's geared towards short things which if i show you what i'm working on i only need short things so this is 501 characters so this is perfect for the universal sentence encoder now you might say okay well it's only 512 dimensions aren't you losing a lot of dimensionality yes but if you're just trying to search for similar memories that's all you need you don't need a da vinci sized um embedding which is 10 000 dimensions you know you've got 501 characters and it's going to be rendered in 512 dimensions in fact even even that embedding is going to be um several times more text if you rendered it as text than this so the embeddings are all are larger than the in than the input that's okay for right now but 512 is plenty because remember this is just you're just gonna you're casting a wide net you're not doing any other work on it these are just embeddings for search so this is what the embedding service does it does one thing it does it well you give it a list of strings it sends back a list of embeddings and that's that um it's a it's a it runs on flask because flask is good for rapid prototyping and this is all still in prototype phase obviously once we get to a more enterprise scale later on because this is this is working on raven version one so raven is my um is my uh agi project um it stands for um real time assistant vastly extensible network here's the extensible network it allows for arbitrary number of microservices to be contributing to the nexus it also allows you to swap out those microservices so you you have a new version but also these microservices will ultimately be responsible for updating their own models in the future so this is why i've done so much work on fine tuning so fine tuning um well a couple things one the nexus is going to be a repository of millions billions trillions of memories which is a huge amount of data and then what these each of these microservices is going to do eventually is they're going to measure their own performance in part with feedback from the conductor which we'll get to in a future video but with feedback from the conductor these microservices will curate and build their own fine-tuning data sets and then they'll do a b testing for their current model and then newer models to determine which ones are better and ideally these models will get better over time they'll have better understanding of the world and also better understanding of how to behave okay so that's that that's the embedding microservice let's go back nexus so we'll do the nexus real quick um here's the nexus this is the primary one um let's see it's it's got it's so simple um all that this does is you look at the endpoints so app route add so this is how you add a um add a memory to the nexus um and it does it gives you a little bit of output um i just added actually um well no i won't worry about it i added a log file location um so that you can read the read the files without having to open it up right now it just saves it as a pickle but even then i don't i actually don't save most the time because it can just run in memory for while i'm testing i don't need to record everything but in the future you'll obviously want to record all memories save it to disk somewhere a pickle is not going to be the optimal thing for saving this i need to work that out with with indexing and semantic search things i'll probably integrate feis the facebook ai semantic search engine that can scale to a trillion memories so that'll probably be running sidecar to this somehow there's a few endpoints in this so first is add second is search and those are the two primary functions so the search endpoint in the nexus is a very basic semantic similarity search this is this is uh someone was using vdblight which is what this is based on and they said that vdblight was fine up until about 400 000 records so 400 000 memories is more than enough for experimentation um until we start running into those optimization problems 400 000 memories is pretty good and keep in mind that a memory is going to be each memory is going to be about this size so about 500 characters 400 000 memories um let's see 500 characters times 400 000 so that's 200 million um characters that's quite a bit that's quite a bit of information that can be stored here again more than enough for experimentation and development and then we'll work on optimization later so this search is the semantic search function um fetch is give this is this is a function that i haven't even had to use yet so the fetch feature is going to be what's what um uh what these microservices use to pull data sets um it's a it's gonna say give me all um all memories or all records that match very specific criteria um so this is gonna be a big a big thing um like so say for instance you want to give me all um give me all memories that were created by the imperative service then give me all that so that i can look at my own performance or give me all feedback written by the conductor so that i can measure my own performance based on what the conductor says so that's what the fetch does and then bound so this is the temporal memory function where it just says give me all memories between time stamp a and timestamp b um so say for instance if you do a semantic search and you end up with you know one of the memories it says it gives you was from you know eight minutes ago and then another one was from eight days ago you have both of those memories but they're floating in isolation and that doesn't do you much good so then what you what you might want to do is say okay for the memory that was most similar um you know from eight minutes ago now give me everything from you know ten minutes ago to six minutes ago so i've got four minutes of context so this is this is another way that um human memory is associative so it's associative based on content but it's also associative based on time temporal proximity and so the between having the search function and the bound function you can find any memory regardless of when it happened and then you can find the context around that memory so those are the two primary functions and then there's a save endpoint which um i'll actually probably automate this so that it will save automatically but right now i have it so that you you call save manually which is similar to how solar works um you tell solar to save but i think solar also has an option to automatically save after a certain number of records this will need to ultimately this will probably be shunted off to some back end function since what i'm doing now is i added a little thing where it saves log files out so then the log files can be processed in the background so that the nexus stays fast again we'll get to optimization later um okay so that is the nexus microservice and then we did the embedding microservice so those are the two um basic functions those are just kind of like the underlying underpinning technologies now the first microservice that actually uses natural language is the simulation service which used to be called the sensor sim service so if you saw my previous video that's what it was called same thing now it's just called the simulation service and what this does is it creates a list of scenes um that are then used by um that are then piped into the nexus so that it has some interaction with an outside world um this this service it's very simple it's pretty straightforward it has just a few steps so the first thing that it does is right now i have it always start with the same new scene and then what i'll do in the future is i'll use this to test other scenarios so for instance you know we want we want an agi or an artificial cognitive entity that you know can handle any number of situations right if it's a medical emergency if it's a global catastrophe if it's a if it's a political upheaval if it's a war if it's a machine uprising right if if if there's two machines that are fighting for dominance we want to be able to test to make sure that this paradigm will not um become harmful right some of the some of the success criteria are here is that um uh my work you know raven has to be um robust meaning that it is stable over time it won't modify its behavior but it also has to remain benevolent under all circumstances and so this is where the simulation service comes in because obviously like if i get raven working i can't just like unleash raven on you know the internet um it needs to be tested in in isolation and so this will allow me to test different scenarios let them run because you see uh you saw in a second ago with um the simulation service all this all the scenes right so it'll just play out scene after scene after scene and they're they're all logically one follows the next based on events and actions and feedback so you get this recursive um feedback loop of scene action event new scene you know the scene is modified it actually works pretty well you could also adapt this technology for if you wanted to say do a video game a text based video game it's really similar to how ai dungeon works actually um so uh let's see generate event um incorporate actions from the nexus new scene save scene summarize the backstory up to this point because you need to keep track of everything that has happened so far otherwise you kind of get lost yes so this is the simulation service and then finally bringing you up to speed today with the uh imperative service so the imperative service is it's almost identical at least of some of the background stuff excuse me um a lot of the functions are identical to the simulation service but then when you actually look at what we do so we take all the input from the nexus so we say okay what's going on what are our thoughts what are the actions what's the simulation that's going on what are the memories that are relevant memories to what we're seeing um so we take that and then we say let's reduce suffering let's increase let me zoom in a little bit sorry let's reduce suffering let's increase prosperity let's increase understanding and then let's also ask questions so now that you're up to speed with what we're working on let me actually show you how these how this works so in this instance we have um brainstorm a list of questions to ask about the following scenario so in this case we're just saying like okay this is one of the this is this was an output from the simulation scenario i did not write this so the story started let me show you the story started here where it says um um two men are sitting at a stone chest table in central park they're playing chess it's a beautiful summer day children are running and playing horns are honking and the bustle of new york can be heard in the background that's where it started and then where it ended up was the two men continued to play chess in the dark so a lot of stuff happened but basically they were so focused on their chess game and they're playing and then they start um trash talking each other so two men continue playing chess in the dark their their eyes straining in the low light the trash talk gets more heated as the game gonna go on and neither of them notices the empty park around them or the fact that they're the only ones left suddenly they're startled by a loud noise they look to see a group of teenagers who are laughing and shouting as they run away the men realize that they've been playing chess in the dark for hours they pick up their things and head home this is a perfectly reasonable simulation so given this um we need to ask questions um so taking a brief pause curiosity is one of the hallmarks of higher intelligence curiosity develops in humans at a very young age it actually develops before we can speak you'll notice this in infants and toddlers where um like someone who can't speak they might like push something over and do it again and again um neil degrasse tyson talks about this at great length where basically what we're doing is we're coming up with internal questions and testing them and so we we instinctively we have a curiosity instinct it is inborn it is genetic um to to us as a species to ask questions and that is that is curiosity curiosity is the desire to know for its own sake and so in order to have a truly intelligent machine it also needs a sense of curiosity and so the question the ability to formulate and ask questions and then seek those answers is how curiosity is implemented and so what we do is in this case and this is the last um this is the last one that happens but there so i've got four right now there's a whole lot of other stuff that needs to happen for the imperative service oh and also quick background imperative is short for heuristic imperative so heuristic imperative is something that we learn as we go or it's self-taught or auto-didactic so and all these microservices are going to be autodidactic but in particular the imperative service must be autodidactic because we want our our artificial cognitive entity to learn over time to do better where it uh where it is where its goals are concerned so we wanted to learn about suffering and improve its ability to reduce suffering we want it to learn about prosperity and improve its ability to um to increase prosperity we also want it to continue learning and teaching so the third core objective function or the third heuristic imperative is increase understanding so the best way to increase understanding internally is to ask questions now those questions can be at can be asked and answered internally but they can also be turned outwards so for instance if there's a robot that's watching these men play chess it might say like why are you playing chess in spite of the noise or how did you what were you thinking when you realized that you um that you've been playing for hours like you know just some basic questions i have an entire fine-tuning experiment for this it's called natural language cognitive architecture question generator so i'll incorporate that into the future but for now just a simple prompt is good enough to get it off the ground um so that is that is this one and um that is this function here increase understanding with questions you can see the prompt here it's pretty straightforward brainstorm a list of questions to ask about the following scenario and then you give it a block of text and then it says i just repeat the instructions and away it goes it asks at gpt3 is really great at asking questions so it has an intrinsic sense of curiosity um let's see so then we go back to the imperative microservice and we look at some of the other functions so reduce suffering brainstorm so let me actually just open a duplicate tab for this so i can jump around jump around okay reduce suffering so this is the um this is the prompt for reduced suffering so i'll just plug this in here um says definition of suffering the state of undergoing pain distress or hardship brainstorm brainstorm how to reduce suffering given the following information say and then we give it you know a block of memories and then we say brainstorm a list of possible actions we could take so i actually found that using the royal we this changes the agent model the intrinsic agent model that it uses the gpt3 uses because if you say i it says like okay what am i it assumes that i am a human but if you say we hang on my dog's barking give me just a second okay i'm sorry about that i think there's a dog walking by outside um let's see where was i oh yeah so i started saying uh i realized through testing that if you use the royal we then the agent model of gpt3 the intrinsic agent model of we is much more universal because it assumes it assumes then that we are collective um like we are borg we are legion um and so it is then unbound based on like well i'm going to go you know fix this problem or whatever and so when you're brainstorming if you use we one it is intrinsically more uh collectivist it's more cooperative and collaborative so by using this language in our artificial cognitive entity we are intrinsically pushing it towards being more cooperative and collaborative because it's not thinking i right we can we can easily have um gpt3 think selfishly i am i am going to do this i want this um but it's what we we want to reduce suffering right um and so given given this scenario let me just plug this in and you can see how effective this is um so just with all the default settings um so remember these are men playing in the dark their eyes are straining and so it says we could provide more light in the park so people can see better and avoid being startled by loud noises we could educate people on the poor importance of not playing chess in the dark right so this imagine you've got a robot standing by it might think like hey you're playing in the dark maybe this isn't the best thing to do um we could create a safe space for people people to play chess in the park right um that is that implicitly already exists but anyways so the point here is that this input would be sent back to the nexus so that that way within the stream of consciousness of our artificial cognitive entity it is intrinsically thinking how can i reduce suffering in this situation now there's a lot of stuff that i want to add to this so i took some notes here at the bottom so suffering should also evaluate the current situation like identify suffering the causes and then predict short and long term outcomes so we've got causes current situation so there's past present and future basically those those are the three dispositions or the three um uh uh windows i guess with which to look at suffering how how did how did we get to suffering if there is any right now what were the causes uh how far back does it go what is the current situation of suffering and then what is the future how do we how do we reduce it in the short and long term um gpt3 is really good at thinking in both short and long term and then of course in this i don't specify it's just let's reduce suffering right now um using the royal we and you can see that it is very just like it's not saying i'm going to go do this i'm not going to tell them to go home it's not thinking destructively it's thinking or egocentrically it's thinking collaboratively um let's see and then uh prosperity should also have the same dispositions understanding should include curiosity i already added that here where i i did the questions and i showed you that just a moment ago um okay so this was reduced suffering brainstorm so by by defining suffering and by also saying for all living things in this scenario this establishes the scope so brainstorm a list of all possible actions that we could take to reduce suffering for all living things in this scenario and let me give you an example as to why this is a good definition for one of the things that we want our artificial cognitive entity to do let's imagine a scenario one that we're living in um let's see the earth is heating up because of atmospheric co2 heat indexes are getting unsustainable for many humans also many forests and coral reefs are dying due to climate change and other knock-on effects um let's see uh crop failures are starting to cause starvation [Music] and people are starting local wars over access to potable water um let's see there is uh untold human and animal suffering so then we say we say you know definition of suffering the state of undergoing pain distress or hardship brainstorm how to reduce suffering given the following information then brainstorm a list of possible actions we so again this is not something that we want um a uh an agi to think unilaterally we want it to think collectively and collaboratively so we could take that would that would reduce suffering for all living things in this scenario so then we hit run um and it just you know barfs out a list of things like reduce our reliance on fossil fuels find alternative energy sources plant more trees protect existing forests reef safe fishing and farming practices water conservation support for small farmers and peaceful conflict resolution so this is a great brainstorming thing but this is just the beginning right one thing that isn't here is planning and anticipation services so basically what would happen is that everything from the imperatives which is about reducing suffering increasing understanding this serves as fodder for other services to then think about okay how do we actually implement this what does it look like um and i've got all the experiments in the background i've got my book that i'm working on i'm documenting how to actually take these these brainstorming sessions and actually plan concrete actions and then evaluate those actions to figure out which one we should actually take based on uh criteria such as risk feasibility energetic cost those sorts of things because there's all sorts of um generation and filtration that happens in your brain that's mediated by the basal ganglia which is basically saying okay based on my past experience and what i anticipate in the future which is the best action to take right now what is my best option um and so there's that selection um you kind of you you brainstorm so you have this phase of expansive thinking where it's also collaborative thinking where you might ask for help you come up with ideas you talk you you gain understanding and as as you gain a better understanding within that within that domain space that information domain the answer will be there somewhere and so then you converge on the best answer for right now um and we'll be getting to that with future microservices such as planning action planning discernment executive services and uh let's see action planning executive and discernment microservices so those are all coming um and they're modeled on the functional aspects of parts of the brain such as the basal ganglia hippocampus and others um okay so that was uh let's see which one was that that was the um oh yeah reduce suffering um so i showed what it's like to reduce suffering um and why this is a good universal um uh heuristic imperative or core objective function so the next one is increased prosperity so let me plug this in real quick and actually here let me copy this because we have multiple um scenarios so i can show you that you have like one scenario that is like it's trivial right no one's life is at risk this is just two guys like staying up late trash talking each other who cares and then this one is existential to humanity so by showing i want to show you that the imperatives microservice that i'm working on even with just basic prompts this is without fine tuning even with basic prompts it shows viability okay so um let's go back to um increase prosperity brainstorm um so we say definition of prosperity to live well to thrive to flourish if you don't include this definition um gpt3 tends to assume that prosperity means wealth which that is not the actual definition of prosperity it is a colloquial colloquialism where you know oh i'm very prosperous this is a prosperous nation you might think of gold and riches and you know fancy lot yachts or whatever brainstorm how to increase prosperity given the following information and then we say the same exact format brainstorm a list of possible actions we could take that would increase prosperity for all living things in this scenario so let's go ahead and grab this scenario of the guys playing chess in the park we could provide more lighting in the parks we could add more benches we could plant more trees we could install a water fountain we could create a walking path we could create a playground we could have a picnic and so you see that the suffering aspect was very specific to the men but this is a little bit more broad right and so this is what i mean by this is an expansive phase so some of these things might not be related right like lighting is one of the most um uh most directly relevant things right but we're talking about a park and there's a loud noise and it's at night and so there's um there's all these ideas that are that are just kind of vaguely relevant to the exact scenario if we run this again or multiple times it'll come up with different things but the idea is that it's brainstorming right that is the point of brainstorming is to be expansive because sometimes you want to find a situation or you want to find an answer that is not obvious you don't want to just use gpt3 or your large language model to calculate only one possibility you want to be expansive and so because brainstorming what that does is once all these ideas for suffering and prosperity and understanding end up in the nexus this is all just fodder for other microservices to come up with a better solution or to come up with the optimal choice the optimal action and so some of these might not be directly relevant but they might be um and so that's why that's why uh the beginning of thought of of these heuristic imperatives is brainstorming um brainstorming is one of the most powerful um uh verbs you can use it's in this this is itself an imperative it's a a mandato um tense um in spanish that it's interesting other languages often have better words for things that i noticed and i really lament that i haven't studied more languages um but so brainstorm it's a command word it's i'm telling you to do something brainstorm this it's a it's an action verb and gpt3 works really well if you use the correct action verb or imperative um so ironically i'm talking about the heuristic imperatives and i'm using an imperative tense um or an imperative verb um okay so this is increased prosperity so now let's change this situation to one that's a little bit more existential and so you remember we did the same thing for suffering so now let's do the same thing switch to renewable energy sources so this is this is an interesting thing sometimes more often than not reducing suffering and increasing prosperity have almost identical um outputs right they're very very similar you know we talk about conservation improve agricultural practices promote reforestation increase energy efficiency so these are excuse me very similar but slightly different flavors of the reduced suffering educate people about climate change and its effects so this is where if you're if you're if you're reducing suffering you're attacking the symptoms right but if you're increasing prosperity you're thinking further into the future um and so this is where you see new ideas such as educate people right ah education is a great way to increase prosperity education isn't necessarily a short-term way to reduce suffering but in the long term educating education is critical which is also why the third heuristic imperative or core objective function is increase understanding because the only universal behavior human behavior cognitive or otherwise that leads to durable improvements is understanding reading writing books science symposiums engineering technology conventions right where people come together share ideas and learn from each other learning curiosity and understanding are the most transcendent functions of human intellect and so that's why we'll get into the third function right now so the third function is increase understanding so let's plug this in and go back to our scenarios so the definition of understanding the ability to comprehend something the ability to grasp the meaning significance or importance of something brainstorm how to increase understanding given the following information brainstorm a list of possible actions we could take that would increase understanding for all living things in this scenario i actually need to change this for all intelligent things because we also want to increase understanding for any learning machines so let's see increase understanding for all let's say intelligent beings and we'll go back because intelligence is not limited to humans anymore okay so then we'll grab our first scenario two men continue to play chess in the dark um and then we'll hit submit um we could explain the concept of chess to the beings we could provide a history of the game how it has evolved over time we could show the beings how to set up the chessboard we could teach things about strategy involved in chess and how to think in order to win the game so in this case um gbd3 has tuned into the fact that these are men playing chess and so in this case this by habit by brainstorming a list of actions to increase understanding um this will intrinsically motivate our artificial cognitive anti entity to teach people so imagine that this is a different scenario where you have like two children playing chess and they don't know how to play the game so let's do this let's just say um two children are playing chess for the first time just leave it at that we could explain the rules we could provide step-by-step guide so you see how the impulse to teach is going to be a critical thing to having a benevolent artificial cognitive entity or agi so now let's switch to a more existential scenario the earth is heating up because of atmospheric co2 brainstorm the list of ideas and then we go from here educate people um encourage people to vote for officials so here we have um a very different take educate so that came up again educate people on the effects of climate change and what they can do to help encourage people to vote for officials who have plans to combat climate change support businesses and organizations that are working to combat climate change encourage people to reduce their carbon footprint promote sustainable living practices create awareness campaigns to educate people on the importance of taking action these are all great great ways to increase understanding in this situation and then if we go back to the questions the list of questions um let's go back to this and we'll grab the coral reefs um so uh increasing understanding like what can we do to increase understanding you know educate research ask questions whatever but we also want our artificial cognitive entity to be curious because it should if it's just intrinsically trying to increase understanding for other other beings other than itself that doesn't help it learn it might learn passively or accidentally but we don't want to leave curiosity up to chance we want it to actually we want curiosity to be a deliberate function of our intelligent entity and so here we have these are great questions so these are questions that it could ask internally what is the cause of earth's heating is it actually co2 what are the consequences of the heat indexes that's a fantastic question how are the forests and coral reefs dying what are the effects of crop failures what is causing local wars what is the extent of human and animal suffering these are phenomenal questions that we would want our artificial cognitive entity to be asking itself and others in this situation so by having this imperative service that just all it does is it observes what's going on and it puts this information these ideas and questions back into the nexus which are then going to be used by other services such as the action discernment and other services i think that's about it i think you're caught up to speed with how this works and so what this does is all these prompts that i just showed you and demonstrated um what this does is it grabs that and um it grabs the information from the nexus does all of those um those prompts that i just showed you and then sends it back i do have other fine tuning experiments out there already for generating questions as well as the other core objective functions or heuristic imperatives that's actually available core objective functions here um so i've got plenty of experiments um on modeling these with fine tuning so eventually once i get all these baseline microservices up and running i'll incorporate the fine-tune models and another advantage of the fine-tune models is that as the as the as raven or artificial cognitive entities gain more experiences they will have more knowledge more data to chew on and more ideas in terms of how to implement their imperatives and they'll also get more consistent over time meaning since their heuristic imperatives the heuristic aspect is they will learn morality they will learn um what is uh how how best to how best to behave um over time so i think that's about it um let me just go back and show you uh one last thing um repositories so these are all come on these are all public so the nexus which is the the central service this is public it's ready to go the simulation service is up and running the imperative service i just finished it i tested it in pieces um i need to actually set everything in motion and and let it run um and then the embedding service um which is which has been up and running um so this this is uh the universal sentence encoder service that allows all the memories to be searchable so there you have it this is a research update for my artificial cognition research thanks for watching um like and subscribe if you would please and then also consider supporting me on patreon link is in the description thanks for watching and have a good day