►
From YouTube: Weekly Sync 2022-02-11
Description
Meeting Minutes: https://docs.google.com/document/d/1vKYEPtqKiwsFwhVKPmPub5ebMqN9HteBcbdFAuTXalM/edit#heading=h.pc3dd67v8mnt
A
All
right,
okay,
so
for
everybody
here
who
is
new,
we'll
go
around
and
we'll
do
some
some
introductions,
real,
quick,
forgive
me!
I'm
still
waking
up
here
and
then
what
we
usually
do
is
we
go
right
into
the
agenda,
so
everybody
says
you
know
whatever
they
might
want
to
talk
about.
You
know.
We've
got
some
things
that
we
we
know.
We
need
to
talk
about
other
than
just
people's
things
like
we
know.
A
We
need
to
talk
about
gsoc
ideas,
so
we're
gonna
have
to
talk
about
that
today,
yeah
all
right,
okay,
so
I'm
I'm
john!
I'm
I'm
one
of
the
maintainers
on
the
project
here,
so
we
just
got
a
new
logo.
There's
some
some
exciting
news.
I
work
on
ci,
cd
and
security,
and
I've
done
some
machine
learning
stuff.
A
Well,
the
fair
amount
of
machine
learning
stuff.
So
I'll
let
sahil
go
go
next.
A
A
A
All
right
man,
well,
I
said
we're
getting
some
ec
and
ee
people
in
here
it's
been
a
mainly
a
bunch
of
cscs
folks.
I
wonder
I
wonder
what
what
what
what
yeah,
what
props,
what
how
did
you
guys
find
us
as
easy.
A
A
A
All
right
great:
well,
let's
get
down
to
it,
then
so
oops
great
to
have
you
guys
here,
let's
see
so,
let's
see
so
sorry.
So
do
you
want
to
just
kick
off
today
with
anything
that
you've
got
going
on
and
we
should
actually,
we
should
mention.
We
emerged
logo,
and
that
was
thanks
to
you
reaching
out
to
jason.
Thank
you
for
that.
That's
very
cool.
A
A
Okay,
great
all
right,
so
I
do
have
a
note
on
the
on
the
so
on
the
data
flow.
No,
so
I've
been,
you
know,
scribbling
random
notes,
trying
to
figure
out.
How
do
we
effectively
explain
the
data
flow
stuff?
So
so
those
of
you
who
had
interest
in
that
you'll
notice,
the
documentation
is
a
little
bit
light.
So
it's
it's
it's
not
it's
not
ideal.
So
we
need
to.
A
A
It
will
be
necessary.
I
think
we
thought
this
before,
but
I
hadn't
really
figured
out.
You
know
what
it
should
be
exactly
so
yeah
so
essentially-
and
this
might
be
might
be
interesting,
so
the
goal
the
goal
would
be
right
is
would
be
to
to
define
to
be
able
to
define
everything
via
these
directed
graphs
right
and
when
I
say
everything
I
mean
like
this
is
this.
This
would
be.
A
I
think
this
would
be
great
everything
everything
so
and
and
so,
if
you're,
if
you
came
from
doing
some
ml
ops
or
something
like
that,
you
know
and
you're
thinking
about,
maybe
ci
cd
pipelines
right
you
could
you
can
define
your
whole.
You
would
define
your
your
feature,
your
oh
man,
oh
wow,
it
is,
it
must
be.
My
brain
must
be
slow
future
engineering.
A
You
would
define
your
feature
engineering
in
as
as
a
pipeline,
essentially
right,
and
so
you
you
would
define
all
your
your
data
set
generation
and
your
cleanup
as
this
directed
graph
right
and
the
reason
for
that
is
basically
what
we
would
go
through
in
these
in
these
tutorials
right
and
we'll
we
would
walk
through.
A
For
example,
you
know
most
most
data
is
generated
by
grabbing
it
from
different
sources
right
and
part
of
the
reason
why
you
might
want
to
do
like
part
of
the
reason
why
you
might
want
to
use
directed
graphs
to
generate
your
data
set
instead
of
instead
of
you
know,
just
just
have
a
flat
file
data
set
is
because
then,
when
you
get
a
new
input,
you
know
how
to
you
know.
A
You
know
how
to
make
a
prediction
on
it
right
and,
and
aside
from
that,
it
allows
you
to
create
new
data
sets
on
the
fly
right,
so
this
set
of
tutorials
is
going
to
go
through.
You
know
some
of
the
the
perils
that
that
one
finds
when
writing
code
that
say
accesses
the
network
or
something
right
and
just
just
to
to
recap.
You
know
some
of
those
things
are.
A
Basically,
you
know
if
you
were
to
access
write
a
bunch
of
code
to
access
the
network
say
scrape
a
lot
of
web
pages.
You
know
generate
your
data
set,
you
may
observe
a
immediate
bottleneck
due
to
you,
know,
non-parallelization
right,
then
you
would
go
through.
You
would
paralyze
your
download
code
right
now
this
now,
if
you've
used
the
multi-processing
module,
you
know
that's
not
fun
or
the
threading
module.
You
know
that
there's
going
to
be
some
some
weird
edge
cases
and
errors
right
and
those
are.
A
Yeah
yeah,
that
would
be,
that
would
be
even
worse,
yeah.
No!
No!
No!
Then
there
would
be
something
really
wrong,
so
yeah,
then
you
might
go
through.
You
would
download
your
parallelize.
The
download
code,
yeah
you'd,
see,
error
and-
and
that's
part
of
this
is
that
we
would
want
to
measure
measure
a
few
things
throughout
right,
and
this
is
this
will
feed
into
the
ideas
discussion
here.
So
so,
then
you
would
you
know
a
common
thing
that
happens.
Is
you
can't
do
something
in
python?
A
You
need
to
call
out
to
a
sub
process
right.
You
you
need
to.
You
need
to
execute
some
shell
command
right.
So
this
is
another
thing
that,
if
you're
doing
this
in
threads
or
maybe
you're
doing
this
with
like
multi-processing
dot
like
the
process
pool
executor
where
you're
not
in
the
same
thread
space.
A
You
know
you're
you're
not
going
to
have
the
signal
handler
for
the
the
sig
child
right
when,
when
you're,
when
you're,
when
your
child
thread
or
process
exits,
because
it
can
only
be
on
one
process,
so
this
is
immediately
going
to
knock
you
into.
You
know
a
world
of
hurt
there
right.
So
then
we
would
show
how
we
move
to
the
event
loop
right
and,
and
we
we
would
hopefully
measure
an
increase
in
speed.
A
You
get
rid
of
these
sub
process
issues,
so
you
know
once
you
have
that
you
would
then
say
well,
wouldn't
it
be
great
to
really
understand
what's
happening
in
this
massive
event:
loop
right,
because
you're
gonna
see
web
requests
flying
everywhere,
and
you
would
like
some
visibility
into
the
things
that
that
happened
there
and
and
then
we
start
getting
into
this
idea
of
the
data
flow
and
and
and
you
having
this
like
director
or
orchestrator-
probably
the
word
orchestrators
better,
and
that
would
help
us
get.
A
You
know
introducing
this
orchestrator
helps
us
get
this
actual
data
flow
based
execution
where
we're
we're
chaining
events
and
we're
seeing
visibility
into
that.
A
Then
we
basically
some
somewhere
along
the
line
here.
We
I
need
to
flush
this
out
still,
but
we
move
to
the
full
data
flow
based
implementation
and
and
the
full
data
flow
based
implementation
that
the
that
that
would
be
there's
many
classes
involved
in
the
in
the
data
flow
orchestrator
right
now,
as
it
exists,
so
there's
ones
for
managing
inputs,
there's
ones
for
managing
the
operations
like
the
individual
blocks.
If
you
were
to
look
at
it
like
lego,
blocks,
right
and.
A
Those
all
provide
you
with
the
ability
to
extend
them
right,
and
so
one
of
those
things
that
you
could
extend
would
you
could
say,
hey,
maybe
run
my
data
flow
in
kubernetes
or
run
it
on
a
remote
machine
via
ssh
right.
So
now,
you've
defined
your
data
flow.
As
you
know,
as
you
you've
defined
your
feature,
engineering
as
a
dataflow,
you
can
now
run
it
anywhere
right
so
that
that
would
be
nice,
so
that's
kind
of
like
the
goal
of
this
set
of
tutorials.
A
And
so,
if
you
are,
you
know
looking
at
the
documentation,
it's
not
quite
clear
what
what
the
point
of
having
the
data
flows
is.
You
know,
hopefully
that
clears
it
up
a
little
bit
so
and
this
might
as
well
so
and
aside
from
that,
you
know
it
makes
it
so
that
you
can
reconfigure
your
your
input
pipeline
easily
right.
So,
okay,
one
of
the
things
we
need
to
do
is
think
about
the
ideas
for
the
next
gsoc
season
here,
and
I
believe
this
is
what
we
did
yeah
the
year
before
last.
A
So
I
still
haven't
finished
updating
this.
We
need
to
update
it
because
we
haven't
done
a
release
yet
so
as
soon
as
I
do
a
release
which
I've
started
the
process
of
there's
a
bunch
of
compliance
stuff
that
I
have
to
do
internally,
then
we
will
I'll
publish
a
new
page
that
says
all
the
things
that
got
done
in
jsoc
and
are
now
in
the
released
version.
A
A
So
we
went
through
this
list
of
things,
so
we
we're
right
now
pre
beta
right,
and
you
guys,
you
know,
I
know
you've
used
software
right
so
once
that
something
hits
beta
right,
it's
sort
of
more
it's
more
official
in
a
lot
of
ways
right
and-
and
you
don't
want
things
to
change
as
much
once
you've
hit
beta
right,
because
you
want
to
provide
a
consistent
experience
to
your
users
right
pre
beta
is
when
you
can
sort
of
change
things
to
your
heart's
content
right
and
not
have
to
worry
about.
A
You
know
making
users
mad
right.
So
everything
is
very
much
in
an
experimentation
phase
right,
and
so
we
are
in
that
pre-beta
pre-beta
phase.
Now,
once
we
hit
beta,
we
want
to
be
very
polished
right,
so
we
want
to
have
all
of
the
the
core
functionality
of
the
library
worked
out
right.
We
want
to
know
how
exactly
people
are
going
to
interface
with
accuracy
scores
right.
A
We
want
to
know
how
video
support
works
right.
We
want
to
know
you
know
in
general
how
this
remote
execution
is
going
to
work.
Even
if
we
don't,
you
know,
support
all
of
the
places
we
might
remotely
execute
yet
right.
We
want
to
know
how
all
these
apis
are
going
to
work
from
an
end
user's
perspective,
so
that
so
that
you
know,
as
as
we
go
forward
from
beta,
we're
just
building
out
existing
capabilities
on
top
of
existing.
A
You
know
interfaces
that
aren't
going
to
change
and
that
way
you
know
you
don't
make
people
upset,
because
if
you,
then,
if
you
once,
you
declare
beta
you're
sort
of
saying,
hey,
I'm
stable
and
you
can
depend
on
me
to
not
change
right
and
if
then
people
might
say,
okay.
Well
now
I
want
to
start
using
this
right.
I
don't
want
to
use
it
if
I'm
constantly
going
to
have
to
change
all
my
code
right,
and
so
this
is
where
we're
headed
right.
A
A
Yeah
yeah,
no,
that's
a
great
idea.
So
when
you
say
you
know
a
design
pattern,
do
you
mean
you
know
something
similar
to
the
high-level
apis
that
we
have
like
the
things.
A
What
you're
saying
we
should
do.
A
Okay,
that's
a
good
idea,
yeah!
So
right
now
we
have
that
in
a
few
places,
but
we
should
probably
you
know
finalize
it
a
little
more
and
make
it
more
official.
So
let's
put
this
on
the
to-do
list
so
to
do
write.
A
A
Well,
I've
been
working
on
windows,
I
know
I
know
I
am
I'm
I'm
like
I'm.
A
A
A
Okay,
I
should
I'll
say
week
after
next.
If
you
have
your
test
next
week,
we'll
just
you
know,
put
it
out
there
all
right
so
so
yeah.
So
we
can
write
up
this
this
adr.
That
would
be
a
good
thing
to
do.
I
think,
as
far
as
that
goes
because
I'm
trying
to
think
about
you
know
right
now,
I'm
trying
to
think
about
what
what
what
tells
us
where
we
need
to
go
as
far
as
ideas
page
wise
right,
so
this
config
files
in
place
of
command
line
parameters.
A
That
is
a
big
one.
It's
a
big
one
and
it's
not
a
big
one.
At
the
same
time,
let's
see
the
http
api
needs
to
be
refactored.
That
could
be
a
really
good
jsoc
project,
jada
flows
with
unfortunate
implementation.
So
so
this
is
our
list
of
things
that
we
want
to
do
before
beta,
and
so
at
this
point
we're
kind
of
like
we're
really
closing
in
on
this.
We
have
a
lot
of
plugins
we've
flushed,
that
out
relatively
well.
How
how
did
the
plugins
work?
How
do
people
implement
plugins?
A
We
we
have
some
more
work
to
do
there,
but
but
doesn't
not
not
a
huge
concern
at
this
point:
writing
more
plugins.
So
one
of
the
things
that
is
a
a
big
thing
that
we
want
to
do
is
auto
ml
right.
So
we
have
a
lot
of
libraries
right,
a
lot
of
machine
learning,
libraries
and
we
have
the
ability
to
the
whole
idea
behind
the
framework.
Is
that
you
you?
You
know
you
can
make
a
new
model
right
and
we
have
these
model
interfaces
that
help
you
train
a
model
of
a
particular.
A
A
Automl,
so
we
want
to
implement
hyperparameter
tuning
okay,
more
than
two
things
implement
model
selection
based
on
accuracy,
score
assessment.
A
Okay,
yeah
well,
this
will
kind
of
all
be
based
on
accuracy,
score,
so
model
selection,
best
model
selection
and
then
implement
auto
feature.
Engineering.
A
That's
something
that
we
can
mutate
in
an
automated
way,
and
we
very
much
want
to
do
that
so
that
that's
an
an
interesting
thing
to
explore.
How
would
we,
you
know,
implement
automated
feature
engineering,
so
the
accuracy
scores?
I
don't
think
there's
a
project
to
do
here.
There
might
be
some
side
work
suit.
Hunter
really
really
took
that
one
a
long
way.
We
need
to
figure
out
videos.
I
don't
think
we
ever
figured
that
out.
I
think
somebody
did
some
pre-work
on
it
at
one
point:
hashem.
A
Yeah
yeah
so
wow,
my
computer
is
really
slow,
so
shane
did
some
pre-work
on
this
yeah
and
I
think
you
and
I
saw
somehow
had
looked
at
the
we
we
had
looked
at
that
one
kind
of
very
convoluted
example
remember
we
were
going
where
you
have
to
pre-process
the
images
using
several
different
models.
A
You
remember
that
it
was
like
the.
Where
was
it.
A
This
one
yeah,
so
we
had
looked
at
this
and
just
to
give
an
idea
of
the
complexity
of
faulty,
so
this
is
sort
of
one
of
those
where
we
would
be
combining
combining
several
things
right
and-
and
so
the
idea
here
would
be.
A
We
said,
okay,
well
what
you
know,
what,
if
we
wrap
this
model
right
and
then
we
we
looked
at
the
and
so
part
of
the
idea
behind
dfml
is
that
you
could
easily
wrap
research
papers
like
this
now
easily
is,
is
once
we're
done
fleshing
out
all
of
the
apis
and
making
sure
that
it
is
easy
right.
So
in
this
one
you
know
they
they
can
remove
the
remove
the
the
background
stuff
that
can
just
grab.
A
It
grab
an
object
out
of
the
scene
right
so
when
they,
when
they
explain
how
to
do
this
right,
it's
more
than
just
you
know,
feed
feed
your
data
into
this
directory
right,
it
turns
out,
you
have
to
resize
the
videos,
get
the
input
object,
mass
you
have
to
run
either
one
of
these
models
or,
and
then
you
have
to
run
this
model.
A
So
there's
several
steps
involved
here
right.
So
you
would
define
these
steps
as
data
flow
right
and
then
you
would
need,
but
but
that
would
require
you
that
you
could
run
this
model
right
and
then
you
would,
you
know,
you'd
put
this
model
as
a
step
in
your
data
flow
right,
so
you
know
a
little
a
little
bit
complex
there
and
we
need
to
figure
out.
You
know
how
videos
work
so
so
something
you
know
you
may,
for
example,
you
know
you
might
you
wouldn't
need
to
do?
A
Let's
see
this
is
like
you'd
probably
do
if
you
were
to
do
a
project
on
videos,
you
would
do
you
know
just
something
that
that
takes
the
videos
just
regularly
right,
like
maybe
I
think,
we've
talked
about
doing
the
yolo
one
like
a
million
times,
so
you
know,
maybe
you
do
yolo
right,
just
wrap.
You
know
you're
wrapping
an
existing
approach.
A
You
don't
have
to
implement
it
from
the
ground
up,
because
the
goal
is
to
figure
out
how
to
get
like
interoperability,
between
models
and
and
and
pre-processors
right,
and
the
goal
is
not
really
to
reinvent
the
wheel,
but
it's
the
opposite
of
that
right.
We
want
to
reuse
everywhere,
where
possible
right,
so
that
is
one
thing
to
consider
and
so
we're
going
to
write
these
up
as
formal
ideas,
but
I
just
want
to
put
it
out
there
since
we're
getting
close
to
the
time
when
we
do
that.
A
A
Yeah,
okay,
so
this
would
be-
and
this
would
go
into
you
know
our
design
patterns
so
change
to
the
model
api
to
allow
for
reporting-
and
this
is
another
thing
that
I
I've
seen-
is
that
something
that
I'm
I'm
seeing
as
I'm
going
through
and
documenting
the
data
flow
stuff
is
that
we
have
a
real
need
and-
and
we
talked
about
this
a
couple
years
ago
now,
but
we
have
a
real
need
for
fine-grained
metric
output,
so
kind
of,
like
you
know,
like
you're,
saying
here
right.
A
The
ability
to
report
out
intermediate
representations
the
ability
to
report
out
data
while
things
are
in
progress
within
a
data
flow.
All
of
that
we
need
to
figure
that
out
so.
A
A
A
I
love
it
so
this
is,
I
think,
it's
onyx
right
yeah.
I
love
that
idea
yeah,
because
you
already
implemented
the
data
flow.
Oh
look
at
that.
You
implemented
the
data
flow
on
save
load
right,
so
you
could
just
throw
in
an
operation
to
that
where
it
runs
through
onyx,
beautiful
beautiful.
I
love
it
all
right.
Okay,
so
does
that
sound?
That
sounds
right
to
you
all
right
great.
I
love
that.
That
is
just
that's
just
that's
good!
That's
nice!
A
A
A
A
Yeah
yeah
exactly
yeah,
so
so
right
now
right
now
I
am.
A
A
Yeah,
okay,
I
need
to
think
about
this.
I
was
hoping
to
I'm
always
hoping
I've
been
hoping
to
get
to
this
for
over
a
year
now
yeah.
I
need
to
prove
this
out.
We
should
probably
have
a
whole
session
on
this
and
we
can
plan
out
how
exactly
it
will
work
because
there's
a
lot
that
needs
to
happen
here.
There's
a
lot
and
there's
not
a
lot.
It's
it's
it's
yeah!
A
So
I
don't
know
we
will,
let's
just
schedule
a
session,
so
I'll
just
schedule
some
time
I'll
schedule,
some
time
and
I'll
run
through
it.
Maybe
I'll
make
a
video
or
something
and
I'll
just
talk
about
what
needs
to
be
done.
Does
that
sound
good,
all
right
cool,
something
something
to
keep
me
honest
on
on
needing
to
get
this
done.
A
This
this
this,
I
think
this
needs
to
be
in
beta.
Actually,
I
had
a
discussion
with
a
team
internally
the
other
day,
and
they
were
looking
for
exactly
what
we're
doing
here
they
were
like
you
know.
We
want
to
be
able
to
find
these
random
test
flows
via
json
files,
which
would
be
how
you
know
we
can
serialize
the
data
flows
to
json
and
they
wanted
to
run
things
in
parallel
right
and
they
wanted
a
web
ui
to
help
them
design
their
flows.
A
I
do
have
somebody
who
who
was
asking
me
about
gsoc
and
as
a
javascript
person,
so
I
might
be
able
to
get
her
in
here
to
do
that.
So
that's
a
project.
A
Yeah
yeah,
I
think,
they're
a
little
bit
busy
at
this
point,
but
they
could
be
good
mentors
on
this
one.
A
Yeah
so
bill
tree,
so
I
don't
know
if
this
will
be
a
this
year,
thing
yeah.
No,
I
I
think
we
probably
want
to
do
the
second.
I
went
back
and
forth
on
that,
but
we
likely
want
to
do
the
second
party
thing
first.
A
So
this
is
a
org
that
some
of
the
previous
gsoc
students
have
created.
Where
I
mean
they,
they
want
to
just
help.
People
write
software,
you
know
connect
students
and
other
people
to
to
try
to
you
know,
say:
hey
I've
got
this
idea,
but
I
need
somebody
who
writes
javascript
right,
for
example,
I
know
how
to
do
python.
I
can
do
this
part,
but
I
need
somebody
to
do
to
that.
A
Can
do
javascript
to
help
me
on
this
other
part
right,
and
so
then
they
they
help
connect
people
and
and
do
projects
and
and
help
out
here
and
there
that's
the
goal
so
cool
stuff.
We
need
to
figure
out.
Eventually
we
talked
about
moving
dfml
under
this
org,
because
this
is
you
know,
previous
gsoc
students.
So
you
know
part
of
the
problem
with
what
we
have
right
now
is
that
the
permissions
on
the
intel
stuff
is
not
flexible.
A
I'm
the
only
one
with
permissions,
which
is
not
ideal,
so
it
would
be
great
if
we
could
move
this
out
to
a
different
org,
where
you
know
everybody
can
have
permissions
on
it
right
or
everybody
who's.
A
maintainer
can
have
permissions
on
it
right
because,
right
now
you
know
we
can.
We
can
really
only
get
people
doing,
reviews
right.
They
don't
have
permissions
to
merge,
so
we're
looking
at
moving
it
over
there.
A
That
also
means
that
we
can
release
a
lot
faster
so
because
there's
a
lot
of
legal
and
security
compliance,
steps
that
that
need
to
happen,
and
if
we
were
not
under
intel,
we
would
not
have
to
do
them
so
yeah
all
right.
So
that
is,
you
know
tbd
on
governance.
They
need
to
figure
out
their
governance
documentation
before
they
do
that
and
that
governance
documentation
is
like
you
know,
hey.
If
I
wanted
to
become
a
contributor,
what
do
I
do
if
I
want
to
become
from
a
contributor
to
a
maintainer?
A
You
know
what
do
I
do
right.
You
know,
what's
my
path
to
progression
to
like
grow,
my
you
know
presence
in
this
org
right,
so
they
need
to
figure
out
their
governance.
A
So-
and
this
is
probably,
this
is
probably
not
going
to
happen
for
this
year's
gsoc
realistically,
because
that
all
will
happen
pretty
soon
and
I
don't
think
they
have
their
governance
stuff
set
up,
and
so
we'll
probably
you
know,
we'll
probably
be
a
python
software
foundation.
Suborg
and
they'll
be
a
you
know,
maybe
their
own
org
or
under
python
software
foundation.
And
then
we
can
look
at
you
know
next
year
moving
it
over
there.
Maybe
I
think
that
would
be
good
yeah.
A
A
Because
I
also
have
to
sell
it
to
legal,
so
I
have
to
be
like
hey.
This
is
great,
should
move
the
project
over
there
and
having
them
have
gone
through
gsoc?
Will
beef
that
up.
A
A
All
right
great,
so,
let's
jump
back
to
our
anything
else.
You
wanted
to
talk
about
any
other
ideas.
There.
A
Yeah
you're
not
getting
rid
of
me;
no,
you,
you
won't
be
able
to
get
rid
of
me.
Don't
worry
yeah,
no,
don't
worry,
you
won't
be
yeah.
You
won't
be
able
to
get
rid
of
me.
No,
that's!
That's
for
sure,
no
yeah,
no
yeah!
No!
I
I
want
to
make
sure
that
that
other
people
have
more
autonomy
over
the
project
right,
but
you
know
I
definitely
will
be
involved
right.
A
I
think
that
we're
doing
really
cool
stuff
here-
and
you
know
I
would
love-
would
would
like
nothing
more
than
to
continue
being
involved
in
this
right.
I
just
want
to
make
sure
that
the
project
can
go
faster
by
not
having
me
as
a
bottleneck,
so
okay,
so
this
is
great.
I'm
glad
we
covered
that.
I
think
that
is
the
onyx
stuff,
that
that
is
a
really
really
really
good
idea
and
you
laid
the
groundwork
for
that
nicely.
A
So
that
is
probably
a
piece
of
a
project,
because
at
this
point
I
mean
I'm
not
sure
what
that
takes
to
onyx
in
an
onyx
auto
model,
but
that
was
something
that
was
on
the
wish
list
for
a
long
time.
I
think
there's
a
really
old
issue
about
it,
so
that,
thanks
for
bringing
that
up
the
remote
execution
stuff,
I've
been
messing
around
with
that.
This
is
not
something
that
I'd
want
to
stick
somebody
on,
because
the
dataflow
tutorial
documentation
is
not
fleshed
out
enough,
yet
so
yeah.
A
I
don't
want
to
saddle
anybody
with
that
it
might,
it
might
be
maybe
I'll
try
to
flush
it
out
before
gsoc.
In
my
apple
free
time,
config
files
in
place
of
command
line
parameters
did
this
one.
This
one
is
important.
I
think
this
is
one.
That's
a
that's
a
good
gsoc
project.
A
Yeah
and
this
so
this
one
combined
with
the
one
below
it
could
be
a
good
project,
so
basically
the
way
that
everything
works
is
is
there's
all
these
classes
and
and
you'll
notice
that
there's
like
config
classes
everywhere.
So
let's
take
a
look
at
the
api,
so
let's
go
to
model
slr,
okay,
so
model
slr
config.
A
This
is
kind
of
not
the
best.
Is
it
well?
That's
a
bummer.
Okay.
We
need
to
improve
that.
That's
not
ideal
at
all!
That's
not
ideal!
At
all!.
A
Okay,
we
need
to
fix
this
all
right,
so
we
need
to
improve
all
right.
Okay,
all
right!
Well,
the
point
being
everything
is
this
class.
Everything
has
a
config
class
and
this
would
go
into
that
adr
that
we
need
to
write
about
the
what's
the
api,
so
you
know
anytime,
you
want,
and
this
is
also
what
allows
us
to
have
serializability
and
the
remote
network.
Stuff
is:
if
everything
is
a
serializable
class,
then
you
can.
A
A
These
config
classes
are
populated
from
a
variety
of
sources
right,
and
so
that
could
be
the
command
line.
If
we
fix
this
issue,
it
would
be
maybe
a
config
file,
and
it
also
might
be
like
the
http
api
if
you're
instantiating
this
via
the
http
api,
and
so
what
would
be
nice
is
that
we
have
all
these
tutorials
and
you'll
notice.
A
lot
of
them
are
cli
based
right,
so
what
would
be
nice
is
if
you
could
take,
for
example,
oops.
A
Okay,
I
guess
we're
here
now,
all
right,
click
click
click
all
right.
What
would
be
nice
is
if
you
could
take
any
command
line
invocation
and
turn
it
like
turn
the
command
line,
parameters
into
a
config
file
or
turn
them
into
the
arguments
for
an
http
call
right
sort
of
like
a
bi-directional
con
like
converter
right,
because
this
would
allow
you
to
quickly
experiment,
maybe
in
python
or
on
the
command
line
and
then
turn
it
into.
You
know
something
that
you
would
use.
A
You
know
in
a
more
production
setting
like
an
http
call
right,
so
that
would
be
really
interesting.
I
think
the
two
of
those
together
could
be
a
good
project,
probably
not
enough
for
either
of
them.
A
So
this
is
something
that's
being
flushed
out,
so
so,
but
the
other
thing
behind
the
data
flows
is
that
you
know,
if
you
define
everything
in
this,
you
know
high
level.
You
know
basically
call
graph
right,
then
you
don't
have
to
care
about
what
language
it's
implemented
in.
So
I
think
I
prototype
some
of
this
stuff.
I
need
to
write
up
more
docs
on
that,
so
that
people
could
actually
get
going.
A
A
Yeah
sudan
sinatra
did
that
so
that
will
move
to
the
done
section
when
we
do
the
next
release:
yeah,
okay,
so
and
aside
from
that
yeah
there's
there's
so
that
covers
a
lot
of
stuff,
so
videos
automl
the
config
file
stuff,
the
onyx
on
the
the
archiving.
A
I
think
the
main
one
of
the
main
things
that
still
needs
to
be
done
is
the
api.
Around
data
flows.
We
don't
have
it's
not
it's
not
pretty
it's
it's
it's
pretty
low
low
level
and
focuses
on
like
the
it's
just
like
a
light
wrapper
on
top
of
the
at
the
actual
serialized
format
and-
and
that
needs
to
be
flushed
out-
and
I
know
sahil
that
you
had
an
idea
around.
You
know
defining
it
more
like
a
a
pie,
torch
model
right.
A
A
I
think
I
think
yeah.
I
wouldn't
concern
with
that
right
now.
I
would
say,
because,
even
if
you
can
write
some
of
the
skeleton
of
how
it
should
look,
then
somebody
else
could
go
and
and
and
and
link
the
format
wise
right
and
just
do
that
translation
right,
because
all
you're
doing
is
there
there's
going
to
be
a
lot
of
different
ways
that
we
define
data
flows?
A
If
you
think
about
it
at
a
very
high
level
right
like
we're
going
to
define
them
via
the
web
ui,
you
know,
there's
going
to
be,
you
know,
there's
there's
many
ways
which
we
might
want
to
do.
We
might
want
to
do
like
some
operator
overload,
syntax
right
to
to
with
with
in
python
code
right.
I
think
that
there's
going
to
be
different
approaches
that
resonate
with
different
people
and
we'll
we
might
we
may
showcase.
You
know
this
one
right.
A
This
pie
torch
similar
one
right,
but
then
we're
always
going
to
give
people
multiple
options
right.
So
if
you
do
get
a
chance
to
to
look
at
the
scaffold
and
and
post
that
that
would
be
cool.
A
I
think
there's
something
to
be
done
with
like
a
active
learning
type
setup
where
you've
got.
You
know
somebody
in
the
loop
continuously.
A
You
know
you
know
maybe
giving
you
more
classifications
or
sort
of
directing
your
training
as
it's
happening.
So
so
all
of
this
is
based
on
like
a
stream
based
approach,
so
you'll
see
async
everywhere
in
the
code.
A
Now
it
doesn't
mean
everything
is
streams
right
now,
everything
is,
is
sort
of
blocks
of
memory
being
moved
around
and
not
a
lot
of
actual
stream
usage,
but
but
the
apis
are
all
set
up
so
that
you
could
have
so
so
that
you
could
stream
any
of
the
data
right
and
you
can
do
all
this
real
time
right.
So
that's
another
thing
that
sort
of
differentiates.
You
know
what
we're
trying
to
do
here
from
from
from
a
lot
of
other
things
right
so.
A
Yes
and
that's
hopefully,
what
will
be
addressed
in
that
tutorial?
I
was
talking
about.
A
Yeah,
I
think-
and
this
is
exactly
what
I'm
hoping
to
flush
out
in
this-
the
tutorial
that
I
outlined
here-
this
will
all
cover.
This
will
be
also
like
it's
a
tutorial
about
data
flows,
but
it's
also
a
tutorial
about
async,
because
the
data
flows
are
inherently
asynchronous
in
that
they're
they're,
a
giant
event
loop
sort
of
so
this
will
be
covered
here.
So
let
me
just
link
to
this.
A
Oh
and
then
there
was
the
project
around
open
source,
health,
okay,
so,
okay
and
then
so,
do
you
guys
have
any
ideas
that
you'd
thought
of
for
gsoc?
They
they
that
when
you
saw
you
know
that
you've
thought
about
as
as
interesting
project
idea,
it
could
really
be.
It
can
really
be
anything.
We
can
usually
find
a
way
to
relate
it.
So
if
you
have
any
ideas,
you
know
shoot
them
out.
A
A
Mm-Hmm
all
right
great,
so
I
think
this
would
build
a
lot
on
the
work
that
sudhashu
has
done
last
year.
I
know
he
did
some
data
set
cleanup
stuff,
so
this
this
is
definitely
something
and
this-
and
you
know
thinking
about
that-
auto
ml
stuff
around
feature
engineering
that
we
talked
about.
This
fits
right
into
that
and
that's
definitely
an
area
that
we
need
to
flush
out.
So
I
think
that
would
make
for
a
great
gsoc
proposal.
A
So
object
so
I
would
say
that
right
now
we
really
want
to
just
the
the
purpose
of
the
video
project
would
be
really
just
any
use
case
to
determine.
How
do
we
deal
with
frames
and
how
do
we?
Because,
because
the
setup
right
now
is
mostly
around
structured
data,
I
think
we
have
a
few
things
with
images.
The
purpose
of
a
project
to
round
videos
would
be
to
to
it
wouldn't
have
to
matter
what
the
use
case
is
now
it
does
have
to
matter.
A
In
some
senses
we
try
to
stay
away
from
things
like
anything
that
might
have
any
possible
ethical
implications
because
we
don't
want
to
get
in
a
review
with
the
legal
department
or
the
ethics
department.
So
you
know,
resolution
enhancement
great.
You
know.
Maybe
people
detection,
I'm
not
sure
right
anything
with
people.
We
try
to
stay
away
from
right.
You
never
know
you
never
know,
but
best
to
just
steer
clear
right.
We
got
enough
problems
on
this
project
enough
technical
problems
right
so
you
know
maybe
resolution
enhancement
so
or
some.
A
A
A
So
are
you
saying
that
that
we
could
have
some
potential
to
say
you
know
score
based
on
a
set
of
accuracy?
Is
that
what
you're
saying
I
like
that?
I,
like
that,
a
lot
any
okay.
I
like
that
a
lot.
So
could
we
provide
a
way
to
score
and
all
of
this
stuff
helps
us
build
to
that
automl
like
that
real
nice
automl
capability
right,
I
mean
at
the
end
of
the
day.
I
think
the
vision
for
this
is
you
take
any
data
set,
and
you
say:
okay
dfmo.
A
What
are
some
things
that
you
learned
about
this
data
set
right
and
you
it
would
just
go
and
train
on
every
possible
permutation
right
and
and
every
possible
model.
Config
and
it
says:
hey,
you
know,
here's
the
things
that
you
can
here's
the
things
I
learned
about
this
data
set.
Here's
you
know
some
interesting
predictions
that
you
can
make.
If
you
have
this
kind
of
data,
and
then
you
know,
if
you
extend
that
to
data
flows,
then
you
can
say:
okay
well
now
go
go
use
that
right
so
score.
A
A
Yep,
so
we
had
something
that
we'd
looked
at
for
a
while
around
the
okay
we're
about
to
get
kicked
off
this
call,
but
we
we
had
something
that
we
look
for.
Okay,
so
we'll
just
say:
we
need
to
look
at
this
and
I'm
we're
getting
the
countdown
here.
So
thanks
everyone
for
joining
today
and
we'll
hopefully
see
if
you
see
you
next
week
and
if
not
see
you
on
getter.
So
all
right,
thanks
guys
great
meeting
you.