working on the new generation of AGI skills

Creamer

Well-known member
#1
recap : 1st ive tried on alg to handle the entire AI process, this failed, it required massive reinforcement data input
next Ive created the skill host platform, which was a success
next I created skills, those laked in flexability so
next I created DISkills : this worked even better, but they lacked in displaying autonomy and learnability so
next will be THESkills

Trigger
Gets assisted items or person
Summon algs with option of contextual alg parts.

Trigger
Exploration and learning

trigger
items and persons preservation

Prediction based alg triggers and default time triggers and clear prediction triggers.

Alg efficiancy tests and sort
Trigger
Preservation alg for items and persons

MAP (items and persons) : link to time cost and pain cost of utilization -> effect
algorithm selection
 

Creamer

Well-known member
#2
moreover the MAP object will function as a rozen maiden replika (with a 'k') :
https://www.youtube.com/watch?v=8sY_Yp5o-dw

it will contain experiences per place items, and persons.
*this will be sectioned to short and long range memories. thus will enable homolougus imprinting (slow and fast).
what about multimemories for the same object tho ?!
one option would be to pair it with skill alg signatures,
another other would be to bury them somewhere to be excaveted in certain conditions

basically those replikas will be used as static access data, for running algs.
 

Creamer

Well-known member
#3
vars :
replika

Trigger() //sensory, souled, predicted
Gets assisted items or person
Summon algs with option of contextual alg parts.

Trigger()// timed
Exploration and learning
Alg efficiancy tests and sort

trigger()//timed
items and persons preservation


Trigger()
Preservation alg for items and persons
causes being annoyed if repeated in day


########################################################## replika :
MAP (items and persons) : link to time cost and pain cost of utilization -> effect
algorithm selection

goal : grid, obj/person dictionary, obj/person log, negative logs|defcon+solution,
default/omni solutions
short term memories or long term for homolougus imprinting

log dump.
 

Creamer

Well-known member
#4
https://www.youtube.com/watch?v=nM5_37r7TLs
here we go
Java:
package chobit;

public class TheSkill extends DISkill{
    public TheSkill(Kokoro kokoro) {
        super(kokoro);
    }
    @Override
    public void input(String ear, String skin, String eye) {
        super.input(ear, skin, eye);
    }
    @Override
    public void output(Neuron noiron) {
        super.output(noiron);
    }
    private void trgAction(String ear, String skin, String eye) {}
    
}
 

Creamer

Well-known member
#5
Java:
package chobit;

public class TheSkill extends DISkill {
    public TheSkill(Kokoro kokoro) {
        super(kokoro);
    }

    @Override
    public void input(String ear, String skin, String eye) {
        super.input(ear, skin, eye);
    }

    @Override
    public void output(Neuron noiron) {
        super.output(noiron);
    }

    private void trgAction(String ear, String skin, String eye) {
        // sensory, souled, predicted
    }

    private void trgExplore(String ear, String skin, String eye) {
        // timed
        // Exploration and learning, Alg efficiancy tests and sort
    }

    private void trgPreserve(String ear, String skin, String eye) {
        // timed
        // items and persons preservation, causes being annoyed if repeated in day
    }
}
 

Creamer

Well-known member
#6
replika : theme, maps, temp maps

map :
dic : obj, point
dic : point, obj
dic : objPoint, timeCost defcon
dic : objPoint, log
*defcon, solutions


temp maps : teleport point to main map. time cost. location map.
short term memories
log dump
 

Creamer

Well-known member
#7
replika : theme, maps, temp maps

map :
dic : obj, point/transport point to temp map
*dic : point, obj
dic : objPoint, timeCost
dic : objPoint, defcon problem
*defcon, solutions
dic : objPoint, log : sensory, problems, other objects



temp maps : teleport point to main map. story map.time cost. location map.
dic : map#,map obj
short term memories
log dump
 

Creamer

Well-known member
#8
replika : theme, maps, temp maps

map :
dic : obj, point/transport point to temp map
dic : objPoint, timeCost
dic : objPoint, defcon problem
defcon, solutions
dic : objPoint, log : sensory, problems, other objects

/*
*dic : point, obj
* obj, gps coordinate
*/



temp maps : teleport point to main map. story map.time cost. location map.
dic : map#,map obj

short term memories
log dump //long term memories
 

Creamer

Well-known member
#11
replika : theme, maps, temp maps

map :
dic : obj, point/transport point to temp map
dic : point, obj // to inflate stories.
dic : objPoint, defcon problem
defcon, solutions
dic : objPoint, log : sensory, problems, other objects

/*
*dic : objPoint, timeCost
* obj, gps coordinate
*/



temp maps : teleport point to main map. story map.time cost. location map.
dic : map#,map obj
myPosition : Point

short term memories //for homologous imprinting
log dump //long term memories
 

Creamer

Well-known member
#18
https://www.youtube.com/watch?v=J43REzFypV8

Java:
package chobit;

import java.util.ArrayList;
import java.util.Hashtable;

public class ReplikaMap {
    private ArrayList<String> objPoint = new ArrayList<String>();
    // private ArrayList<String> objPointGPS = new ArrayList<String>();
    private Hashtable<String, String> pointObj = new Hashtable<>();
    private Hashtable<String, String> objPointDefcon = new Hashtable<>();
    private Hashtable<String, String> defconSolution = new Hashtable<>();
    private Hashtable<String, String> objPointLog = new Hashtable<>();// sensory log
    private ArrayList<ReplikaMap> tempMaps = new ArrayList<ReplikaMap>();// *different class
    // ***algs

    public Integer timeCost() {
        return 0;
    }

    public void getShortTermMemories() {
    }
    // log dump (long term memories)
    public void makeStory(int inflationLv) {
    }

    public String answer(String question) {
        return "";
    }

    public String warning(String input) {
        return "";
    }

    public String walkThrough(String question) {
        return "";
    }

    public String shortConvo() {
        return "";
    }
}
I hate foids haha hahaha !!!!!
 
Last edited:

Creamer

Well-known member
#20
Java:
package chobit;

import java.util.ArrayList;
import java.util.Hashtable;

public class SupeReplikaMap {
    private ArrayList<String> objPoint = new ArrayList<String>();
    // private ArrayList<String> objPointGPS = new ArrayList<String>();
    private Hashtable<String, String> pointObj = new Hashtable<>();
    private Hashtable<String, String> objPointDefcon = new Hashtable<>();
    private Hashtable<String, String> defconSolution = new Hashtable<>();
    private Hashtable<String, String> objPointLog = new Hashtable<>();// sensory log
    // ***algs

    public Integer timeCost() {
        return 0;
    }

    public void getShortTermMemories() {
    }

    public void makeStory(int inflationLv) {
    }

    public String answer(String question) {
        return "";
    }

    public String warning(String input) {
        return "";
    }

    public String walkThrough(String question) {
        return "";
    }

    public String shortConvo() {
        return "";
    }
}
sub class :

Java:
package chobit;

import java.util.ArrayList;

public class ReplikaMap extends SupeReplikaMap {
    private SupeReplikaMap activeMap = null;
    private ArrayList<SupeReplikaMap> tempMaps = new ArrayList<SupeReplikaMap>();// *different class
    // log dump (long term memories)

    public void setHomeReplikaMap() {
    }
}
 

Creamer

Well-known member
#22
should the replika be a part of the actual AGI platform or a part of the actual TheSkill ?
the later would not require a change from the platform but the 1st would enable easier access for homologous imprinting.
i'll go with the later. therefore the imptrint process would work per skill, seemingly a shortcoming BUT it facilitates non homologous imprinting.
jizz in my pants.
 

Creamer

Well-known member
#23
additional TheSkill fields :

*friend field //active friend used with skill if any
*active Mcode(item) field //active item being used

call chobit by name : assume friend|aquire friend|temp friend, visual |friend name->assert friend
friendAsserted : Boolean
//general call such as hello/hadouken : no need to assert friend
 

Creamer

Well-known member
#25
Java:
package chobit;

import java.util.Calendar;
import java.util.Date;

public class ZeroTimeGate {
    // a gate that only opens x minutes after it has been set
    private int pause = 1;
    private Date openedGate = new Date();
    private Date checkPoint = new Date();

    public ZeroTimeGate(int minutes) {
        super();
        this.pause = minutes;
    }

    public ZeroTimeGate() {
    }

    public Boolean isClosed() {
        return !openedGate.before(new Date());
    }

    public void close() {
        this.openedGate = addMinutesToJavaUtilDate(new Date(), pause);
    }

    public void close(int minutes) {
        Date now = new Date();
        openedGate = addMinutesToJavaUtilDate(now, minutes);
    }

    private Date addMinutesToJavaUtilDate(Date date, int minutes) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(date);
        calendar.add(Calendar.MINUTE, minutes);
        return calendar.getTime();
    }

    public void setPause(int pause) {
        if (pause < 60 && pause > 0) {
            this.pause = pause;
        }
    }

    public void resetCheckPoint() {
        this.checkPoint = new Date();
    }

    public int givenTwoDateTimesInJava8_whenDifferentiatingInSeconds_thenWeGetTen() {
        Date now = new Date();
        long diff = now.getTime() - this.checkPoint.getTime();
        long diffSeconds = diff / 1000 % 60;
        // long diffMinutes = diff / (60 * 1000) % 60;
        // long diffHours = diff / (60 * 60 * 1000) % 24;
        // long diffDays = diff / (24 * 60 * 60 * 1000);
        // System.out.print(diffDays + " days, ");
        // System.out.print(diffHours + " hours, ");
        // System.out.print(diffMinutes + " minutes, ");
        // System.out.print(diffSeconds + " seconds.");
        return (int) diffSeconds;
    }
}
https://www.youtube.com/watch?v=V3iBhY9e1vs

many of the old skills will be scrapped and scavenged for slices of code. the new code must be simpler and much much more powerful.
the skills will need to hold friend data also
 

Creamer

Well-known member
#26
Java:
package chobit;

public class TheSkill extends DISkill {
    private Person friend = new Person();
    private Boolean friendUpdatable = false;
    private RegexUtil regexUtil = new RegexUtil();
    private DISkillUtils diSkillUtil = new DISkillUtils();
    private PlayGround playGround = new PlayGround();
    public TheSkill(Kokoro kokoro) {
        super(kokoro);
    }

    @Override
    public void input(String ear, String skin, String eye) {
        if (playGround.getMinutesAsInt() % 2 == 0) {
            friendUpdatable = false;
        }
        if (ear.contains(friend.getName()) || (ear.contains(friend.getJutsu())))// or friend visual
        {
            friendUpdatable = true;
        }
        if (friendUpdatable) {
            friendUpdate(ear);
        }
    }

    @Override
    public void output(Neuron noiron) {
        super.output(noiron);
    }

    private void trgAction(String ear, String skin, String eye) {
        // sensory, souled, predicted
    }

    private void trgExplore(String ear, String skin, String eye) {
        // timed
        // Exploration and learning, Alg efficiancy tests and sort
    }

    private void trgPreserve(String ear, String skin, String eye) {
        // timed
        // items and persons preservation, causes being annoyed if repeated in day
    }

    protected Algorithm makeFriend() {
        return diSkillUtil.verbatimGorithm(new APVerbatim("what is your name"));
    }

    private void friendUpdate(String ear) {
        friend.setPhone(regexUtil.phoneRegex1(ear));
        // friend.setEmail(regexUtil.);
    }
}
hmm,
no for that email regex
 

Creamer

Well-known member
#29
Java:
package chobit;

import java.util.ArrayList;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

// returns expression of type theRegex from the string str2Check
public class RegexUtil {
    public String regexChecker(String theRegex, String str2Check) {
        Pattern checkRegex = Pattern.compile(theRegex);
        Matcher regexMatcher = checkRegex.matcher(str2Check);
        while (regexMatcher.find()) {
            if (regexMatcher.group().length() != 0) {
                return regexMatcher.group().trim();
            }
        }
        return "";
    }

    public ArrayList<String> regexChecker2(String theRegex, String str2Check) {
        // return a list of all matches
        ArrayList<String> list = new ArrayList<String>();
        Pattern checkRegex = Pattern.compile(theRegex);
        Matcher regexMatcher = checkRegex.matcher(str2Check);
        while (regexMatcher.find()) {
            if (regexMatcher.group().length() != 0) {
                list.add(regexMatcher.group().trim());
            }
        }
        return list;
    }

    public String contactRegex(String str2Check) {
        // return a list of all matches
        String theRegex = "(?<=contact)(.*)";
        ArrayList<String> list = new ArrayList<String>();
        Pattern checkRegex = Pattern.compile(theRegex);
        Matcher regexMatcher = checkRegex.matcher(str2Check);
        while (regexMatcher.find()) {
            if (regexMatcher.group().length() != 0) {
                return regexMatcher.group().trim();
            }
        }
        return "";
    }

    public String emailRegex(String str2Check) {
        // return a list of all matches
        String theRegex = "^([_a-zA-Z0-9-]+(\\.[_a-zA-Z0-9-]+)*@[a-zA-Z0-9-]+(\\.[a-zA-Z0-9-]+)*(\\.[a-zA-Z]{1,6}))?$";
        ArrayList<String> list = new ArrayList<String>();
        Pattern checkRegex = Pattern.compile(theRegex);
        Matcher regexMatcher = checkRegex.matcher(str2Check);
        while (regexMatcher.find()) {
            if (regexMatcher.group().length() != 0) {
                return regexMatcher.group().trim();
            }
        }
        return "";
    }

    public String duplicateRegex(String str2Check) {
        // return a list of all matches
        // String theRegex = "\\b(\\w+)(\\b\\W+\\b\\1\\b)*";
        String theRegex = "\\b([\\w\\s']+) \\1\\b"; // set to 1 repeat of a word like hadoken hadoken
        ArrayList<String> list = new ArrayList<String>();
        Pattern checkRegex = Pattern.compile(theRegex);
        Matcher regexMatcher = checkRegex.matcher(str2Check);
        while (regexMatcher.find()) {
            if (regexMatcher.group().length() != 0) {
                return uniqueWord(regexMatcher.group().trim());
            }
        }
        return "";
    }

    public String uniqueWord(String str) {
        ArrayList<String> list = new ArrayList<String>();
        String s[] = str.split(" ");

        String p = s[0];
        list.add(p);

        for (int i = 1; i < s.length; i++) {

            if (!(p == s[i])) {
                list.add(s[i]);
            }
            p = s[i];
        } // i

        return list.get(0);
    }
    public String afterWord(String word, String str2Check) {
        // return a list of all matches
        String theRegex = "(?<=" + word + ")(.*)";
        ArrayList<String> list = new ArrayList<String>();
        Pattern checkRegex = Pattern.compile(theRegex);
        Matcher regexMatcher = checkRegex.matcher(str2Check);
        while (regexMatcher.find()) {
            if (regexMatcher.group().length() != 0) {
                return regexMatcher.group().trim();
            }
        }
        return "";
    }

    public String phoneRegex1(String str2Check) {
        return regexChecker("[0]\\d{2}\\d{4}\\d{3}$", str2Check);
    }
}
now she will be able to detect jutsus and animal cries
 

Creamer

Well-known member
#32
Java:
package chobit;

public class TheSkill extends DISkill {
    private RegexUtil regexUtil = new RegexUtil();
    private DISkillUtils diSkillUtil = new DISkillUtils();
    private PlayGround playGround = new PlayGround();
    private MCodes mCodes = new MCodes();
    private ReplikaMap replikaMap = new ReplikaMap();
    private Person friend = new Person(); // if you deal with several friends handle it in the sub class
    private Boolean friendUpdatable = false;
    public TheSkill(Kokoro kokoro) {
        super(kokoro);
    }

    @Override
    public void input(String ear, String skin, String eye) {
        detectFriend(ear);
    }

    @Override
    public void output(Neuron noiron) {
        super.output(noiron);
    }

    private void trgAction(String ear, String skin, String eye) {
        // sensory, souled, predicted
    }

    private void trgExplore(String ear, String skin, String eye) {
        // timed
        // Exploration and learning, Alg efficiancy tests and sort
    }

    private void trgPreserve(String ear, String skin, String eye) {
        // timed
        // items and persons preservation, causes being annoyed if repeated in day
    }

    protected Algorithm makeFriend() {
        return diSkillUtil.verbatimGorithm(new APVerbatim("what is your name"));
    }

    protected void friendUpdate(String ear) {
        String temp = regexUtil.phoneRegex1(ear);
        if(!temp.isEmpty()) {friend.setPhone(temp);}
        temp = regexUtil.emailRegex(ear);
        if(!temp.isEmpty()) {friend.setEmail(temp);}
        temp = regexUtil.afterWord("i am ", ear);
        if(!temp.isEmpty()) {friend.setName(temp);}
        temp = regexUtil.duplicateRegex(ear);
        if (!temp.isEmpty()) {
            friend.setJutsu(temp);
        }
    }

    // key stuff detection and handling
    protected void detectFriend(String ear) {
        if (playGround.getMinutesAsInt() % 2 == 0) {
            friendUpdatable = false;
        }
        if (ear.contains(friend.getName()) || (ear.contains(friend.getJutsu())))// or friend visual
        {
            friendUpdatable = true;
        }
        if (friendUpdatable) {
            friendUpdate(ear);
        }
    }
}
 

Creamer

Well-known member
#33
Java:
package chobit;

public class TheSkill extends DISkill {
    protected RegexUtil regexUtil = new RegexUtil();
    protected DISkillUtils diSkillUtil = new DISkillUtils();
    protected PlayGround playGround = new PlayGround();
    private MCodes mCodes = new MCodes(); // items
    private ReplikaMap replikaMap = new ReplikaMap();
    private Person friend = new Person(); // if you deal with several friends handle it in the sub class
    private Boolean friendUpdatable = false;
    public TheSkill(Kokoro kokoro) {
        super(kokoro);
    }

    @Override
    public void input(String ear, String skin, String eye) {
        detectFriend(ear);
    }

    @Override
    public void output(Neuron noiron) {
        super.output(noiron);
    }

    private void trgAction(String ear, String skin, String eye) {
        // sensory, souled, predicted
    }

    private void trgExplore(String ear, String skin, String eye) {
        // timed
        // Exploration and learning, Alg efficiancy tests and sort
    }

    private void trgPreserve(String ear, String skin, String eye) {
        // timed
        // items and persons preservation, causes being annoyed if repeated in day
    }

    protected Algorithm makeFriend() {
        return diSkillUtil.verbatimGorithm(new APVerbatim("what is your name"));
    }

    protected void friendUpdate(String ear) {
        String temp = regexUtil.phoneRegex1(ear);
        if(!temp.isEmpty()) {friend.setPhone(temp);}
        temp = regexUtil.emailRegex(ear);
        if(!temp.isEmpty()) {friend.setEmail(temp);}
        temp = regexUtil.afterWord("i am ", ear);
        if (temp.isEmpty()) {
            temp = regexUtil.afterWord("my name is ", ear);
        }
        if (!temp.isEmpty()) {
            friend.setName(temp);
            friend.setActive(true);
        }
        temp = regexUtil.duplicateRegex(ear);
        if (!temp.isEmpty()) {
            friend.setJutsu(temp);
            friend.setActive(true);
        }
    }

    // key stuff detection and handling
    protected void detectFriend(String ear) {
        if (playGround.getMinutesAsInt() % 2 == 0) {
            friendUpdatable = false;
        }
        Boolean friendRequest = (ear.contains("friends") || ear.contains("my name is")) && !this.friend.getActive();
        if (ear.contains(friend.getName()) || (ear.contains(friend.getJutsu())) || friendRequest)// or friend visual
        {
            friendUpdatable = true;
        }
        if (friendUpdatable) {
            friendUpdate(ear);
        }
    }
}
 

Creamer

Well-known member
#35
Java:
package chobit;

import java.util.ArrayList;

public class Alg {
    private ArrayList<ArrayList<String>> algs = new ArrayList<ArrayList<String>>();
}
 
Top