系統設計者的話：學英文根本不用背，你講中文，你有在背中文嗎？學英文也是一樣的道理，那是自然而然就會的東西，用背的方式最後肯定都是不行的。 更多...

最好的學習就是有英文的父母，不斷的跟你說話、耐心的教導你，時間長了，你也就慢慢就融入其中了。

但是我們沒有英文父母怎麼辦？看影片學英文就學的起來嗎？學不起來。

我們從小到大，也看過了不少英文電影，至少也看過1、200部也跑不掉，但是為什麼看了這麼多的英文電影，英文還是很爛呢？

主要的原因是我們沒有從基礎性的強化學習。舉個例子，西方的幼兒出生時，他至少聽了各種大人講英文至少聽了2年，才慢慢開始說英文、與大人互動。

而且都是一字一句慢慢的說、慢慢的教、漸進式的、慢慢的、越來越習慣、越來越聽的懂、越來越會說的過程。

那麼我們看的影片、電影過程中，都是大人成熟型的講話速度、方式、語調，我們怎麼可能跟的上？

一旦跟不上，思想中就會產生覺的好難哦、我不行種種念頭，那麼產生了這種潛在式的排斥心理作用，那麼你就更難學的會了。


所以我們必須打好基礎、深厚的基礎，萬丈高樓平地起，唯有打下深厚的基礎，後面你走的路才會越來越順。

程式界裏有句話，程式債欠的越多，最後就只能放棄。學英文也是一樣，英文單字債欠的越多，你就直接上來文法、句型、語調，最後也只能放棄。

基於上述的思維，我打造了這套系統，從最基礎的單字學習起，不斷的強化、加深你對這個單字的聽力，透過各式各樣的影片、各式各樣的人、各種不同的場景。

就只是為了訓練一個單字的聽力，無數的人跟你講同一個單字，講個20遍、50篇、100遍(且不重覆)，我就不信學不起來。


這套系統做出來後，我自己在使用的過程中，確實真的能聽出來他們講的這個單字，而且他們講的速度再快也能聽的出來。

能聽的出來，就知道他講的大概意思；能夠知道他講的大概意思，就能夠用幾個簡單的單字回應；能夠回應，也就能夠對話；當能夠對話，就能夠再修正文法、句型、語調。


我的目地就是希望自己至少能聽的懂人家在說什麼，用英文跟人家對話，大家共同努力、學習。若有其它想法或對這套系統設計的建議，也可以與我聯絡：ichich2013@gmail.com

XLA: TensorFlow, Compiled! (TensorFlow Dev Summit 2017)
觀看次數：685
tensorflow
extensible
and
we've
heard
about
some
of
interpretive
nature
it's
in
the
name
tensorflow
it
uses
this
dataflow
those
nodes
and
executes
them
so
that's
contraflow
it's
dynamic
and
this
is
owed
expressiveness
when
you
define
your
graph
and
you're
not
constrained
by
some
like
you're
used
to
programming
in
other
environments
and
it's
black
box
modular
flow
that
the
original
sensor
flowed
exemplified
what
we're
going
for
with
compilation
via
xla
which
stands
for
compiler
infrastructure
that
we've
video
you'll
see
the
tensorflow
shell
as
the
excellet
assembly
that's
produced
so
we're
pasting
in
a
very
simple
four
floating-point
numbers
and
explicitly
on
to
the
excel
a
cpu
device
one
mode
inside
of
tensorflow
code
on
the
excel
a
underscore
gpu
bit
more
boilerplate
because
it's
launching
multiple
threads
and
thread
launching
for
gpu
threads
and
I
am
at
runtime
in
the
tensor
flow
graph
and
and
gpu
works
in
standard
tensorflow
could
do
with
compilation
there's
a
lot
i've
said
just-in-time
compiler
so
what's
this
just-in-time
stuff
all
about
runtime
so
when
I
type
in
a
tensor
flow
that
it's
defined
so
you
get
to
tensorflow
development
to
the
gist
of
this
a
just-in-time
compilation
so
if
we
top
talk
but
excellet
slots
into
the
tensor
flow
ecosystem
here
on
the
bottom
capabilities
where
we'll
find
clusters
explicitly
onto
on
devices
as
we
showed
complementary
attributes
so
the
benefits
of
compilation
on
the
flip
side
so
tensorflow
actually
handles
all
of
the
after
the
comp
the
compiled
easier
to
targets
a
new
exotic
devices
so
through
this
jit
compilation
and
specialization
that
we've
talked
about
we
see
model
shapes
benchmark
whims
of
looking
micro
benchmarks
see
roughly
in
extreme
in-house
example
we
saw
a
syntax
net
get
latency
reductions
from
around
200
microseconds
to
5
microseconds
and
some
latency
overhead
and
by
compiling
just-in-time
compilation
but
you
can
much
of
the
tensorflow
runtime
and
for
arm
powerpc
and
x86
cpu
platforms
so
from
26
megabytes
to
less
than
600
we'll
optimizer
that's
able
to
look
at
a
reusable
toolkit
of
global
optimizations
other
exotic
devices
we've
parameterised
optimization
toolkit
level
and
so
you're
so
that
if
there's
some
optimization
optimizations
in
the
toolkit
for
involvement
and
prioritization
we
workload
so
to
recap
to
go
over
the
benefits
of
compilation
we're
able
to
compiler
dispatcher
overhead
we're
able
to
fuse
we're
able
to
make
compile-time
unroll
and
vectorize
which
are
some
key
optimizations
for
today's
modern
value
and
by
specializing
for
it
we're
optimizations
that
modern
cpus
and
gpus
fundamentally
an
extra
layer
gram
is
a
set
of
static
decomposed
tensor
flow
value
but
then
softmax
that's
kind
of
implemented
hand-coded
and
c++
in
in
softmax
has
inside
it
has
dots
and
adds
and
reduces
and
exps
decomposition
taking
the
macro
operation
to
generate
diffused
an
optimized
expressible
in
tensor
flow
all
those
tensor
flow
operations
together
so
we're
also
able
to
avoid
combinatorial
primitives
inside
the
macro
operation
back-end
cpu
gpu
different
platforms
for
a
llvm
pipeline
and
a
runtime
plugin
gpu
backends
are
effectively
using
these
use
jit
compilation
when
you're
prototyping
you
get
to
use
compilation
you're
not
compiling
every
time
you're
hitting
in
a
compilation
cache
that
says
ah
here's
the
specialized
and
optimized
embedded
devices
and
for
latency
mobile
and
embedded
devices
this
can
be
flow
ecosystem
so
Todd
contraflow
integrates
with
excel
eh
directories
for
the
code
right
there's
four
directories
down
here
and
i'm
going
unsurprisingly
this
is
sort
of
a
when
we
talk
to
compiler
people
it's
the
graphs
or
like
lowering
the
graphs
different
representations
but
at
the
end
open
source
compiler
toolkit
sort
of
is
that
like
it's
just
a
compiler
it's
subdirectory
is
tf2
xla
and
these
tf2
Excel
a
sort
of
unsurprisingly
it's
tensorflow
is
and
so
on
the
Left
we've
runtime
that
actually
executes
this
and
so
there's
two
components
here
one
is
i've
labeled
two
of
the
graph
notes
here
like
add
and
softmax
for
softmax
that's
basically
how
tensorflow
kind
of
take
tensorflow
add-in
softmax
labels
okay
on
the
right
tensorflow
runtime
but
we've
swapped
out
tensorflow
to
keep
with
the
theme
and
all
my
slides
so
we
swapped
out
that
tensorflow
kernels
we
swapped
in
like
kernels
instead
of
actually
executing
mentioned
softmax
like
you
know
dot
and
exponentiation
and
transform
tensor
flow
graphs
into
excel
the
kernels
that
we
have
they're
not
haven't
implemented
every
tensorflow
op
and
that's
the
reason
we
haven't
compiler
on
inside
tensor
flow
alright
just-in-time
compilation
and
so
in
the
transformations
i'm
going
to
describe
we've
in
this
red
trapezoid
we've
compiled
by
Excel
a
the
other
nodes
in
know
the
we've
chosen
the
clustering
tensorflow
like
the
runtime
works
it's
simplified
this
one's
all
obviously
also
trapezoid
so
so
the
clustering
phase
is
which
clusters
are
going
to
be
compiled
bubbles
and
when
the
attentively
non-trivial
at
scale
and
so
so
this
fact
it's
a
bad
clustering
now
you
might
the
right-hand
side
where
we've
created
nodes
and
the
jaded
nodes
and
the
issue
to
turn
on
the
jit
compilation
we've
got
conceptually
what
you're
doing
is
you've
determine
which
clusters
of
the
graphs
turn
on
jit
compilation
this
one's
a
you
explicitly
put
scopes
inside
of
your
transform
tensor
flow
into
excel
a-and
how
we
do
the
just-in-time
compilation
couldn't
be
compiled
that's
fine
you
know
we'll
we'll
we'll
just
leave
those
the
inputs
are
and
what
the
outputs
are
c++
header
is
conceptually
like
a
arguments
and
the
fetches
are
the
output
arguments
and
so
that's
that's
pretty
not
just
reducing
binary
sizes
but
also
computations
and
tensorflow
right
and
you
can
build
these
extraordinarily
with
your
inputs
in
your
outputs
and
so
the
the
only
binaries
that
we
currently
haven't
done
it
yet
that's
definitely
through
this
header
file
there's
no
reason
why
conceptually
we
couldn't
add
sort
of
Google
protobuf
so
if
you're
not
we're
identifying
the
inputs
in
to
the
this
is
a
good
point
to
re-emphasize
for
compilers
it's
much
better
if
you
sizes
that
we're
going
to
use
similarly
basile
so
basically
through
basel
we've
here's
the
feeds
here's
the
fetches
invoke
the
computation
particular
computation
we're
going
to
assume
is
like
a
matrix
multiplication
button
and
basically
that's
invoking
you
compiler
subdirectory
under
tensorflow
compiler
tf
tex
la
which
does
the
describing
well
what's
the
speed
up
or
normal
tensor
flow
and
we've
run
another
for
gmt
that's
the
neural
machine
we've
got
inception
alex
net-like
some
operations
get
automatically
fused
computation
is
streaming
through
all
the
parallelization
and
buffer
allocation
highlighting
the
training
examples
or
condemning
paper
or
something
you'd
be
benchmarks
that
we've
been
running
like
micro
benchmarks
that
we're
running
our
existing
implementations
of
fast
fused
kernels
and
so
when
tensorflow
when
the
tensorflow
wap
comes
in
that
does
that
know
slowdowns
and
redress
but
to
be
bad
so
we
have
to
prioritize
and
we're
kind
tensor
worse
is
that
currently
tensorflow
of
the
within
single
op
parallelism
have
separate
backends
for
sequential
megabytes
to
be
downloaded
for
your
sort
of
binary
size
reductions
the
then
3d
and
it's
compiled
for
android
one
megabyte
for
the
tensor
flow
runtime
bytes
of
that
is
code
and
330
kilobytes
88
kilobytes
so
the
next
box
that
we
depending
on
your
sizes
in
Excel
a
we
implementations
that
already
exist
we
the
matrix
multiplications
that
happen
graphs
are
compiled
vxl
a
we
have
both
compilation
and
so
they're
both
pretty

相關影片

加Line好友 每日8AM 推播1單字

加入好友

其他人正在學習的單字

1. salute
2024-04-27 21:18
2. involve
2024-04-27 21:18
3. than
2024-04-27 21:18
4. sensing
2024-04-27 21:18
5. assured
2024-04-27 21:18
6. donkey
2024-04-27 21:18
7. network
2024-04-27 21:18
8. catches
2024-04-27 21:18
9. made
2024-04-27 21:17
10. me
2024-04-27 21:17
11. immensely
2024-04-27 21:17
12. stream
2024-04-27 21:17
13. print
2024-04-27 21:17
14. jumbo
2024-04-27 21:17
15. ogre
2024-04-27 21:17

本月觀看影片單字排行榜

本月查閱單字排行榜

本月聆聽單字排行榜