►
From YouTube: Weekly Sync 2021-01-12
Description
Meeting Minutes: https://docs.google.com/document/d/16u9Tev3O0CcUDe2nfikHmrO3Xnd4ASJ45myFgQLpvzM/edit#heading=h.lduy7p64intm
B
B
This
is
internal
compliance
stuff
that
I
have
to
do
for
intel
so
yeah,
so
so
so
the
last
thing,
but
but
that
resulted
in
in
the
upgrade
of
tensorflow
2.4,
got
to
make
sure
to
use
the
latest
versions
of
things
and
so
in
the
process.
Upgrading
to
tensorflow
sensor
flow
2.4
transformers
then
needs
to
be
updated,
and
when
you
update
transformers
to
the
4.x
release,
then
things
break.
So
it's
a
major
version
change.
B
So
basically
we're
gated
by
issue
844
right
now,
so
so
himachu
said
that
he'd
look
into
that.
I
think
he's
looking
into
it
and
then
then
we'll
be
able
to
roll
the
next
release.
So
so,
and
and
if
he
doesn't,
then
I
don't
know
we
can
try
or
we
can
try
to
see
if
there
is
a
3.x
transformers
release
that
supports
tf,
2.4,
so
yeah,
I
don't
know
about
that.
One
though
it
would
be
yeah
who
knows,
maybe
they
have
a
3.x
version
that
supports
2.4,
we'll
we'll
find
out.
B
B
B
We
break
api
all
the
time
so
because
we
gotta,
we
gotta
figure
everything
out
first,
and
I
think
just
on
that
note,
I
think
I
think
we're
gonna
try
to
have
we're
going
to
try
to
stabilize
things
for
beta,
which
is
going
to
be
the
next
one
which
is
going
to
include
that
accuracy
scoring
stuff
suit.
Honshu
is
working
on,
but
we
aren't
there
yet
so
things
are
still
in
flux.
B
So,
if
there's
major,
basically,
what
that
means
is
is
if
there's
major
changes
to
the
way
that
we
call
functions
or
you
know
we
define
classes
and
things
like
that.
We
have
the
command
line.
We
will
try
to
we
we're
open
the
project.
Dffml
is
a
project.
We
can
change
whatever
we
want
right
now,
but
then
eventually
once
we
say
that
we're
not
going
to
make
api
breaking
changes,
so
I
was
thinking
beta
would
be
a
good
place
for
that.
B
Then
we're
going
to
we're
going
yeah
we're
going
to
stop
making
big
changes
to
command
line
flags
and
stuff
like
that,
because
people
will
expect
that
it
doesn't
change
between
minor
version
numbers,
which
would
be
everything,
that's
not
the
first
version
number
so
and
and
and
that
way
people
can
safely
upgrade
these
two
numbers
of
dffml
without
having
to
worry
about
any
of
their
code
breaking
and
then,
when
we
upgrade
that
the
first
number.
That
means
that
hey
your
code
might
break.
B
A
B
B
E
E
B
B
B
B
Okay,
great
yeah,
I
think
I
might
have.
I
think
I
saw
that
and
then
I
think
I
clicked
on
it
and
then
it
became
you
know.
It
tells
me
that
there's
no
notification
in
there
anymore
and
then
I
forget
about
it.
So
sorry,
let's
see
all
right
great,
okay,
yeah,
let's
go
over
that!
First,
it's
definitely!
Oh!
Oh!
That's
right!
B
B
We
we've
verified
that
all
of
these
versions
of
all
of
our
dependencies
work
together
and
since
we're
installing
so
many
dependencies,
we
can
easily
end
up
in
a
situation
where,
if
somebody
upgrades
something,
then
all
our
users
can't
install
the
end
package
so
we're
going
to
pin
all
of
the
versions
when
we
do
a
release
this
time,
and
that
means
it's
going
to
be.
You
know,
package
name
equals
equals
the
specific
version
number
in
all
of
the
requirements.
Txt
files.
B
This
has
upsides
and
downsides,
but
the
the
target
audience
here,
I
think,
will
will
benefit
more
from
this.
So
so
we're
gonna
we're
gonna,
pin
it
just
because
that
way,
no
one
has
to
wonder
why
anything
is
not
working,
and
if
they
don't
like
the
pinned
version,
then
they
don't.
They
can
do
this
in
a
virtual
environment.
B
B
So
if
you
type
dfml
service
dev-
and
you
guys
probably
use
this
to
create
modules
and
stuff,
but
this
is
the
this-
is
the
code
in
here
that
yeah
here's
the
creation
module
creation
code?
Let's
see
so
there
is
a
command
in
here.
That
does
the
pin
depths.
I
think
it's
at
the
end.
Yeah
pin
depth
all
right.
So
what
this
does
is
it
goes
through
and
it
looks
at
a
log
yeah
it
looks
it.
Does
it
look
at
the
archive
or
does
it
look
at
the
file?
B
I
can't
remember
we
have
a
test
for
it,
but
yeah
okay,
so
it
looks
at
a
single
file.
So
right
now
I
added
to
this
to
the
ci
run
in
the
in
the
main
package,
where
we
install
every
single
package
where
it'll
dump
it'll,
say:
pip,
freeze,
right
and
pip
freeze
dumps
every
single
version
of
every
python
package
that
you
have
installed
so
it'll
say
you
know
all
of
the
package
names
equals
and
then
all
of
the
the
versions
for
each
one,
and
so
what
we
do
here
is
we.
B
We
read
that
file
or
we
read
that
the
log
file
containing
that
dump
this.
We
read
the
output
of
the
ci
job
and
when
and
and
then
we
go
and
we
read
all
of
the
requirements,
txt
files-
and
we
basically
say
okay
for
each
line
in
the
requirements
txt
file.
Each
time
you
find
a
package
go
look
up
what
what
the
installed
version
of
that
package
was
in
the
ci
job,
because
then
we
know
that
you
know
we
know
we
can
safely
pin
that
package
to
that
version.
B
So
the
issue
comes
in
here
right,
where
we've
added
a
new
model,
and
so
now
this
model
is
not
present
in
that
old
ci
run.
So
so
the
question
here
is:
what
do
we
do
and
so
there's
a
the
the
test
case.
The
issue
is
that
the
test
case
is
failing
right,
because
the
ci
run
that
the
test
case
is
based
off
of
doesn't
contain
the
new
it's
an
old
old
log
file
right.
So
we
have.
We
have
a
couple
options
right.
E
B
New
commit
whenever
we
make
a
model
like
whenever
we
have
a
pull
request
that
adds
a
new
model.
We
could
have
a
commit
in
that
pull
request,
which
updates
the
test
case
here
to
to
to
the
log
file
for
that
pull
requests
the
plugin
equals
dot,
which
is
going
to
be
the
the
main
domain
suite
that
that
installs
every
package.
So
we
can
update
the
log
file
to
be
that
one,
and
then
it
would
include
all
the
version
numbers.
B
B
So,
and
let
me
just
find
out
where
that
is
here
so
point
you
right
at
it
yeah,
okay,
here
it
is
so
basically
oh-
and
this
is
so
here's
here's
a
trick
that
I
use
frequently
if
you
need
to
include
if
you,
if
you
want
to
include
something.
So
if
you
have
a
file
that
you
don't
want
to
add
to
a
git
repo,
you
can
drag
it
into
a
github
issue
and
then
it'll
upload
it
and
you
can
even
delete
it
from
the
text
of
the
issue
and
it'll
stay
there.
B
So
what
you'll
do
is
you
want
to
look
at
the
you
want
to
go,
but
we'll
just
go
through
the
process
right
now
and
then
we'll
have
it
on
video.
So
all
right.
So
when
we're
adding
a
new
model,
we
have
to
update
the
service
dev
pindeps
test
case
to
point
at
the
new
to
point
at
the
logs,
which
contain
the
installed
versions
of
that
model's
dependencies.
A
B
And
say
yeah:
this
is
the
test
case.
That's
failing!
So
we
look
at
the
raw
logs
and
we
should
see
a
bunch
of.
We
should
see
a
pip
freeze
command
pretty
soon
here.
So
the
test
case
for
the
main
package,
which
is
plug-in,
equals
dot,
which
is
just
dffml
itself,
goes
through
and
it
does
service
dev
install.
B
And
that
will
install
every
single
dependency,
so
all
of
our
plugins
that
we
have
and
okay,
I
don't
think
we
made
it
through
the
main
test
suite
all
right.
This
is
a
problem.
Okay,
so
yeah.
It's
failing
it's
failing
out
here
before
we
install
the
plug-ins.
So
oh
wait,
no
yeah!
It
is
failing
now
yeah,
because
this
is
the
old
plugin.
So
because
all
right
so
the
way
that
the
test
suite
works
is
we
run.
B
We
run
it
once
without
any
of
the
plugins
installed,
and
then
we
run
it
again
when
once
we've
installed
the
plugins,
so
we
need
we.
We
need
to
change
all
right
and
let
me
just
show
so:
here's
run
plugin.
So
this
is
the
function
that
runs
the
test
suite
for
a
given
plugin
right,
and
so
this
is
dot,
meaning
that
runs
it
based
on
the
directory.
So
this
is
the
top
level
directory,
which
is
our
main
package.
B
So
it's
it's
not
a
plugin,
and
this
is
let's
see
yeah,
so
it
does
it
does
that
it
runs
the
test
and
then
it
says:
okay,
if
we
are
not
in
the
main
package
run
whatever
you
know.
Examples
there
may
be
so
if
we're
in
like
model
tensorflow,
it'll,
look
in
the
examples
directory
and
it
will
run
any
tests
that
might
be
in
the
examples
directory
of
model
tensorflow,
so
model
slash,
tensorflow
examples.
B
If
we
are
in
in
the
root
directory,
then
we
want
to
go
through
and
we
want
to
run
the
the
tests
for
each
create.
So
we
go
and
we
create
you
know
all
of
the
the
various
plugin
types
that
we
can
create,
there's
stuff
in
dffml,
skel
and
then
there's
a
directory
for
you
know
that
this,
the
stuff
that
you
might
use
when
you're
creating
a
new
model.
B
Why
is
there
no
pip
freeze
all
right?
Oh
here's,
the
pip
freeze,
it's
at
the
very
end
yeah.
So
this
this
is.
The
issue
is
that
this
test
case
that
checks
for
the
presence
of
all
the
plug-ins
that
you're
able
to
freeze
them
runs
here
and
the
pip
freeze
runs
at
the
end
after
we've
installed
everything,
so
we
could
look
at.
Actually,
I
think
we
can
look
at
the
docs.
B
B
So
if
we
add
pip
freeze
there,
then
we
can
use
the
log
file
from
the
docs
ci
job
and
that
will
you
know,
give
us
a
list
of
all
the
dependencies
in
and
their
interrelated
versions
that
that
work
together
and
then
we
can
upload
the
log
file
for
the
docs
right.
So
just
like
how
we
went
here-
and
we
did
view
raw.
So
basically
you
just
download
this
file
and
put
it.
Where
is
that
github
issue?
B
History
is
all
good
so
that
we
can
rebase
this
in
and
then
create
a
fresh
commit
that
just
changes
this
log
file
and
it's
sha,
so
that
we
can
so
that
then
this
test
will
pass
and
that,
I
think,
will
be
what
we
need
to
do
here
and
then
and
we'll
we'll
formally
document
this
process
after
we've
done
it
once
to
make
sure
it
works,
but
we
yeah
so
this
this
is.
This
is
a
bit.
B
B
B
A
B
B
Pin
depths
test
to
point
at
the
new
file
with
the
new
hash
for
that
file,
all
right
yeah,
so
it's
not
as
much
work
as
that
all
sounded.
I
just
wanted
to
give
some
background
there.
So
this
is
it's
really
basically
like
a
couple
lines.
I
think
there's
like
four
lines
here
that
need
to
be
changed.
You
add
two
lines
and
then
you
modify
two
lines
and
you
upload
the
file
so
yeah,
it's
it
should
be,
should
be
pretty
pretty
pretty
easy.
B
C
B
C
So
that's
what
sdf5
config!
Basically
it's
like
a
directory
kind
of
stuff,
so
I
just
take
a
file
name:
that's
the
dot,
sdf,
the
path
of
dot,
htf5
file,
name
and
then
in
that
file
we
have
a
group
path.
That's
basically
act
like
a
directory,
and
in
that
directory
there
is
a
numpy
kind
of
data
data,
that's
known
as
data
set.
So
I
just
take
data
set
as
a
config
and
read
and
write
allow.
So
now,
I'm
just
doing
a
load
fd
function
just
because
dump
fd.
I
have
to
work
on
that.
C
So
basically,
here
I'm
just
reading
hd
from
hdpy
the
file
that
is
passed
at
the
in
the
config
of
file
name
and
then
go
to
the
group
path
and
from
that
group
I'm
just
extracting
the
data
set
and
just
loading
that
data
set
on
that
memory.
That's
it!
So
that's
what
I'm
doing
in
the
load
fd
part
right
now
and
it's
it's
working.
Fine
here
still
look
command
yeah.
Actually
I
forget
the
command,
so
I
have
to
search
in
the
history
part.
So
that's.
What
is
it
this
source
file
name?
C
B
All
right
cool,
great
you're
off
to
a
good
start
here.
So
let's
see
so
a
couple
things.
I
know
I'm
putting
these
in
the
minutes,
but
minor
thing
style
wise
with
python.
Generally,
let's
try
to
stick
to
underscores
instead
of
camelcase
unless
we're
doing
a
class
name.
So
group
path
would
be
group,
underscore
lowercase,
p
path
and
then
there's
something
like
that:
yep
snake
case
right.
C
B
Yeah,
so
this
is
this,
is
this
would
be
yep
yeah,
okay,
so
and
okay,
and
then
the
other
thing
is
so.
It
looks
like
you
probably
followed
the
file
source
tutorial,
which
is
definitely
it's
so
you
got
it
working,
which
is
I'm
very
excited
about.
The
only
thing
is
that
the
file
source
tutorial
is
meant
to
be
for
loading
into
memory
right,
and
I
think
we
had
talked
about
the
fact
that
that
you
know
these
files
probably
are
are,
are
pretty
big
here.
B
You
know
sometimes,
and
so
we
probably
don't
want
to
load
the
whole
thing
into
memory
at
once,
right,
so
what
we
would
like
to
so
so
that
and
that
and
that's
what
the
the
file
source
does,
and
so
we
should
probably
make
that
more
clear,
so
make
a
file
source
tutorial
and
because
I
think
this
is
actually
one
of
the
things.
We
noticed
last
time
that
this
was
not
clear.
So.
C
B
Okay,
so
we
can
load
data
set
in
chunks,
okay,
so
all
right,
so
we
want
okay,
so
just
real
quick.
This
is.
This
is
a
great
first
start
here
we
do
want
to
make.
We
do
want
to
use
the
basically
the
other
tutorial,
the
complex
source
tutorial,
because
we're
gonna
you're
gonna
want
to
implement
that
this
abstracts,
the
the
this
abstracts
the
source
stuff,
so
that
it
can
be
backed
in
memory
pretty
easily.
But
we
don't
wanna
back
this
in
memory.
B
B
B
I
think
that's
going
to
be
that's
going
to
be
what
you
want
to
do
here:
yeah
and
okay,
we'll
explore
as
a
side
note
to
that
we're
going
to
explore
how
we
might
be
able
to
make
this
make
it
more
async,
io
friendly,
because
file
I
o
in
in
python
is,
is
there's
no,
they
don't
they
don't
put
it
through
async.
I
o,
unless
there's
there's
third-party
modules
to
do
it,
but
but
they
they
don't.
I
don't.
B
There
should
be
a
way
to
do
that,
but
they
don't
do
it
yeah,
okay
and
so
yeah.
Let's
take
a
look
at
the
complex.
Why
don't
you
take
a
look
at
the
complex
source
tutorial
and
it's
not,
I
think
it's
kind
of
brief.
Let's
see
yeah
sources
so
yeah
on
the
sidebar,
if
you
scroll
down
on
the
sidebar
or
if
you
just
go
and
hit
next
yeah
example:
sql
light
source.
B
B
F
B
You
know,
whatever
whatever
you're
doing
here,
which,
with
hdf5
so
you're,
going
to
replace
the
body,
but
so
so,
basically
you
can
copy
this
stuff.
You
know
remove
things
in
the
body
and
and
make
it
make
it.
You
know
make
it
like
what
you're
doing,
and
so
one
thing
of
interest
here
is
going
to
be
that
those
a
inter
methods.
B
So
if
you
scroll
down
to
the
the
custom
sql
light
source,
so
the
body
of
that
a
enter.
So
what
happens
here
is,
I
think
we
might
have
talked
about
this
a
little
bit
last
week,
but
so
within
dffml.
Everything
follows
this
double
context:
entry
pattern
and
that's
why
we
have
a
class
and
then
we
have
a
class
context.
B
B
So,
first
we
enter
base
sources
context,
and
that
means
we
call
the
a
inter
method
of
base
source
and
then
we
call
the
a
exit
or
we
call
the
a
inter
method
of
base
source.
Now,
once
we
call
the
a
inter
method
of
base
source,
then
we
call
the
a
inter
method
of
base
source
context.
So
now,
first
we
enter
enter
so
we
do
with
on
base
source,
so
we
say
async
width
base
source.
B
Then
we
do
async
with
base
source
context
so
and
when
you
do
async
with
that
means
you're
calling
the
a
inter
method.
So
that's
that's,
that's
the
width
blocks
essential,
a
with
block
when
you
say
width
and
then
a
class.
It
just
calls
the
inter
method
and
if
you
do
async
with
it,
calls
the
a
inter
method,
and
so
what
we're
doing
here
is
we're
making
a
connection
to
the
sql
lite
database
and
that's
just
a
file,
and
so
with
aio
sql
lite.
You
end
up
doing
a
wait.
B
So
if
you
wanted
to
do
a
with
statement,
you
would
do
right.
If
you
had
a
with
statement,
you
would
effectively
call
the
inter
method,
and
if
you
had
an
a
sync
with
statement,
you
would
effectively
be
calling
the
a
inter
method.
So
when
you
look
so
why
don't
you
pull
up
the
documentation
for
a
I
o
sqlite
right
now,
just
google
for
it,
because
this
is
going
to
be.
C
B
B
All
right,
okay,
so
check
this
out.
So
you
see
how
so
you
see
how
it
says:
async
with
aio
sql
like
connect
as
db,
so
the
equivalent
of
that
is,
if
you
flip
over
to
the
source,
we
were
just
looking
at
in
dfml,
so
you
it
looks
so
we're
making
a
call
to
aio
sqlite
connect
and
then
we
we
do
async
with
on
the
result
of
that
call
and,
and
the
result
of
that
is
as
db.
B
B
B
F
B
An
open
method-
but
this
is
this-
is
this-
is
designed
to
be
sort
of
your
and
you're
going
to
basically
copy
paste
it.
So
this
is
designed
this
is
written
as,
if
you're
going
to
copy
paste
it,
which
you
essentially
you
pretty
much,
are
so
see
how
they
had
that
they
had
that
acquire
a
aio
sqlite
connect
call
and
then
they
used
they.
They
had
async
with
aio
sqlite
connect
as
db
right,
so
they
called
the
connect
function
and
then
so
we're
we
call
the
connect
function.
B
I
o
based
module,
it's
a
regular
module
right
and
and
if
you're,
not
async
io,
if
things
aren't
defined
with
async
def
you're
not
going
to
put
the
weight
and
that's
sort
of
that's
just
a
general
rule
right.
So
if
you
have
a
function,
that's
defined
async
def.
Then
you
have
to
call
the
function
and
p
prefix
it
with
a
weight.
If
there's
no
async,
then
you
have
no
weight.
So
does
that
I
know
that's
there's
a
lot
going
on
there.
Does
that
make
sense.
B
And,
and
if
that
so
this
is
probably
going
to
be
the
trickiest
part
right
here
and
I
would
just
sort
of
I
would
watch
the
recording
again
and
and
on
the
a
exit
you
basically
just
will
do
self
underscore
underscore
db,
underscore
underscore
exit
underscore
underscore
and
then
you're
not
going
to
pass
it
any
of
those
values.
So
because
a
exit
is
async
and
and
the
other
one
is
not
async.
So
you
can't
pass
it
the
same
values:
okay,
yeah.
That
should
do
it
for
you.
B
If
you're
struggling
with
the
a
inter
method
and
the
a
exit
method,
here,
don't
implement
them
and
then
you
can
just.
I
would
start
with
just
doing
the
records
method
and
basically
copy
what
you
had
in
load
fd
into
records
and
then
modify
it
so
that
you're
yielding
a
record
for
for
each
each.
You
know
each
record
that
would
be
in
the
source,
so
that
yields
a
record.
B
Let's
see
yeah,
I
think
you
know,
try,
try,
try
to
put
it
into
this
format
and
see
how
it
goes
and-
and
just
you
know,
keep
me
in
the
loop
there's
not
a
lot
of
you
know.
We
don't
have
a
lot
of
data
sources,
so
there's
not
a
lot
of
information
to
go
on
here.
So
we
want
to
make
sure,
keep
keep
me
in
the
loop
and
and
we'll
try
to
make
sure
that
this
is.
You
know
as
clear
as
possible,
and
then
we
can
update
the
documentation
appropriately.
B
B
B
C
A
B
B
B
B
So
I
think
what
happened
there
was
we
need
to
have
that
raw.
We
need
to
declare
the
doc
string
as
a
raw
literal,
which
means
we
need
to
prefix
the
block
comment
with
a
the
letter
r.
So
it
basically
is
the
letter
r
and
then
quote
quote
so.
If
you
go
into
the
light
gbm
model
definition,
the
class
just
go
prefix
that
with
the
r.
B
B
C
B
Okay,
great
yeah
rebase
in
master
and
then
because
I
think
the
thing
is
that
I
added
I
changed.
I
changed
the
way
the
docs
get
built
recently,
so
that
we
make
sure
to
build
every
plug-in
that
we
have
and
before
that
we
had
to
manually
add
all
the
plug-ins
to
this
list
of
plugins
that
we
wanted
to
include
in
the
documentation.
B
Now
it's
just
going
to
include
any
any
dfml
plugin,
that's
installed
into
the
documentation,
and
so
that's
why
the
ci
job
was
still
passing.
Even
those
failing
here
because
you
were
you
were
you
had
the
you
had
it
installed
and
and
we
switched,
we
switched
over
to
building
everything
that
was
installed
and
since
you
were
building
from
the
master
branch
version
of
the
docs,
it
was
like.
Oh
light,
gbm
is
installed.
Let
me
go
build
that
and
then
it
failed
all
right,
cool.
A
B
F
B
B
Okay,
great
all
right,
perfect,
so
shaw:
let's
see,
let's
talk
about,
let's
talk
about
the
nlp
models
and
then
we'll
talk
about
the
dependency
issue,
because
we'll
just
work
through
that
and
and
if
the
other
people
need
to
drop,
they
can
drop
so
yeah.
So
what
did
you
want
to
talk
about
with
nlp
models?
You
said
how
we
evaluate
them.
E
B
Okay,
if
we're
talking
about
assess
the
accuracy,
I'm
gonna
say:
don't
do
it,
because
I
think
sudhanshu
is
getting
really
close
on
that.
So
I
think
we're
just
not
gonna
worry
about
accuracy
stuff
for
now,
because
I
I
don't
I
don't
want
to
have-
I
don't
want.
I
don't
want
us
to
do
work,
that's
going
to
get
wiped
out
within
a
matter
of
weeks,
so
I
think
don't
worry
about
it.
It's
my
response
to
that,
because
we're
going
to
implement
multiple
ways.
B
E
B
B
Oh,
oh,
I
clicked
share
and
then
I
didn't
select
which
screen
to
share.
Thank
you
all
right.
Okay,
so
I
put
together
a
little
demo
and
this
is
the
master
docs
and
here's.
I
posted
this
on
getter,
but
now
it
says
the
commit
so
yeah.
I
put
together
this
little
example
and
the
main,
the
main
point
of
this
example
is
to
illustrate
sort
of
just
the
python
api
and
stack
feature
stacking
now
here
it
is-
and
so
here
here
this.
Let's
put
this
here.
B
B
Okay,
so
yeah
you,
you
feel
free
to
take
this
issue,
so
yeah
create
a
new
model
and-
and
somebody
there's
this
package
darts-
was
it
darts
yeah.
I
just
saw
that
I
checked
the
trending
github
page
every
day
in
case
there's
something
that
that
means
that
we
have
to
do
less
work,
and
this
is
that
so
for
casting
okay.
Here
we
go
so
check
this
guy
out.
This
basically
is
a
wrapper
on
on
top
of
profit
and
sk
time
and
a
few
other
forecasting
things.
B
I
think
sk
time
is
another
thing
that
we'll
want
to
do
eventually,
but
I
do
all
I
did
was
quick
scroll
it
at
about
this
pace
through
that
read
me,
so
I,
if,
if
this
turns
out
to
to
not
be
something
that
that
is
good,
then
then
that
that's.
Why?
Because
I
have
not
done
much
looking
at
it,
it's
just
it
looks.
It
looks
from
from
a
screenshot
of
this
page.
I
would
say
this
is
something
that
we
could
use
so.
E
B
Yeah,
do
I
mean
do
whatever
right
so
so
sk
time
is
good
and
and
the
the
for
your
format's
going
to
be
similar
right
to
basically,
you
know
create
the
model
yeah,
so
you
you've
got
the
gist
of
it.
So
yeah
I
mean
feel
free
to
go
for
that,
and
then
I
did
put
up
this
covet
data
example,
which
shows
how
I
wrapped
I
wrapped
profit
and
speaking
of
accuracy.
I
just
didn't
implement
it,
and
I
think
I
put
a
little
note
in
that.
B
Oh
no,
I
added
to
the
model
tutorial
saying
that
don't
worry
about
the
accuracy
method
so
much
because
we're
going
to
be
getting
rid
of
it.
Where
did
it
yeah
there?
It
goes.
I
I
mentioned
explicitly
sudhanshu's
project
right
here
in
the
tutorial
too
the
other
day
but
yeah.
So
you
can,
I
mean,
go,
go
for
go
for
sk
time
go
for
this,
but
yeah.
I
think
some
forecasting
stuff
would
be
good
to
add
in
in
you
know,
having
some
forecasting
models.
The
sk
time
I
know,
is
really
good.
B
This
one
just
popped
up,
so
I
added
it
because
I
try
to
add.
You
guys
see
models,
you
know
just
throw
you
see
interesting
machine
learning,
frameworks
or
things.
You
know
just
throw
an
issue
up,
because
chances
are,
somebody
can
soon
can
wrap
it.
You
know
and
and
then
we
we
have
more
models
to
expose
right.
So
we
want
to.
We
want
to
create
a
giant
library
of
models
for
people.
All
right
is
that
does
that?
Suffice
to
answer
your
question
there.
Basically,
yes
do
it.
B
Yeah
I
mean
I
mean,
create
I
mean
yeah.
So
when
I
say
rap
I
mean
you
know,
implement
a
model
class
that
uses
the
library
that
we're
talking
about
right.
So
I'm
I'm
saying
rap
because
we're
leveraging
the
you
know
the
computational
stuff,
that's
being
done
by
another
library,
which
is
our
dependency.
B
B
B
A
B
A
B
E
B
A
B
Oh
yeah
feature,
so
this
just
needs
to
change
because
I
think
yeah
the
and
I
updated
the
model
tutorial
too
recently,
but
just
make
model
feature
into
model
features
because
I
believe
we
changed
yeah.
The
config
has
features
it's
a
feature.
So
just
add
the
s
everywhere
and
I
think
you're
good
to
go.