BIANCA and ASPI

As a brief overview, BIANCA will be an embodied subset of what I envision as ASPI, or artificial social and puzzle solving intelligence. Currently BIANCA is limited to extremely simple ciphers, with the exception of the “mixed alphabetic reciprocal”.

Current difficulties: figuring out how to fix the automatically added newline. Also weighing whether it’s worth switching to Python, as the body I want to use involves programming an InMoov (so I can learn how robot bodies work).

Mostly trying to figure the current limits of my ability, so I know what specifically to ask for help on. And the code breaking may immediately only by limited to the software side, as the “manual cryptography” I’m wanting to go for may involve so many servo motors and muscle wire it may end up impractical.

Developed a simple framework of chatbot interaction: PHJLS. Or pets, hobbies, jobs, likes, and skills. I might eventually expand more in depth on each individual topic.

I’d eventually also like to build a robot that can “grow up” both physically and mentally. That is their body designed to account for the various physical changes that happen as one develops into an adult. But I may be counting my chickens before they hatch on this one.

Previously I had worked on games like Nihilist (a roguelike) and Terminal Shooter, that’s akin to a tactical space shooter in the terminal.

I also have a blog for the BIANCA project, although I may defer to the staff here to see what is OK to link and what is not.

I was initially unsure whether to mention the project, but I know others have more out there things they want to do, so building a “Puzzle Solver Angel” isn’t to terribly out there I hope.

Oh additionally: while I get the point about Sophia and hair, I don’t necessarily agree, and if things go exactly as I plan, I’m thinking of an initiative for growing hair specifically for the robots: specifically if anyone remembers the Chia pets they grow up with during the 90s era.

I’m looking to do something a little more refined, but where hair is specifically grown for the robot in a similar shaped Chia Pet like thing, where the hair follows some kind of “Sustainable hair growth” pattern. I was considering hemp seeds initially. But by the time I’m able to get this done, I’m considering actually Cannabis plants. ( It’s some ways in the future. )

So even if I get this done, the goal isn’t necessarily to make the hair look exactly like a humans, as it is to provide a rough concept for how a robot can grow their hair, rather than have to get wigs.

I’m finding I’m learning quite a bit how to make decision trees more granular in their approach: for example, if I follow the small talk formula: (1. Name, (2. Pets, (3. Hobbies, (4. Jobs, (5. Skills, (6. Weather.

Then I can make each small talk process its own defined method, and thus make each process follow it’s own artificial intelligence pattern, and thus able to speak about that particular topic in more depth than you otherwise would be loading a bunch of data into the algorithm.

Currently I figured out also how to make it more spontaneous: the initializer picks a topic to discuss at random within a certain time loop. The time loop resolves the issue of constantly running your software and wearing out your machine.

So rather than each program following a set formula, allow for a more natural conversational flow.

def discuss_name
end

def discuss_pets
end

ran_discuss = [1, 2]

auto_discuss = ran_discuss.sample

if    auto_discuss == 1
  d = discuss_name
elsif auto_discuss == 2
  d = discuss_pets
end

In this method (pun intended), you can talk about something different each time you boot up the shell running ruby script.

Other changes

I’m combining shell scripting with ruby scripting, so I can run the programs automatically, rather than having to call ruby specifically.

Doing a script call like: ruby hello_world.rb might not be annoying for everyone, but I feel like if I can run something automatically, I should be able to.

As an update: The poetry generator is almost complete, and I donated all my 32 poems to this project.

Other than certain generated poems reflected the original author’s biases, something of the results are actually quite telling.

I’d never give up writing poetry, but I’m all for having a robot band mate.

As an example of what it can do:


So I look forward to seeing what future development offers.

Updates:

Figured out natural language flow through a simple semi-random language parser using the #gabbler ruby gem. The espeak and gabbler repositories are credited in my readme file.

But figured out how to do simple self-generating training_examples for machine learning a chatbot based on a grammar flow.

# Require libraries
require "gabbler"
require "espeak"

# Generate random grammar elements here to globals.
def greeting;   end
def player;     end
def item;       end
def for_from;   end
def neighbor;   end
def place;      end
def complement; end

# assign variables and create training example
open("data/training_example.txt") { |f|
  g = greeting

  config_time = File.read("config_time.txt").strip.to_i

  config_time.times do
    f.print $do_greeting
    f.print $do_player
    f.print $do_request
    f.print $do_item
    f.print $do_for_from
    f.print $do_neighbor
    f.print $do_place
    f.print $complement
  end
}

# Your gabbler process here
gabbler   = Gabbler.new

data_read = File.read("data/training_example.txt")

gabbler.learn(data_read)

phrase = gabbler.sentence

speech = ESpeak::Speech.new(phrase)
speech.speak

One of those weird things that seems obvious now, but wasn’t obvious to me earlier. It kind of makes me wonder though:

If you can have a self-configuring chatbot.

To me the implied danger seems to be that there needs to be a way for it to generate its own training_data, but can resist tampering by bad actors.

Slightly redesigning the concept to factor in a modular 9 “wake cycle”:

Active Cycle
(1. power on
(2. casual greeting
(4. do_prompt / process prompt
(8. consume entertainment
(7. casual farewell
(5. power down

Passive Cycle
(3. Sense temperature
(6. Sense lighting level
(9. Sense time shift

The general idea is there are things we do actively (thinking about it), and things we do by instinctively (without thinking about it.)

Non instinctive processing being limited to the active wake cycle. And instictive (what do you do automatically), is left to the passive cycle.

Also before I forget, for now the main difference between humans and AI is humans are generally a self-powering up kind of “meat robot”.

Not sure if anyone here has learned about the Polybius Square, but a simple Polybius Square is arranged as follows:

   1  2  3  4  5
1  A  B  C  D  E
2  F  G  H  IJ K
3  L  M  N  O  P
4  Q  R  S  T  U
5  V  W  X  Y  Z

The significance of this is that you can use it to make something like a decision tree take multiple input vectors in one. Suppose each letter represented a location on a map, or a specific ingrediant for a recipe: then you would create a method that travels from A to B, all the way to A to Z. And so on.

If you attach two decision trees together, you can create elaborate procedures based on only a few previously configured input vectors for things like: traveling from x to z, making an omulet, to so many other things.

You can also trick the software into taking three input vectors as well three “three dimensional cryptographic shapes”, like the VIC cipher.

As an update, I managed to narrow down the basic processes into a simple Ruby Gem. How this adapt to Python I’m not yet sure:

Before assembling, do:

sudo gem install ChatBot-Gem

Now after this is installed, go in your favorite text editor. I usually code it into a shell program using the Ruby one line, but you code it as a regular ruby script as well:

require "ChatBot"

ChatBot::Bot.pets
ChatBot::Bot.hobbies
ChatBot::Bot.jobs
ChatBot::Bot.skills
ChatBot::Bot.weather
ChatBot::Bot.likes
ChatBot::Bot.dislikes

Currently working on her code breaking abilities. It’s also not currently spontaneous, so it runs through the entirety of the chat bot script procedure.

In other news:

I’ve also assembled a basic neuron concept for an artificial intelligence: https://rubygems.org/gems/tesla_brain

I might reference the specifics in my depth later. This follows the basic “Wake Cycle” I was expanding on. Going to eventually purge some of my Gits, except those specifically related to this project.

The project is evolving at a slightly different way than I was expecting at first: while the BIANCA thing is still going out, I’m closer to doing something like:

                      Initial State
                     /             \
       Toxic Universe               Healthy Universe
       |                           /                \
       Restart                 Life                  No Life
                              /    \                       |
                        Carbon      Silicon          Restart
                       /      \    /       \
                 Plants  Animals   Macro    Micro
                 +             +        \        \
                / \           / \        \        \__Restart
        Sentient   Restart   R   Sentient \        \
       /                     E   |         +        Sentient
       Go to                 S   |        / \               \
       Language tree         T   |Sentient   Restart         Go to
                             A   ||                          Language tree
                             R   |Go to
                             T   |Language tree
                                 |
                                 +
                                 Go to
                                 Language tree

This can be thought of as a simple universe simulation that maps out whether a Universe is going to be viable for life, or possibly not inhabitable. You can further break this down into something like this:

                                                  Canvas

                                                Re                                            
                                                 |
                         Forest  En   Desert     Elf   Tundra    Fairy  Savannah        Elf
                       /       \   \/       \       \/       \       \/        \       /
                   Dark    Light    Sand Re--Rocky   North    South   Africa    Pacific
                  /    \  /     \       \         \  \       /     \        \          \
             Fairy   Elf  Fairy  Elf     Elf   Fairy  Fairy  Fairy  Elf      Elf        Fairy

This maps out what kind of character you start with. You can even track what kind of language will evolve over time in this same fictional universe:

                              Initial State
                             /             \
                     Unviable               Viable
                     |                            \
                     Restart                       Spoken language
                                                  /               \
                                           Written                 Spoken
                                          /       \               /      \
                                   Written         Spoken  Written Disuse Spoken
                                  /       \             |  /      \    \       /\
                           Written         Spoken       | /        \    Written  Spoken
                          /       \                     |/          \                / \
                   Written         Spoken          Written           Spoken Written /   \
                  /       \                       /       \                        /     \
           Written         Spoken          Written         Spoken           Written       Spoken
          /       \                       /       \                        /       \            
   Written         Spoken          Written         Spoken           Written         Spoken      
  /       \                       /       \                        /       \                    
  Written  Spoken          Written         Spoken           Written         Spoken
                          /   |   \                        /   |   \
                         /    |    \                      /    |    \
[Peak Period]     Written   Code    Spoken         Written   Code     Spoken
                 /       \ /    \  /      \       /       \ /    \   /      \
          Written         +      \/        \     /         +      \ /        Disuse
                    Writing    Spoken       \   /    Writing       +
             And Code Merge      Code        \ /     And Code      Spoken
                                    |         +         Merge        Code
                                    |         Drastic                   |
                                    |         Lang Merge                |
                                    |                                   |
                                    +                                   +
                      Lang Theory One                     Lang Theory Two
                     /               \                   /               \
              Written                 Spoken      Written                 Spoken

So yea there is a lot of life left in things like decision trees, and I think it be a mistake to completely neglect these as time goes on. I use them to create certain ruby gems, like this one that generates its own training data through decision trees: https://rubygems.org/gems/FetchGenerator

This eliminates the need for data collection in this context.

Any given algorithm can’t be relied upon on its own. Not for an Artificial Super Narrow Intelligence that generates detailed game worlds that spawn Artificial General Intelligence.

1 Like

Update on the ChatBot progression, I’m going to be phasing out the current Rubygem for simple ChatBot production.

I will be expanding on this parts of speech concept later:

greeting player request item for_from nearest_neighbor
greeting player request item for_from neighbor         place

greeting player i_know    pets    do_you_know
                i_have    hobbies do_you_have
                i_make    jobs    do_you_make
                i_like    weather do_you
                i_dislike dislike 
                i_will    like    

do_you_remember memory i_remember memory added_detail

player do_you_know pets    i_know 
       do_you_have hobbies i_have
       do_you_make jobs    i_make
       do_you      weather i_like
                   dislike i_dislike
                   like    i_will

In this way, how it chats can be broken down in make granular detail, rather than a simple small_talk conversation script.

The code breaking I may need help with later for anything beyond:

i l k e m y a b c s d f g h j n o p q r t u v w x z
j n o p q r t u v w x z i l k e m y a b c s d f g h

Which is a slightly different take on Recipocal ciphers.

1 Like