Hello, hello to them. Let's go to our last lecture. The last lecture called
architectures of sensor-based intelligent systems. It is a brief history
of architectures to give you an idea of the concepts that have previously been
used in case you ever face the problem of deciding about the architecture to
use. The first CMSE model, I believe maybe none of you haven't heard it.
Some machine architecture, maybe you have a little bit of an idea about it, and
the control architecture of a fish. This is not a real fish, a robot fish. And some
reasoning system, a hierarchical control system, and architectures for
learning robots. First of all, what is a sensor-based intelligent system?
Obviously, it has multiple sensors, different kinds of sensors, and different
one sensor can present one current state of the robot, and then the sensors can
present the basic behavior of the robot. But if we have different kinds of
sensors, then maybe we need to use multiple sensory data to decide to check
the robot current state. For example, we maybe need the camera and also the
tactile sensor, these two sensors to check to decide where the robot
hand, hold, and object tightly. But all the sensor datas, maybe they're
not at an equal level. Some are at a higher level and some are at a lower level. Then
different kind of sensors can decide a higher level command and a low level
command. Sub-assumption, we will discuss, talk about this kind of different
sensor data, then you can decide a different series of actions. And then
hierarchical architectures. Obviously, sub-assumption is also one kind of
hierarchical architecture and some interactive architecture. The robot always
interact with humans and the robot learning something from humans. Then let's
start. We use sensors, can perceive the robot, can get the perception, and this
perception can decide the behaviors of the robot and the different behaviors
present a different action. Then this action will give feedback to this. We can
use some sensors get the feedback from the action and it will influence other
sensors. Then this is something like a loop. There's a loop in here. This is a
typical perception action model with memory. Now where is memory?
So after we get the perception and then we need something to somewhere to
store this data and based on this data and the previous data, we will
decide the behaviors. So this is a typical architecture of sensor-based
robot systems. And then the next one, even me, I'm not so familiar about this
model, sorry. This is one kind of architecture which is very similar to
neural networks but much before neural networks. They were popular in robotics.
You know, neural networks start from a single field from the computer vision
field, not start from the robotics. But this cerebellar model architecture
controller, they're really used in robotics. So what is it? You see,
cerebellar, then it's something very related to human. It is a type of neural
network based on a model of the human cerebellum. Let's see what the
components in this controller. The first is sensory input. In here you also
can call the firing cell patterns and association vector, then cell pattern
combination. Then it seems this S8 vector is used to combine
these sensory input vectors. And then here have P. This is a response output
vector. We use A multiply W. The W in here is a weight matrix. Now you can see
the model can be viewed as two mappings. From S, we can go to A. A will combine all
the input vectors. And from A, based on these weight matrix, you can get P.
You see, this is really similar to neural network. And then let's see this big
architecture. Wow, it looks a little bit crazy, right? But let's come down and have
a look. So first, S is sensory cells. And then we have associated cells, which
combine these sensory input. Then we get A. And based on this A, we have different
kind of weights. These adjustable weights, maybe you need to learn to train. And then
based on these weights, you can get different R1, R2, R3. This is the response.
So actually, the architecture is not hard to understand. The CMSC model was first
proposed as a function model for robotic controllers in 1975. It's almost 50 years
ago. And now, a change of value of the input points results in a change in the
set of the association cells. And therefore, a change in the set of these
associate cells, they will multiply with these weights, and then the output will
also change. So the output is there for storage in distributed association, such
that the output corresponding to any point in the input space is divided from the value
stored in a number of memory cells. So that's why we said this is also a type of associative
memory. And this provides a generalization function. And then this is the typical, like
typical, maybe you can say this is the most simple artificial neural network. Then we
have input and here have the different weights. And this is the hidden layer. And then they also
have some adjustable weights, we need to train these weights. Now we get the output. So a
different input will get a different output. And we also can the output also corresponds to any
points in the input space. And we know artificial neural network, it's also come, it's like it's an
idea comes from animal brains, because human, the brain neurons, we think like this way, we need
different weights, different neuron cells, then we get the final output. Also, for this
architecture, we just, you just know, okay, in 50 years ago, they have a sensor model
architecture controller, based on human, also human brain, the cerebellar structure. And it's
very similar to artificial neural networks. But nowadays, we use architecture neural
networks in robotics is very popular. And maybe you can take a lecture about the neural network.
The next one is the sub assumption architecture is a modeling of planning paradigm. And this
paradigm composed of sequence of steps and each step they have a function units transform sensory
data to actions. So from sensory data from sensors to action and from action to the specific goal.
And then this is quite a broad introduction. Then let's see an example, the mobile robot
a rock warrior. It is a very small, you can think it is a mini version of total vault. And it is
designed for education, researchers for hobbies, and not for industry usage. And they have two
lights infrared sensors at the left side and the right side can detect the opposite goal. And it
can either have a model that can go forward and it also can rotate. Let's see what is related to
our sub assumption architecture. First, it begins with a cruise behavior. Oh, I forgot to say,
I will put this link in the supplementary material in this lecture folder that you can find out
more interesting message by information by yourself. Okay, so start from the cruise behavior,
then we can control the robot most forward or turn around. And then if they have a follow
behavior that comes from a phone cell, then the robot will this follow behavior subsums the
cruise behavior. And this robot will move towards the light, not the cruise command from the
cruise system. And then they also have avoid behavior. This is based on the infrared sensors,
if they detect the collision, then the robot will avoid the collision and this
behavior, avoid the behavior, suppress the follow and cruise behaviors. Then on the top,
they have escape behavior. If the robots detect the bomb and then it will try escape first,
then this escape behavior will suppress the avoid, follow and cruise behavior. It will
reverse and bus by the obstacle. And on the top, they have top level behavior maybe sent from human.
Then if humans and some high level commands, then we'll make the robots play a buzzer,
they have peers or a buzzer in there. Then this will suppress all the other behaviors.
So you see in the subsum architecture, it's like have more higher level and
some behavior will suppress other behaviors. And in each step, they only will have one
behavior to decide the action. But they also have some architectures like for the mobile robot
architecture, they have foraging and flogging. Let's see what's the difference between this
foraging and flogging architecture compared to the subsumption architecture. Let's see here are
one, two, three, four, five. These are four or five basic behaviors. They are sequentially
executed and some sensor data provide for these behaviors. And if we fuse all these sensor data,
then this will be the actual data output. So they are parallel. And if they have some basic behavior
such as disparaging, aggregation, and self-wandering, and this three will compose,
my microphone is falling down. Let's continue. This three basic behavior will compose a new
behavior. We call it flogging. And then the aggregation and the self-wandering and the
flow. These three behaviors will compose a new behavior called surrounding. And
wondering, surrounding, and flogging will compose a hurting behavior. And afterwards, we add these
five behaviors together, also include the flogging here, then we will get a foraging behavior,
all of these together, then this will be flogging. You see, this have the basic behavior and have
some composite behaviors, not only suppress one behavior, suppress the other behavior, but
some basic behavior will compose a new behavior. And this, there will also have like a flogging
will based on the flogging behavior. This like a hierarchical architecture, but in
a subsumption control architecture, there are only one behavior will happen at one time.
Okay, then the next example is a cockroach behavior. You see, this is the census for this
animal. The mouse has a tactile and the mouse mechanical and also the
antenna, and then the mechanical and the antenna. Then for different sensors, they will have
different behaviors like these two can decide the ingestion and an antenna can decide the
very defined fold and also antenna for the edge following. But ingestion also this behavior
will go next, will decide whether find the fold. And then this edge following will also
give feedback and get information from find the fold and finally for wandering. This is also some
kind of architecture. You see the basic, maybe some basic behaviors can compose to a high level
behaviors and they also can give feedback. So this is also different with the subsumption behavior,
subsumption architecture. The next thing we will see is how to control a robot fish.
I also put a YouTube video in the supplementary material. You can have a local robot fish.
In times earlier research, we also have some colleagues, they research on a robot fish and
we still have one prototype in our lab, but no one use it at all in this time, but let's have a look.
Basically it also have perception, we have these sensors, then we have the behaviors,
then the fish also need to have brain, have mind because we need to design this
based on a fish's habits and intention generator. Then we need to learn optimize the
behavior, maybe the trajectory of the robot and then we need a motor to control the fish
how to move it or because extra editor or some muscles. This is the architecture, okay.
So first this is the perception. Where we can get the perception, you see the eye and we can
get the sensors from, I don't know how to say it, but I hope you can see here. Then
we also we can get the sensor information from these three parts of this fish and based on this
sensory data, then we can fuse this data, then we can see the behavior of these robots,
then this behavior also based on the habits of this fish, then based on these habits then we can
know the intention generation, then know what the fish want to do and also based on the perception
then they will have behavior routines and this part together for the intention and the
fusion data, then we can do the optimization, we will know okay and what the fish should turn left or
turn right or go up or down, then they should have a learning architecture, learning process
in here. This is like the brain, like the mind of the fish and then this will control the motor
and then the robot can move, then this will lead to the actuator and the muscles. So you see inside
of this fish, all in the stomach of this fish, they are all actuator and muscles. This is the
physical model. I hope you can have fun in the YouTube video and then I also link the YouTube
video in here. Now we can have a look now. Basically a robot fish, they are always a soft robot.
I know some channels for the nature of animal channels, they will build some robots or even
some prototype which is very similar to the robot, to the animal itself and then put a camera on this
artificial animal, then let this animal play around with the real animals and then
can collect some very natural information of the animals.
Okay, you will see this later. Let's go back to our lectures.
The next one is Procedure Reasoning System. In artificial intelligence, a Procedure Reasoning
System, short for PRS, is a framework for constructing real-time reasoning systems
that can perform in a very complex or dynamic environment. Let's see the frame.
The input are the sensors and the output are the commands for the actuators and in the
between, they have something we haven't seen before called interpreter and interpreter contains
four parts, beliefs, desires, plans and intentions and on the top they have operator
interface and this is from the user. Okay, then from sensors we can monitor the state of the robot
and beliefs means what the agent believes to be true about the current state of the world.
So from the sensors, the agent can get the beliefs and desires means the agent is
school, where they want to go and what they plan to do and plans, we can consider plans and
intentions together so this means the agent has current plans for achieving these goals.
So the desire means the goal, beliefs means the perception of the agent feel about the current
environment and the plans and intentions means the plan to achieve the goal and this interpreter
will contain these four parts then you see they do a lot of things right and in here the operator
interface we can think this user interface is predefined and provided to a PIS system
and it is a set of knowledge areas you see this like the knowledge we can which can give the
feedback to the beliefs and each knowledge area is a piece of procedural knowledge
and they specify how to do some specific things for example how to navigate to the kitchen
and or how to plan a path or how to detect a human so this predefined knowledge we together
with this interpreter it will help the robot to decide to have the human to decide to control the
agent to do correct things. The other system called real-time control system short for RCS
is also an architecture for intelligent systems and the very typical property of this system
is their hierarchy basically their OS has two modules one is behavior generation
and the other one called word model the behavior generation is used to form a command tree to send
to generate the commands then the word model is used to share the information from the knowledge
database then let's see some examples and this one is a typical hierarchy in architecture
they have level one to level seven and in each level they have the sensory processing
and they have word modeling and have task decomposition and value judgment
then in the middle is a global memory and the word modeling can get the information from the
global modeling and the sensory processing is used to process the sensor data from the multiple
sensors and the task decomposition is used to departure these tasks and send this task to the
robots and the other more this example will be more obvious to understand this hierarchical
architecture first you see from the bottom layer they have sensors and actuators
you see the arrows in here they have arrows point up and point down so the point up one
is from the sensors to get the sensor processing and in between they have word model to use the
knowledge from the database and then they have behavior generation then this will generate
commands send back to the actuators in each level you see they both have these three
modules and from bottom to up they become more and more high level for example here from points
lines surface objects and then what will we do for these objects then task context for next
five minutes and next hour and next day and all these layers will depend on the operating
inter factors so this is an example to show this hierarchical real-time control system
the other sensor hierarchy we can see here they're also from the raw data this is the sensor data
from level zero to level four and you see at the beginning we only get the property of points in
the space and then we go to higher level level one then we can understand the aggregates of
the points and their features then this is object level and then we will recognition of all these
aggregates of the features then this is from description to recognition
and this step is defined by level one and then level three are
defined or decided by level one and then level two together then this is description of relations
of objects or unrecognized aggregates so not only the objects we know the recognition we know
the features and also we need to figure out we need to know how to face these unknown objects
then after the level three we get the level four then this is recognition of the relations and of
course they have more higher sensor hierarchy then the next thing we want to see in the last
session is an architecture of learning robots using the learning-based robots nowadays learning
this world is very popular we need to look at this architecture from top to down to bottom
we send a goal then if we want to achieve this goal that we need to have a strategy and this
strategy maybe involve recognition of the object and also involve some path planning or trajectory
planning or task planning and all these strategies based on the sensor transformation signal
transformation the sensor datas we get from the robots then we know this sensory data and then
we can get a strategy it's like we have training a model if we have trained a model we will put a
model in the database then this model can use the for the neuron servo controller can use to
send some commands to the robots or the plant and then the robot execute these
commands then we get new sensor if we