►
From YouTube: Weekly Sync 2021-08-10
Description
Meeting Minutes: https://docs.google.com/document/d/16u9Tev3O0CcUDe2nfikHmrO3Xnd4ASJ45myFgQLpvzM/edit#heading=h.5c13eb36goty
C
B
B
B
B
C
B
C
A
A
B
B
C
A
B
B
A
B
A
B
A
B
B
C
B
B
B
A
B
B
A
C
B
B
B
B
B
Right
other
accuracy
context,
and
it
wants
two
features
right,
maybe
or
maybe
it
can
take
a
variable
amount
of
features
right
then,
if
this
one
gets
called
with
more
than
one
feature,
it'll
just
throw
an
error
right
on
call.
If
this
one
gets
called
with
more
than
one
feature,
it'll
just
grab
them
all
and
use
them
right
yeah.
I
think
that
might
be
the
way
to
go.
If
we're
gonna
try
to
put
this
in
the
methods
or
in
the
method,
signature
that
would
solve
your
problem
now.
B
The
question
is,
like
you
know
we
use,
so
we
use
the
so.
The
question
in
my
mind,
is
is:
is
we
use
the
you
know?
We
use
the
config
for
a
lot
of
things
right
and
it's
like
where,
where
where
do
you
draw
the
line
between
something
that
goes
in
the
config
and
something
that
goes
in
the
you
know
in
the
method?
Signature
for
these
various
classes?
B
So,
and,
and
the
reason
why
it's
contained
within
the
config
for
the
model
is
because,
if
you
serialize
the
model
to
disk,
then
the
model
that's
been
trained
is
tied
to
those
features,
so
the
accuracy
scores
not
serializable,
but
at
the
same
time
yeah.
So
the
accuracy
score
is
once
again
yeah
the
feature.
The
feature
really
should
reside
in
the
method
signature,
because
it's
not
something
that's
ever
going
to
be.
You
know
tied
to
the
specific
score
right
say
if
that,
if
you
were
to
serialize
it
to
disk,
does
it
make?
Does
it?
B
B
B
Is
there
the
one
thing
that
concerns
me
here
is
okay,
so
let's
see
the
one
thing,
that's
actually
context.
The
thing
is
with
the
accuracy
score
is
like
it's
all
sort
of
it's
all
sort
of
dynamic.
So
is
there
something
at
what
at
what
point?
You
know?
Okay,
so
because
this
is
like
you
know,
I'm
thinking
about
that
double
context,
entry
pattern
right
and-
and
so
with
the
accuracy
scores.
B
You
know
you
configure
the
class
and
you
okay.
You
enter
the
context,
I'm
trying
to
figure
out
whether
there's
whether
there's
a
reason
to
use
the
double
context,
entry
pattern
there
and
I
think
the
the
answer
is
probably
you
know
the
reason
why
we
use
it
is
because
we
don't
know
if
there's
a
reason
in
the
future,
so
we
should
probably
just
keep
those
configs
so
we'll
keep
the
actual
score.
Let's
just
move.
Let's
just
move
features
to
the
end
of
this,
because
it's
dependent
on
it's
highly
dependent
on
on
the
model
context.
B
That's
given,
yeah,
okay,
that's
perfect,
so
features
is
dependent.
The
the
features
here
in
the
signature
sort
of
go
hand
in
hand
with
this
stuff.
That's
being
passed
also
in
the
method,
therefore,
all
of
this
stuff
is,
you
know
con
this.
This
stuff
is
like
the
three
arguments
that
we
have
are
very
closely
related
to
each
other,
which
means
that
they
all
belong
in
the
method.
Signature.
Nothing
belongs
in
the
config
for
the
accuracy
context
there
and
if
it
did,
then
you
know
the
the
the
qualification
on
moving
something
from
a
config
to
a
method.
B
Signature
is:
is
it
related
to
the
other
things
for
the
method
call
right,
and
I
think
the
answer
is.
Is
you
know
if
we
had
sort
of
like
you
know,
for
example,
this
is
a
dumb
example,
but
if
we
wanted
to
make
this
too
configurable
right,
that
would
not
be
necessarily
related
to
model
context,
sources
and
feature.
B
B
This
is
so.
This
is
not
mean
squared
error.
This
is
in
general
if
I,
if
we're
implementing
an
accuracy
score
right.
So
this
is
other
accuracy
context
down
here.
This
would
be
our
our
next
implementation
right.
This
is
a
some
other
implementation
of
an
accuracy
score
right,
yeah.
So
in
that
case
say
this
one
accepts
multiple
features.
A
B
B
Let's
see
so
I
was
like
okay,
I
was
like
this
is
probably
going
to
get
complicated
when
we
hit
the
http
service,
and
this
makes
sense
so
because
yeah
this
is
not
now
it's
it's
no
longer
exactly
straightforward
to
do
the
to
do
the
to
do
the
modifications
to
the
http
service.
Unfortunately,
so,
let's
see
so
okay
yeah,
I
think
what
you're
going
to
have
to
do
is
you're
going
to
have
to
do
something
similar
to
what
you
did
to
high
level.
B
B
B
B
B
B
A
B
Okay,
well,
we
don't
have
an
issue
for
this,
but
so
for
now,
for
now,
let's
do
exactly
what
you
did
let's,
but
let's
just
move
it.
You
know
one
over
so
because
yeah
see
the
thing
is.
This
is
what
I
was
getting.
This
is
what
I
was
left
with
this
right
here
is
going
to
be
a
pain
to
add
features
too.
I
mean
it's
not
that
bad,
it's
basically
the
same
code.
B
A
B
B
B
A
A
A
B
A
B
A
B
B
B
B
B
We
need
to
move
the
score
feature
to
the
end
of
the
argument,
so
once
you've
done
that
then
ping
me
for
a
review
and
then
I'll
I'll
tell
you
you
know
if,
like
you
know,
I
mean
you
know
how
this
goes
right.
So,
let's
see,
but
let's
just
make
sure
that
it's
all
as
cleaned
up
as
possible.
Right,
if
it
all
looks
good,
then
I'll
just
merge
it.
But
you
know
I'm
assuming
that
you
probably
you
made
a
logical
tutorial
so
yeah.
B
Let's
just
try
to
make
sure
that
we
captured
the
other
types
of
things.
You
know
if
you
use
cash,
download
link
to
it
that
type
of
stuff
that
we
had
in
the
last
ones.
Let's
see
so
and
then
obviously,
hopefully,
you've
you've
mentioned
you
know.
Here's
where
you
can
find
the
list
of
or
all
the
models
support.
Multi-Output
right
is.
Do
you
wrap
yeah,
yeah?
Okay?
B
C
I
was
working
on
the
tuning
models,
notebook
and
I
thought
we
could.
You
know-
have
some
sort
of
optimizer
to
optimize
the
hyper
parameters
like
grid
search
and
etc.
So
I
didn't
really
implement
grid.
Sir
well.
Good
search
involves
a
cv
as
well,
so
I
just
created
a
parameter
grid
to
search
through
the
parameters
and
look
through
their
accuracies
to
see
which
one
works
better.
With
the
model.
B
B
B
C
B
B
C
B
B
A
B
Okay,
we
need
to
make
sure
that
we
can
we
can
we
get
those
psychic
models
working
though
yeah
and
that's
essentially
it
looks
like
we
have
a
open
open
questions
around.
You
know
make
config
numpy
may
config
inspect,
make
config
tensorflow
all
those
to
to
you
know
integrate
those
with
the
mutable
config
stuff
a
little
more,
and
we
can
talk
about
that
in
a
future
meeting.
So
we
don't
take
up
more
time
with
that,
but
I
think
you
know
what
it'll
come
down
to
is.
A
B
Inspect
is
probably
more
friendly
to
look
at
what
it'll
come
down
to
is
okay,
so
we're
looking
at
the
parameters
right.
So
we
can
imagine
this
is
kind
of
like
the
numpy
thing
and
then
you
know
we'll
need
to
set
field.
We'll
have
field
and
we'll
need
to
say
mutable
equals
true
or
mutable
equals
false
right.
So
so
my
config
so.
B
My
brain
just
gave
out
yeah
we'll
need
to
set
mutable
equals.
True
remediably
equals
false
right
and
we
talked
about
how
we
might
want
to.
You
know,
set
those
for
set
those
for
integer
parameters,
or
you
know,
et
cetera,
and
actually
that
it
kind
of
kind
of
with
the
way
that
it
works
right
now,
with
the
way
that
the
mutable
config
patch
works
right
now.
B
It
creates
a
specific
setter
and
getter
method
for
each
config
property,
but
we
could
sort
of
make
that
run
time
configurable
so
that,
after
the
config
is
created
that
we
could
set
specific
properties
to
be,
you
know,
enforcing
immutability
or
not
enforcing
immutability
at
the
property
level.
That
could
be
a
really
good
way
to
go
there
yeah.
B
B
B
A
B
C
B
C
B
C
A
D
D
D
So,
actually,
instead
of
passing
the
action
from
the
model
class,
we
are
just
deducing
it
because
action
can
be
reduced.
Pretty
simply
if
input
as
a
directory
an
output
is
a
file.
Then
it
is
a
compression
action
archive.
I
mean
archive
action
and
extraction,
otherwise,
okay,
so
so
what
you're
looking
at
here
is
actually
three
cases.
D
It's
like
a
file
can
exist
and
it
cannot
exist,
and
the
other
thing
that
can
change
is
that
other
variable
is
the
path
can
be
a
file
or
a
directory,
and
the
third
variable
is
it
could
be
in
input
or
output.
So
taking
the
cross
product
of
all
these
three
possibilities,
we
end
up
with
two
into
two
into
two
that
has
eight
possibilities
out
of
which
three
are
invalid,
and
five
possibilities
can
be
grouped
into
three
cases
which
are
being
shown
which
have
been
shown
here
right.
D
So
I
have
spotted
that
those
data
flows
where
we
were
adding
a
compression
operation
after
archive
operation
or
an
archive
operation
after
compression
operation.
Decompression
operation
was
actually
very
much
same
just
with
some
minor
changes.
So
I
made
it
as
like
chained
operation,
where
I
can
switch
the
order
of
the
operations
and
it
will
work
in
an
operation,
agnostic
manner.
B
B
D
B
B
D
D
So
I
just
like-
and
ideally
it
should
not
break
anything,
because
we
have
not
added
any
archive
tests
yet
in
any
of
the
models,
but
all
of
the
models
are
giving
a
similar,
similar
error
with
the
same
error
message,
which
has
a
very
same
trace,
similar
trace
path.
So
if
you
can
check
the
second
last,
if
the
latest
one
hasn't
completed
yet
they
have
all
like
something
wrong
with
the
high
level
stuff
being
called.
Let's.
B
D
D
B
D
D
B
D
D
D
B
B
If
we
want
to
add
so
why,
why
would
we
want
to
add
a
property?
I
guess
you
know
so
so
the
reason
why,
okay,
let
me
say
the
reason
why
we're
doing
that
get
at
her
with
the
default
of
none
is
just
in
case
the
because
this
is
the
model
based
class
right,
so
we're
implementing
some
some
helpers
and
stuff
in
in
the
base
class.
If
the
you
know
the
the
subclass
defines
these
properties
like.
B
B
D
B
Okay,
because
we
would,
we
would
take
a
location,
we'd
load,
the
location
into
memory,
then
we'd
load,
the
config
json
and
then
once
we
had
the
config
json,
then
we
could
instantiate
the
model
right,
but
the
model
calls
this
part
right.
Well,
that's
what
I'm
saying
we're
going
to
have
to
change
that
right.
B
A
B
Yeah,
so
so
exactly
yeah,
so
this
is
sort
of
like
an
extension
of
that
right.
Where
you'd
be
doing-
and
I
think
we
even
talked
about-
maybe
the
name-
the
need
to
didn't-
we,
I
think
we
talked
about-
perhaps
the
need
to
rename
the
load
or
to
repurpose
the
load,
function
or
load
class
method,
because
I
think
what
we
end
up
with
here
is
really
like.
B
Yeah
yeah,
and
I
think
this
is
going
to
be
generic
code.
I
mean
this
isn't
even
going
to
be
tied
to
models
at
this
point
right.
It's
really
just
going
to
be
like
you
know,
this
is
how
you
load
any
of
these
data
based
data
flow
facilitator
objects
right,
because
we
we
have
yeah
like
this-
would
work
for
anything
that
has
a
config
right.
A
B
B
B
B
A
A
B
B
B
It's
configurable
so
base
configurable
is
basically
anything
that
takes
a
config
right,
yeah,
okay,
so
yeah.
So
basically
we
can
use
the
stuff
that
you
implemented
here
to
save
and
load
anything
right.
Let's
see
see
the
so
you
all
of
a
sudden,
your
your
project
is
applicable
to
more
than
just
models,
so.
B
B
B
B
B
B
So
this
is
a
tricky
thing,
so
we've
talked
about
this
many
times
before,
because
you
need
to
give
people
control
somewhat,
but
you
can't
so
you
can't
give
this
information
on
disk
too
much
control,
because
if
you
give
it
too
much
control,
then
all
of
a
sudden
you
open
yourself
up
to
you,
know
unintentional
side
effects
and
unintentional
side
effects
is
basically
like.
You
know.
B
B
Okay,
so
basically,
essentially
the
yaml
spec
says
that
you
can
sort
of
it's
very
similar
to
the
what
we've
got
here,
where
it
says
you
can
sort
of
take
a
python
path.
Right,
like
a
you,
know:
module
dot,
sub
module,
dot,
sub
module.
You
know
colon
class
type
of
thing,
or
I
think
it
just
uses
dots,
but
doesn't
really
matter
and
you
can
and
then
you
can
instantiate
that
class
or
you
can
even
call
like
you
know
the
thing
was
they
could
call
os
dot
system
right
and
run
commands
right.
B
We
know,
we
know
the
type
right.
So
the
type
in
this
case
is
a
model
right.
So
we
know
that
when
we
load
back
in
the
model
like
we
know
that
we're
loading
using
the
model
like
you
know,
we
know
we're
so
think
about
this
from
the
standpoint
of
a
config
right.
So
if
I
have
a
config-
and
it
has,
you
know
the
properties
and
then
the
data
types
right.
B
B
I
know
that
it's
of
type
so
features
isn't
a
grid.
Well,
so
if
I
were
to
load
features
from
a
from
a
location,
then
I
know
that
the
data
type
is
features
right.
So
I
know
I'm
going
to
load
a
features,
object
so
say
it
wasn't
one
of
our
plugins
right
or
better.
Yet
you
know
say
say:
let's
see
say
we
had
a
config,
whereas
let
me
just.
B
So
the
model
yeah
model
predict
right
so
say
we
have.
We
have
this
model
predict
config
right
and
it
takes
you
know
a
type
of
model
right,
so
we
know
that
we
know
that
we're
loading
a
model.
So
then
we
just
need
to
know
which
model
we're
loading
right.
So
if
we,
if
we
open
it
up-
and
we
say-
okay,
you
can
load
anything.
Then,
all
of
a
sudden,
we
we
open
ourselves
to
that
libiamo
style,
cve
right
and
we
don't
want
to
do
that.
B
B
B
A
A
B
B
Just
going
to
put
this
in
another
function,
though,
is
is
really
the
deal
right.
So
this
all
you're
doing
is
is
this:
a
exit
method
is
just
going
to
call
a
function
where
you
you've
made
the
body
this
right
and
you're
passing
self-config
location
right.
So
this
stuff
here,
let's
see
11.74
so
ghpr
check
out.
B
B
B
B
Yeah-
let's
put
this
after
gsoc,
but
it
it's
good
to
know
that
I
think
we're
almost
there.
So
so
and
then
the
main
thing
was,
you
know
what
happens
with
the
load.
So
I
think
this
is
also
gonna
sort
of
fix
the
load
problem
so
right
now,
because
that
was
how
this
discussion
started.
So
you
come
in
and
you
need
to
know.
B
Well,
you
can
load
if
you
instantiate
a
model
with
parameters,
you
can
load
the
model
right
and
that
would
load
it.
You
know
and
give
it
the
correct,
tempter
and
everything
right
with
the
loaded
model
contents.
It
just
wouldn't
load
the
config
properly
right
now,
right,
yes,
okay,
so
yeah!
So,
let's
see
and
then,
if
from
from
that
perspective
yeah,
I
think
let's
just
do.
B
B
B
B
B
B
D
B
E
E
E
E
And
after
that
I
have
this
output
layer.
So
in
the
output
layer,
what
I
am
trying
to
achieve
is
is
to
get
like,
like
this
is
in
the
form
of
a
matrix
right
this
thing,
so
I
was
actually
trying
to
get
like
a
single
row
of
this
matrix
and
and
return
it
so
that
it
can
again
be
converted
into
a
form
of
records.
E
Yeah,
so
I
what
I
was
actually
doing
here
is
like
I
created
a
class
output
layer
class
and
in
that
I
have
this
index
value,
so
it
will
give
me
like
which
row
we
want
to
output
and
for
the
context
I
have
written
this
code,
but
the
the
problem
in
this
part
here
is
like
suppose,
we
have
19
features
and
let's
say
we
have
20
data
points.
We
have
20
rows
in
the
a
csv
file.
Then
this
code
actually
runs
both
the
multiplied
by
that
times.
B
E
B
B
B
B
E
E
Let's
see
in
the
collect
output
actually
in
the
nlp
example,
what
we
have
is
we
have
sentences
and
the
output
actually,
so
we
we
just
take
all
the
sentences
and
then
we
create
a
matrix
out
of
it
and
for
the
output.
How
it
is
done
is
we
take
each
of
the
input
string
and
we
find
what
is
its
index
in
the
in
the
collected
output
and
then
whatever
is
the
corresponding
like
value
the
list
value?
We
actually
return
that
okay.
E
B
A
B
A
B
A
E
B
Okay,
and
previously
we
could
just
index
in
easily
because
we
just
needed
to
we
could
use
so
we
could
use
this
string
right
and
now
we
can't
just
pull
from
the
string.
We
need
to
know
a
specific
index
that
it
entered
at
right,
yep.
Okay,
I
mean,
I
think
you
could
return
can't
you
return
something
from
your
input
layer
operation,
that
is
the
index.
It
was
input
at
or
something.
B
B
E
Not
necessarily,
we
need
to
know
like
what
we
need
really
need
to
do
is
like
give
the
out
like
we
have
this
matrix
b
process
matrix
and
we
have
to
just
return
each
of
the
row
so
that
it
will
come
in
the
csv
format
when
we
do
the
merge
command
or
even
if
we
not
do
the
merge
command.
But
if
we
try
to
train
on
something,
then
at
least
we
have
the
column
name
so
that
we
can
do
training
on
top
of
them.
B
B
E
B
E
Very
small
but
like
it
is
a
very
large
data
set,
but
I
actually
kept
it
small
so
that
we
can
run
through
it
multiple
times.
So
this
is
the
data
set
we
have,
and
it
is
a
csv
format.
Okay,
yes,
so
now
here,
what
we
are
doing
here
is
in
the
flow,
so
we
have
three
things.
So
this
is
the
output
layer
result.
We
want
to
get
it
into
single
spec.
E
This
is
the
source
length,
which
is
actually
how
many
rows
we
have
in
the
csv
file,
and
it's
the
feature
length
like
in
each
of
the
row
how
what
are
the
number
of
features
that
we
have
right
so
in
the
seed?
What
I
am
doing
here
is,
I
am
providing
all
these
values
to
the
input
layer,
input,
data
points.
E
So,
after
that,
the
input
layer
will
return
a
data
which
is
this
output,
which
will
then
go
to
one
of
the
standard
scalar
operations,
which
will
remove
the
mean,
and
it
will
transform
it
in
such
a
way
that
it's,
it
has
a
unit
variance.
So
this
is
the
operation
which
you
are
performing
on
top
of
this
matrix,
okay
and
when
we
are
done
with
the
performing
the
matrix.
So
what
I
am
doing
here
is
whatever
the
result
we
are
getting
out
of
this
operation.
E
E
So
this
was
the
data
flow
creation
operation,
and
then
we
have
the
merge
command.
So
in
the
merge
come
on.
What
I'm
doing
is
I'm
running
the
whatever
the
data
flow
we
got
in
the
json
format,
I'm
trying
to
run
it
through
the
data
set
that
we
have
and
create
another
data
set,
which
is
the
pre-processed
dataset,
which
we
have.
B
Now,
if
we,
if
we
had
another
way
of
of
of
doing
you
know
if
we
had
a
source,
for
example,
that
output
you
know,
output
records,
not
necessarily
based
on
you
know,
not
necessarily
a
one
to
one
mapping
of
input.
So
so,
if
we
had
a
if
we
had
a
source
that
when
you
ran
it
every
time,
the
the
results
were
yielded
from
the
output
like
if
we
had
a
source
that
within
within
so
basically
it
runs
a
data
flow
and
within
the
data
flow.
B
We
load
all
the
data
from
a
source
from
a
from
a
sub
source
right,
so
we
want
to
load
data
from
that
csv
file
right
that
kc
house
data.
Right
so
say
we
had
a
data
flow
that
ran
some
operation,
that
load
every
single
record
from
the
kc
house.
Data
set
csv
file
right
and
now
it
takes
all
of
the
records
and
it
passes
them.
You
know,
as
now
you
have
you
know
an
operation
that
loaded
all
of
your
stuff.
So
now
it
is
flat
right.
B
So
now
you
can
go
and
you
can
pass
that
you
know
to
other
operations
within
this
data
flow,
and
then
you
just
need
a
way
to
yield.
One
record:
you
know
for
each
row
right
it's
because
in
this
in
this
new
setup
right,
we
don't
necessarily
have
you
know.
We
don't
necessarily
know
that
we're
doing
you
know
a
set
of
operations
on
each
row.
We
just
know
that
we're
running
a
data
flow
and
it's
going
to
yield
us
a
bunch
of
records
right
yes,
so
this
is
almost
like
a
streaming
use
case
here
right.
B
This
is
like
a
run,
a
data
flow
and
it
will
return
a
variable
amount
of
records
right,
and
it
just
happens
to
be
that
we
know
how
many
records
it's
going
to
return,
because
it's
it's
doing
that
it's
it's
doing
that
from
from
a
from
a
csv
file
that
we
know
of,
but
but
in
general
you
know
it
doesn't
we.
This
is
essentially
our
first.
This
would
be
our
first
like
streaming
source
right.
B
So
the
question
is:
how
do
we
I
mean?
Would
that
I
mean
that
that
should
make
things
a
lot
easier
for
you?
Wouldn't
it
yes,
okay,
so
then
we
would
need
to
figure
out.
You
know
what
does
that
source
look
like
right
and
how
do
we?
How
do
we
grab
the
records
out
of
it
right?
Do
you
return
some
giant
object
and
then
each
you
know
dude.
Does
it
return?
B
B
I
think
that
might
be
a
really
easy
path
forward
to
for
you
and
and
because
you
know,
part
of
what
you're
doing
here
is
is
is
you're
implementing
cleanup
operations,
but
you're
also
trying
to
discover
what
is
the
best
way
to
to
implement
cleanup
operations
right,
and
I
think
what
we've
seen
so
far
is
that
you
know
we.
We
know
that
there
are
operations
that
take
the
whole
data
set
right
and
so
the
the
existing
approach
that
we
have
a
process.
B
B
We
can
have
multiple
data
flow
sources
or
sources
based
on
data
flows
right
because
the
current
one
it
may
just
need
to
be
renamed
right
to
you
know,
run
data
flow
on
you
know
one
run
data
flow
on
each
record
type
or
something
like
that
right
and
this
one
is
just
you
know,
run
the
data
flow
and
the
output
is
each
record.
So
I
would
say
I
would
say:
that's
probably
does
that
do
you
feel
like
that,
would
give
you
a
clearer
path
forward
here.
B
B
B
Yeah
this
stuff
all
needs
to
get
this
stuff
will
all
get
consolidated.
So
I
think-
and
this
just
hit
on
this
again-
because
I
don't
think
we
quite
quite
did
it,
but
you
know
how
we're
like
with
the
location
stuff.
We
now
have
another
place,
so
we
have
the
data
flow
source.
We
have
the
data
flow
running
stuff
and
then
we
have
the
run
data
flow
operation
and
we
have
the
model,
saving
and
loading.
All
of
these
are
places
where
you
know
where
we
are
taking
a
data
flow
and
we're
executing
it.
B
I
think
that
what
we'll
probably
get
to
is
we're
going
to
go
through
and
consolidate
all
of
those
places
to
actually
call
through
the
run
data
flow
operation
eventually
and
that
way
anytime,
you
run
a
data
flow
you're.
You
know
you're
leveraging
the
same
code
right
because,
what's
going
to
end
up
happening
pretty
quickly,
here
is
you
know
we
already
have
seen
it
in
the
dataflow
source
and
the
existing
data
flow
source
and
in
the
existing
command
line.
Interface
code-
and
I
think
in
http
service
code-
is
that
we
have
to
it's
like.
B
B
Eventually
and
then,
like
we
talked
about
with
this,
you
know
you
know
everything
is
sort
of
a
plug-in
right
and
this
will
have
to
do
with
the
unified
config
is
once
we
can
get
the
config
a
little
more
unified
to
where
operations
you
know
individual
functions
and
operations
and
stuff
like
that,
look
more
like
the
rest
of
our
classes,
then
anytime
we
want
it.
You
know
we
have
something
that
needs
to
to
take
a
data
flow.
It
will
take
a
configured
run.
Data
flow
instance
right
because
that
configured
run.
B
B
Yeah,
I
think
you
need
to
write
a
new
data
flow
source
is
what
I'm
saying.
I
think
that
you
can
borrow
some
of
the
code
but
you're.
Essentially,
writing
a
new
data
flow
source
right,
so
I
I'm
this
you're
right.
So
so
the
way
you
should
think
about
this
I
mean
you're,
writing
a
new
source
right,
so
you're
implementing
the
record
method
and
the
records
method,
and
you
can
probably
leave
off
the
update
method
for
now
right.
B
Actually,
in
fact,
I
would
just
say,
raise
not
implemented
error
during
in
the
record
method
and
in
the
in
the
update
method
and
then
only
implement
the
records
method
right
now.
Right,
because
that's
the
only
thing
that
matters
for
your
use
case
at
this
point
right,
so
so
for
a
path
forward
here,
so
cleanup
operation
so
implement
a
new
source,
raise
not
implemented
error
in
dot
record
and
dot,
update,
implement
dot
records
to
be
to
run
a
data
flow
provided
via
the
config.
B
Then
then,
you
should
be
able
to
index
easily
and
stuff
right.
So
if
you
were
and
so
then
you
need
to
figure
out
so
you
have
all
of
your
at
this
point
you
you
would
have
loaded
in
all
your
stuff
into
a
giant.
You
know
an
array
of
array
or
an
array
of
objects
or
an
array
of
arrays
right
once
you
implement
that
that
operation
and
you're
running
that
operation
from
this
data
flow,
which
you're,
which
you're
running
from
your
new
source,
yes
and
when
so
you
need
to
figure
out
okay.
E
What
like
we
have
this
source
right
and
we
will
take
all
the
data
from
the
source.
We
will
do
pre-processing
on
it
and
we
will
save
the
pre-process
data
in
the
same
source,
format
and
and
then
I'm
thinking
we
don't
have
to
do
indexing
or
anything
like
that.
We
can
just
take
the
data
from
the
source
and
do
the
training
on
that.
B
Well,
you
don't
have
to
do
that
either
way.
Right,
like
that's
just
I
think,
for
the
sake
of
a
tutorial,
it's
nice
to
show
the
merge
command
right,
because
that,
basically
you
know,
then
you
can
cat
the
output
of
the
csv
file
and
you
can
show
them
that
the
data
changed
right
and
then
you
can
show
them
that
they
train
on
it
right
the
the
modified
data
right.
B
B
Okay,
because
I
think
so
I
think
your
output
layer
might
be
similar
here.
I
think
you're-
probably
gonna
not
have
that
input
layer,
type
of
thing
right-
that
input
layer
becomes
this
operation
that
loads
all
the
data
from
the
source
right
and
then
the
output
layer
is
still
okay.
Now
the
output
layer
is
okay.
How
do
I
select
you
know?
How
do
I
turn
these
things
into
records
now.
B
Or,
like
you
know,
how
do
I
return
probably
dictionaries
that
then
you
know
in
the
source
itself.
I
now
interpret
each
dictionary
in
some
kind
of
list
that
gets
output
as
a
as
a
record
rate,
which
I
then
yield
okay
cool.
So
let's
have
another
meeting
on
on
friday.
Just
because
I
want
to
make
sure
that
we're
all
you
know
we're
all
making
progress
here
and,
and
nobody
gets
stuck.
You
know
I
want
to
make
sure
everybody
can
can
finish.
B
You
know
all
the
stuff
that
they
set
out
to
so
obviously
you
know
we
can
do
stuff
after
gsoc.
That's
always
good,
but
let's
try
to
get
this
stuff
done
here,
while
we're
at
it.
Okay,
so
and
please
reach
out
to
me,
and
also
please
ping,
you
know
saksham
and
yash
and
himachu.
If
you
guys
need
extra
input.
Okay,.