►
From YouTube: Weekly Sync 2021-05-11
Description
Meeting Minutes: https://docs.google.com/document/d/16u9Tev3O0CcUDe2nfikHmrO3Xnd4ASJ45myFgQLpvzM/edit#heading=h.s13ccncidv2c
A
This
is
actually
the
input
value,
so
this
says
this
image
pre-processing
source,
the
operation
that
we
want
to
do
on.
The
image
feature
is
array
normalize
and
the
feature
should
be
passed.
So
the
data
of
the
feature
should
be
passed
to
the
input
named
array
of
the
array,
normalize
operation
and
then
the
then
you
can
use
this
inputs.
So
then
you
can
say
inputs
and
you
can
set
another
specific
input
so
of
the
array.
A
A
A
Well,
we
never
implemented
it
because
what
happened
was
saksham.
I
believe
this
is
before
saksham
did
the
whole
revamp
of
the
config
infrastructure
and
changed
it
into
these.
I
think
I
think
we
didn't
have
this
yet
at
the
time
this
was
like.
You
know
our
original
inspiration
for
trying
to
figure
out
this
at
config
thing
I
believe-
and
so
I
think
this
yeah,
so
I
think
the
main
thing
was
we
needed
to
figure
out
how
to
implement
this.
A
You
know
the
dictionary
within
the
config
structure
and
I
don't
think
that
will
be
too
difficult.
It's
really
well,
okay,
so
you
are
you
you
haven't,
have
you?
Have
you
been
much
in
the
config
code?
I
can't
remember.
A
Okay,
so
well,
you
did
do
the
auto
def
of
the
def.
You
know
you
did
do
the
auto
definitions,
but
that's
more
in
the
data
flow
data
flow
area.
I
think,
let's
just
look
at
it
real,
quick,
because
it's
a
bit,
I
mean
it's
a
bit
of
a-
and
this
is
part
of
the
thing
is:
is
it
was
a
bit
of
a
mess
right
like
the
config
vote,
the
config
a
lot
of
this
project?
A
And
you
know
I
said
this
a
million
times,
but
a
lot
of
the
project
is
config
right,
trying
to
configure
all
these
objects
consistently.
So
why
are
you
all
owned
by
gitlab
runner,
all
right?
Okay,
okay,.
A
So
I
think
you
know
everything
is
things
have
pretty
much
gone
into
base
yeah
into
dfml
such
base,
dot,
py
and
this
convert
value
and
arg
are
pretty
critical
here.
So
if
you
wanted
to
do
this,
I
think
the
main
thing
was
and-
and
you
know
you
could
you
could
propose-
I
think
you
know-
I
I
think
yash
and
saksham-
and
I
I
think
flushed
it
out
pretty
well
and
I
think
there's
a
recording
of
this
too.
There
may
be,
let's
see,
let's
see
january
20th,.
A
A
Oh
we've
been
doing
this
for
a
while,
okay
2019,
oh
man,
was
there
no
recording
of
this
day.
What
was
it
let's
look
in
here?
B
A
A
Wait
which
one
I
don't.
B
A
You
know
you
know,
I
think
it
could
be.
I
guess
you
know
it's
all
sort
of
right.
It's
all
what
we,
what
we
make
it
right.
I
think
it
could
be
because
at
the
end
of
the
day
you
know
what
you're
going
to
end
up
with
is
that
this
syntax
behind
the
scenes,
you're,
probably
just
going
to
create
a
data
flow
right.
A
A
So
I
think
the
your
output
of
this
could
very
easily
be
a
data
flow
right,
so
you
may
actually
you
may
want
to
do
this
at
sort
of
more
of
a
base.
You
may
want
to
split
this
into
two
things
right,
you
could
you
could
create.
You
could
start
with
this
pre-process
thing
right
and
then
you
know,
but
before
you
run
it
like,
you
know,
I
think-
and
I
think
this
is
what
happens
on
where
did
it
go?
A
I
think
this
is
what
ends
up
happening
wait.
Where
did?
Why
is
so?
I
think
this
is
what
happens
here
on
this
op
sources.
We
basically
yeah.
We
grab
the
op,
we
only
grab
a
single
operation
implementation
and
then
we
we
make
a
data
flow
and
then
we
just
run
the
data
flow.
A
So
you'll
probably
end
up
doing
something
similar
where
you
basically
just
make
the
data
flow
out
of
the
stuff
that
you're
given,
and
then
you
run
it
through,
like
the
data
flow
pre-processing
source,
you
know
because
yeah
you're
really
making
a
shorthand
right,
and
so
you
could
then
refactor
that
once
you
have
this
working
or
before
you
have
it
working,
maybe
you
could
just
start
with
this
right.
A
You
could
start
with
the
thing
that
takes
that
config
and
creates
a
data
flow
right
and
then
you
know,
then
you
maybe
just
use
the
data
flow
pre-processing
source
after
that
right,
because
you
could
right
now
you
have
this
syntax
right,
and
so
this
dataflow
create
command.
So
you
could
have
this,
be
you
know,
data
flow
create
or
you
know,
data
flow
shorthand
or
something
right.
Data
flow
like
or
maybe
we
do.
A
You
know
we
change
the
create
command
a
little
bit
and
you
add
another
flag,
for
you
know
the
shorthand
creation
right
so
or
you
can
either
change.
You
know
you
can
change
this
right
here
to
instead
of
create,
be
something
else
or
you
can
add
a
flag
to
it
right
and
then
that
triggers
you
know
the
reinterpretation.
A
Actually
you
probably
want
to
create
another.
You
probably
want
to
make
another
command
so
that
you
can.
You
can
have
the
flags,
be
what
you
want,
but
I
think
that
that
then
then
you'll
have
a
different
dataflow,
create
command
right
and
you'll.
Your
output
is
still
a
data
flow
and
you
can
still
run
it
through
the
data
flow
pre-processing
source
right
or
you
can
just
combine
those
into
it's
probably
best
to
leave
them
as
separate
things.
A
You
know,
rather
than
trying
to
throw
them
into
one
one
command
or
one
source,
because
then
we
leverage
the
existing
data
flow
source
code
and
if
we
want,
if
we
feel
like
that,
necessitates
having
a
wrap,
you
know
a
wrapper
to
do
both
things
at
once,
the
create
and
the
running.
Then
we
just
make
that
later.
You
know
that
should
be
easy.
Yes
all
right!
So
then
I
think
you
know,
I
think
main
thing
and
what
we're
talking
about
here
so
yeah
so
on
this
right.
A
I
think
that
that's
that
could
be
part
of
this
right.
You
know
you
could
you
could
take
you
could
take,
and
you
can
you
can
start
with.
You
can
start
with
this
thing
where
you're
doing
you
know
just
just
inputs
and
outputs
right
and
you
can
treat
you
can
treat
the
inputs
if
you're
running
with
the
data
flow
source.
You
would
know
that
the
inputs
are.
A
You
would
know
that
the
inputs
are
coming
from
the
the
feature,
the
features
of
of
the
records
and
actually
that's
an
interesting
thing
too,
because
right
now
a
data
flow
doesn't
necessarily
know.
You
know
you
can
look
at
the
seed
values
to
determine
what
what
is
expecting
for
seed
values,
but
you
don't
necessarily
know
that
you
wouldn't
necessarily
know
that
all
of
them
are
coming
from
record.
A
The
records
features
right
if
you're
using
the
data
flow
source,
because
you
still
have
the
ability
to
add
inputs
at
runtime,
so
you
could
make
an
assumption
right.
A
You
could
make
an
assumption
that
everything
that
you
that
you
see
in
the
seed
for
the
data
flow
for
source,
like
if
you
loaded
data
flow,
if
the
data
flow
source
loads,
a
data
flow,
and
it
can
look
at
all
the
seed,
the
possible.
You
know
that
the
it
can
look
it.
It
can
inspect
all
the
flows
and
see
what
all
the
possible
seed
definitions
are,
and
it
could
just
auto
say
you
know
it
could
automatically
say
if
the
features
weren't
provided
that
it
would
use
anything
that
that
is
from
the
seed
right.
A
So
you
could
add
that
logic
there
and
then
you'd
basically
end
up
with
a
straight.
You
know
shorthand,
create
command,
outputs,
a
data
flow,
and
then
you
pass
the
data
flow
directly
to
the
you
know,
the
data
flow
source
you
wouldn't
have
to
specify
the
features,
because
it
would
auto
populate
from
the
things
that
it
sees
in
the
seed
right,
and
so
that
would
be
more
streamlined
right.
B
A
Okay,
I
think
I
I
think
you
know
and-
and
you
know
feel
free
to
this
is
just
me
spitballing
here
so
so
so
let
me
know
if
this
doesn't
does
you
know
just
just
comment:
why
don't
we
use
this
issue
to
track?
And
actually
let's
note
that
so
cli,
okay
and
we
should
probably
have
you
know
we
should
make
this
okay,
so
we're
having
a
cli
command
here,
but
we'll
see
how
this
goes.
Okay,
so
data
flow
shorthand
create.
A
Command
all
right
and
then
I'll
make
a
note
back
here.
So
so
we
talked
about
this.
A
Zero
five
meeting,
we
decided
that,
instead
of
making
this
a
source,
we
are
sort
of
this
issue
being
about
a
new
source.
We
should
focus
on
creating
this
issue
should
be
about
creating
or
making
a
shorthand
for
the.
A
We
can
then
use
this
new
shorthand.
A
A
Okay,
we
can
also
modify
the
data
flow
source
to
inspect
the
input
flow.
A
Objects
to
see
which
values
it's
expecting
or
which
definitions.
A
From
seed,
if
the,
if
there
are
no
inputs,
that
also
contain
those.
A
A
A
This
needs
to
be
updated.
Doesn't
it
wow?
No
description?
Great,
let's
see
this
is
the
data
flow
process
input
so
where
is
it
inputs
so
right?
So
if
we
have
this,
if
the
inputs
is
given,
if
inputs
is
given-
and
it's
not
given
here,
but
if
it's
given
and
it
contains
any
input
values
that
that
have
definitions
that
match
that
are
that
are
present
in
seed
we
safely,
you
know
we
can
safely,
then
assume
that
that
the
input
is
not
going
to
be
coming
from
from
a
record
right.
B
A
Okay,
we
can
use
this
list
of
definition
as
the
feature
names
to
grab
from
each
record
and
label
and
sign
in
the
core
is
definition
name:
okay,
if
there
are
no
input
or
if
there
are
inputs
that
also
contain
values.
With
those
definitions,
we
shouldn't
grab
that
feature
from
each
record.
Okay,
all
right!
This
will
be
great
yeah,
because
this
I
mean
having
a
shorthand
for
the
create
command
would
be
awesome,
and
then
I
think
also
you
know
like
what
you
were
saying
about
this
is
this.
A
You
know,
thinking
about
a
an
easier
way
with
the
merge
command
is,
if
you
had
I
I
bet
I
mean,
and
this
isn't
clear
right
now,
but
I
bet
you'll
quickly,
figure
out
that
you
know
if
one
of
your
inputs
right,
you
could
probably
do
something
where
you
have
like
a
you
know:
some
kind
of
chain
command
instead
of
merge,
because
merge
takes
two
data
flows
and
it
it
makes
them
the
same
thing
right
it
overlays
one
on
top
of
the
other,
so
you
probably
you
could
end
up
with
some
kind
of
chain
command
right
where
you
could.
A
Basically,
you
know
maybe
leverage
some
of
the
stuff
that
you're
doing
here
with
the
shorthand
to
say:
okay.
Well,
I
was
looking
at
inputs
and
outputs
right
and
I'm
making
this
shorthand.
That
basically
just
says
these
are
the
seed
values
right
and
the
data
flow
pre-processing
source
will
interpret
those
as
these
are
the
things
I
need
to
get
from
the
record,
but
whatever
this
may
be
like
chain
data
flow
chain
command
or
something
might
say,
okay,
this
is
you
know
the
seed
values
of
the.
A
If
there's
the
n
data
flow
and
the
n
plus
one
data
flow,
the
seed
values
of
the
n
plus
one
data
flow
might
will
assume
that
they
come
from
the
you
know.
The
output
values
of
the
end
data
flow,
and
you
can
look
at
the
the
you.
Could
this
command?
Could
hypothetically
look
at
the
the
outputs?
A
You
know
the
output
operations
of
the
the
end,
the
n
plus
one
data
flow.
You
know
the
commit
this
whatever
this
thing
is,
could
look
at
the
output,
definitions
of
the
end
data
flow
and
link
them
to
the
seed
definitions
in
the
n
plus
one
data
flow
right?
A
Yep,
I
think
that
would
provide
a
very.
I
think
that
would
you
know
a
lot
of
this
stuff
is.
Is
we
have
sort
of
there's
there's
a
lot
of
complexity
that
still
exists,
but
I
think
that
we
have
a
lot
of
the
you
know
we,
the
thing
is:
we've
had
to
build
a
lot
of
the
the
primitives
right
and
I
think
that
we're
getting
to
a
really
good
space,
especially
with
the
work
that
you've
been
doing
cool
great,
I'm
glad
we
touched
on
this
anything
else.
You
wanted
to
talk
about
with
this.
A
That
would
be
great
yeah.
I
went
and
I
tried
to
rebase
it,
but
I
basically
got
let's
see
what
happened
to
me.
Oh,
this
is
now
I'm
gonna
make
the
other
machine
again.
This
is
what
this
machine
is
doing.
A
All
right,
yeah
I
tried
to
rebase
it
and
I
can't
remember
I
couldn't
figure
out
what
was
going
on.
I
was
pretty
confused
here
to
be
honest
because
I
remember
we
had
cherry-picked
some
commits
and
I'm
not.
I
know
you
rebased
recently,
though
right
yes,
and
I
felt
like
some
of
these
things
that
were
happening
seemed
like
they
were
farther
away
ago
than
they
should
be,
so
I'm
not
sure
like.
I
might
have
screwed
this
up
like
what
I
can't
remember.
A
I
think
maybe
I
I
looked
at
the
wrong
branch
too,
when
I
did
this
because
which
one
did
we
go
into,
we
did
we
do
actually.
Oh,
was
it
this
actually.
A
It's
wait,
sorry,
which.
A
Oh
see
that
makes
more
sense
because
I
think
I
probably
need
to
go.
I
grabbed
a
different
accuracy
branch.
I
think-
and
I
think
yeah
condensed
makes
sense,
because
we
tried
to
this
has
less
commits
and
we
tried
to
cut
down
some
of
those
commits
yep
and.
A
A
Okay,
great
okay,
so
we
should
probably
I
didn't
want
to
delete
yeah
february
11th,
okay,
so
that's
probably
where
I
went
wrong
here
because
I
was
like
there
haven't
been
that
many
changes
to
things
that
should
screw
all
this
stuff
up
since
then.
So
I
wonder
what
happens
if
we
take
that?
If
it
will
be,
I
mean
we'll
be
we'll
be
we'll
be
very
excited
if
it
runs
cleanly
abort,
okay,.
A
A
A
A
But
this
is
pretty
pretty
minimal,
oh
and
then
I
think
what
I
run
into
here.
I
also
ran
into
oh.
We
had
changed
what
was
it?
The
accuracy
command,
yeah,
here's
the
accuracy
command
and
we
had
modified
this
slightly
to
be.
We
had
done
this
and
I
realized
there's
a
bug
here.
You
know
because
this
was
basically
and
if
the
model
is
already
modeled
and
don't
reopen
it,
and
I
realized
well
mctx
is
not
present,
then
so
we
have
a
bit
of
that's
a
bit
of
bug,
so
I
think
anyways.
A
And
then
the
other
thing
was,
I
can't
remember
if
you
changed
it
later,
but
is
this
accuracy
context
in
the
current
version
or
is
it
actually
score
or
context.
A
Oh,
it's
accuracy
context.
We
probably
need
to
change
this
to
just
do
a
find,
replace
and
make
it
accuracy
scorer
context,
but
we
can
just
do
that
as
like
a
single
commit
on
top
of
the
rest
of
them
just
because
for
consistency,
if
this
is
accuracy
score,
this
should
be
accuracy
score
context
to
follow
the
rest
of
the
convention,
okay
and
then
well.
The
other
thing
is
also
like.
A
Accuracy
score
dot
score,
so
maybe
we
should
just
rename
this
thing
to
accuracy.
We
could
either
rename
accuracy
context
to
actually
score
context
or
we
could
rename
actually
score
to
accuracy
and
then
change.
You
know,
because
I
think
that
might
make
more
sense.
What
do
you
think
do
you
think
it
should
be
accuracy
score?
Do
you
think
it
should
be.
A
Yeah,
it
will
conflict
yeah,
it
will
conflict
so
but
then
we'd
have
to
rename
that
one,
but
that
one
is
hardly
used
anywhere
and
it's
basically
just
like
an
alias
for
a
float.
So
I
don't
know
it
could
make
more
sense
if
you
think
it
makes
more
sense.
So
you
know
I'll.
Just
you
know,
leave
I'll.
You
know
update
whatever
you
think
when
you
get
to
it.
You
know
either.
A
Okay,
yes,
okay,
okay,
great
all,
right.
A
A
A
B
A
A
Oh,
maybe
we've
I
forgot
to
drop
some
of
them.
I
think,
is
what
happened.
Let's
see
yeah,
I
forgot
to
drop
two
of
the
commits.
Okay,
you
know
I'll
just
drop
those
I'll
drop
those
and
then
so
I
think
what
can
we
do?
I
think
we
can
just
do
get
rebase
skip
and
then
this
is
another
thing
and
that's
the
other
one:
okay,
okay,
yeah,
okay
and
now
we're
to
here.
Do
we
have
transformers
good
log?
One
line.
A
A
Okay
yeah-
and
this
was
test,
for
example,
okay
yeah.
This
is,
let's
see,
I
think
this
is
pretty.
I
mean
you're
pretty
much
there
with
this
thing.
This
has
been
a
big,
a
big
big
endeavor.
A
A
Let's
see
so
is
this:
do
you
think
this
is
correct?
Let's
see
we'll
I'll
check
it
here.
A
Model
xg
boost
yes,
where's.
This
regressor.
A
A
A
A
A
Okay-
and
this
is
when
we
changed
it
back,
so
I
think
the
only
change
here
is
this
yeah
when
we
changed
it
to
the
actx.
A
B
A
B
I
feel
there
was
once
a
time
we
decided,
we
should
keep
the
anya,
but
whatever
scorer
we
are
passing.
A
Let's
check
out
high
level,
it
needs
to
go
to
your
accuracy
all
right.
So
I'm
going
to
push
this
to
this
branch,
and
now
we
have
too
many
of
these
actually
branched,
but
I
labeled
this
one
at
the
date.
So
hopefully
that
makes
it
a
little
more
clear,
and
then
we
have
this
issue
here.
So
I'm
going
to
post
a
I'm
going
to
post
something
about
cat,
a
different
high
level.
A
A
A
A
If
model
is
model
context.
A
And
accuracy
context
respectively
for
accuracy
score
all
right.
You
see
what
I'm
talking
about
here.
Basically,
if
we
pass
in
model
and
then
we
use
well,
we
use
model
later
or
we
use
mctx
later
down
here.
This
was
supposed
to.
I
wrote
this
and
I
screwed
up,
but
this
was
supposed
to
be
a
way
to.
If
you
pass
an
open
model
context
to
this,
you
would
end
up
just
still
using
the
model
context
but
model
context.
The
variable
for
model
context
won't
be
defined.
I'm
pretty
sure
is
the
main
issue
here,
because,
let's
see.
A
A
All
right,
so
I
think
we
have
a
clean
apply
there.
You
know
relatively
clean,
so
I'll,
let
you
you
know,
let
let
me
know
if
this
I
might
have
screwed
something
up
right,
but
but
let
me
know
how
this
goes
because
I
think
we're
very
close.
I
see
this
being
in
the
4.1
release.
A
So,
yes,
I
think
start
with
phase
eight
yeah.
That
sounds
good
all
right,
let's
see,
and
this.
A
A
Let's
see
if
this
tracked,
okay
well,
I
will
put
in
the
description
so
accuracy,
rebase.
A
A
A
Okay,
all
right
yeah,
so
you
can
start
from
this
branch.
Rebase
mastered
onto.
A
All
right:
well,
I
hope
you
have
a
great
great
rest
your
evening
and
great
great
week.
Let
me
know
how
it
goes.
Have
a
good
one,
bye,
bye.