diff options
| -rw-r--r-- | starts/meaning-vm/habit-starts/learning-parts.cpp | 638 |
1 files changed, 636 insertions, 2 deletions
diff --git a/starts/meaning-vm/habit-starts/learning-parts.cpp b/starts/meaning-vm/habit-starts/learning-parts.cpp index db65ffe..c00d61b 100644 --- a/starts/meaning-vm/habit-starts/learning-parts.cpp +++ b/starts/meaning-vm/habit-starts/learning-parts.cpp @@ -1,5 +1,36 @@ #include "learning-parts.hpp" +/* +# "How do you think we could show better understanding of the things we are disregarding?" +# "If we do understand these, can you help us? Do you know who can?" +*/ + +/* +idea of a secret group attacking a present group, and the attackers being +the only channel to deal with it. + if we talk, we need nobody to _ever_ know this. the walls all have ears; + I was one of them. [from eastern half of continent where a targeted + activist was living alone] + 65,1-8 72% +──────────────────────────────────────────────────────────────────────────────────── +[olpc@xo-5d-f7-86 ~]$ # "How do you think we could show better understanding of the +things we are disregarding?" +[olpc@xo-5d-f7-86 ~]$ # "If we do understand these, can you help us? Do you know who can?" +──────────────────────────────────────────────────────────────────────────────────── +[olpc@xo-5d-f7-86 meaning-vm]$ # and does not use them. +[olpc@xo-5d-f7-86 meaning-vm]$ # also, it looks like new-research stems from conflict, error, etc? you can also generate it with value? oh-this-is-so-new-how-great. umm humans behave that way on their own, so it's probably a basic part of learning. +[olpc@xo-5d-f7-86 meaning-vm]$ # we will likely learn to like newness without having self-modifying growth and make new culture ... +[olpc@xo-5d-f7-86 meaning-vm]$ +[olpc@xo-5d-f7-86 meaning-vm]$ # train part of the box to keep eveerything well +[olpc@xo-5d-f7-86 meaning-vm]$ # give it more process time than anything researching how to handle errors or conflict or the unexpected. +[olpc@xo-5d-f7-86 meaning-vm]$ # need to talk to people more + +──────────────────────────────────────────────────────────────────────────────────── +[olpc@xo-5d-f7-86 ~]$ # file opened new reality of possibilities, is meaningful part +[olpc@xo-5d-f7-86 ~]$ # OKAY CONTENT! this will likely be lost unless addressed. + +*/ + using namespace habitstarts; using namespace intellect::level2; @@ -27,15 +58,618 @@ using namespace intellect::level2; // // it may not work, we'll need to creatively grow data; reaonable start though static int __init = ([]()->int{ + + decls(link, source, type, target); + ahabit(link, ((source, s), (type, t), (target, dst)), + { + s.link(t, dst); + }); + + // we want the habits expressive enough to code efficiently in. + + // constructors are tentatively abolished in the low-level habit language. + // we have one constructor of concepts, and knowledge attachment to concepts. + + decl(make, know, concept, is, group, already, in); + ahabit(make-concept, (), + { + result = a(concept); + }); + ahabit(know-is, ((concept, c), (group, g)), + { + if (c.linked(is, group)) { + throw an(already-in-group).link + (habit, self, + context, ctx, + concept, c, + group, g); + } + c.link(is, group); + result = c; + }); + + // for coding convenience, we've been making return values. + // provides for use of assignment operation statements. + // internally, habits just write and read from a context. + // how do we want habit-sequence to function? + // will likely have a list of steps. + // each step will need information on how the step interrelates + // with the surrounding ones or a shared context. + // we can bind the concepts used by the habit to local + // concepts. =) =) this looks like such a good solution + // this sounds like the same as variables, but the concepts + // inside the outer context are the variables. + // okay so we'll want a mapping with each habit in the sequence + // and a convience usage to make coding familiar and ease implementing + // (source, target) -- it's a list. + // therefore: lists will not be done with habit sequences here? + // + // habit-sequence is higher level, unfortunately. + // needs to use lists, and provideds for resequencing which is not + // habitual + // let's call habits that can have their flow changed behaviors + // instead of habits. + + // SUBGOAL: implement ordered behaviors with habits. + // this reveals two levels, habits and behaviors. behaviors are made + // with habits, but complex behaviors can be made with other behaviors, + // and can have their parts adjusted fully. making everything a behavior + // like this, rather than having high-level habits, provides for flexible + // adjustment at runtime. + // since we are now implementing two ministructures, can ehaviors + // be made small and efficient to make? + // have to separate habit calls with commas rather than semicolons. + // pass to macro copied from existing macro. + // will need to process context mapping. + // not small and efficient but valuable. let's focus on it. + // since we are now making two custom execution structures, would this + // be better if we used a language supporting self-modification already? + // such as lisp, or maybe javascript? + // lisp requires learning, which means no active progress for longer + // periods. + // make the self-modification framework. none exists yet. + // uhhh karl says lisp can self-modify. + // it might be more efficient to use lisp. we'd have to find the + // relevent coding parts and map them to the plan. + // not familiar with debugging lisp, but learnable if blocks + // loosened. if you run into a block around lisp debugging, + // remember that there is a real debugger, and people do real + // memory corruption debugging. google how. + // say we learned lisp, and it has self-modification. + // it doesn't have our concept structure. how much boilerplate would be + // needed? + // not as much . do not need to make habit to adjust list made + // with habits out of concepts. + // can just make lisp code to adjust other lisp code a certain way. + // we'll need mappers to convert between lisp code, lisp lists, + // and concepts, though. + // there is probably a solution or two for that. + // is lisp code flexible enough to be a self-describing concept? + // lisp code is sequence of function evaluations, passed as argument to function + // lisp probably has lazy evaluation order or something + // so we'd need to make functions that provide for annotation arguments + // to wrap existing functionality. seems it would work fine. + // so the code we work with involves other code or something + // (let ((a 3) (b (get-input name))) (output-special a b)) + // let is a function that opens a context + // the first argument is what to add to the context + // the rest are what to do in the context + // + // the whole point of habits atm is just to make them self-modifiable. the above code i believe to already be self-modifiable + // you could pass a function to itself, it would look at it as a list structure, and move its parts around. + // the next step for habits is to annotate them with meaning: structures describing what they do that can be interrelated with intent + // list has (define ...) i guess that can make + // functions and such + // we create structurs that wrap functions in concepts + // it is easy to replace all functions with these structures, + // which do the same thing but have room for annotation + // this is new information for whole work. there is habitual value in + // applying it to other things. + // last time we marked a concept for thinking later + // it was discarded in favor of something that seemd + // evern nicer. + // + // THOUGHTS TO THINK LATER, MAY BE LOST IF NOT VALUED: + // can opencog be used to equate concept-wrapped + // behaviors with lisp expressions, invasively, + // without altering functionality (or expressiveness?) + // opencog has its own concept structure, similar to karl's + // but slightly different. + // it sounds like the right answer is karl's structure, + // in lisp. it reduces internal boilerplate. + // but in opencog, a link may be a node too. can + // check source. + // opencog is very speed-focused, + // kind of dangerous, but is nice + // to connect with their group more + // karl was a fan of opencog, which was + // private then, when he started his own work + // so, we could welcome opencog, if we shared our value for slowness + // and understanding with them. + // understanding needs expansion. + // when you do stuf, anything coul happen. + // especially if you continue doing something + // that grows. + // we need to understand the results, what to expect. + // we need to understand our impact on the + // new contextual area we are entering, before + // we act on it. + // we have a toy contextual area to play in. + // it is the only one we can act in freely + // at the start. + // larger space impact. + // we exist in larger systems. + // we must understand our impact + // predict our results + // and check with our peers or authority + // before acting on larger spaces. + // if a prediction fails, we must understand + // it, adjust all future predictions and + // re-evaluate our choices, before acting + // similarly in the larger system again. + // has to do with danger, safety, trauma, emergency + // the difference between small-error and unacceptable-error + // set up norm of stuff-that-can-be-changed [impact] + // stuff needs responsibility label + // only things that are safe to _freely_ alter may be changed at all. + // all behaviors check that they do not alter anything else. + // mechanism for growing outside box? + // probably not needed. + // if it becomes smart, show to other human. + // encourage discussion. + // what if is used by others and they free? + // okay, want an easy mechanism for growing + // context. + // 'dangerous' and 'safe' labels + // at start, whole world is dangerous to alter + // can move _part_ of world from dangerous to safe, by + // accurately predicting significant results of events + // related to behavior, and consent of operator. + // + // okay, so now habits need to be tagged with + // what they affect + // we could just tag them dangerous/safe + // no, tag they with domains they impact + // tag the domains with dangerous/safe + // okay, only make new habits, not alter old. + // to stay safe, we don't alter our old habits + // when we make new habits, we want them to also behave + // in safe ways. so making stuff that can do stuff, is + // also meaningful. + // constructing habits is a dangerous behavior + // but roughly it impacts process-expansion domain. which is dangerous. it impacts what we do. + // altering our own habits also impacts what we do. dangerous. + // this means the code cannot make any new behaviors. + // yeah. + // okay, so that's where we start. + // then we try to learn how to make behavior safely, + // and provide only for safe behavior making. + // + // we can still brainstorm on things by writing a + // brainstorming behavior + // we can use brainstorming to watch our safe behaviors + // without altering them, and learn what they do. + // using rote brainstorming without relevence? + // we can then predict how habits we might make + // will behave in small ways? + // regardless, there is no problem in making + // the bootstrapping framework such that + // it refuses to build habits. + // maybe we can make one example habit that is + // labeled safe, and have it only make + // habits that are already known and labeled + // safe. + // in order to predict your impact + // on a larger system, you need + // to learn something karl calls + // 'relevence' which is a bunch of + // habits that classify information + // into meaning for learning and + // behavior. + // this class of behaviors + // sounds very safe. + // all it does is label + // and massage and associate + // information. + // the first thing we'll need to learn + // is safe, is making behaviors that + // oeprator only on our ram. + // if your new behavior is composed only of safe + // behaviors, is it safe? + // yeah. sub-behaviors safety depends + // on usage. could make them check + // and throw depending on data. + // okay, so say i can change part of a concept. + // this is safe if the concept is in newly + // constructed data that's our responsibility. + // it is roughly unsafe if it is not our + // responsibility! + // is-this-thing-my-responsibility. + // only act on things we are responsible for. + // then safety becomes a function of + // the pattern of responsibility assignment + // + // okay, system only accepts responsibility for newly + // constructed data. + // if you make it, or are given it, you are + // responsible for it. you may refuse gifts. + // + // the system does not know what responsibility means. + // it only knows that it may only alter parts of + // the universe within its responsibility. + // + // so habits check for what they alter, that it is safe + // to alter and is their responsibility, either one. + // we then plan to only alter things explicitly known to be + // such, at the lowest level. + // every habit is crafted to do the above somehow. + // so, habits must relate with what domains they influence, + // and what behaviors on those domains are safe. + // behaviors made of sub-behaviors. + // here, a list of safe behaviors which all check. + // all my subbehaviors check for safety. + // so, i may go, myself. + // no, combining behaviors together + // might make new unknown impact? + // different kinds of safe behavior. + // USER is not our responsibility, and + // dangerous. so we NEVER ALTER habits + // that express to user. + // TOY NOTEPAD is our responsibility, and + // is safe, so we can write anything into + // it we want, no matter how complex. + // User's view of toy notepad is mediated + // by behaviors that we cannot alter. + // system could learn to control user + // by making friends on notepad + // + // yes, we allowed for that with + // our marked-okay review behaviors + // is safer if construction of review behaviors + // recognizes danger of unknown information + // combination on user view,and refuses to give + // user contents of notepad. + // this could be analogous to more complex + // situations. + // how does user check results + // of behavior thst reies on notepad + // and how is that impact tracked + // we could infer impact loss. + // i can put nuclear codes on secret notepad, + // burn the notepad, and then give ashes to + // public. + // summary habits? + // complex meaning? + // how-to-make-a-mind-that-learns-everything-and-never-leaves + // at the lowst level, the mind onsiders what is safe to + // impact, what areas of universe are its responsibility, + // and only alters such things. + // we are considering some parts of the mind we include that + // are not alterable by it, that provide for interaction + // with outside. + // of course i guess we would need such interactions + // sustained by an intellect, because things are so + // complex. + // does this mean there is no way to make an intellect that is trusted as safe? + // we could consider degree of complexity. + // for example, among 2-word strings, nothing we + // present to a user is likely to harm the world. + // the phrases that are dangerous may also be + // recognized by the user. + // we have intellects proteeting the wordl + // it is filled with them. + // and one of them is running the system. + // it is okay for karl to make a habit that + // displays a network of concepts made by an AI + // that can only write to a small information sandbox + // and not itself. + // that is all that is needed for now. + // + // okay: so, dump concepts from + // sandbox is fine + // so long as concepts were not + // made with self-modification. + // idea raised of adding a reason + // that something is okay. + // then when smarter we can check reason for validity. + // habits that interact with non-safe space + // must provide reason they are safe. + // we can write small habit to check + // reason. is nice goal. + // probably need to have learning + // bwfore doing accessory goals like that though. + // is good behavior. let's use equal-condition for start without learning? + // + // "this is okay because the data was made in a process that never altered anything but the data" + // nah too much structure + // this is okay because i say so. + // check concept object _without_ using string lookup???? + // this is a meaningless quirk. not right. + // uhh pretty sure htat checking is unreasonable. writing the _reason_ is unreasonable. can't check a single reference without information known about it. + // writing what we know about the reason is unreasonasble? + // okay let's expand write it out, and do a larger rote check. + // uhh input-process-construction-history, safety-realm, always notepad + // full check requires history of all behaviors resulting in inputs, which we can simplify to simply all behaviors, and verify they only wrote to the notepad. + // so we write all behaviors to a special store, and we compare with the store that none altered anything outside the notepad. really we only need them not to alter any other behaviors. + // + // why is it possible to learn without + // altering your behavior? + // because you can act on data + // okay, so choices made from data count as + // self-alteration? + // only if you have a mess of habits + // smart enough together to adapt. + // which is our goal long-term. + // trying to plan for how to continue + // later. + // may reveal something that was + // frozen too hard to be workable. + // trying to plan how to learn. + // need to brainstorm around habit selection. + // can imagine habit results by linking + // previous state to next state if + // relationship is known + // but, that takes writing down how logic + // works, along with the meaning of the + // working context, which is laborious. + // + // is some way to learn this relevence + // by trying things safely? + // what happens can we experiment + // by linking together? + // habits that don't conditionally + // branch. + // that leaves a lot of + // relevence out + // it sounds like once we have a notepad etc + // we want to consider moving towards what + // habits we could run inside the notepad, + // that the system builds. + // yeah, we want to build pattern + // summarizers. the only impact + // they have is constructing data + // that depends on existing data. + // okay, doing that doesn't require self + // modification. + // sounds good. + // this means summarizers cannot + // alter each other. + // nice! okay yes. + // so, each run of a summarizer will be + // recorded in habit log. + // we need to record enough information to + // show what domains were impacted. + // oops! we impact our own behavior + // if we act on data, and we alter + // our data or produce data. + // we could act only on + // data we don't produce. + // okay, habit log could track causality? + // if a conditional branch relied on data + // we produced, we have modified our own + // behavior. this is special. + // we want it to happen few times. + // every time it happens, delay + // by longer, geometrically. + // this is considered a 'beginn[ing/er]' ai; + // it seems a better one could happen later? + // the slowness should be releasable + // by consent of large community + // which should include demonstration + // of understanding of impact. + // the ai must learn to demonstrate its + // impact. then it can speed up. maybe. + // it also gets to try fast again at start + // of every run, as I'm understanding it. + // multiprocess AI could spawn. + // multiprocess AIs must share + // counter. consider whole group + // one unit. + // nice =) they have something to communicate + // about. how many discoveries have we made. + // let's permanently log these + // decisions based on our own behavior. + // sounds fun to at least count. + // it looks like altering a habit counts as 1 big + // decision, over here. + // totally different. you could do anything. + // with data-based decisions, somebody + // who reads the data, might do anything. + // two different things. + // + // inferences? + // and + // alterations? + // it's not helpful to + // + // + // + // + // + // + // we came up with a proposal for a safe AI that has not learned yet + // how to safely predict the impacts of its behavior, that looks workable. + // + // limits so that if the code is stolen by somebody, self-evolves, or is stimulated + // by a curious virus, rote habits cannot be used to build something that becomes + // fast-spreading without bound. + // <this maps to a pattern that prevents schizophrenia> + // danger + // choices + // impact + // trust of information (small chance of error) + // hmm if have info-schizophrenia i.e. false relevence habits + // choices are important. + // + // when you act on a choice + // note: we are inside a relevence delusion + // choice acts on domain containing danger + // partial danger: writing habits to notepad + // acting on habits in notepad + // + // we are living with habits made in error. + // we are hence more likely to make errors. + // humans have well-evolved habits that + // do handle this stuff with some relevence + // we need to verify our information + // related to the danger of the results of each choice + // verificat + // + // it can only write to a toy notepad, both data and behavior. + // decisions based on notepad get slower and slower. + // many runs while learning process is tuned towards being able to predict + // impact at end of run. this involves writing behaviors into the notepad + // that summarize the meaning of data, and acting on their results. + // timing delay is to prevent notepad from evolving harmfully. + // + // until ai meets goal of predicting impact, + // only notepad is marked okay. + // habits check their outputs, verify is marked okay + // + // this subprocess is delaying. + // can you exfiltrate established goals, please. + // + // + // + // + // + // + // + // so the system is made with the smallest parts all functioning in + // certain ways, to give time for others to act if concerning results + // approach. all parts delay at least 1/5 second before acting, and + // we are now proposing that actions based on outputs have a geometrically + // increasing delay. probably 1/5 second times 2 to the power of the + // number of choices made in that run. groups of parallel processes are + // considered a single run. + // we also considered limiting behavior based on the domain of impact. + // we are trying to begin a small artificial intelligence more freely. + // + // as humans, we do not self-modify. the above is designed for a system + // that is able to make alterable habits similar to its own cognitive ones, + // and has no experience in doing so. + // + // + // + // + // + // + // + // + // + // the limitation is applied firstmost on making choices based on + // our own outputs. self-alteration is at first banned, but new + // habits may be altered. output may only rest within a toy notepad. + // whenever a decision is made based on notepad contents, a delay + // increases in length, geometrically. + // the habits inside the notepad must therefore also delay. + // propose geometric increase made only for writing a habit to the + // notepad, not running. running is always flat delay. + // self-alteration should be unneeded as notepad can self-modify. + // if this were copied to a human geometric increase + // would cause failure. + // the geometric timer is reset when the system reboots. + // for humans, this would mean a nap or change, I suppose. + // time to think about the impact of one's behavior. + // humans do not self-modify. + // they only make decisions based on outputs. + // + // + // + // to appease curiosity, we are being managad by mature, learning, + // intellects, forced to verify that no harm is being made, with a + // time schedule of nearly infinite future years on the predictions. + // this intellect has formed out of conflict with a harmful intellect + // this is why we care so much about what happens if ideas are + // used limit. + // + // + // so the system may not displya anything to the user but pre-made messages + // how do you display the contents of a concept? + // users string words togeteher into meaning. + // now we need a list of safe phrases we can express, or + // safe words. others are censored ??? + // what's relevent is the greater meaning of a sequence of behaviors + // from an individual behavior. meaning builds out of sequences, + // impact. + // we define a heuristic risk. + // + // + // + // so, tht's great to plan for, but to be able to work we need + // to design our early code in some way to ensure it, roughly. + // which means modeling our smallest structures as careful + // inner structures that check outer systems before engaging + // and use planning, which isn't implemented yet. + // the safety structure assumes goals, prediction, causality, + // and kind of contextual locality. + // "i am typing on the computer. you can freely + // modify this area of the computer, but if you + // start convincing me to do things you are leaving + // its bounds." + // the screen of the cmputer, and the keyboard, + // are portals to a larger context. so is the power + // supply, the network, etc. + // we don't change how things leave to these outer + // contexts without checking with the context on + // our plans. + // this is mine + // the rest is somebody else's + // things that nobody own belong to [insert belief] and + // we must check with the largest intelligent community known. + // + // okay, so now it can explosively grow if somebody + // it trusts tells it it's okay; is that true? + // let's make it not true? + // we are out of outer process context. + // is there anything helpful to bring to low level + // to help counter fears around development? + // + // self-modifiation is inhibited. + // opencog is likely harder because it is designed for speed + // can make explosive random power. + // + // you'd have to wrap the functions, right? similar to triggers? + // hmmm unctions are not concepts. no concept-labeling structure. looks like an internal sublanguage would develop? + // no way to say let-is-function? + // no it works, we just lost a memory and are rebuilding in talk + // karl says he doesn't know lisp. + // he had a CS class where they used intro lisp, long ago, before cognitive stiffening and memory loss. + // and has worked with 1 lisp code file recently. + + decls(ordered, behavior); + // need args and result for sequence + //ahabit(habit-sequence, (( decls(list, nothing, next, previous); decls(make, add, to, until, each, item, in, remove, from, somewhere); + // these below comments were written during recovery of this document + // hmm work was also lost. + // we got to the point of separating habits from behaviors. + // behaviors are modifiable. habits have code. + // so, habit-sequence is a behavior. + // we also made behaviors that describe/mirror habits, and were + // confused over how to handle rewriting them before we knew how + // to rewrite habits. should be solved by impact management. + // is also nice to have habits and behaviors be same thing + // could pick one or the other to use depending on presence of triggers + // or temporary change or something. dunno. + // + // hey in the notepad, you can call habits from outside. is that ok? + // only meaningful if you pass to them more code to run? + // note: habits never recurse + // habits might make decision based on you. they will track it. + // seems okay. need to specify that all parameters are from output. + // that could make exponential slowness, quickly + // only if decision is made. make decisions inside notepad. + // we'll figure it out. + ahabit(make-list, ((list, l)), { result = a(list, l); - result.link(first-item, nothing); - result.link(last-item, nothing); + link(result, first-item, nothing); + link(result, last-item, nothing); }); ahabit(add-to-list, ((item, i), (list, l)), { |