
Korean: 
아, 이거다!
완벽하군
이 여분의 레이어는
훨씬 더 잘 할 것 같습니다.
예,이 레이어의 크기를 늘리는 것은
정말 좋은 생각이었습니다.
좋아요
오케이
더 이상 기다릴 수 없어요.
테스트 할 시간이에요.
자브릴! 자브릴!
내가 소설을 썼어요.
와우 존, 그린봇.. 네가 뭘했다고?
소설을 썼어요.
소설??
한번 보자.
와우..
존 그린 봇,이건 너무 엉성해.
너 손글씨 공부부터 해야겠다.
잠깐, 잠깐
잠깐, 잠깐
너 한 쪽에 글씨 하나를 썼네?
이건 읽을 수 없어..
존 그린 봇, 너의 소설을 사람들에게 보여줘야겠어.
기계학습으로 디지털화 해보자!
존 그린 봇, 너의 소설을 사람들에게 보여줘야겠어.
기계학습으로 디지털화 해보자!
근데 먼저 해야할 게 있어.

English: 
Oh this is it.
Perfect.
I think these extra layers are going to make
it so much better.
Oh yeah, increasing the size of this layer
was a really good idea.
Alright.
Okay.
I can’t wait any longer.
It’s time to test it.
John-Green-Bot: Ja-bril. Jabril.
I wrote a nov-el.
Jabril: Woah John-Green-Bot.. you did what?
John Green Bot: I wrote a novel.
A novel?
Let me see this.
Wow..
John Green Bot this is pretty sloppy we need
to work on your handwriting.
Hold up.
Hold up.
You wrote one letter per page!
This is impossible to read.
John Green Bot we’ve got to get your novel
an audience so let’s digitize this using
machine learning!
But first, there’s something else we have
to test.

Korean: 
 
Crash Course AI에 온 것을 환영합니다!
저는 호스트 Jabril 이고 오늘 우린 좀
다른 것을 시도해 볼 겁니다.
이것은 Crash Course에서 실습을 시도하는 첫 번째 사례
이므로 프로젝트를 함께 다루고
신경망을 프로그래밍하여 필기 문자를 인식할 것입니다.
자, 존그린봇 우린 뭣 좀 하고 다시 너에게 올게.
우리는 Google 공동 작업 도구에서 파이썬이라는 것으로
모든 코드를 작성할 것입니다.
우리는 Google 공동 작업 도구에서 파이썬이라는 것으로
모든 코드를 작성할 것입니다.
여러분은 우리가 점검하려는 코드를 설명에 있는 
링크를 통해 브라우저에서 열어볼 수 있습니다.
이 비디오랑 같이 보면서 흐름을 따라갈 수도 있습니다.
이 협업 파일에는 수행하려는 작업을 설명하는 일반 
텍스트와 재생 버튼을 눌러 실행할 수 있는 코드가 있습니다.
이 협업 파일에는 수행하려는 작업을 설명하는 일반 
텍스트와 재생 버튼을 눌러 실행할 수 있는 코드가 있습니다.
이 코드 조각들은 서로를 의존하여 지어지므로, 그들을
위에서 아래로 실행해야 한다는 것을 명심해야 합니다.
순서대로 하지 않으면 에러가 날 수 있습니다.

English: 
[INTRO - LAB]
Welcome back to Crash Course AI!
I’m your host Jabril, and today we’ll
be doing something a little different.
This is the first time we’re trying a hands-on
lab on Crash Course, so we’ll tackle a project
together and program a neural network to recognize
handwritten letters.
Alright John Green Bot we’ll get back to
you when we’ve got something.
We’ll be writing all of our code using a
language called Python in a tool called Google
Colaboratory.
You can see the code we’re about to go over
in your browser from the link we put in the
description, and you can follow along with
me in this video.
In these Colaboratory files, there’s some
regular text explaining what we’re trying
to do, and pieces of code that we can run
by pushing the play button.
These pieces of code build on each other,
so keep in mind that we have to run them in
order from top to bottom, otherwise we might
get an error.

English: 
To actually run the code and experiment with
changing it you have to either click “open
in playground” at the top of the page OR
open the File Menu and click “Save a Copy
to Drive.”
And just fyi, you’ll need a Google account
for this.
Remember, our goal is to program a neural
network to recognize handwritten letters and
convert them to typed text.
Even though this stack of paper is unreadable
to me, we can work with it, and it could actually
make our project a little easier.
Usually with a project like this, we’d have
to write code to figure out where one letter
ends and another begins, because handwriting
can be messy and uneven.
That’s called the segmentation problem.
But because John-Green-bot wrote his novel
like this, the letters are already segmented,
and we can just focus on recognizing the letter
on each page.
By the way, avoiding the segmentation problem
is also why official forms sometimes have
little boxes for each letter, instead of just
a line for writing your name.
Even though we don’t have to worry about
segmentation, recognizing handwritten letters

Korean: 
실제로 코드를 실행하고 코드 변경을 실험하려면 페이지
상단의 "놀이터에서 열기"를 클릭하거나
파일 메뉴를 열고 "드라이브에 사본 저장"을 클릭해야 합니다.
파일 메뉴를 열고 "드라이브에 사본 저장"을 클릭해야 합니다.
참고로 이걸 하려면 Google 계정이 필요합니다.
우리의 목표는 손으로 쓴 글자를 인식하고 이걸 입력된
텍스트로 변환하는 신경망을 프로그래밍하는 것입니다
우리의 목표는 손으로 쓴 글자를 인식하고 이걸 입력된
텍스트로 변환하는 신경망을 프로그래밍하는 것입니다
이 용지 더미를 제가 읽을 수 없지만,
그걸로 작업할 수 있고
실제로 프로젝트를 좀 더 쉽게 만들 수 있습니다.
일반적으로 이와 같은 프로젝트를 사용하려면,
한 글자의 끝과 다른 글자의 시작부분을 찾아내는 코드를 작성해야 합니다.
손글씨가 지저분하고 고르지 않을 수 있기 때문입니다.
이를 분할 문제라고 합니다.
존 그린 봇이 소설을 이렇게 썼기 때문에,
이 글자들은 이미 분할되어 있습니다.
그래서 우린 각 장에 쓰인 글자 인식에 집중하기만
하면 됩니다.
그건 그렇고, 분할 문제는 가끔 공식 문서에 이름을 쓰는
줄 대신 칸으로 나뉘어져 있는 이유이기도 합니다.
그건 그렇고, 분할 문제는 가끔 공식 문서에 이름을 쓰는
줄 대신 칸으로 나뉘어져 있는 이유이기도 합니다.
분할 문제에 대해서 걱정할 필요는 없지만,

English: 
and converting them to typed text is still
tricky!
Every handwritten “J” looks a little different,
so we need to program our neural network to
recognize a pattern instead of memorizing
a specific shape.
But before we do this, let’s think about
what we need to get there.
Neural networks need a lot of labeled data
to learn what each letter generally looks
like.
So Step 1 is: find or create a labeled dataset
to train our neural network.
And this involves splitting our dataset into
the training set and the testing set.
The training set is used to train the neural
network.
And the testing set is data that’s kept
hidden from the neural network during training,
so it can be used to check the network’s
accuracy.
Next, Step 2 is create a neural network.
We’ll actually need to configure an AI with
an input layer, some number of hidden layers,
and the ability to output a number corresponding
to its letter prediction.
In Step 3, we’ll train, test, and tweak
our code until we feel that it’s accurate
enough.
And finally in Step 4, we’ll scan John-Green-bot’s
handwritten pages and use our newly trained

Korean: 
손글씨를 인식하고 입력된 텍스트로 변환하는 것은 
여전히 까다롭습니다.
모든 필기체  "J"는 약간 다르게 보입니다.
그래서 우리는 글자의 특정 모양을 기억하기보다는
패턴을 인식하도록 신경망을 프로그래밍 해야 합니다.
하지만 이 작업을 하기 전에, 목적에 도달하기 위해 
무엇이 필요한지 한 번 생각해봅시다.
신경망이 각 글자의 일반적인 생김새를 배우려면 많은
라벨링된 데이터가 필요합니다.
신경망이 각 글자의 일반적인 생김새를 배우려면 많은
라벨링된 데이터가 필요합니다.
따라서 1단계는 신경망을 훈련시키기 위한 레이블이
지정된 데이터 세트를 찾거나 작성하는 것입니다.
여기에는 데이터 세트를 훈련 세트와 테스트 세트로
나누는 것이 포함됩니다.
훈련 세트는 신경망의 훈련에 사용됩니다.
그리고 테스트 세트는 보관된 데이터로써,
훈련 중에 신경망에 숨겨져 있고
네트워크의 정확성을 확인하는 데 사용할 수 있습니다.
다음으로, 2단계는 신경망을 만듭니다.
실제로 입력 레이어,  몇 숨겨진 레이어와 예측 문자와
대응하는 숫자를 출력하는 기능으로 AI를 구성해야 합니다.
실제로 입력 레이어,  몇 숨겨진 레이어와 예측 문자와
대응하는 숫자를 출력하는 기능으로 AI를 구성해야 합니다.
3단계에서는 학습, 테스트 및 코드가 충분히 정확하다고
느낄 때까지 조정을 수행합니다.
3단계에서는 학습, 테스트 및 코드가 충분히 정확하다고
느낄 때까지 조정을 수행합니다.
마지막으로 4단계에서는 존 그린봇의
손으로 쓴 종이를 스캔해서

English: 
neural network to convert them into typed
text!
Alright, let’s get started.
Step 1.
Creating a labeled dataset can be a huge and
expensive challenge, especially if I have
to handwrite and label thousands of images
of letters by myself.
Luckily, there’s already a dataset that
we can use: the Extended Modified National
Institute of Standards and Technology dataset,
or EMNIST for short.
This dataset has tens of thousands of labeled
images of handwritten letters and numbers,
generated from US Census forms.
Some of the handwriting is relatively neat
and some... not so much.
We’re going to use the EMNIST letters chunk
of the dataset, which has 145,600 images of
letters, because we’re only recognizing
letters in John-Green-bot’s book, not numbers.
This code here will give our program access
to this dataset, also called importing it.
So now we need to make sure to keep our training
and our testing datasets separate, so that

Korean: 
입력된 테스트로 변환하는 새로 훈련된 신경망을
사용해 볼 거에요!
자, 시작해 볼게요.
1단계.
레이블이있는 데이터 집합을 만드는 것은 엄청나고
비용이 많이 드는 문제 일 수 있습니다.
특히 수천 장의 글자 이미지를 직접 
작성하고 레이블을 지정해야하는 경우에요.
운 좋게도, 사용할 수 있는 데이터 세트가 이미 있습니다.
: 확대 수정된 표준 기술 데이터 셋트 국립 연구소
짧게 EMNIST라고 하죠.
이 데이터 세트에는 미국 인구 조사 양식에서 만들어진
수만 개의 필기문자와 숫자의 이미지 레이블이 있습니다.
이 데이터 세트에는 미국 인구 조사 양식에서 만들어진
수만 개의 필기문자와 숫자의 이미지 레이블이 있습니다.
필기 중 일부는 비교적 깔끔합니다.
그리고 일부는 .. 별로에요.
145,600개의 문자 이미지가 있는 EMNIST의 데이터 세트
문자 청크를 사용하도록 하겠습니다.
왜냐하면 우리는 존 그린봇의 책에서 숫자가 아닌
글자만 인식할 것이기 때문입니다.
여기 이 코드는 프로그램이 데이터셋에 접근하도록 
해 줍니다. 이를 'Importing'라고도합니다.
이제 우리는 훈련과 테스트 데이터 세트를 분리하여
정확성을 테스트 할 때,

English: 
when we test for accuracy, our AI has never
seen the testing images before.
So now in our code at step 1.2 let’s call
the first 60,000 labeled images “train”
and the next 10,000 labeled images “test.”
These images of letters are 28x28 pixels,
and each pixel is a grayscale value between
0 and 255.
To normalize each pixel value and make them
easier for the neural network to process,
we’ll divide each value by 255.
That will give us a number between 0 and 1
for each pixel in each image.
Performing a transformation like this to make
the data easier to process is a machine learning
method is called preprocessing.
By the way, we’ll need different preprocessing
steps for different types of data.
Alright, it may take a few seconds to download
and process all of these images, so while
that’s happening, I want to clarify that
EMNIST is a luxury.
There aren’t many already-existing datasets
where you have this much labeled data to use.
In general, if we try to solve other problems,
we’ll have to think hard about how to collect

Korean: 
AI는 그 테스트 이미지를 이전에 본 적이 없어야 합니다.
이제 1.2 단계의 코드에서 처음 60,000개의 레이블이
붙은 이미지를 "훈련"
그리고 다음 10,000개의 레이블이 있는 이미지는
"테스트"라고 합시다.
이 글자 이미지는 28x28 픽셀이고, 
각 픽셀은 0과 255 사이의 회색조 값입니다.
이 글자 이미지는 28x28 픽셀이고, 
각 픽셀은 0과 255 사이의 회색조 값입니다.
각 픽셀 값을 정규화하고 신경망이 
처리하기 쉽도록 만들기 위해,
우리는 각 값을 255로 나누겠습니다.
그것은 우리에게 각 이미지의 각 픽셀에 대해 
0과 1 사이의 숫자를 줄 것입니다.
데이터를 쉽게 처리 할 수 있도록 이와 같은 변환을
수행하는 기계학습방법을 '전처리'라고 합니다.
데이터를 쉽게 처리 할 수 있도록 이와 같은 변환을
수행하는 기계학습방법을 '전처리'라고 합니다.
그건 그렇고, 우리는 다른 유형의 데이터를 위해
또다른 전처리 단계가 필요합니다
이 이미지를 모두 처리하고 다운로드하는 데에 
몇 초가 걸릴 수 있습니다.
하는 동안, 저는 일단 EMNIST가 럭셔리하다는 것을
명확히 하고 싶습니다.
레이블이 많은 데이터를 사용할 수 있는
기존 데이터 세트가 그리 많진 않습니다.
일반적으로, 다른 문제를 해결하려고 하면,

English: 
and label data for training and testing our
networks.
Data collection is a very important step to
training a good neural network!
In this case though, we’ve got plenty to
use in both sets.
Okay, let’s write a little piece of code
to make sure that we imported our dataset
correctly.
This line lets us display an image and we’ll
also display the label using the print command.
See, this letter is labeled as a Y.
We can display a different example by changing
this index number, which tells our program
which letter image in the EMNIST dataset to
pull.
Let’s look at the image indexed at 1200…
this is labeled as a W.
These are already labeled images.
There’s no neural network making any decisions
yet, but this /is/ a labeled dataset, so we’re
done with the first step!
Step 2
Now that we have our dataset, we need to actually
build a neural network, but we don’t need
to reinvent the wheel here!
We’re going to stick with a multi-layer
perceptron neural network or MLP, which is
the kind we’ve focused on in the Neural
Networks and Deep Learning Episodes.

Korean: 
신경망의 훈련 및 테스트를 위해 데이터를 수집하고 라벨링하는 방법에 대해 열심히 생각해야 합니다.
데이터 수집은 좋은 신경망의 훈련을 위해
매우 중요한 단계입니다.
하지만 이 경우, 두 세트에 사용하기 충분한 
수많은 데이터가 있습니다.
좋아요, 올바른 데이터셋을 가져왔는지 확인하기 위해
작은 코드를 작성해 봅시다.
좋아요, 올바른 데이터셋을 가져왔는지 확인하기 위해
작은 코드를 작성해 봅시다.
이 줄을 통해 이미지를 표시할 수 있습니다.
또한 인쇄 명령을 사용하여 레이블을 표시하겠습니다.
보세요, 이 문자는 Y로 표시되어 있습니다.
이 색인 번호를 변경하여
다른 예제를 표시 할 수 있습니다.
이는 EMNIST 데이터 세트에서 어떤 문자 이미지를
가져올 지 프로그램에 알려줍니다.
1200에서 색인 된 이미지를 봅시다.
이것은 W로 레이블되어 있습니다.
이들은 이미 레이블이 지정된 이미지입니다.
의사 결정을 하는 신경망은 아직 없지만, 이것은 
레이블이 붙은 데이터 세트이므로
우리는 첫 번째 단계를 완료했습니다!
2단계
이제 데이터 셋을 가지고 있으므로, 실제로 신경망을
구축하지만 우리는 바퀴를 재발명할 필욘 없습니다.
이제 데이터 셋을 가지고 있으므로, 실제로 신경망을
구축하지만 우리는 바퀴를 재발명할 필욘 없습니다.
우리는 다층 퍼셉트론 신경망 (줄여서MLP) 을
고수하겠습니다.
MLP는 신경망 및 딥 러닝 에피소드에서 집중해서 봤었죠.

Korean: 
파이썬에는 우리가 네트워크를 만드는 데 사용할 수 있는
라이브러리라고 하는 곳에 이미 몇 가지 도구가 있습니다.
파이썬에는 우리가 네트워크를 만드는 데 사용할 수 있는
라이브러리라고 하는 곳에 이미 몇 가지 도구가 있습니다.
우리는 SK Learn이라는 라이브러리를 사용할 것입니다
(Sci Kit Learn의 줄임말)
접근할 수 있도록 가져오겠습니다.
SKLearn에는 다양한 기계학습 알고리즘이 포함되어 
있습니다.
우리는 이 실험에서 다층 퍼셉트론 알고리즘을
사용할 것입니다.
우리의 신경망은 입력으로 손글씨 이미지를 받을 것입니다.
EMNIST의 각 이미지는 28 x 28픽셀입니다.
이러한 각 픽셀이 하나의 입력으로 표시됩니다
총 784개의 입력 뉴런이 있습니다.
이전에 처리한 덕분에, 특정 픽셀이 얼마나 어두운 지에 
따라 0과 1 사이의 회색조 값을 갖게 됩니다.
이전에 처리한 덕분에, 특정 픽셀이 얼마나 어두운 지에 
따라 0과 1 사이의 회색조 값을 갖게 됩니다.
출력 레이어의 크기는 신경망이 추측을 원하는 레이블
유형의 수에 따라 다릅니다.
출력 레이어의 크기는 신경망이 추측을 원하는 레이블
유형의 수에 따라 다릅니다.
우리는 글자를 추측하려고 하고,
영어 알파벳에는 26글자가 있기 때문에
우리는 26개의 출력 뉴런을 가질 것입니다.
우리는 실제 이걸 네트워크에 말할 필요가 없습니다.
자체 훈련 셋트의 레이블로부터 스스로 알아낼 거니까요.

English: 
There are already some tools in Python called
libraries that we can use to help make the
network.
We’re going to use a library called SKLearn
(which is short for Sci Kit Learn), we’ll
import that so that we have access to it.
SKLearn includes a bunch of different machine
learning algorithms, and we’ll be using
it’s Multi-Layer Perceptron algorithm in
this lab.
So, our neural network is going to have images
of handwritten letters as inputs.
Each image from EMNIST is 28 pixels by 28
pixels, and each of these pixels will be represented
by a single input neuron, so we’ll have
784 input neurons in total.
Depending on how dark a particular pixel is,
it will have a greyscale value between 0 and
1, thanks to the processing we did earlier.
The size of our output layer depends on the
number of label types that we want our neural
network to guess.
Since we’re trying to guess letters and
there are 26 letters in the English alphabet,
we’ll have 26 output neurons.
We don’t actually have to tell the network
this though --- it will figure this out on

English: 
its own from the labels in the training set.
For the structure of the hidden layers, we’ll
just start experimenting to see what works.
We can always change it later.
So we’ll try a single hidden layer containing
50 neurons.
Over the span of one epoch of training this
neural network, each of the 60,000 images
in the training dataset will be processed
by the input neurons, the hidden layer neurons
will randomly pick some aspects of each image
to focus on, and the output neurons will hold
the best guess as to whether each image is
a particular letter.
You’ll see that the code in our Colab notebook
calls this an “iteration.”
In the specific algorithm we’re using, an
iteration and an epoch are the same thing.
After each of the 60,000 images are processed,
the network will compare its guess to the
actual label and update weights and biases
to give a better guess for the next image.
And over multiple epochs of the same training
dataset, the neural network’s predictions
should keep getting better thanks to those
updated weights and biases.

Korean: 
우리는 실제 이걸 네트워크에 말할 필요가 없습니다.
자체 훈련 셋트의 레이블로부터 스스로 알아낼 거니까요.
숨겨진 레이어의 구조를 위해,
어떤 것이 효과가 있는지 실험 해보겠습니다.
나중에 언제든지 변경할 수 있습니다.
그래서 우리는 50개의 뉴런을 포함하는 하나의
숨겨진 레이어를 시도 할 것입니다.
이 신경망을 훈련하는 한 시대에 걸쳐,
각 6만 개의 이미지는 입력 뉴런에 의해 처리될 것이며,
숨겨진 레이어 뉴런은 각 이미지의
일부 측면을 랜덤으로 선택하고,
출력 뉴런은 각 이미지가 특정 문자인지의 
여부를 최선으로 추측합니다.
출력 뉴런은 각 이미지가 특정 문자인지의 
여부를 최선으로 추측합니다.
Colab 노트의 코드에서는
이것을 "되풀이"이라고 부릅니다.
우리가 사용하는 특정 알고리즘에서
되풀이(iteration)와 시대(epoch)는 같은 것입니다.
6만개의 이미지가 각각 처리 된 후
네트워크는 그 추측을 실제 레이블과 비교하고
그리고 가중치와 바이어스를 업데이트 하면
다음에 이미지를 더 잘 추측 할 수 있습니다.
그리고 같은 훈련 데이터셋트로 여러 시대를 거치며,
신경망의 예측은 업데이트된 가중치, 바이어스 덕분에
계속 향상될 것입니다.

English: 
We’ll just go with 20 epochs for now.
We’ve captured all that in a single line
of code iin step 2.1, which creates a neural
network with a single hidden layer with 50
neurons that will be trained over 20 epochs.
This is why libraries can be so useful, we’re
accessing decades of research with one line
of code!
But, keep in mind, there are cons to using
libraries like this as well.
We don’t have a lot of control over what’s
happening under the hood here.
When solving most problems, we’ll want to
do a mix of using existing libraries and writing
our own AI algorithms, so we would need a
lot more than just one line of code.
For this lab, though, step 2 is done.
Step 3.
Next, we want to actually train our network
over those 20 epochs and see how well it guesses
the letters in the training and testing datasets,
with this line of code in step 3.1!
For every epoch, our program prints a number
called the error of the loss function.
This basically represents how wrong the network
was overall.

Korean: 
지금은 20시대만을 거쳐 실험하겠습니다.
우리는 2.1단계에서 했던 
모든 라인의 코드를 캡쳐했습니다.
50개의 뉴런과 하나의 숨겨진 층으로 만든 신경망은
20시대에 거쳐 훈련될 것입니다.
한 줄의 코드로 수십년의 연구에 접근할 수 있는 것이 
라이브러리가 매우 유용한 이유입니다.
한 줄의 코드로 수십년의 연구에 접근할 수 있는 것이 
라이브러리가 매우 유용한 이유입니다.
그러나 이와 같은 라이브러리를 사용하는 것은
단점 또한 있다는 걸 명심하세요.
우리는 내부의 핵심에서 무슨 일이 일어나는지
알 수 없습니다.
대부분의 문제를 해결할 때, 우리는 기존 라이브러리를
사용하여 자체 AI알고리즘을 쓰고 싶어할 것입니다.
따라서 한 줄 이상의 코드가 필요합니다.
하지만 이 연구실에서 2단계는 다 됬습니다.
3단계로 갑시다.
다음으로 우리는 실제로 20개의 시대를 통해
네트워크를 훈련시키고,
3.1단계의 이 코드 라인을 사용해 훈련 및 테스트 데이터
세트의 문자를 얼마나 잘 추측하는지 확인하고 싶습니다.
모든 시대마다, 프로그램은 손실 함수의 오류라고 하는
숫자를 인쇄합니다.
이것은 기본적으로 네트워크가 얼마나 전체적으로
얼마나 오류가 있는지 나타냅니다.

English: 
We want to see this number going down with
each epoch.
The number that we /really/ care about is
how well the network does on the testing dataset,
which shows how good our network is at dealing
with data that it’s never seen before.
And we have 84% correct!!
Now that’s not bad considering we only trained
for 20 epochs, but we still want to improve
it.
To see where the network made the most mistakes,
we can create a confusion matrix which we
made in step 3.2.
The color of each cell in the confusion matrix
represents the number of elements in that
cell, and a brighter color means more elements.
The rows are the correct value and the columns
are the predicted value, and the numbers on
the axes represent the 26 letters in the alphabet.
So, zero is “A”, one is “B”, etc.
So cell (0,0) represents the number of times
that our network correctly predicted that
an "A" is an "A." It’s good to see a bright
diagonal line, because those are all correct
values!

Korean: 
우리는 각 시대마다 이 숫자가 작아지길 원합니다.
우리가 정말로 관심을 가지는 숫자는 신경망이
테스트 데이터 세트에서 얼마나 잘 수행하는지,
네트워크가 이전에 본 적 없는 데이터를 얼마나 
잘 다루고 있는지 보여주는 수 입니다.
그리고 우리는 84%의 정확도를 얻었습니다.!
20시대만 훈련한 것 치고 결과는 나쁘지 않지만,
우리는 여전히 그것을 개선하고 싶습니다.
20시대만 훈련한 것 치고 결과는 나쁘지 않지만,
우리는 여전히 그것을 개선하고 싶습니다.
네트워크가 가장 실수한 위치를 확인하기 위해,
3.2단계에 오차 행렬을 만들 수 있습니다.
네트워크가 가장 실수한 위치를 확인하기 위해,
3.2단계에 오차 행렬을 만들 수 있습니다.
오차 행렬에서 각 셀의 색상은
그 셀에서 요소의 수를 나타냅니다.
색상이 밝을수록 더 많은 요소를 나타냅니다.
행은 올바른 값, 열은 예측값이고
축에 있는 숫자들은 알파벳의 26개를 말합니다.
축에 있는 숫자는 알파벳의 갯수인 26을 나타냅니다.
따라서 0은 "A", 1은 "B" ···입니다.
셀 (0,0)은 우리의 신경망이 A를 올바르게 A로
예측한 횟수를 나타냅니다.
이들은 모두 정확한 값이기 때문에 밝은쪽
대각선을 보는 것이 좋습니다.
이들은 모두 정확한 값이기 때문에 밝은쪽
대각선을 보는 것이 좋습니다.

Korean: 
그러나 다른 밝은 셀에는 레이블이 잘못되어 있으므로
패턴이 있는지 확인해야합니다.
예를 들어 "I"와 "L"은 혼동하기 쉬울 수 있으므로
이러한 상황이 발생한 경우를 살펴보겠습니다.
예를 들어 "I"와 "L"은 혼동하기 쉬울 수 있으므로
이러한 상황이 발생한 경우를 살펴보겠습니다.
신경망이 "U"를 "V"로 추측한 것과 같은
다른 유형의 오류도 시도해 볼 수 있습니다.
신경망이 "U"를 "V"로 추측한 것과 같은
다른 유형의 오류도 시도해 볼 수 있습니다.
정확성을 향상시킬 수 있는지 확인하기 위해,
약간 다른 신경망을 프로그래밍 할 수 있습니다.
더 많은 시대, 더 많은 숨겨진 레이어, 숨겨진 층의 더 많은
뉴런 등이 모두 도움이 될 수 있습니다.
그러나 이것의 단점은 조금 느릴 것입니다.
우리는 여기 나온 구조를 가지고 
무슨 일이 일어나는지 보겠습니다.
이제 각 100개의 뉴런이 있는 5개의 숨겨진 층이 있는
신경망을 만들어 보겠습니다.
그리고 그것을 50 시대 이상 훈련시킬 것입니다.
실행하려면 몇 분 걸립니다.
이제 우리는 데이터셋트에서 84% 대신 88로,
더 나은 정확도를 얻었습니다!
이게 바로 개선이죠!

English: 
But other bright cells are mislabeled, so
we should check if there are any patterns.
For example, "I" and "L" may be easy to confuse,
so let's look at some of the cases where that
happened.
We can also try other types of errors, like
every time our network guesses that a “U”
is a “V.” 37 times.
To see if we can improve our accuracy, we
can program a slightly different neural network.
More epochs, more hidden layers, and more
neurons in the hidden layers could all help,
but the tradeoff is that things will be a
bit slower.
We can play around with the structure here
to see what happens.
For now, let’s try creating a neural network
that has 5 hidden layers of 100 neurons each,
and we’ll train it over 50 epochs.
It’ll take a few minutes to run.
Now we’ve got better accuracy rates on our
testing dataset -- we have 88% correct instead
of 84% correct and that’s an improvement!

Korean: 
시간이 지남에 따라, 우리는 신경망이 더 나은 결과를
얻도록 구조화 하는 직관을 개발할 수 있습니다.
시간이 지남에 따라, 우리는 신경망이 더 나은 결과를
얻도록 구조화 하는 직관을 개발할 수 있습니다.
여러분이 우리가 테스트하는 데이터셋트에서
더 높은 정확성을 얻도록 신경망을 만들 수도 있습니다.
하지만 지금은 이 훈련된 네트워크로
계속 진행할 것입니다.
4단계입니다.
마지막 단계는 결정적인 순간입니다.
우리는 훈련된 신경망을 사용해서 존 그린봇의
소설을 읽으려고 합니다.
이 종이 더미를 파헤쳐 봅시다.
먼저 이 모든 용지를 스캔하여 올바른 형식의
데이터를 얻어야 합니다.
끝났네요. 우리는 Google Colab을 사용하고 있기 때문에,
온라인으로 연결해야 합니다.
그것들을 공동 작업 노트로 가져오기 위해 
GitHub 저장소에 저장하고 있습니다.
그것들을 공동 작업 노트로 가져오기 위해 
GitHub 저장소에 저장하고 있습니다.
보시다시피, 스캔한 이미지는 거대합니다.

English: 
Over time, we can develop an intuition about
how to structure neural networks to achieve
better results.
See if you can create a network that has a
higher accuracy than ours on the testing dataset.
But, for now, we’re gonna move forward with
this trained network.
Step 4.
The final step is our moment of truth.
We’re going to use our trained neural network
to try and read John-Green-bot’s novel,
so let’s dig into this stack of papers.
First, we’ve got to get our data in the
right format by scanning all these papers.
And done. And because we’re using Google Colab, we need to get them online.
We’re storing them in a GitHub repository
which we coded to import into our Colaboratory
notebook.
But, as you can see, those scanned images
are HUGE.

Korean: 
따라서 너무 많은 데이터를 계산하고 다운로드할
필요가 없도록 스캔에서 약간의 전처리를 했습니다.
따라서 너무 많은 데이터를 계산하고 다운로드할
필요가 없도록 스캔에서 약간의 전처리를 했습니다.
모든 이미지의 크기를 128x128픽셀로 변경했습니다.
여러분이 알아차릴 만한 다른 점은 EMNIST데이터 셋이
어두운 배경과 밝은 획을 사용하지만,
우리가 스캔한 것들은 어두운 선과 흰색 배경입니다.
따라서, 우리는 계속해서 EMNIST와 일치하도록
색상을 반전 시켰습니다.
다 됬습니다.
이제 Collab Notebook으로 돌아갑시다.
4.1단계의 이 코드는GitHub에서 수정 된 문자를
불러옵니다.
이제 그것들을 배열로 읽어서 그들 중 하나를 표시하고
올바르게 가져올 수 있도록 합니다.
이제 그것들을 배열로 읽어서 그들 중 하나를 표시하고
올바르게 가져올 수 있도록 합니다.
이건 꽤 좋아 보이네요!
실제로 EMNIST데이터보다 명확합니다.
그러나 우리가 처음에 왜 이 작업을 했는지로
다시 한번 돌아가 봅시다.
-존 그린봇의 이야기를 처리할 수 있는지로요.
아…
이건 하나도 말이 안되네요..
우리는 뭔가 잘못하고 있습니다.
우선, 존 그린 봇의 이야기는 
단어 사이에 빈 공간이 있습니다.

English: 
So we've also done a bit of preprocessing
on these scans to avoid having to download
and compute over so much data.
We've changed the size of every image to 128x128
pixels.
The other thing you may notice is that the
EMNIST dataset uses a dark background with
light strokes, but our original scans have
a white background with dark strokes.
So, we also went ahead and inverted the colors
to be consistent with EMNIST.
Alright.
Now, back to the Collab Notebook.
So this code right here in Step 4.1 will pull
the modified letters from GitHub.
Now, we’ll read them into an array and display
one of them, just to make sure we’re able
to import correctly.
This looks pretty good!
Clearer than the EMNIST data actually.
But back to the point why we’re doing this
in the first place - let’s see if we can
process John Green Bot’s story now.
Ummm…
This is not making any sense…
So we’re doing something wrong.
First off, John-Green-Bot's story had some
empty spaces between words.

English: 
We never actually trained our model on empty
spaces, just the 26 letters, so it wouldn't
be able to detect these.
But blank pages should be easy to detect.
After all, unlike handwritten letters, all
blank images should be exactly the same.
So, we'll just check each image to see if
it’s a blank space, and if it is, we'll
add a space to our story.
This looks better.
There are separate words and I can tell that
the first word is "The," but not much beyond
that.
So something else isn’t going right here.
Well, even though the letters on the papers
we scanned look clear to my human eyes, the
images were really big compared to the handwritten
samples that were used to train EMNIST.
We resized them, but that doesn't seem to
be enough.
To help our neural network digitize these
letters, we should try processing these images
in the same way that EMNIST did.
Let’s do a little detective work to figure
out how the EMNIST dataset was processed,
so our images are more similar to the training
dataset, and our program’s accuracy will

Korean: 
실제로 우리 모델에서 빈 공간을 훈련하지 않았고
26글자만 했으므로 공백을 감지할 수 없습니다.
실제로 우리 모델에서 빈 공간을 훈련하지 않았고
26글자만 했으므로 공백을 감지할 수 없습니다.
그러나 빈 페이지는 쉽게 감지될 수 있어야합니다.
결국 손으로 쓴 편지와는 달리,
빈 이미지는 정확히 같아야 합니다.
따라서 각 이미지를 확인하여 빈 공간인지 확인하고,
공간이 있으면 스토리에 공간을 추가합니다.
따라서 각 이미지를 확인하여 빈 공간인지 확인하고,
공간이 있으면 스토리에 공간을 추가합니다.
좀 더 좋아 보이네요.
첫 번째 단어가 "The"라고 할 수는 있겠는데
그 이상은 모르겠네요.
첫 번째 단어가 "The"라고 할 수는 있겠는데
그 이상은 모르겠네요.
다른 일은 여기서 일어나지 않았죠.
우리가 스캔한 종이의 글자가 인간의 눈에는
선명하게 보일지라도,
EMNIST를 훈련시키는 데 사용 된 샘플 이미지와 비교
했을때 정말 크기가 컸습니다.
우리는 그것들의 크기를 조정했지만,
충분하지 않은 것 같습니다.
우리의 신경망이 글자들을 디지털화하는 것을 돕기 위해,
이미지를 EMNIST와 같은 방식으로 처리해야 합니다.
우리의 신경망이 글자들을 디지털화하는 것을 돕기 위해,
이미지를 EMNIST와 같은 방식으로 처리해야 합니다.
알아내기 위해 EMNIST 데이터셋트가 어떻게 처리됬는지
약간의 탐지 작업을 하여
이미지가 훈련 데이터셋트와 더 비슷해지고
프로그램의 정확성이 향상 될 것입니다.

English: 
hopefully get better.
Hmmm….
“Further information on the dataset contents
and conversion process can be found in the
paper.”
We’re not going to go through the paper
but we’re link it in the description if
you want to learn more.
Basically, I made the following additions
to the code.
We’re applying some filters to the image
to soften the letter edges, centering each
letter in the square image, and resizing each
one to be 28x28 pixels.
As part of this code, we’re also displaying
one letter from these extra-processed images,
to do another check.
Even though to MY eyes, the letter looks less
clear now, it does look much more similar
to the letters in the EMNIST dataset, which
is good for our neural network.
The edges of the letters are kind of fuzzy
and it’s centered in the square.
So, let’s try processing this story ONE
more time.
Keep in mind that with an 88% accurate model,
we expect to get about 1 in 15 letters wrong
in the story.John-Green-bot are you ready?

Korean: 
이미지가 훈련 데이터셋트와 더 비슷해지고
프로그램의 정확성이 향상 될 것입니다.
흠…
“종이 위의 데이터셋트 내용과 변환 과정에 대한 
추가 정보는 ..."
“종이 위의 데이터셋트 내용과 변환 과정에 대한 
추가 정보는 ..."
우리는 종이관련 부분을 다루진 않겠지만, 
여러분이 더 배우고 싶으면 설명의 링크로 가면 됩니다.
우리는 종이관련 부분을 다루진 않겠지만, 
여러분이 더 배우고 싶으면 설명의 링크로 가면 됩니다.
기본적으로, 저는 코드에 다음과 같이 추가했습니다.
이미지에 일부 필터를 적용해서 글자의 가장자리를
부드럽게 하고, 사각형 중심에 글자를 놓고
문자 하나의 크기를  28x28 픽셀로 조정했습니다.
이 코드의 일부로, 추가 검사를 위해 이러한 추가 처리
이미지에서 한 글자를 표시합니다.
이 코드의 일부로, 추가 검사를 위해 이러한 추가 처리
이미지에서 한 글자를 표시합니다.
비록 제 눈에는 문자가 덜 명확해 보이지만,
훨씬 EMNIST 데이터셋트의 글자와 비슷해 보이므로
신경망에 작업하기엔 좋습니다.
가장자리는 흐릿하고, 글자는 사각형의 중앙에 있습니다.
이 이야기를 한 번 더 처리해 봅시다.
88% 정확도의 모델을 사용했을 때, 이 이야기의
15글자 중 1개가 잘못 될 것으로 예상합니다
존 그린봇, 준비 됬니?

English: 
Alright let’s see what you were talking
about.
“The Fault in Our Power Supplies”
“I fell in love the way your battery dies,
slowly and then all at once”
Quite poetic John Green Bot.
Okay, it’s not perfect, but it was pretty
easy to figure out with context and by knowing
which letters might be mistaken for each other.
Regardless, thanks John Green Bot for giving
us a little taste of your first novel.
And thank you for following along in our first
Crash Course Lab.
Let us know in the comments how you think
you could improve the code and tell us if
you use it in any of your own projects.
Now, this kind of supervised machine learning
is a big component of the AI Revolution, but
it’s not the only one!
In later videos, we’ll be looking at other
types of machine learning, including unsupervised
and reinforcement learning, to see what we
can do even without a giant labeled dataset.
See you then.

Korean: 
좋아, 무슨 이야기를 했는지 보자.
"전원 공급 장치의 결함"
“배터리가 죽는 것처럼 서서히
그리고 한 번에 사랑에 빠졌습니다.”
매우 시적이네, 존 그린 봇.
네, 완벽하지는 않지만 상황에 따라 그리고 어떤 문자가
서로 잘못되었는지 알면 알아내기 쉽습니다.
네, 완벽하지는 않지만 상황에 따라 그리고 어떤 문자가
서로 잘못되었는지 알면 알아내기 쉽습니다.
그럼에도 불구하고, 첫 소설을 맛보게 해줘서 고마워
존 그린 봇.
그리고 우리의 첫번째 크래시 코스의 실험을 
따라와 준 여러분에게 감사드립니다.
댓글을 통해 코드를 향상시킬 수 있다고 
생각하는 것들을 알려주세요.
또한 여러분의 프로젝트에서 이 코드를 사용한다면
출처를 밝혀주세요.
자, 이러한 종류의 감독하는 기계학습은 
AI 혁명의 큰 요소 이지만,
그것만이 유일한 것이 아닙니다!
나중의 비디오에서 우리는 비지도와 강화 학습을 포함한
다른 기계학습 유형을 살펴볼 것입니다.
이들은 레이블이 지정된 거대한 데이터 세트 없이도 
할 수 있습니다.
그때 만나요.

Korean: 
크래시 코스 Ai는 PBS 디지털 스튜디오
협회에서 제작됩니다.
Crash Course가 모두를 위해 무료일수 있도록
도움을 주시고 싶으면 Paetron 커뮤티에 가입해주세요!
Crash Course가 모두를 위해 무료일수 있도록
도움을 주시고 싶으면 Paetron 커뮤티에 가입해주세요!
프로그래밍의 기본에 대해 배우고 싶다면
Crash Course Computer Science를 참고하십시오.

English: 
Crash Course Ai is produced in association
with PBS Digital Studios.
If you want to help keep Crash Course free
for everyone, forever, you can join our community
on Patreon.
And if you want to learn more about the basics
of programming in any language, check out
this Crash Course Computer Science video.
