►
From YouTube: Weekly Sync 2020-07-10
Description
Meeting Minutes: https://docs.google.com/document/d/16u9Tev3O0CcUDe2nfikHmrO3Xnd4ASJ45myFgQLpvzM/edit#heading=h.czhro95mmi41
A
A
I
can't
remember
how
I
found
it
now,
but
they'll
basically
host
ipython
notebooks
for
you
and
then
like
up
to
a
hundred
concurrent
users
at
a
time
which
is
pretty
sweet,
so
I
wanted
to
I
think
I
added
added
in
issues
somewhere
to
give
this,
because
this
would
be
good
as
like
an
alternative
together,
because
they
don't
think
it
requests.
It
doesn't
require
a
sign
in
so
people
can
just
sort
of
like
do
stuff
right
away
in
their
browser,
which
is
always
good.
So
I
was
going
to
try
to
get
that
going.
A
Alright,
so
Augen
I
still
need
to
do
the
PR
on
the
chat,
bot
and
all
have
a
big
bad
I
was
I
was
trying
to
do
it
yesterday
and
then
I
I
lost
the
tab
and
then
I
and
then
I
went
on
to
something
else.
So
so
I
will
get
you
feedback
to
that
sent
and
what
else?
So?
What
else
has
been
going
on
with
you?
Oh.
B
B
A
B
B
B
A
B
B
D
B
A
B
So
I
did
tell
cousin
lay
it
now
like
Frank
we
know
starts
some
more
starts
the
exchange
operation
and
incest
name
and
like
a
to
our
signal
Isis.
The
next
step
is
to
the
next
step.
The
primary
no
will
announce
a
we
won't
to
instantiate
the
operations
and
that's
the
next
step.
Okay,
I
hope
in
network
all.
B
B
A
B
D
D
A
A
A
B
A
I
recording
yes,
I
am
yeah.
Okay,
let's
see
so
yes,
dagger,
create
connections
create
connection
after
right.
So
basically
it
goes
through
and
it's
gonna
say
you
know
ACK,
oh,
so
you
can
use
this
wait.
Call
you
can
say
win
something
like
just
return.
Basically
I,
oh
wait,
usually
waits
for
all
the
co-routines
to
complete
and
then
returns.
You
know
the
set
of
the
set
of
them
that
have
been
completed
and
then
the
set
of
them
that
are
still
not
completed.
A
And
then
you
know
the
not
completed
ones
are
basically
just
never
gonna
be
there
unless
you
set
it
to
first
completed
our
first
exception,
and
so,
if
you
set
it
to
first
complete
it,
then
it's
going
to
it's
gonna
get
as
soon
as
the
first
co-routine
completes
its
going
to
return.
The
rest
are
going
to
be
in
the
pending
sit,
and
so
let's
see
yeah.
So
basically
we
go
through
and
we
create
we.
We
do
this
staggered
connection
creation,
so
I
one
second.
A
Okay,
we
do
this
staggered
connection
creation,
and
so
we,
this
is
basically
just
a
sleep
and
then
you
do
a
connect
like
a
TCP
connection
and
the
reason
why
it's
done
this
way
is
because
within
so
when
you,
when
you
do
this
within
a
user
space,
the
whole
idea
is.
We
want
to
make
the
test
the
start
as
soon
as
the
server
starts
right,
but
not
before
the
server
is
ready
for
connections
right.
A
So
because,
when
you
start
the
sub
process,
you
need
to
start
the
sub
process,
and
then
you
need
to
wait
and
tell
that
sub
sub
process
binds
to
a
socket
and
then
it's
ready
to
listen
on
that
socket
and
in
some
cases
like
with
the
my
sequel
test
and
stuff,
we
need
to
wait
until
it's
not
only
ready
not
only
bound
to
the
socket
but
bound
and
ready,
actually
ready
for
my
sequel
connections
right.
So
in
this
case
the
with
this
simulator
as
soon
as
it's
ready
for
a
TCP
connection.
It's
ready
for
you
know.
A
That's
what
you're
going
to
want
to
do
here,
but
but
it
might
just
be
as
simple
as
just
copying
this,
because
you
know-
and
the
other
thing
is
that
the
port
number
that
you
choose
this
is
this
is
the
only
reason
why
we're
choosing.
So
you
should
always
choose
port
0
if
you
want
a
port
to
be
randomly
assigned
to
a
service,
because
the
colonel
will
then
pick
a
unused
port
and
give
give
that
unused
port
to
the
service.
This
is
not
that
way,
because
the
simulator
is
not
written.
That
way.
A
You
can't
give
it
4-0.
It
thinks
it's
an
invalid
port,
so
we
just
have
to
try
to
choose
a
random
port
within
the
range
of
usually
randomly
assigned
ports
and
hope
that
it
is
free,
and
so
there's
some
code
here
that
you
can
see
of
where
it
tries
to
it,
tries
again
if
that,
if
it
didn't
work
well
inside
loop
right,
so
actually
maybe
it
doesn't
even
do
that.
Yeah
I
might
not
even
do
that,
but
if
they're
correct
way
to
do
this
is
to
have
Matz
try
to
find
a
port
0.
A
And
if
that
doesn't
work,
then
you
can
use
this
same
sort
of
hack,
where
we
just
give
it
a
port.
And
the
other
thing
is
that
Nats
is
probably
gonna
need.
I
I
would
assume
it
might
need
like
a
config
file
or
something
like
more
than
just
command-line
options,
I'm,
not
sure,
but
if
it
does
then
you're
just
gonna,
you
know
create
temp
files
and
stuff
and
and
tempters
and
spin
it
off.
B
A
B
A
A
Yeah
you
spin
up
the
server.
You
read
the
output
logs,
you
parse
the
port
number,
and
then
you
do
this.
Then
you
do
now
I
moved,
but
then
you
do
that
that
try
to
connect
until
the
connection
is
successful
because
it
might
be
outputting
that
before
it's
really
ready,
so
there's
a
bind
call
and
then
there's
a
listen
call
on
the
bind
calls
when
you
get
the
the
port
number.
A
B
A
A
My
sequel,
one's
kind
of
crazy:
how
do
my
sequel
ones
very
crazy,
now,
I
remember
what
the
hell's
going
on
here.
We
have
to
create,
as
a
cell
search
for
it
actually
you're
going
to
need
to
do
this
too,
because
you're
not
going
to
need
to
don't
worry
about
this
yet.
But
you
are
gonna
need
to
you're
going
to
need
to
do
this
because
we
have
to
whatever
we
do.
We
have
to
support
doing
it
over
the
security
over
a
secured
version
of
what
we're
doing
so.
A
A
A
D
A
A
B
A
B
B
B
B
B
B
A
B
A
A
B
E
A
So
that's
so
so
the
first
thing
that
happens
is
that
you
have
an
a
enter
with
the
with
the
double
context:
entry.
You
have
an
a
enter
on
this
object
and
then
you
have
a
call
and
then
you
have
an
a
enter
immediately
after
the
call.
You
have
an
a
enter
on
this
object
here
within
this
within
the
context.
So
if
you
need
to
do
anything,
then
you
would
do
put
it
in
the
a
interior
like
if
you
need
to
do
it
after
the
call.
You
would
put
it
in
the
a
enter
of
this
okay.
D
D
A
So
here
you
connect
to
the
Nats
notes:
server.
Ok,
so
then
they
also
yeah
yeah,
so
I
mean
the
first
thing
that
I
would
say.
Is
you
probably
want
to
make
this
connection
initially
right?
You
probably
want
to
make
this
not
in
the
context,
but
rather
in
the
in
the
main
object
right
and
then
you
want
to
create
a
new
context.
A
F
B
A
B
B
A
B
A
A
A
A
This
one
would
have
something
like
you
know:
the
it
sounds
like
you
need,
I
mean
you're
subscribing
to
there
there's
going
to
be
a
channel
for
the
data
flow
right.
So
this
one's
gonna
sit
here,
it's
gonna
do
a
enter,
and
then
okay,
I,
guess
also.
My
confusion
here
comes
from
like
how.
So
how
is
this
thing
getting
used
right?
Is
it
basically
just
sitting
there
in
a
for
loop
and
then
launching
new
ones?
Whenever
is
it
basically
like
for
new
data
flow
in
nat,
sublet.
A
A
G
B
B
A
So
so,
essentially
you
have
this
one.
That's
waiting
for,
for
it
makes
the
connection,
and
then
it
sits
here
and
it
waits
for
you
know
new
data
flows
right
to
come
in
right
and
when
it
gets
a
new
data
flow,
it
needs
to
create
a
a
context
which
is
going
to
run
that
data
flow
right
or
run
the
operations
within
that
data
flow
right.
So
then
it
so
it
creates
a
new
context
right.
So,
let's
see
in
it
connection
to
Nats
server.
A
So
you
need
this:
a
exit
stock
because
you're
going
to
be
entering
the
context
within.
Actually
you
need
that
here
so
all
contexts,
let's
see,
let's
see,
let's
see,
let's
see,
okay,
you
have
okay,
now
yeah
you
have
to.
You,
have
two
threads
to
sort
of
things
going
on
here:
you're
going
to
have
you're
gonna
have
this
thing
which
basically
waits
for
it.
This
is
gonna
be
similar
to
how
the
memory
the
the
main
loop
in
the
in
the
memory
Orchestrator
works.
A
A
B
B
A
B
D
A
A
A
A
F
H
A
A
F
A
F
F
A
Yes,
that
is
true:
yeah,
okay,
that's
just
what
I
that's
what
I
was
trying
to
get
at
here.
Is
it's
not
it's
if
we
so
are
yet,
but
our
pre-processing
like
yeah,
so
the
pre-processing
that
we
do
is
is
yeah
yeah.
So
if
the,
if
the
neural
network
itself
can
can
has
has
what
the
other
convolutions
I
can
do
it
the
same
thing
functionally
then
then
yeah,
that's
gonna
be
faster
than
running
a
pre-processing.
So
if
that's
the
case,
then
don't
spend
you
know,
don't
spend
cycles.
A
A
G
A
A
Nope,
that's
correct,
yeah,
okay,
great
okay,
sweet!
Now
we
should
be
good
on
that.
So
let's
say
that
it
already
failed.
Oh
yeah,
okay,
we
just
failed
again.
So,
let's
see,
maybe
we
got
all-merciful
requests
this
morning
and
hopefully
we
can.
We
can
not
be
failing
again,
okay,
so
okay
and
there's
your
pull
request
for
that.
Okay,
so,
okay,
so
that's
all
on
your
side!
Right!
A
A
A
A
A
A
H
A
A
A
A
So
if
we've
got
this,
if
we
do
path,
lift
up
path
file-
and
so
this
is
the
path-
the
path,
love
path,
object
to
this
file
right
and
this
file
is
this
test
file
within
this
directory,
and
we
say
well
resolve
resolve
is
going
to
make
it
so
that
no
matter
where
we
come
from
it's
going
to
be
top
level
right.
So
then
we
say
parents
and
we're
gonna
get
this
list
of
things
that
are
all
the
parents
to
this
file,
the
parent
directory
to
this
file.
A
A
So
it
might
be
more
helpful
to
do
it
like
this
too.
We
can
say,
I've
been
I've,
been
doing
this
where
I
say,
root,
equals
that
and
then
root
slash
example,
/
and
LP.
So
I
think.
The
reason
why
it's
also
misleading
is
that
in
the
test
is
I've
noticed
it
creates
a
directory
called
DF
FML
and
then
our
repo
is
cloned
within
it
as
DF
of
MLS.
H
A
So,
instead
of
getting
as
it
looks
like
you
have
this
create
data
flow
and
then
are
you
using
this
anywhere
if
you're
using
it
so
you're
using
it
within
the
rest
of
these
right
and
then
you're
using
it
within
the
diagram
command
but
yeah?
So
you
never,
like
you
know,
you're
not
like,
including
that
directory
or
that
directly
and
the
docs,
so
I
think
I
think
we
can
get
rid
of
that.
A
D
D
D
G
A
G
A
G
So,
oh
yeah,
so
here's
the
accuracy
context.
So
here
like
there's
just
this
abstract
method,
sport,
which
will
take
the
record
the
production
records
which
we
get
from
the
models
method-
and
this
is
the
prediction
features
which
will
be
a
list
of
features
on
which
we
did
the
prediction.
So
I
have
made
abstract
so
like
you
will
have
to
implement
it
like
yeah.
D
D
A
D
D
A
All
right,
okay,
I'm,
just
trying
to
think
okay.
So
we
have
accuracy
and
we
have.
Let's
see,
let
me
see
that
code
again.
Okay,
so
yeah.
We
have
accuracy
and
you
have
accuracy
context:
okay,
great
okay,
because
I
was
thinking
I.
Remember.
We
had
some
hesitation
on
whether
we
were
going
to
do
the
double
context.
Entry,
but
I
think
that
I
think
that
time
has
shown
that
it's,
it's
always
a
safe
option,
because
we
can
always.
We
can
always
do
like
what
we
did
with
simple
model
and
make
it
so
that
that's
not
required.
A
Okay.
So
yes
and
then
base
entry
point
you
have
formal
accuracy,
accuracy,
perfect,
yeah!
That's
this
is
all
correct
and
then
the
next
thing,
I
guess
the
next
guy
sort
of
the
next
thing
is
just
you
implement
the
first
one
right
and
then
we
start
figuring
out
how
how
we
want
act,
how
we
want
it.
We
probably
want
a
high
level
method
to
for
this.
Well,
we
have
the
high-level
accuracy
method,
so
we're
gonna
modify
the
high-level
accuracy
method.
Let
me
write
these
in
the
notes.
G
G
A
Yeah,
okay,
so
yeah
those
will
have
in
the
the
model,
the
whatever
predicted
will
be
in
it'll,
be
in
the
predictions.
Let's
say
so.
You
know
the
the
record
predict
it'll,
be
in
the
records
prediction,
data
right
so
and
so
yeah
so
it'll
be,
and
then
that
list
of
features
is
just
the
the
ones
that
we're
gonna
grab
out
of
there
right
and
since
these
are
records
that
should
be
should
have
test
data
there,
that
that
information
should
also
be
in
there.
A
D
A
Below
yeah,
okay,
here
we
go
so
yeah,
so
it
takes
a
model
and
then
it
takes
yeah.
You
know
records
or
sources.
So
the
next
it's
going
to
now
take
a
model
and
then
an
accuracy
plug-in
right,
and
so
the
the
modified
version
of
this
is
it's
it.
It's
it's
a
weight,
accuracy,
open
friends,
model,
comma
accuracy
plug
in
right
and
then
the
things
that
then
the
you
know
the
records
here.
Will
the
sources
or
whatever
right
and
then
so?
A
What
we're
going
to
do
is
we're
going
to
use
just
like
we're
here
with
here
right.
We
we
do
this.
We
do
a
sync
with
sources
of
sources
model
as
model,
and
then
you
know
you
know
accuracy
plug-in
as
accuracy
plugin
and
then
we
do.
You
know
a
sync
with
sources
as
SCT
ex
model
as
MC
TX,
comma
accuracy
plug-in
as
AC
T
X,
and
then
we'll
do
a
CT
x,
dot
score,
and
then
we
will
pass
so.
A
G
A
A
D
A
Yeah,
okay,
so
I'm
trying
to
think
about
this
from
the
perspective
of
like
what,
if
we
had
you
know,
I
always
try
to
bring
this
back
to
like
you
know
and
when
we
finally
create
whatever
the
would
the
web
UI
is
in
front
of
this
icon,
as
it
makes
sense
to
configure
all
these
things
and
wire
all
of
this
up
right,
because
that
sort
of
lead
stick
and
that
can
help
us
help
us
make
our
design
decisions
here
right.
A
So
in
that
case,
the
really
like
the
reason
why
having
everything
in
configs
is
nice
is
because
well
you
know
we
can.
We
know
the
data
types
and
we
can
export
the
data
types
and
we
know
what
the
what
the
you
know,
what
the
what
the
field
help
is
for
all
of
them
and
and
we
can
configure
them
at
the
time
we
instantiate
the
object
before
we
enter
the
context
and
now
so
now
we
have
this
situation
where
we
need
to
know
what
are
the
features
that
we're
doing
prediction
on?
A
So
perhaps
it's
best
that
the
model
implement
some
sort
of
abstract
base,
like
the
model,
implement
a
a
method
that
returns
which
features
it's
a
predicting
right,
because
that
would
then
tell
us
because
the
models
gonna
get
it
in
the
config
accuracy
score
so
because,
because
so
every
model
could
define
a
different
config
and,
and
the
name
of
what
you're
predicting
could
be
something
other
than
predict
right.
So
we
could
have
a
method
which,
basically,
you
know
says
if
the
config
dictionary
has
a
you
know
predict.
A
If
the
config
dictionary
has
a
predict
as
a
has
a
predict
property,
then
we
return
that
otherwise
we
raise
not
implemented
error
or
something
because
that
way,
if
someone
doesn't
have
a
predict
property
within
there
within
their
model
config,
then
they
need
to
tell
us
what
their
model.
You
know
what
you
know,
they
wrote,
they
wrote
the
config
object
and
they
named
it
something
other
than
predict,
so
they
need
to
now
predict
or
well.
I
guess
predict
is
already
a
method.
Obviously
they
need
whatever
this
thing
is
you
know
predicting
or
something
to
return.
A
A
A
A
A
Yeah
I
mean
okay,
so
the
core
problem
here
is
that
now
that
accuracy
is
no
longer
in
the
model,
okay,
well,
okay,
wait
a
minute
wait
a
minute!
We
could
just
take
this
thing
and
pass
it
to
the
accuracy
method
of
the
model,
and
then
then
the
model
just
uses
this
accuracy
scoring
plugin,
because
it
knows
what
features
it
has
and
it
knows
what
yeah.
Okay
here
we
go.
This
is
where
this
works.
This
works.
Okay,
so
we
modify
the
accuracy
method
of
the
model
so
that
it
takes
this
accuracy
scoring
context.
A
So
like
so
sources
we
take.
Basically
we
modify
that
at
the
signature
of
that
method,
so
that
it's
self
sources
accuracy
score
and
then
we're
in
the
model.
So
we
have
all
the
information
we
need
about
the
feature
names
and
what
we're
predicting
and
we
can
pass
they
sync
iterator
and
we
can
implement.
We
can
now
implement
accuracy
as
we
can.
A
Then
then
we
raise
not
implemented
error,
so
the
body
of
accuracy
is
now
going
to
be
so
the
body.
So
basically
we
yeah
we
remove
the
abstract
method,
declaration
from
models,
accuracy,
method
and
we
implemented
default.
One
which
says
which
says
you
know
run
predict,
write
and
use
feed
the
output
of
predict
to
this
accuracy
score
right.
So
basically
we're
just
going
to
call
call
and
pass
that
as
the
first
argument
to
this
to
the
score
method.
A
Right
because
predict
returns,
this
async,
iterator,
so
yeah
and
so
predict
returns
to
say
sync
iterator,
so
we
call
from
within
accuracy
we
call
the
accuracy
plugging
dot
score
we
passed.
The
first
argument
is
the
predict.
You
know
with
the
sources
that
we
were
passed
in
for
accuracy
and
then
the
second
argument
is
the
features
that
we're
predicting
right
and
since
we're
in
the
model,
we
know
that
you
know
by
default.
One
is
going
to
be
config
dot
predict.
If
there's
no,
you
know
we
can
do
a.
A
A
A
G
A
A
You
see
context
I'm
I'm,
reading
I
should
share
so
because
I
know
when
I
I
know
I,
write,
notes
and
I
talk
and
I,
probably
don't
I'm
pretty
not
to
do
this
job.
Is
that
so?
Okay?
So
alright,
so
we're
going
to
change
the
accuracy
minute
method
of
model
to
no
longer
be
an
abstract
method
we'll
make
it
so
that
it
takes
the
second
parameter,
the
accuracy
score,
which
is
of
type
accuracy
context.