►
From YouTube: From Pterodactyls and Cactus to Artificial Intelligence - Ivan Seidel Gomes, Tenda Digital
Description
From Pterodactyls and Cactus to Artificial Intelligence - Ivan Seidel Gomes, Tenda Digital
"Among many things I love, what I really appreciate doing is the different, and learn with it.
Breaking barriers is complicated for any person. Knowledge barriers many times are formed by ourselves by incomplete parts of our mind’s puzzle. What If I could help you out with some piece of Artificial Intelligence, without ""puzzling"" your head?
This project consists of an A.I. coded in Node.JS that learns by itself to play the ""Google Chrome""’s Dino game (the one that pops up when there is no internet).
Using Neural Networks, and a Genetic Algorithm, I could manage to let the computer learn by itself how to play the game like a ninja. The project has been hosted in github (https://github.com/ivanseidel/IAMDinosaur) and it’s called IAMDinosaur.
There is also an video with English subtitles in Youtube, explaining it from the ground up how it work: https://www.youtube.com/watch?v=P7XHzqZjXQs
I was invited to speak at Brazil NodeConf 2016, and this is one of my speaker subjects (A.I. in Node.JS)
--
Also, another subject that I love working with NodeJS is Hardware. Interfacing things with Hardware is what I most like (be it through Internet, USB, Bluetooth...). One of my last projects used an ABB robot and could play Tic Tac Toe all programmed in NodeJS (Video: https://www.youtube.com/watch?v=V9dOoicowb0). Also, it’s open-source code: https://github.com/ivanseidel/ABBNator"
A
Hi,
my
name
is
ivan
and
I
will
talk
about
preterite,
ductus
and
cactus.
That's
a
really
hard
work,
but
I'm
pretty
sure
you
understand
what
I'm
saying,
because
this
will
not
be
something
technical,
something
that
puts
a
high
level
of.
I
don't
know
technicity
to
understand
what
I'm
going
to
show
you
to
begin
with
I'm
from
brazil,
and
this
project
shows
a
bit
of
how
we
all
makers
do
things.
We
get
some
topic.
We
get
some
challenge
and
we
face
that
and
we
resolve
that
problem
and
we
learn
by
doing
it.
A
So
this
is
a
project
I
made
with
a
friend
ron
pedro.
Is
there
yeah
and
basically
we
wanted
to
learn
ai
and
we
wanted
to
learn
it
with
something
that
was
at
least
some
useful
for
a
fun
or
something
like
that,
and
we
made
something
that
could
learn
by
itself
how
to
play
a
game,
and
I
mean
I
I
don't
like
to
play
games,
but
seeing
computer
playing
games
is
really
nice.
So
basically
we
wanted
something
that
could
be
easy
to
teach
and
easy
to
analyze
and
easy
to
get
information
about
it.
A
A
So
it's
a
game
all
right
and
the
game
is
really
really
simple.
It's
basically
you
jump
and
they
you
make
the
dinosaur
jump
and
skip
the
cactus
and
also
avoid
pitera
dactus,
that's
further
more.
This
is
me
playing,
so
it's
not
ai
yet,
and
the
reason
why
we
made
this
is
really
simple.
It's
because
we
wanted
to
learn.
Okay,
it's
because
we
wanted
to
do
something
and
to
learn
by
doing
not
by
studying
many
things
and
getting
many
technical
words
and
not
actually
understanding
deeper.
A
So
how
did
we
make
to
how
we
managed
to
make
a
dinosaur
learn
to
play
the
game?
So
the
first
impression
that
was
that
it
would
be
something
really
difficult,
but
then
we
thought,
okay,
let's
try
to
think
as
a
robot.
Let's
try
to
think
of
something
that
we
already
do,
which
is
robot.
We
love
robotics,
and
so
we
think,
let's
put
sensors
on
on
that,
that
dinosaur
all
right.
So,
let's
create
sensors
virtual
sensors
that
the
dinosaur
can
understand.
A
There
is
more
information
that
we
can
achieve
from
that
game.
One
really
important
information
is
the
distance
and
the
second
most
important
one
is
the
the
widget
of
the
cactus.
You
may
think
that
the
widget
may
not
alter
the
behavior
of
your
game,
but
actually
it
does,
because
if
the
cactus
is
really
long,
you
should
probably
jump
a
little
after
you
usually
do
so
you
may
think
that
it
alters
a
bit
the
behavior
of
your
plane
right
and
the
third
information
is
the
speed,
the
game
with
time
gains,
speed
and
with
speed.
A
It
increases
difficulty
because
you
need
to
jump
a
little
bit
before
and
in
order
to
us
to
understand
how
this
is
done,
I'll
show
you
how
it
is
actually
implemented.
So
at
many
steps
here
I
put
in
the
code,
I
got
it
from
the
github
repo
and
I
kind
of
make
it
up
it
and
simplified
it.
So
I
could
show
it.
I
will
not
be
able
to
explain
all
the
steps,
but
the
presentation
is
online
in
event
mobi,
so
you
can
download
it
there
and
maybe
have
a
bit
more
insight
about
it.
A
So,
basically
we
scan
the
screen
and
we
find
the
offset
of
the
game
because
we
are
not
reading
and
not
injecting
javascript
code
into
the
browser
we
are
reading
the
pixels
from
the
computer
screen.
So
we
are
basically
reading,
you
know
rgb
data
and
the
first
step
is
to
find
and
locate
where
the
game
is
on
the
screen
and
that's
done
by
multiple
passes
and
finding
that
color
and
matching
that
pattern.
And
after
that
we
have
a
offset
point
and
that
offset
points
lead
us
to
the
starting
point
of
of
each
sensor.
A
So
basically,
the
sensor
is
offsetted
from
the
origin
of
the
game.
It's
always
fixed
and
that's
basically
how
it
works.
So
the
next
thing
we
thought
about
was
we
need
to
activate.
We
need
to
generate
output
from
that
intelligence
or
whatever
we
are
doing,
and
in
order
to
do
that,
we
are
calling
it
actuators.
A
So
we
have
two
actuators.
One
is
the
up
key
and
the
other
one
is
the
down
key
yeah.
The
dinosaur
can
skill
who
didn't
know
that?
Okay,
so
I
made
a
few
people
more
happy
yet
so,
basically,
there
are
two
outputs
of
the
game.
You
can
jump
and
you
can
also
skew
I'm
not
sure
if
that's
a
word,
but
you
can
do
that
to
output
all
right
and
if
we
abstract
that
and
imagine
that
a
code,
a
really
generic
code
has
inputs
and
outputs.
A
We
like
to
write
in
english
because
we
understand
english,
but
machine
doesn't
need
to
have
five
letters
for
while
it
just
needs
one
byte.
You
may
think
that
machine
can
simplify
things.
We
try
to
complicate
it
or
to
visualize
it
better
and
that's
a
way.
We
do
it
in
order
to
understand
and
comprehend
better
code.
So
in
order
to
achieve
a
let's
say
another
code,
we
cannot
have
really
code
going
on.
A
So
that's
the
reason
why
exists
on
neural
network
in
a
neural
network
is
a
really
generic
thing
that
connects
inputs
to
outputs,
but
in
different
manners.
So
we
may
think
that,
instead
of
having
code
in
between
it,
we
would
have
weights
on
each
connection
and
each
connection
can
actually
trigger
something
but
not
trigger
as
an
event
trigger
as
a
discrete
event
that
we
after
process
it.
A
A
We
may
think
that
a
neural
network
consists
of
neurons
and
a
neuron
is
basically
a
unit
that
receives
input
and
has
one
output
all
right.
That
output
can
also
go
to
many
places,
so
we
can
think
that
the
same
output
can
go
to
many
inputs
all
right
and
what
basically
a
neuron
does.
Is
it
aggregates
inputs?
A
So
you
can
have
any
number
of
inputs
and
you
have
one
output
for
that
neuron
specific.
So
this
is
a
really
simple
neural
network,
and
this
is
how
neuron
works.
You
may
think
that
it
has
an
a
and
a
a
bigger,
and
this
is
constant,
constant,
constant,
all
right,
and
this
a
and
b
the
small
ones
are
actually
the
real
values
coming
from
the
the
past
layer.
All
right
and
the
mathematics
is,
let's
spawn
the
rate
each
input,
so
we
basically
multiply
by
the
weight.
A
This
yellow
and
red
are
basically
the
weight
of
each
input
and
you
sum
with
an
x
which
we
call
bias
all
right.
So
basically,
bias
is
a
sum.
After
all,
and
after
calculating
this
line
function,
you
go
and
put
it
on
a
sigmoid
or
even
a
logistic
function,
and
something
like
that
in
order
to
limit
your
output,
you
don't
want
it
to
go
to
infinity
or
negative
infinity.
You
want
it
to
stay
there
between
0
and
1
or
negative
1
and
1..
So
you
may
do
that.
A
But
a
cool
thing
is
with
a
simple
thing
like
that:
you
can
create
higher
order
functions
and
even
basic
order
functions.
For
example,
if
we
input
zero
and
zero
and
the
weights
are
one
and
one
with
bias,
zero,
the
output
is
zero.
Okay,
zero
times
zero
plus
zero
times
zero
plus
zero
zero
pretty
obvious.
A
So
imagine
that
the
one
becomes
a
0.5
and
you
move
that
bar
up
and
you
make
a
end,
and
you
say:
okay
net,
let's
make
a
x
or-
and
you
cannot
do
with
one
neuron,
but
you
can
add
more
neurons.
You
can
complex,
make
it
more
complex
right,
you
can
give
it
opportunity
or
give
it
flexibility
to
manipulate
inputs
and
given
to
become
outputs,
so
it
can
become
something
like
this.
A
This
is
a
xor
function
and
it
basically
has
like
two
limits
here,
all
right
and
well.
Basically,
this
is
a
neural
network
and
it
for
me,
it's
really
nice
to
see
that
we
can
generalize
problems
in
that
way,
because
this
has
three
neurons.
But
what
if
we
have
a
hundred
neurons,
two
hundred
thousand
neurons
or
even
millions
of
neurons,
in
order
to
process
image
and
detect?
If
it's
a
happy
cat,
you
know
that's
something
everyone
likes
so,
and
a
neural
network
becomes
this.
A
After
all,
you
have
connected
inputs
for
two
outputs
and
outputs,
your
input
and
so
on.
So
imagine
that
we
have
the
inputs
here
which
are
distance
speed
and
we
did
and
we
have
the
output
from
the
keyboard.
I
simplified
it
a
bit
okay,
but
imagine
that
it
can
be
any
size
and
what
is
cool
about
it
is
that
if
we
remove
all
the
connections
actually
visually
on
our
head,
it
doesn't
actually
disconnect
oops,
okay,
so
yeah.
A
A
A
So
let's
go
and
now,
let's
forget
about
the
connections
and
just
think
about
the
neurons
as
being
a
bias
which
are
the
bigger
circles
and
oh
and
also
the
weights,
the
small
ones.
So
let's
re
build
this
so
imagine
we
have
no
connections
at
all
and
we
linearize
all
that
data.
We
will
have
like
a
neuron.
A
We
will
have
like
a
genome.
Sorry,
so
imagine
that
this
configures
this
gives
the
ability
to
a
neural
network
to
work
in
a
determinant
form.
So
if
we
change
values
from
that
circles,
imagine
each
circle
is
like
a
floating
point:
number.
Okay,
you
will
alter
the
behavior
of
the
neural
network
and
what
we
do
now
and
now
we
are
in
the
inside
the
generic
algorithm
algorithm,
and
what
we
do
now
is
that
we
create
those
guys
randomly.
A
A
So
imagine
that
we
start
a
generation
of,
and
elements
are,
and
individuals
and
each
individual
is
different.
Okay,
we
randomly
created
them.
They
may
not
work,
probably
they
not
work,
but
they
can
be
good
at
some.
Some
point
so
imagine
that
the
generation
is
like
many
life
forms
that
we
will
put
in
practice,
because
there
is
no
way
to
telling
this
one
is
better
than
this
one
without
testing
them.
We
are
putting
them
into
practice.
A
We
read
the
sensor,
we
apply
to
the
neural
network,
we
get
the
output
and
apply
to
the
key
presses
on
the
computer
and
that
basically
makes
the
genome
be
alive
all
right
by
looping
that
by
continuously
updating
the
the
key
presses
with
the
output
from
the
neural
network-
and
this
is
the
first
step-
start
learning.
Okay,
the
code
is
all
really
has
name
and
methods
that
you
can
comprehend.
So
maybe
it's
nice
to
download
the
ripple.
A
I
will
show
the
link
after
all,
and
basically,
we
build
gynoms,
and
here
we
say:
oh,
it
has
three
input
layers,
three
values
and
one
output
layer,
and
then
we
execute
the
generation
and
what
execute
generation
does
is
basically,
it
binds
the
sensor
change
value.
A
sensor
change
listener
to
the
output
of
the
keyboard,
and
this
is
actually
some
wrapping
up
stuff,
but
it's
really
simple
to
see
it.
A
A
So
what
we
do
is
we
score
them?
We
rank
them
and
we
say
goodbye
to
the
not
so
good
ones
yeah,
so
I
killed
them
in
memory.
Actually
garbage
collector
does,
but
what
matters
that
they
vanish
from
the
program
and
what
matters
most
is
that
the
best
ones
keep
on
the
program
they
keep
running.
They
keep
leaving,
and
this
is
called
natural
selection,
but
actually
it's
not
natural.
A
So
now
we
have
individuals,
it
may
be
two
three
four
ten.
Maybe
you
are
running
a
generation
with
a
thousand
and
what
actually
do
now
is
we
have
to
get
information
from
them.
We
cannot
keep
generating
genomes
randomly
that
doesn't
get
information
and
get
that
that
learned
information
and
proceed
to
the
next
generation.
A
So
we
actually
have
to
get
these
genomes
and
make
something
that
can
be
better
and
the
word
can
is
really
important
because
it
will
not
for
sure,
be
better,
but
by
joining
them
by
crossing
over
them,
it's
important
so
that
you
can
make
a
genome
better
faster,
so
we
cross
over
them
and
create
a
new
genome,
and
after
that
we
have
to
okay.
This
is
the
code
you
can
see
it
later
and
after
that
we
have
agenum,
but
imagine
that
in
the
first
generation
we
started
all
the
values
with
zero.
A
Imagine
that
all
the
values
were
zero.
If
you
swap
zero
of
zero,
you
always
be
zero.
Can
you
see
it
there
will?
No,
there
is
no
chance
that
the
genome
will
get
better
from
the
values
that
you
started.
So
we
have
to
do
something
in
order
to
allow
the
genome
to
improve
or
even
be
worse,
okay
and
that's
called
mutation
and
mutation
is
basically
a
way
of
randomizing
and
select
randomly
selecting
and
randomly
multiplying
a
value
from
that
list,
and
you
actually
mutate
each
value,
so
you
basically
go.
A
A
A
When
I
know
it's
ready,
you
know
for
production,
I
mean,
let's
produce
dinosaurs.
No,
but
that's
the
cool
part.
That's
the
part
that
I
most
like
about
the
generic
algorithm.
It
can
always
be
improved,
but
it's
always
limited
to
the
input
data
you
put
and
also
to
the
speed
to
the
processing
speed.
In
this
case,
the
computer
reading
pixels
takes
too
long
and
makes
the
algorithm
a
little
bit
slow
like
50,
40,
milliseconds
and
the
ideal
would
be
like
15
milliseconds
to
reach
at
least
60
frames
per
second,
so
I'll
show
a
little
demo.
A
Now
you
can
download
and
run
node
index.
You
put
the
terminal
aside
from
the
google
chrome
and
you
must
be
offline,
of
course,
but
there
is
a
tricky
I
found
out.
You
can
simulate
offline
connection
with
google
chrome,
so
that's
useful,
and
then
you
run
the
program.
You
see
that
the
mouse
will
go
to
the
okay
you're,
not
seeing
because
thank
you
for
letting
me,
though,.
A
A
A
So,
basically
I
will
play
the
game
here
myself.
You
can
see,
there
are
three
bars
and
I'm
really
bad
at
this
game.
I
think
that's
the
reason
I
made
a
this
this
project,
but
the
first
one
is
the
distance.
The
second
one
is
the
size
and
the
third
one
is
the
speed
and
the
fourth
one
is
the
activation,
and
the
activation
was
the
version
one
that
I
shipped.
A
If
the
value
from
activation
goes
above
0.55,
it
simulates
the
up
key
if
it
goes
below
0.45
it
simulates
the
down
key,
and
in
the
middle
of
that
it
just
releases
the
key
all
right.
So
we
can
think
that
the
fourth
bar
is
the
actuator
okay,
that
output
from
our
neural
network,
so
right,
putting
three
three
three
values
and
getting
this.
A
So
this
is
how
I
started
after
coding,
and
this
is
really
bad
for
debugging,
because
this
is
not
something
you
expect
this
is
he
he's
already
playing
it
and
he's
starting
from
scratch
to
learn,
so
you
can
see
that
he
built
genomes.
He
built
12
genomes
and
he's
testing
the
genome,
4
of
12
5
of
12
and
he's
reading
the
game
state
from
the
with
color
from
the
screen.
A
A
A
thing
happened,
and
I
made
a
function
to
speed
that
up
by
actually
checking
if
the
genome
is
at
least
not
dumb
enough,
and
I
can
label
it
with
a
true
here,
which
is
the
flag,
shoot
track
experience.
Okay,
so
that's
pretty
direct,
but
what
it
actually
does
it
is.
It
takes
the
neural
network
and
it
tests
many
inputs
and
check
if
the
output
at
least
gives
me
two
state
possibles
for
the
keys
up
and
down,
not
nothing
and
down
nothing
and
up
down
and
up.
I
I
don't
care,
I
just
check.
A
If
there
are
two,
because
if
there
is
only
one
we
know
he
will
die,
even
if
he
keeps
jumping,
he
will
die
and
that's
not
a
good
genome.
So
if
we
try
it
out
again,
you
see
that
generation
is
in
the
fourth
generation
and
maybe
something
is
useful.
No
and
that's
basically
the
process
in
a
sp.
You
know
faster
way.
All
right
I
didn't
want
to
we.
A
A
Let
me
kill
him
okay,
so
here's
that
I
can
load
ninja
generation
and
start
he
keeps
down,
and
you
may
think
all
right.
That's
that's
dumb
right,
but
actually,
no
after
we
got
to
that
generation
that
keeps
down
all
the
time
we
saw
that
keeping
down
is
the
better
solution
for
the
game,
because
when
you
press
down
you
like
increase
gravity
and
the
dinosaur
goes
faster
to
the
ground
and
also
the
pterodactyls,
they
are
up
and
he
can't
see
them.
A
A
A
Yeah
the
fitness
at
first
we
tried
to
use
the
scoring
from
the
game,
which
was
the
time,
but
that's
not
good
enough,
because
the
cactus
are
random
and
in
a
given
time
you
may
jump
more
and
less
cactus.
So
we
count
how
many
cactus
he
is
jumping
right,
yeah.
So
the
fitness,
how
we
check
how
good
is
a
genome
is
by
checking
how
many
cactus
he
jumped
it's.
Basically,
when
the
distance
go
bigger
than
the
last
state.
So
if
it
increases,
then
that's
a
new
cactus
he
jumped
or
he
died.
A
Yeah,
so
that's
basically
life,
you
know
if
there
isn't
random,
plus
random,
which
gives
random,
then
there
wouldn't
be
life,
because
there
wouldn't
be
a
random
thing
to
initiate
something.
So
I
picked
it
up
a
few
values
and
I
tested
them.
I
couldn't
plot
graph
because
it
would
take
time
and
I
tried
it
on
the
airplane,
but
my
battery
ran
out.
So
basically,
mutation
rate
is
like
0.2
and
the
crossover
is
random,
completely
random.
A
There
is
no
ponderation
there,
but
we
pick
it
up
values
that
I
checked
it
on
the
internet
and
I
saw
that
they
were
okay,
that's
20,
I'm
not
sure,
what's
the
actual
value
for
life,
but
it
should
be
around
less
than
five
percent.
I
guess
otherwise.
There
would
be
a
lot
of
problem,
yeah,
okay,
anyone
else
so
yeah
the
high
score.
Okay,
so
yeah,
he
beated
me
and
my
friend
and
all
my
friends
as
well.
A
I
will
try.
Oh,
I
cannot
access
here,
it's
offline,
but
here
is
online,
so
the
video
is
basically
a
version
of
what
I
said
today.
My
channel
has
a
few
videos
about
pid
and
algorithms
for
robots,
and
also
there
are
a
few
other
projects
that
I
made
with
node.js
like
controlling
abb,
robot
with
node.js.
That's
a
cool
one
yeah.
So
there
is
the
video
here
it
has
english
subtitles
and
at
the
end
it
plays
the
game,
and
here
is
e-learning.