►
From YouTube: Weekly Sync 2020-12-01
Description
Meeting Minutes: https://docs.google.com/document/d/16u9Tev3O0CcUDe2nfikHmrO3Xnd4ASJ45myFgQLpvzM/edit#heading=h.c2c7l32wyv70
A
Sweet
all
right,
so,
let's
jump
in
the
minutes
so
saksham.
What
did
you
want
to
talk
about
today?.
B
So
you
opened
this
issue
last
week
I
was
not
in
the
meeting.
I
was
getting
busy
9-0.
B
C
A
B
A
B
A
Yeah,
you
can
just
do
it.
Yeah
just
make
sure.
C
A
B
A
B
Can
have
like
the
sequential
layer
stuff
I
added
is
just
for
a
little
more
speed
process
like
we.
Don't
then,
if
there
are
sequential
layers
right.
So
if
there
are
three
sequential
layers
like
block
one
block
to
block
three,
we
don't.
We
won't
have
to
specify
the
forward
method
here.
Oh.
A
B
Yes,
well,
I
might
have
added
very
extra
small
features
here
that
need
explaining.
I.
A
Yeah
yep
yep
well
and
I
think
it'll
be
good
right.
So
somebody
was
interested
enough
to
to
to
want
to
want
to
know
what
was
going
on
right,
so
so
yeah.
Let's
just
make
sure
we
have
some
kind
of
example
for
that
and
then
yeah
so
and
then
the
view
right.
So
what's
what's
going
on
with
bu
right,
because
it's
not.
B
View
just
changes
the
like:
if
there
is
a
tensor,
it
just
interprets
the
tensor
like
we've
given
minus
one
and
one
to
nine
six
one,
two
nine
six
is
then
I
think
it's
the
number
of
it's
the
batches
into
the
into
the
out
channels
into
our
channels.
Yeah.
A
B
A
B
B
Like,
like
the
it's,
I
think
we've
you've
seen
that
in
the
numpy
examples
too
right
minus
one,
just
flattens,
it.
A
E
A
Yeah,
because
if
this
is
not
something
unless
because
the
main
thing
was,
it
doesn't
appear
up
here
right
and
yeah,
it
doesn't
appear
up
here
and
anything
that
appears
up
here.
They
can
go.
Look
on
up
on
the
pi
torch
website,
which
actually
may
need
to
be
made
clear
as
well.
A
Cool,
so,
let's
see
just
might
be
or
would
be
helpful
to
add
links
to
the
pytorch
documentation.
B
A
A
A
chance
to
take
a
look
at
that
one
yet
yeah,
let's
see
so
it
would
help
to
add
links
in
the
pi
torch
documentation
so
that
users
know
where
to
go
for
more
information
on
each
yeah
layer,
yeah
each
layer,
okay,.
A
A
A
B
Yes,
so
I
was,
I
told
you,
the
model
was
working
now
using
the
fml
all
right
so
like
how
was
I
asked
you
a
question
like
how
would
we
connect
the
content.
A
Okay,
so
we'll
take
a
look
at
that,
then
let's
do
let's
just
get
some
other
stuff
down
first
and
then
we'll
do
that.
A
A
A
C
C
A
Oh
and
then
the
other
thing
was
that
we
created
a
new
issue
to
say
that
the
layers
should
have
the
out
channel
set
to
the
previous
in
channels
or,
let's
see
yeah.
The
in
channel
should
be
set
to
the
previous
out
channels.
B
A
Yeah,
I
think
yeah
I
saw
that
so.
Actually
I
think
I
was
trying
to
get
back
to
them
too
yeah.
I
have
a
unfinished
comment
to
them
all
right.
So.
A
Glad
glad
you're
glad
you
think
so
so
all
right
all
right.
So
then,
let's
shaw
so.
E
Things
I'm
pretty
good.
Actually,
I
finished
training
the
model
and
it
works.
So
I'm
on
my
way
to
writing
the
test.
This
is
right
now.
E
The
first
thing
is
that
usually,
when
a
user
is
using
a
dfml,
they
have
to
have
three
sets
right.
One
is
a
training
set,
one
is
the
sort
of
the
validation
set
in
which
they'll
give
some
data
test,
the
accuracy
of
the
model
and
one.
E
That,
if
you
already
have
a
validation
set,
why
not
use
that,
instead
of
like
cutting
off
a
portion
of
the
training
set.
A
Yeah
yeah,
so
I
mean
I
think
this
is
this
is
something
that
obviously
we're
we're
trying
to
figure
out.
We've
gone
back
and
forth
on
the
on
this
stuff,
with
actually
in
training
and
what
what
to
do
here.
This
is
a
semi-related
issue,
but
I
think
that
and
and
saksham
you
can
have
some
more
input
on
this,
but
I
think
that
we
should
probably
yeah
so
there's
we
should
probably,
let's
see
so
if
you,
I
guess.
E
Can
you
show
us
what
you're
doing
exactly
yeah
yeah
absolutely
absolutely
like
this
issue
makes
sense
right,
because,
if
you,
if
we
took
in
data
in
one,
go
like
apart
from
the
test
that
we
took
in
training
and
training
and
validation,
sets
in
one
core
and
gave
a
sort
of
config
parameter
to
allow
the
user
to
split
the
data
as
they
desired.
I
think
it
would
be
helpful.
A
Be
I
mean
that
should
be
pretty
easy
to
do
so
right
now.
The
way
that
it
works
is,
let's
see,
yeah
the
way
that
it
works
right
now
is.
You
can
basically
specify
all
of
the
data
that
you
want,
so
any
sources
that
you
list
get
combined
together,
so
they
all
go
based
off
the
same
key
so
basically
like.
If
you
had
rows
in
a
csv
file,
unless
you
explicitly
keyed
them,
they
would
be
just
keyed
off
like
from
from
zero
to
n.
A
So
if
you
wanted
to
give
multiple
data
sources,
you
just
add
them.
You
just
you'd
string
them
together.
So
I
can
why
don't
we
do
an
example
here
so.
B
Actually,
I
still
don't
understand
what
he's
talking
about
exactly.
E
Good,
if
you
show
us
first
yeah
yeah
I'll
present,
my
screen
give
an
example.
E
E
E
E
E
E
D
E
So
what
I'd
like
to
do
is
to
have
validation
set
as
an
input
somewhere
here
in
the
train
method,
so
that
I
can
use
that
instead
of
cutting
off
a
portion
from
the
tendency,
it's.
A
E
This
is
mostly
a
problem
with
small
data
sets
like
data
sets
with
like
300
to
400
examples.
If
you
have
like
bigger
comparatively
with
like
10
000
plus
examples,
I
don't
think
it
should
be
a
problem.
E
A
E
A
A
A
E
Like
what
you
really
wanna
know
is,
why
am
I
splitting
the
training
set.
A
E
Yeah,
so
the
thing
is
how
the
model
works.
Is
it
use
it
sort
of
predicts
and
hyper
parameter
from
the
data
itself,
so
it
uses
a
part
of
the
data
to
sort
of
set
a
hyper
parameter,
epsilon,
which
it
then
uses
to
make
predictions
so
either
way.
I
need
some
some
part
of
the
data
to
sort
of
set
that
hyper
parameter,
which
is
what
I
need.
B
So
from
what
I
understand
is
you
want
like
you
are?
You
have
two
data
sets
here
like
one
is
the
training
data
set
and
one
is
the
validation
data
set,
and
you
want
both
of
them
to
go
to
the
train
method
right.
E
A
Yeah,
so
I
think
there's
gonna
be
a
slight
slight
difference
here
in
that
right.
So
we'll
do
we'll
take
a
stab
at
this.
Let
me
just
so
yeah
I
see
what
you're
I
see
what
you're
asking
for.
I
think
that
we
should
have
a
way
to
do
this.
I'm
not
sure
I
think
yeah,
we'll
we'll
we'll
make
sure
that
we
have
a
way
to
do
this,
and
I
think
that
this
becomes
so
so
this
becomes
one
of
those
things
where
you
know.
A
Part
of
the
goal
here
is
to
sort
of
one
of
the
overarching
goals
with
the
ffml
is
to
make
sure
that
things
are.
You
know,
usages
are
standardized
across
models
right,
so
this
is.
This
introduces
a
you
know,
a
different
case
where
you
have
to
add
your
test
data
to
your
training
data
right
and
so,
and
it
sounds
like
that's
I
mean,
is
I'm
not
yeah,
so
it
sounds
like
what
you're,
what
you're
saying.
E
E
A
Okay,
so
why
can't
you
train
the
model
twice
like
retrain
the
model
or
something
I
mean
I
guess
in
just
yeah.
So
basically
like
train,
like
you
know
like
you,
have
some
stave
save
state,
and
then
you
you,
so
you
have
your
saved
f1
state.
You
train
it
again
using
more
data
right.
You
have
an
existing
model.
You
train
the
model.
A
You
have
a
you
know
less.
You
have
just
just
the
training
data,
then
you
train
the
model
again
and
now.
You've
you've,
you've
added
the
test
data
to
the
trained
data
effectively
right.
Is
there
a
way
to
do
that
to
to?
Basically
just
you
know,
to
do
another
round
of
training
and
improve
the
f1,
or
do
you
have
to
do
the
whole
data
set
at
once
in
in
one
pass.
E
A
I'm
just
I'm
more
just
posing
that
as
an
idea,
for
you
know
the
fact
that
that
you're
saying
you
need
the
whole
data
set
to
do
this
right.
You
know
it
sounds
like
you're,
just
you're
really
saying
that
you're
getting
better
accuracy,
because
you
have
a
larger
data
set
right,
but
it
I
don't.
E
What
I'm
saying
is
normally
when
a
user
supplies
data
the
standard
format,
is
you
supply
some
training
data?
Then
you
have
data
which
tests
your
accuracy,
which
is
essentially
the
validation
set
data,
and
the
third
is
the
data
you
want
to
predict
on
right.
E
What
I'm
saying
is,
would
it
be
possible
to
have
the
validation
set
data
and
the
training
data
supplied
to
the
train
method
in
one
go.
A
Yeah,
I
guess
so.
Yes,
I'm
I'm,
and
I'm
saying
I'm
saying
yes
it's
so
I
just
want
to
make
sure
that
we're
we're
were
just
looking
at
this
from
the
right
angle
here
right,
so
so
you're
you're,
it's
giving
you
I
mean
the
effective.
The
effect
of
this
is
that
you
have
a
bigger
test.
Data
set
right.
That's
that's
the
end
effect
essentially
right.
A
So
can
you
could
you
introduce
yourself.
A
F
A
I
say
that
right:
yeah,
yes,
okay,
cool,
okay
and
I'm
john
and
we've
got
such
sham
and
and
shaw
on
the
on
the
phone
here
and
shaw
is
taking
us
through
anomaly
detection
model
right
now,
so
we'll
we'll
jump
back
into
your
we'll
we'll
circle
back
with
you
in
a
minute
here
and
we'll
ask
for
your
agenda
items
and
and
we'll
continue
on
with
our
meeting.
But
I
just
want
to
make
sure
we
we
we
introduce
you
to
everybody,
so
cool
yeah,
okay,
all
right
so
yeah.
A
So
all
right,
you
know
we'll
just
I
think
I
think
we've
we've
debated
this
for
for
we've
talked
about
this
for
long
enough,
so
we'll
just
jump
in
and
we'll
figure
out
how
to
I
muted
myself
in
the
middle
of
talking
all
right,
so
we'll
figure
out
how
to
give
you
both
both
data
sets.
So
here
I'll
start
sharing
and-
and
we
can-
we
can
just
get
going
on
this
so.
A
A
All
right,
let
me
know
if
it
looks
too
small,
so
let's
go
through
just
the
quick
start
and
see.
Let's
see
about
this.
A
All
right,
so
we've
got
our
test
data
set
and
our
training
data
set,
and
so
we
have
this
issue
here
from
a
long
time
ago,
where
we
talked
about
you
know
if
we
had
basically
one.
This
is
the
reverse
of
this
situation.
Basically,
is
this
issue
where
we
have
one
data
set
and
we
want
to
do.
We
want
to
use
part
of
that
data
set
during
a
train,
command
and
part
of
that
data
set
during
an
accuracy
command.
A
So
with
this
case,
we
want
to
use
both
and
as
part
of
the
as
a
part
of
the
train
command.
So
I
think
you
know
what
we're
just
going
to
do
here
is
we're
going
to
try
listing
things
well,
because
we
know
how
this
is
going
to
end
up,
but
so,
basically,
right
now,
all
of
the
all
of
the
sources
should
be
combined
into
one
data
set
right,
so
we
should
end
up
with
basically
an
override
here
where
one
of
these,
since
this
is
row
zero-
and
this
is
row
one.
A
A
Now
we
get
a
source,
one
file
name
so
test
source,
two
file
name
training,
and
you
know
we
only
end
up
with.
Oh,
we
only
end
up
with
the
first
straight,
because
we're
only
going
to
iterate
over
the
first
okay.
So
all.
A
A
A
B
Oh
so
I
thought
it
added
it
appended
that
to
the
other
yeah.
A
It
used
to
append
it
and
then
we
changed
it
at
some
point.
I
can't
remember
when
that
was,
but
we
changed
it
to.
A
So,
basically,
what
we
need
is
we
have
another
issue
that
talks
about
yeah.
This
one
established
way
to
pass
arguments
to
subclasses
of
list.
Slash
collections
used
list
so
because
what
our
current
yeah
this-
and
we
were
talking
about
this
back
in
march-
and
I
think
this
is
what
led
you
into
doing
the
unified
config
stuff.
So
I
think
this.
A
Our
last
mile
things
there.
So
basically,
we
had
this
large
effort
that
such
sean
went
through
and
changed
the
way
the
configuration
works
throughout
the
code
base
to
to
be
based
on
those
config
classes.
Right
because
we're
trying
to
get
closer
and
closer
to
a
quote:
unquote:
unified
config
approach,
which
is
basically
every
every
class.
An
object
throughout
dfml
gets
configured
the
same
way
so
that
we
can
accept
inputs
from
the
command
line
or
from
wherever
you
know,
and
json,
blob
or
python
in
the
same
way.
E
A
At
this
command
here
I
wonder
if
we
can
do
set
plus
x
minus
x.
I
wonder
if
this
all
right
great
so
when
we
run
this
command
here,
this
list
records
right,
we're
doing
sources
so
we're
we're
specifying
sources
right.
So
if
we
want
to
figure
out,
what's
going
on,
there,
we'd
go
in
dfml
source
source
right
and
we're
looking
at
this
sources
class.
A
So
this
is
the
thing
that
we're
instantiating
here
right
and
when
we're
instantiating
it
we're
passing
it
these
two
arguments,
and
then
these
are
the.
This
is
how
we're
passing
arguments
to
the
sub
sources
right.
So
this
this
sources
class
holds
two
instances
of
a
base
source,
so
this
is
singleton
equals
base
source.
A
So
singleton
like
this
is
the
the
single
thing
like.
If
you
look
at
one
of
the
elements,
what
is
it?
What
is
the
class,
the
type
of
the
class
that
it
is?
Well,
it's
a
base
source
which
is
also
in
this
file.
That's
yeah,
so-based,
search
context.
This
is
record
record
update
and
here's
base
source,
so
we're
instantiating,
two
of
them
right.
So
first
one
is
of
type
it's
a
csv
source
and
the
second
one
is
also
csv
source.
A
Then
we
say:
okay
source,
one
file,
name
so
for
the
source
that
we're
instantiating
source,
that's
with
the
tag
or
label
one
the
file
name,
for
it
is
test
and
source
with
the
label.
Two,
the
file
name
for
it
is
training.
A
So
then
we
end
up
merging
the
two
of
them
right
now
with
the
current
implementation,
and
that
happens
let's
see.
So
where
is
that
yeah
sources?
So
when
we
do
the
record,
so
a
source
has
three
methods.
Basically,
it
has
update
records
and
record
right
and-
and
so
everything
in
dffml
is
based
on
a
unique
key
so
that
we
can
combine
across
sources
and
stuff
like
that
easily.
A
So
so,
basically,
update
updates
one
record
records,
grabs
all
the
records
in
a
source
and
record
grabs
a
single
record
by
its
unique
key.
So
in
this
case,
what
we're
doing
is
we
did
the
records.
A
Basically,
when
we
list
all
the
records
we're
effectively
calling
this
records
method
on
the
sources
context,
and
so
basically
we're
everything's
context,
managed
and-
and
we
actually
have
two
context-
managers
for
every
object
and
that's
sort
of
the
paradigm
that
we're
using
and
that
you
can
read
if
you're
not
familiar
with
that,
you
can
read
about
that
under
the
contributing
documentation.
A
I
think
it's
under
like
one
two
punch
or
something
so
basically
we
create
the
sources
or
we
create
this
sources
object,
and
then,
from
that
we
create
sources
context
and
then,
within
that
we
we're
calling
this
records
method
and
I'll
pull
that
up
here.
So
you
can
see
that
too.
So.
A
A
A
Okay
list
records
all
right,
so
here
it
is
so
async
with
sources
as
sources,
so
async
with
sources
as
sources
context
and
then
so
async
for
record
in
records
right.
So
that's
now
we're
calling
this
method,
and
then
we
have
the
pretty
printing
stuff
here
so
and
yeah,
but
that's
not
really
important
right
now,
so
all
right.
So
what
we're
interested
in
here
is
the
fact
that
we
need
a
way
so
right
now
it
goes
through
for
for
each
source
in
itself.
A
So
basically-
and
it
breaks
on
the
first
one,
so
it's
going
through
the
first,
it's
going
through
each
source
and
it's
merging
them
with
all
the
other
sources
right.
So
this
is
basically
I
swear.
We
have
an
issue
for
this.
A
Oh
yeah,
here
we
go
yeah
so
this
this
is
the
issue
where
we're
silently
merging
things.
So
this
is
basically
that
the
issue
that
we're
looking
at
right
now,
so
we
changed
it.
When
did
we
change
it?
Yeah?
Well,
I
don't
know
but
yeah.
We
changed
this,
I
guess
in
january,
and
we
made
it
so
that
for
for
some
reason
we
we
realized,
you
know
well.
The
intended
behavior
here
was
that
we
needed
to
merge
with
every
other
record
right.
A
So
you
could
specify
multiple,
I
think,
is,
for
example,
with
the
image
source
or
something
you
know
we
had
the
you
may
have
the
image
data,
an
actual
image
file
through
the
directory
source,
and
then
you
may
have
you
know
some
some
metadata
about
the
image.
That's
not
just
the
raw
image
data
in
like
a
csv
file
or
something
I
think
that
might
have
been
the
original
use
case
but
anyway.
A
So,
basically,
what
we
need
to
do
is
we
need
to
be
able
to
say
that
we
don't
want
to
merge
the
sources
right.
So
we
want
to
basically
say
in
this
case:
we
want
to
say:
let's
see
yes,
so
we
go
through
we're
grabbing
the
first
source
and
then
we
grab
the
other
sources
and
we
merge
the
record
and
then
we
yield
it
right.
So
we
basically
want.
A
A
Okay,
so
yeah,
so
really
that's
that's
the
goal
here.
So
we
need
some
kind
of.
We
need
some
kind
of
parameter
that
we
can
pass.
We
need.
We
need.
A
A
Group
space
source
okay,
so
we
need
something
like
this
right,
where
we
can
now
configure
it
using
the
named
com,
and
so
the
name
parameters
that
we
were
using
here
right.
So
this
file
name
is
something
that
we'd
usually
get
from
a
config
object
like
this
right,
where
it
would
be
file
name
and
then
string
right.
A
So
we
need
something.
That's
like
you
know,
merge
so,
and
it
should
be
a
pool
and
it
should
default
to.
I
guess:
well,
okay,
this
is
the
other
thing.
Is
that
part
of
doing
these
command
line
flags?
Making
things
part
of
the
fact
that
we
have
this
unified
config
thing
is
that
when
we
end
up
with
command
line
flags,
you
know
you
kind
of
want
to
do
when
you
have
a
bullying,
you
usually
want
to
do
something
that
ends
up
being.
You
know
a
specify.
A
Basically,
so
if
we
had
merge
and
if
defaulted
to
false,
then
we'd
have
to
say
merge
or
if
it
defaulted
to
true,
then
we'd
have
to
say,
merge
off
or
something
right,
whereas
if,
since
the
merge
command
defaults
to
since
we'd
want
with
the
default,
is
that
it
should
merge,
then
if
we
specified
no
merge,
then
we
wouldn't
have
to.
We
wouldn't
have
to
give
it
anything.
It
would
just
say
you
know
no
merge,
and
this
is
part
of
thinking
about,
like
okay,
things
gonna
end
up
on
the
command
line.
A
So
you
know,
if
you
have
a
command
line
flag,
you're,
usually
that's
a
bullying.
You
usually
just
want
to
specify
it
where
you
don't
really
want
to
give
it
another.
There's
no
need
to
say
anything
after
it
right
so
we
might
say
no
merge.
A
Well,
I
think
it
was
like,
like
I
was
saying
you
know.
If
you
have
say
you
have
the
directory
source
with
images
and
then
you
have
the
or
you
have
some
data
in
a
csv
file
and
you
have
some
data
in
a
database
and
then
you
you
wanted
to
you
know
you.
You
wanted
to
combine
them
based
on
the
same
key.
I
guess
we
could
just
make
it
merge.
A
B
A
I
think
I
think
that
that's
usually
you
know
yeah,
I
don't
know
I
mean,
there's
an
argument
to
be
made
for
either
way,
but
we
have
it
right
now
as
the
default.
So
if
we're
going
to
change
it,
let's,
let's
let's
leave
it
as
is,
and
let's
change
it
later
right.
So
so
no
merge
equals
false.
A
So
so
because
we
can
only
yeah,
we
can
always
go
in
and
change
it
later,
so
no
config.
So
this
is
how
we
use
it
right
so
we'd
say:
okay,
self.parent!
So
within
a
context
you
need
to
reach
into
the
parent
and
you
grab
the
config
object.
You
check
for
no
merge.
A
No
merge
and
I
believe
we
want
not
no
merge,
so
no
merch
equals
false.
Now
this
creates
a
bit
of
an
awkward
syntax,
but
the
end
user
sees
the
right
thing
so,
okay,
so
if
not
self.comparent.fig.nomerge,
then
we
break.
So,
let's
just
see
how
this
ends
up.
I'm
not
sure
if
this
will
explode
on
us
yeah.
A
C
A
Sources
object
has
no
attribute
config
yeah,
so
this
may
explode
on
us
here.
He
thinks
async
context
made
your
list.
Let's
go
check
out
that
so
there's
think
helper
yeah.
I
want
to
see
if
we
can
just
do
this
right
here,
because
this
has
been
an
issue
for
obviously
a
year
now.
So,
let's
see
if
we
can
get
it,
let's
see.
A
Context
manager
list
user
list
and
then
what
is
the
instantiation
on
this?
So
init
args.
A
So
yeah,
I
think,
there's
there
might
be
too
much
heavy
lifting
to
do
in
this
meeting
right
now,
but
this
is
the
start
of
it.
So
basically
the
next
thing
is
that,
and
you
can
you
can
you
can
explore
doing
this
yourself,
but
it
may
get
a
little
tricky
this
may
be.
It
may
be
something
that
you
you
yeah
you
may
you
may
be
able
to
do
this.
You
may
not.
You
know
without
a
significant
amount
of
effort.
A
Yeah
might
as
well
right,
you
know,
so
I
think
yeah.
So
I
think
the
the
first
thing
is
that
okay,
so
let's
do
a
diff
here,
so
you
can
see
so.
Basically,
the
first
thing
is
that
we
needed
to
add
this
config
here
right.
So
sources
has
no
attribute
config
and,
let's
just
let's
just
make
sure
that
this
does
the
right
thing
just
so
that
this
we
know
that
this
will
do
the
right
thing,
because
we're
going
to
make
this
two
commits
so
self.parent.config
equals
sources
config.
A
So
when
the
object
is
instantiated,
we're
going
to
need
to
make
sure
that
it
has
this
config
right.
Okay,
so
if
oh
did
we
do
wait
a
minute,
no
merge,
okay,
yeah.
So
this
is
why
this
is
why
it's
important
to
test
this
okay,
so
sources,
config,
oh
and
then
no
merge
equals
true,
okay
yeah.
So
that
gives
us
the
behavior
that
we
want.
A
If
no
merge
is
true
right,
which
is
what
we
did
here,
then
now
we
have
the
behavior
we
want
so
so
this
is
the
correct
patch
then,
provided
we
can
pass
config
or
provided
so
this
would
be
the
correct
patch
for
to
implement
this.
If
we
had,
let's
see
or
was
it
this
issue
complete
right
so
because
this
is
so
what
is
this
add
configuration
parameters
to
sources
to
toggle
combination?
A
Okay,
now
this
is
this-
is
the
correct
patch
for
this
right,
so,
okay,
yeah
so
I'll
paste
this
in
here,
so
the
key
is
figuring
out.
A
How
do
we
fix
this
issue
right,
so
this
one
is
basically
solved
by
this
patch
right
and
then
you
know
updating
documentation
appropriately,
but
I'm
not
sure
if
there
is
much
documentation
for
this
so
might
be
creating
documentation.
So
let
me
just
make
a
note
here
so.
A
Try
the
quick
start
tutorial
using
test
and
training
data
sets
then
do.
A
The
no
merge
flag
added
to
not
merge
records,
okay,
so
yeah
and
then
we'll
paste
this
in
here
and
then
this
will
be
so
you'll
you'll
know.
Things
have
gone
well
when,
when
this
right,
when
this
starts
doing
what
what
it's
supposed
to
do,
when
we
hard
coded
in
the
instantiation
of
the
config
class
right.
A
A
On
okay,
so
yeah,
and
so
this
is
the
main
thing
right
and
so
if
we
get
into
and
now
I'm
just
gonna
do.
A
I'll
just
get
stash
all
right
so
now,
looking
at
this
code
in
here
right,
so
this
is-
or
let
me
pull
up
this
again
because
that's
probably
going
to
be
helpful,
but
so
dfml
source
source
right.
So
this
is
this:
is
the
sources
context
class
right
where
we
just
did
that
patch?
And
we
know
we
gave
this
sources
class
a
config,
and
so
usually
what
happens?
A
A
Base
config
base
configurable;
okay,
yes,
so
basically,
this
is
the
base
configurable
meta
class
and
base
configurable,
so
everything
in
dffml
all
classes
derive
from
base
configurable
or
they
should,
but
not
if
they're,
this
list
class
right,
because
that's
that
derives
from
the
user
list,
which
is
basically
you
know
a
user-defined
list
type
in
python.
So
it's
it's
kind
of
a
wrapper
that
they
added
to
the
collections
module.
A
So
it's
this
module
if
you
wanted
more
information
and
user
list,
and
so
this
is
something
that
it's
not
it's,
you
can
read
all
about
it
and
why
it
was
added
and
everything
here,
but
this
is
essentially
you
know
that's
what
we're
wrapping
here,
we're
subclassing
from
that
right
and
then,
because
everything
in
dfmail
follows
this.
A
One
two
context:
entry
pattern
where
we
do
async
with
and
then
async
with
again
right,
so
we
hit
two
a
inter
blocks
and
if
you're
not
familiar
with
context
management,
then
I
with
statement,
so
I
would
check
out
just
I
would
check
out
maybe
yeah
context.
Lib
might
be
a
good
place,
let's
see
with
statement,
or
this
is
really
not
a
great.
I
hate
it
when
they
explain
things
like
this.
Let's
see:
yeah,
okay,
yeah,
okay,
this
is
kind
of
yeah.
This
is
exactly
what
it
is.
A
So,
basically
there's
an
enter
and
an
exit
method
on
things
and
when
you
do
a
with
statement,
this
is
basically
it
it's.
Basically,
this
tri-accept
block,
where
you
would,
let's
see
yes,
you
do
enter.
You
enter
the
context
manager
by
calling
the
enter
method
and
then
on
the
finally,
you
exit
and
yeah.
You
can
do
some
things
where
you
don't
raise
exceptions
to,
but
that's
not
the
intent
of
any
of
these
context.
Managers
so
and
then
this
context,
lib,
is
another
great
place
to
learn
about.
A
But
the
reason
why
we
use
context
managers
everywhere
is
because
they
ensure
that
if
we
have
issu
or
any
exceptions
that
are
caught
within
the
width
or
any
exceptions
that
are
thrown
within
the
width
blocks
anywhere
get
cleaned
up
correctly.
A
So
anybody
is
there
any
questions
on
that
at
all.
For
anybody
who
hasn't
had
anybody
all
right.
Okay,.
E
A
E
So
I'll
try
and
see
if
I
can
solve
this
issue
in
the
meantime,
should
I
still
continue
with
the
test
cases.
A
A
E
The
model
code
that
you
sent
me
for,
I
think
hd
boost,
was
really
helpful.
I'll
find
the
tests
written
for
similar
models
in
the
github
repo
as
well
right.
A
A
So
all
right
all
right.
So
this
needs
to
be
completed
then
so
list.
A
Command
is
a
good
example
all
right
so,
and
let
me
just
one
second
here
so
you're
going
to
want
to
do
you're,
basically
going
to
want
to
make
it.
So
actually
you
might
want
to
do
the
meta
class
here.
That
might
be
helpful.
So,
let's
see.
A
Yeah,
your
the
thing
is
that
okay,
what
is
going
on
here,
all
right
so
you're,
going
to
run
into
some
of
the
the
ancient
config
handling
code-
that's
been
around
for
a
long
time
and
that's
all
this
args
and
config
and
git
args
and
all
of
this
stuff.
So
when
this
class
this
class
is
instantiated
now,
where
is
it
so
it's
in
dffml,
util
cli?
A
Yeah,
okay,
so
action.
So
basically
there's
this
system
where
this
the
config
stuff
works
like
this,
so
we
have
these
config
classes
and
then
and
those
are
basically
data
classes.
It's
it's
a
wrapper
on
top
of
data
classes,
which
is
a
python
module
in
the
standard
library,
and
so
you
we
take
data
classes
and
we
turn
them
into.
Basically,
these
dictionary
objects,
which
we
have
this
abstraction
called
arg,
because
it's
an
argument
and
the
argument
so
the
arg
classes
describe
to
us.
A
You
know
what
is
this
property
in
the
in
in
this
config
object,
so
we
go
through
and
we
do
mk-arg
for
each
field
in
the
data
class,
which
is
that
config
object
and
it
goes
through
and
you'll
see
so
default
factory.
I
think
we
talked
about
default
factory
last
week,
so
default
default
factory
and
it
it
provides
an
extra
layer
of
abstraction
up
on
top
of
that
on
top
of
the
data
class
fields-
and
oh
here
we
go
so
here
is
the
thing
where
it's
does.
Okay.
A
A
Then
we
go
in
and-
and
we
said
this
part
of
this
stuff
is
about
arg
person
and
making
sure
that
they
we
can
pass
all
this
stuff
to
arc
parts
to
parse
these
on
the
command
line
right,
so
we
go
look
at
and
we
see
if
it
has
the
singleton
right
and
we
create
the
action
for
it.
So
this
is
an
arg
parse
action
and
then
we
create
the
type.
Now
the
thing
is
with
the
arc
parse
action.
A
What
that's
doing
is
it's
taking,
so
the
arc
price
action
is
saying
when
use
when
when
you
see,
then
you
can
read
more
about
arc
parse
in
the
standard
library
too
right
so
we
say
nrx
equals
plus,
which
means
that
we're
going
to
have
a
list
here.
So
when
you
say
when
our
part
sees
sources,
it
should
expect
to
see
multiple
arguments
following
that
before
the
next
argument
or
before
the
next
flag,
which
is
something
with
that.
A
You
know
a
hyphen
in
front
of
it
right,
so
it's
going
to
see
one
equals
csv
and
two
equals
csv
and
it's
going
to
go.
Okay.
Those
are
those
are
for
this
sources
argument.
So
when
we
come
in
here
and
we
so
it's
gonna,
the
first
thing
it
does
it
is
it
executes
the
action
that's
assigned
to
it
and
we
told
it
that
this
is
the
action
for
it
as
a
list
action,
and
so
what
what
that
means
is
it's
going
to
call
this
class
here,
which
is
this
arc
action
class?
A
And
it's
going
to
come
in
and
it's
going
to
say
you
know
what
are
the
values
and
you
know
what
what
are
all
the
stuff
that
I'm
this
is.
This
is
your
chance
to
do
initial
modification
to
this
and
the
initial
modification
that
we
do
is
basically
we
just
say:
okay,
if
it's
one,
if
there's
only
was
one
of
these,
it
ends
up.
Actually,
just
passing
you
a
single
value
instead
of
a
list,
so
we
put
it
into
a
list
and
then
we
instantiate
this
class
right.
A
So
the
problem
that
you're
going
to
run
into
immediately
is
that
you
don't
have
access
to
any
of
the
other
variables
at
this
point
right.
You
only
have
access
to
and
you
you
may
have
access
to
them
in
this
name
space,
but
that's
not
really
a
given,
because
you
don't
know
what
order
these
things
run
in.
You
may
have
access
them
to
in
in
the
parser
or
in
the
name
space.
But
I
wouldn't
I
wouldn't
count
on
that.
A
A
At
the
same
time,
it's
not
going
to
be
able
to
create
the
config
object
that
contains.
You
know
the
no
merge
right
it's
going
to
initialize
it
to
its
default
value,
which
is
going
to
be
false
right.
So
you're
going
to
need
to
go
in
at
a
later
time
and
that
later
time
is
essentially
so,
let's
see
so
you
may
need
to
add-
let's
see
so
yeah
you're
going
to
need
to
go
in
at
a
later
time
and
specify
and
add
those
properties
back
to
that
class,
and
this
is
going
to
get.
A
I
mean
it's
gonna
get
a
little
tricky
here.
So
where
is
that
so
that
is
where's
the
parse
unknown
or,
let's
see
yeah?
You
may
want
to
do
so
shock
charm.
Help
me
remember
here.
So
basically
we
do
all
the
ad
arguments
I
think
happen
in
command
right.
So
util
cli
command.
A
It's
yeah
here
right,
so
we
go
through
and
we
add
arguments
to
the
our
and
this
is
standard
par
stuff.
So,
okay,
so
we're
doing
this
ad
argument
right
and
we're
using
those
arg.
Let's
see,
yeah
we're
actually
using
the
field
classes
right
here,
but
so
yeah.
This
is
where
this
is,
where
we're
doing
the
the
add,
arg
stuff
or
add,
argument
stuff
right.
So
this
is
where
sources
gets
added
to
the
argument.
A
A
You'll
want
to
add
each
property
of
its
config
as
well,
and,
let's
see
is
that
going
to
be
the
best
way
to
do
it?
Maybe
maybe
not
now
you
may
want
to
grab
these
from
parse
and
used,
let's
see
so
yeah
so
saksham
help
me
help
me
think
about
this
here.
So
I'm
thinking,
if
you
add
them,
I.
A
So
there's
basically
there's
two
situations
here,
so
if
we
add
them
to
yeah
okay,
so
I
think
we
don't
want
to
add
them
here.
So
if
we
add
them
here,
basically
they
end
up
in
and
where
is
that
add,
subs
parsergs,
okay
yeah?
So
if
we
add
them
in
that
in
that
spot,
they'll
end
up
in
here
in
this
args,
I
think
it's
yeah.
It's
like
an
object
or
it's
the
name.
It's
this
is
the
namespace.
A
This
is
the
same
thing
here,
which
is
why
we're
doing
set
after
so
yeah,
because
in
this
case
self.dest
is
the
string
sources,
so
you're
saying
basically
args.
This
is
equivalent
to
args
dot
sources,
equals
list
class
and
then
expand
the
values.
A
So
if
you
do
add
args
there,
then
you're
going
to
need
to
look
within
args
here
to
to
to
for
the
extra
arguments
that
are
related
to
sources,
whereas
if
you
do
this,
so
basically
this
parse
unknown
handles
everything.
That's
these
multi-levels
deep,
and
so
this
is
probably
a
better
place
to
look
for
the
arguments
because
we
need
to.
We
need
to
make
sure
that
this
stuff
can
happen
like,
even
if
this
sources
class
is
nested
down
below
other
classes,
for
example
with
the
data
flow
pre-processing
source.
A
If
you
were
to
nest
it
under
there,
you'd
need
to
make
sure
that
that
it
doesn't.
You
know
it
still
picks
up
these
keyword
arguments,
even
though
that's
not
a
top
level
on
the
command
line,
so
that
where
these
come
in
is
in
this
parse,
unknown
and
and
so
basically
all
of
that
ends
up
in
this
extra
config,
which
is
a
it's
a
let's
see,
where's
that
I
think
we
have.
The
config
format
documented.
A
A
Where
is
it
yes
here?
This
is
a
good
parse,
unknown,
okay,
so
yeah.
If
you're
looking
in,
where
is
this
test
utility
test,
cli
parse
unknown
you'll
see
this
giant
structure,
which
is
basically
you
know
if
you
have
something
like
this,
this
becomes
plug-in
here
and
then
under
it.
So
things
like
this
right,
this
gets
nested
under
config
and
then,
whenever
you
have
an
actual
argument,
it
gets
called
plug-in
yeah
and
that's
because
usually
we're
loading.
A
We
may
be
loading
a
plug-in
by
that
name,
which
would
be
something
that's
an
entry
point.
Otherwise
we
treat
it
as
an
argument
to
something
like
otherwise
we
treat
it
as
an
argument
to
you
know
like
the
config
structure
right.
So
that's.
What
we're
going
to
be
doing
is
basically
we'll
go
in.
We
we
have
parse
unknown,
will
will
grab
all
this
stuff
and
put
it
in
extra
config
in
that
format.
A
A
Let's
see
with
config,
so
the
top
level
ones
are
considered
to
be
instantiated,
but
they
should
have
hit
with
config
somewhere.
A
A
So
basically,
when
things
get
instantiated
and
where's
the
other,
with
configs
yeah
from
dick,
so
the
thing
when
things
get
instantiated
that
our
base
configurables
they
hit
this
with
config
method
and
that
basically
ends
up
passing
them
that
extra.
What
is
it
extra
config
that
we
just
saw
coming
from
parse
unknowns?
That
is
in
this
format
right?
So,
but
that's
that's
that's
if
they
haven't
been
instantiated
already
now.
The
issue
that
you're
gonna
hit
is
that
basically,
this
guy
is
instantiated.
It's
an
instantiated
object
right.
A
So
what
you
need
to
do
is
you
need
to
come
in
and
say
you
need
to
come
in
and
say
actually
yeah.
You
need
to
come
in
and
say:
okay,
it's
been
instantiated,
but
it's
a
collections
user
list.
Therefore
I
need
to
go
populate
its
config
properties
from
the
extra
config,
which
is
basically
it's
it's
coming
through.
Let's
see
well
in
places
where
you
see
things
being
instantiated
with
with
config
see
this
says
if
it's
a
class,
you
need
another
block.
A
That
says
if
it's
an
instance
of
collections
user
list
and
then
you
need
to
go
through
and
you
need
to
say:
okay
well
now,
let
me
cycle
through
all
of
the
properties
of
that
and
instantiate
them,
and
that's
that's
basically
how
you're
gonna
end
up
fixing
this
problem.
Now
there
was
a
lot
of
background
and
a
lot
of
information
there,
which
is,
which
is
why
this
is
recorded.
A
But
if
you're
up
for
it,
then
you
you,
hopefully
have
some
background
on
how
you
would
fix
it
now.
So
all
right,
any
any
questions
on
that.
I
know
there
was
a
lot
of
information
there.
E
A
That's
okay,
I
mean
yeah.
I
would
I
would
assume
there
will
be
re-watchings
of
this.
If
you
try
to
do
that
because
obviously
we
haven't
done
it
since
january
so
and
there
was
a
reason
we
haven't
done
it,
it's
not
easy.
So
if
you
feel
like
doing
it,
you
you,
hopefully
that
gives
you
a
path
there.
But
yes,
it's
definitely.
If
you
don't
feel
like
doing
it.
No
one
will.
No
one
will
blame
you.
We
we
maybe
need
to
do
some
more.
A
There
may
need
to
be
some
more
work
done
on
config
stuff,
because
some
of
it
right
now
is
not.
We
have
a
large
amount
of
code
that
deals
with
configuration
and
it
may
need
to
get
sort
of
refactored
into
saksham.
Got
it
all
to
the
point
where
we
can
now
use
everything
the
same
now.
We
need
to
go
through
and
probably
look
at
where
certain
code
paths
are
different
because
we
have
some
some
code,
that
seems
is
is
a
bit.
A
It
seems
like
we
have
some
duplicated
functionality
in
different
places
without
the
code
base
that
might
in
make
this
a
easier
to
solve
issue.
If
we
put
it
off
until
later,
but
that's
sort
of
been
why
it
keeps
getting
put
off
too
so
it
may
just
be
good
to
just
go.
Do
it
but
either
way
now
you
know
so
all
right.
Well,
that
was
a
very
long
explanation
there.
So
so
is
there
a
way
to
okay,
yeah.
B
A
There's
yeah
there's
just
so
much
the
the
thing
is
that
so
much
of
yes,
this
project
is
about.
You
know
abstracting
machine
learning,
but
you
know
how
do
you
end
up?
Abstracting
things
is
by
making
sure
that
you
configure
them
all
in
similar.
You
know
in
in
standard
ways,
and
so
there's
a
lot
of
the
code
base
in
the
main
library
has
to
do
with
config.
C
A
Let's
see
yeah,
it's
definitely
the
most
challenging
part
of
the
code
race,
let's
see
so
okay,
so
we
covered
this
in
the
meeting.
There's
a
lot
of
info
c
recording
for
more
details.
A
Okay,
all
right
anything
else,
you
wanted
to
touch
on
today,
shaw.
E
No,
it's
not
really
urgent,
but
I
was
having
some
trouble
taking
in
that
float
argument
from
the
config
part,
but
I
don't
think
I
needed
to
do
it
right
now.
We
can
maybe
do
it
later.
Okay,.
A
Yeah,
if
and
if
you
can
post,
if
you
can
send
us
like
a
link
to
your
fork
or
something
that
really
helps
like
and
if
some
people
post
screenshots
it's
a
frequent
thing,
but
it's
it's
definitely
easier
from
a
review
perspective
to
go
in
and
see
the
whole
the
whole
cult
base.
So
if
you
have
like
a
link
to
a
branch
or
something
that's
always
really
helpful,
then
we
can
just
maybe
you
know
point
in
the
right.
E
Direction
I'll
send
I'll
send
a
link
to
my
to
the
github,
repo
or
I'll,
try
and
make
a
pull
request
once
the
test
cases
are
complete.
Okay,
cool
that
sounds
good.
A
All
right
great,
so,
let's
see
it
was
sorry
remind
me
of
your
name
again.
A
All
right
so
natash
you've
been,
let's
see,
let
me
just
get
so
you've
been
doing.
Oh,
you
were
trying
to
train
the
pie
torch
model.
So
I
think
that.
C
A
I
think
that
what
might
be
going
on
here
is
that
you
are
looking
at
maybe
the
current
release
of
things,
and
you
probably
want
to
look
at
the
docs
for
the
master
branch
so,
and
that
would
be
so
anything
with
with
slash
master
in
it
and
we
just
updated
the
contributing
docs
actually
to
say
this.
So
there's
two
different
versions
of
this
documentation.
A
A
Basically
this
version
of
the
docs
and
you're
going
to
want
to
be
doing
you're
going
to
be
wanting
to
uninstall
anything
you
have
installed,
because
that
would
have
installed
the
that
would
have
installed,
like
the
the
latest
release
of
things
and,
if
you're,
installing,
let's
see
what
is
this
yeah,
this
you're
not
going
to
have
this
in
the
latest
release.
This
is
only
pi.
Torchnet
stuff
is
only
in
the
development
version
of
things
which
is
probably
what's
going
on
there,
because
I
see
that
this
got
installed,
not
in
development
mode.
A
So
if
it's
installed
to
the
site
packages
director
directory,
it
wasn't
installed
in
development
mode,
which
is
probably
what's
going
on.
So
you
probably
got
the
latest
release
of
some
packages
and
you
want
to
be
working
on
the
stuff
from
the
get
repo
does
that
sound?
Like
maybe.
F
Yeah
and
one
more
thing
yeah,
as
has
as
I
wanted,
to
install
the
diffml
and
all
this
thing.
So
is
there
any
way
to
write
code
so
that
we
can
update
the
python,
because
I
think
that's
the
one
of
the
common
mistake,
common
problem
and
error
of
the
throws
that
the
the
version
of
python
is
not
from
above
3.7
like
that.
So
we
can
write
a
code
for
that
that
it
automatically
updates
the
python
as
well.
A
F
A
Is
something
that
I
don't
think
we
can
do
or
well
so
it's
something
so
nothing's
impossible.
The
question
is
more
whether
we
should
do
it,
and
that
is
usually
I
mean
I
would
say
that
is
not
that's
not
really
our
place
as
a
package
to
do
that.
A
But
I
know
that
this
is
a
frequent
cause
of
of
headache,
but
unfortunately,
some
of
the
features
that
we
rely
on
for
async
stuff
are
are
3.7
and
above
now
there.
C
A
Some
backfills
I've
seen
more
and
more
backfills
for
certain
things,
so
I
think
one
of
the
main
things
that
we
use
is
async
context
manager,
I'm
actually
that's
another
context.
Libs
or
aids
async
context
manager
in
async
exit
stack,
and
this
is
added
in
3.7.
I
think
that
was
the
main
thing
that
that
that
that
pushed
us
over.
A
So
we
could
look
and
see,
because
I
know
I've
seen
a
lot
of
things
recently
that
are
backfills
or
so
what
is
it
called
back
back
ports
so
back
ports
and
that
could
allow
us
to
run
on.
A
This
could
allow
us
to
oh,
maybe
not
okay,
open
issue,
probably
not
so
if
we
had,
if
there
were
some
packages
out
there,
that
that
that
provided
back
ports,
we
could
require
those
as
dependencies
on
things
like
python
3.6,
and
then
we
could
support
that,
and
that
would
probably
be
the
the
better
path
forward.
A
So
but
it
looks
like
these
people
haven't
done
that,
and
I
would
bet
that
this
is
probably
the
place
that
would
have
done
that
if,
if,
if
it
was
around
so
yeah
so
so
I
don't
know,
if
I
don't
know
if
this
is
something
that
that
it
would
be
possible
to
support
3.6
but
yeah
you're
going
to
have
a
it'll,
be
it
would
be
better
to
figure
out
what
are
the
back
port
packages
that
are
required
to
support
3.6
than
to
try
to
install
new
versions
of
python
for
people,
because
there's
just
many
you
get
into
you
know
a
whole
different
problem
space
there
yeah
yeah
that
people
are
gonna
need
to.
A
You
know,
make
sure
that
they
have
configured
things
specifically
to
their
systems
but
yeah.
So
yeah,
I
would
say
you
know,
get
started.
You
know,
try
to
try
to
get
things
installed
from
from
the
git
repo
and
that's
gonna
mean
probably
uninstalling
the
existing
packages
that
you
had
and
you
may
want
to
install
to
a
virtual
environment.
You
may
just
be
able
to
go
through,
and
I
think
the
thing
is
that
you're
going
to
run
into
is
is
uninstalling
all
the
pr
packages
properly,
because
you've
already
done.
A
My
guess
is,
and
you're
going
to
need
to
this
example
just
shows
uninstalled
dffml,
but
we
need
to
probably
I
think
this
came
up
recently,
but
we
need
to
probably
have
a
command
that
uninstalls
all
of
the
dffml
packages,
because
pip
doesn't
let
you
do
like
a
star.
It
doesn't
let
you
do
like
dfml
star,
which
means
that
you're
going
to
have
some
that
are
still
lying
around
and
the
way
that
python
works
is.
A
It
will
use
an
installed
package
over
a
package
in
development
version,
every
time
which
is
very
annoying
for
us
who
are
working
on
things,
but
I
guess
not
I'm
not
sure
who
that's
not
annoying
for,
but
that's
how
it
works.
So
you're
going
to
need
to
uninstall
things
if
you've
installed
them
not
in
development
mode.
F
A
A
All
right
cool,
so
any
did
you
have
anything
else
you
wanted
to
talk
about,
or
else
we're
gonna
jump
into
saksham's
context
capacity
stuff.
So.
F
Yeah,
I
think
I
think
it's
it's
enough
for
me
right
now:
okay-
and
it's
been
just
four
or
five
days
for
me-
to
read
the
code
base
of
pfms.
So
I
think
it's
it's
enough
for
me
for
today,
right,
cool
cool.
A
A
Well,
yeah.
D
A
Then
yeah!
Well
thanks
and
just
let
us
know
I
mean
so
yeah
we're
all
on
getter,
and
then
we
have
this
meeting
every
week
so
where
we
can
all
just
kind
of
sync
up
and
talk
in
virtual
show
person
so
yeah,
so,
okay,
so
now
we
want
to
get
into
this
need
to
specify
context
capacity
from
the
command
line,
and
so
we're
just
talking
about
a
million
config
things.
So
now
now
we
know
the
back
the
backbone
of
all
that
that
was
good
primer.
A
For
for
this,
so
we
do
have
a
branch
suksham
that
we
can
pull.
Oh.
F
B
We
have
linked
it
in
the
meeting
chat.
A
A
Awesome,
okay,
so
this
is
another
thing
for
anybody
who
hasn't
seen
this
git
log
dash.
P's
is
my
favorite
thing,
because
it
helps
us
figure
out
what
what
changed
in
the
code.
So,
okay
operations.
A
Okay-
and
this
is
in
yeah
the
orchestrated
context-
config,
okay,
so
yeah
this
is
this
is
tricky
because
now
we're
we're
in
the
config.
So
I'm
thinking
you
know,
my
first
thought
here
is
like
does
that
need
to
be
in
the
config
or
in
the
context
config
right?
So
because
I
think
the
thing
is.
A
So
I
think
this
gets
tricky
because
we
haven't
dealt
with
with
the
context.
Oh,
you
know,
I
think
we
might
have
an
easy
solution
for
this.
Actually
so
yeah.
Oh,
this
is
okay.
Okay,
so
I
feel
like
there's
an
easy
solution
to
this,
which
is
basically
for
a
case
like
this,
where
we
instantiate
a
context
when
we
instantiate
a
context
where
is
it
yeah,
so
we
instantiate
the
context
here
right
and
so
we
end
up
with
you
know.
A
B
Yeah
it's
I
just
added
that
1000.
A
A
A
B
A
Okay,
oh
yeah,
I
probably
did
yeah
okay
yeah.
It
should
be
none
that
sounds
right
so
yeah,
because
now,
basically
what
we
could
do
is.
Is
you
know
if
you
wanted,
so
if
one
instantiated
a
data
flow
here
right
so
in
this
instance,
this
data
flow
right.
A
If
you
gave
it
a
data
flow,
so
the
only
reason
the
only
time
you're
going
to
give
it
a
context,
is
your
if
you're
extension
this
from
the
python
api
right,
in
which
case
you
would
have
made
your
own
context,
object
and
you
wouldn't
be
grabbing
things
from
the
command
line
right.
So
if
you
are
doing
this
here,
then
we
could
basically
just
say
so:
kwrx.set
default
default
max
ctxs.
A
At
least.
I
think
all
the
command
line
paths
take
this
to
take
this
path
here,
where
they
say
is
instance,
data
flow
right,
so
you
should
be
able
to
just
give
max
ctxs
to
memory
orchestrator
on
the
command
line
and
it
will
it'll
propagate
through,
because
it'll
say
you
know,
it'll
just
override.
Does
this
make
sense.
B
A
B
A
Oh
yeah
I'd
need
the
images
okay,
but
we
can
just
basically
check.
Let's
see,
I
don't
know
yeah.
What's
the
question
is.
C
C
F
F
B
These
are
labeled
label
directories
right,
okay,
okay,
you
can
just
I
I
think
you
can
take
that
and
just
give
the
label
directory
signal
label
directly.
Like
oh.
A
Wait
but
I
don't
need
I
don't
we
don't
need
this
to
test
it.
We
can
just
run.
We
can
just
run
any
command,
I
mean.
Let's
see
we
should
be
able
to
run.
We
should
be
able
to
run
just
the
command
line.
Dataflow
example
here
yeah.
We
should
be
able
to
run
this
and
see
if
it
see
if
it
propagated
through.
So
because
this
isn't,
I
mean
it's
not
dependent
on
what
what
you're
sort
of
a
separate
issue
right.
A
This
is
a
really
long
one,
so
it's
let
me
just
make
sure
that
we're
actually
going
to
pick
this
up
here.
So
dfml
data
flow
run
context.
A
Orchestrator,
okay,
so
it
does
get
the
orchestrator
so
orchestrator
max
ctxs,
oh
no!
It's
not!
Let's
just
put
42
and
then
let's,
let's
see
when
we
know
which
log
when
we
instantiate
the
orchestrated
context.
A
A
So,
let's
see
orchestrator
config
are
we
logging
on
creation
of
the
orchestra
context,
config
error,
orchestrated
context,
extruder
context,
extruder
context,
initializing
data
flow.
Oh,
I
think
we
have
overridden
the
print
on
that
one.
That's
probably
what's
going
on.
So
let's
just
come
in
here
and
do
dfml
df
memory.
A
Yes,
so,
and
that
should
because
basically
you
know
so
what
we
did
here
was
say:
okay,
if
you
get
a
data
flow
right.
So
if
you,
if
this
thing
has
been
passed,
a
memory
orchestrated
context
when
we
initialize,
so
when
we
do
that
that
one
two
pattern
of
async
with
orchestra,
you
know
memory
orchestrator
as
orchestrator.
B
A
Yeah,
well,
I
I
know
you're
talking
about
the
training,
but
look
at
your
your
train
command
right,
so
your
train
command
is
your
train
command
is?
Is
the
data
flow
pre-processing
source
right?
So
it's
taking
the
data
flow
here
right.
So,
if
you
looked
at,
you
know,
if
we
look
at
the
plug-in
docs
for
the
data
flow
pre-processing
source.
B
A
I
made
this
change
at
some
point
because
it
was
a
performance
thing
yeah
when
was
that
but
yeah.
So
basically.
A
Inputs
yeah,
I
don't
know,
I
mean
it's
not
entirely
important
when
it
happened,
but
yeah.
Basically,
we
at
some
point.
We
we
allowed
for
the
orchestrator
to
be
specified.
Okay
here
it
was
yeah,
create
quirk
by
creating
orchestrated
context
within
the
source
context
we'll
get
about
a
6x
speed
up
so
yeah,
so
it
basically
just
does
you
know
it?
We
added
this
property
to
the
class
right,
and
so
basically,
all
you're
gonna
have
to
do
is
say.
A
And
then
max,
and
then
this
is
where
the
weirdness
comes
in
underscore
ctx,
then
that
should
do
it
so
and
then
I
think
we
were
going
to
do
one
more
invocation
of
this
command,
just
to
make
sure
that
the
that
the
what
happened
with
the
where's,
the
yeah
run
context
where's.
That
print.
A
Yeah,
okay,
so
yes,
it
did
get
it
so
the
context
config
it
does
propagate
that
bad
context.
The
max
context-
hey
that's
great
news.
That
was
a
much
easier
fix
than
our
other
config
situation,
so
yeah.
So
that
is
your
patch
for
that
and
I'll
just
do.
A
Yeah
there's
the
context
config
and
then
there's
the
orchestrator
config
and
the
context.
The
orchestrator
context
is
tied
to
a
data
flow.
Specif
is
tied
to
a
specific
data
flow,
whereas
the
orchestrator
is
not
tied
to
any
specific
data
flow.
You
know
you
create
instances
of
the
orchestrator
context.
Every
time
you
want
to
run
a
data
flow
right,
so
we
we're
basically
saying
you
know
we're
doing
here
is
we're
saying
here's
the
co,
here's,
the
config
for
the
orchestra
and
here's
the
config
for
the
orchestrator
context
right
and
by
default
in
the
class
definition.
A
A
I
want
you
to
set
the
max
context
if
you're,
if
it
hasn't,
been
explicitly
set
right.
Okay,
so
I'll,
post,
this
patch
I'll
just
post
this
and
get
her.
Does
that
make
sense
or
is
everything
still
a
little
bit
unclear.
A
Okay,
okay,
this
is
great,
so
I'm
glad
we
figured
that
one
out.
It
didn't
take
as
much
explanation
into
the
whole
config
infrastructure,
but
at
least
hopefully
for
those
who
hadn't
seen
it.
There
was
more
more
background
on
on
why
that
change.
This
is
this
is
why
that
config
code
is
so
hard
is
because
you
know
that
was
a
pretty
simple
change
there
right
and
we
can
go
multiple
levels
we
saw.
A
We
talked
about
how
you
know
in
saksham's
case
he
actually
wants
to
set
it
within
the
data
flow
pre-processing
source
right,
so
that
really
just
becomes
or
oh.
This
was
the
other
thing
that
really
just
becomes
source
dash,
orchestra
dash
max
ctx,
right
and-
and
so
that's
that
was
the
main
you
know.
This
is
why
there's
so
much
config
code
is
because
you
can
change
this
and
then
this
is
what's
required
to
propagate
it,
to
the
config
property
of
a
different
within
a
different
class
right,
and
that's
why
jaw?
A
When
you
go
to
change
things,
you
know
you're
going
to
need
to
make
sure
that
it
doesn't
just
apply
to
the
top
level
class,
because
there's
some
discrepancy
in
there
with
some
of
the
code
and
which
is
why
I
was
in
you
know,
there's
some
cleanup
to
be
done
on
the
whole
thing,
but
yeah
anyways,
okay,
a
lot
of
config
stuff
today.
B
So
how
do
you
like
beautify
this
command
line,
come
on
this
command.
A
Yeah,
so
that
is
where's
the
okay,
so
if
you
have,
if
I'm
in
vim
or
so,
if
you
have
regex,
if
you
can
do
find
and
replace
with
regex,
which
most
things
can
basically
what
I
this
is
the
this
is
the
regex
that
you
use
to.
A
Beautify
command
line.
A
A
So
and
what
this
does
is
basically
say:
okay,
search
for
anything
where
you
see
a
space
with
a
hyphen
and
then
turn
that
into
a
backslash
and
control
or
and
and
for
some
reason
in
vim
at
least
it's
it's
carriage
return
ends
up
actually
producing
a
new
line,
and
if
you
do
a
new
line,
it
doesn't
actually
produce
a
new
line.
So
so
so
yeah
you
just
you're,
basically
saying
okay,
every
time
you
see
a
space
with
a
hyphen
make
that
into
a
backslash
and
then
a
new.
C
A
And
then,
however
many
spaces,
you
want
and
then
add
the
hyphen
again,
which
is
what's
going
on
here,
so
the
space
backslash,
which
is
double
escaped
and
then
a
new
line
which
is
actually
carriage
return,
so
slash
r,
backslash,
r
and
then
space
and
then
a
then
hyphen,
because
we
we've
got
rid
of
the
hyphen.
So
we
need
to
add
it
back.
B
A
hand
in
jackax
but
got
a
little
intimidated,
yeah.
A
It's
I
mean
yeah,
I
I
have
a
really
hard
time
with
that's
one
of
the
things
I
really
want
to
learn.
So
if
you
are
on
the
command
line,
then
this
becomes
sed
I
oops
and
then
this.
A
So
if
you
don't
use
vim
and
you
just
have
the
command
line-
or
maybe
you
can
put
this
into
like
vs
code
finder
plate,
so
okay,
so
now,
if
we
do
nope,
okay
yeah,
so
if
you're
doing
this
on
the
command
line,
then
you
want
to
do
dash,
and
so
I
guess
it's
just
vim
that
yeah,
it's
just
vim
that
has
the
weirdness
with
the
r.
So
let
me
just
do
that
so
or
there's
r.
A
If
in
them
that's
I
see,
I
have
no
idea
why
they
do
that,
but
they
do
so
all
right
anything
else
from
anyone
or
if
not,
then
we
will
call
this
meeting
wrapped
up
and
we
will
convene
next
week.
A
So
I
know
this
is
long
thanks
for
thanks
for
sticking
in
there
everybody
we,
I
think
we
covered
a
lot
of
good
stuff.
So
all
right
thanks
everyone
and
have
a
good
one.