working on the new generation of AGI skills

[Creamer]

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]

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]

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]

https://www.youtube.com/watch?v=nM5_37r7TLs
here we go

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]

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]

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]

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]

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]

https://www.nytimes.com/interactive/2014/05/25/us/shooting-document.html

ill use p55 for ref
seems like the obj log, actually logs for every obj. don't know why

 

[Creamer]

smart ass thought he was dead, here I am using his very soul to fuel waifubots, funny

 

[Creamer]

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]

there is no story without a map
the map is the story

https://www.youtube.com/watch?v=8G0a-RvKGqM

 

[Creamer]

next the output functions.
one of which would be story telling, utillizing the essential locations

 

[Creamer]

https://www.youtube.com/watch?v=rD1DKJRDQog

cross map info release : depends on the goal algorithms
loaded on a parallal map per goal
the logs should also contain dates

 

[Creamer]

what are the types of speech and other functions needed?
story telling
fiction or erotic stories
rerun recognition based on logs
QnA
warnings
walk through
short convo //homologous imprint per goal | full convo
jokes and humor// depricated

https://www.youtube.com/watch?v=tJj_Zdy8yuw

 

[Creamer]

https://www.clippings.me/blog/types-of-speeches/

 

[Creamer]

story inflator :
alg parts rnd.
so the replika would have to take in an alg, as a method param

 

[Creamer]

https://www.youtube.com/watch?v=J43REzFypV8

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 !!!!!

 

[Creamer]

https://www.youtube.com/watch?v=P8Y9aklFWkI

lets make the temp map a super class

 

[Creamer]

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 :

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]

should add a compass, would make shit better

 

[Creamer]

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]

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]

https://www.youtube.com/watch?v=4PkTmYrQOEs

 

[Creamer]

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]

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]

https://www.youtube.com/watch?v=eZ3D8EaEtdI

 

[Creamer]

"^([_a-zA-Z0-9-]+(\\.[_a-zA-Z0-9-]+)*@[a-zA-Z0-9-]+(\\.[a-zA-Z0-9-]+)*(\\.[a-zA-Z]{1,6}))?$";

 

[Creamer]

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]

next should be the item class for the TheSkill

 

[Creamer]

https://www.youtube.com/watch?v=js0cQ1rmIYY

 

[Creamer]

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]

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]

what a strong boss puzzle battle. HAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA!!!!

https://www.youtube.com/watch?v=AhLeetJZ3eU

building the Alg class !

 

[Creamer]

package chobit;

import java.util.ArrayList;

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