머신 러닝과 OpenCV
머신 러닝 개요
- 머신 러닝(machine learning)이란 주어진 데이터를 분석하여 규칙성, 패턴 등을 찾고 이를 이용하여 의미 있는 정보를 추출하는 과정.
- 데이터로부터 규칙을 찾아내는 과정을 학습(train) 또는 훈련이라고 하고, 학습에 의해 결정된 규칙을 모델(model)이라 한다. 그리고 새로운 데이터를 학습된 모델에 입력으로 전달하고 결과를 판단하는 과정을 예측(predict) 또는 추론(inference)라고 한다.
- 머신 러닝은 크게 지도 학습(supervised learning)과 비지도 학습(unsupervised learning)으로 구분된다.
- 지도 학습은 정답을 알고 있는 데이터를 이용하여 학습을 진행하는 방식으로 훈련 데이터에 대한 정답에 해당하는 내용을 레이블(label)이라고 한다.
- 아래 그림은 지도 학습 방식으로 영상을 인식하는 과정을 나타낸다.
- 영상 데이터는 픽셀로 구성되어 있지만, 이 픽셀 값을 그대로 머신 러닝 입력으로 사용하지는 않는다. 영상의 픽셀 값은 조명 변화, 객체의 이동 및 회전 등에 의해 매우 민감하게 변화하기 때문.
- 때문에 많은 머신 러닝 응용에서는 영상의 다양한 변환에도 크게 변경되지 않는 특징 정보를 추출하여 머신 러닝으로 전달한다.
- 이처럼 영상 데이터를 사용하는 지도 학습에서는 먼저 다수의 훈련 영상에서 특징 벡터를 추출하고, 이를 이용하여 머신 러닝 알고리즘을 학습 시킨다.
- 학습의 결과로 생성된 학습 모델은 이후 예측 과정에서 사용된다. 예측 과정에서도 입력 영상으로부터 특징 벡터를 추출하고, 이 특징 벡터를 학습 모델 입력으로 전달하면 입력 영상이 어떤 영상인지에 대한 예측 결과를 얻을 수 있다.
- 지도 학습은 주로 회귀(regression) 또는 분류(classfication)에 사용된다.
- 회귀는 연속된 수치 값을 예측하는 작업으로 학생들의 키와 몸무게의 상관관계를 학습하고, 새로운 학생의 키를 입력으로 주었을 때 몸무게를 예측하는 것과 같은 것이다.
- 분류는 이산적인 값을 결과로 출력하는 머신 러닝으로 사과와 바나나를 구분 –또는 인식(recognition)– 하는 것이 이에 해당한다.
- 비지도 학습은 훈련 데이터의 정답에 대한 정보 없이 오로지 데이터 자체만을 이용하는 학습 방식이다.
- 예컨대 무작위로 섞여 있는 사과와 바나나 사진을 두 개의 그룹으로 나누도록 학습시키는 방식이다. 이 경우 분리된 두 개의 사진 집합이 무엇을 의미하는지는 알수 없고, 단지 두 사진 집합에서 서로 구분되는 특징을 이용하여 서로 분리하는 작업만 수행한다.
- 비지도 학습은 주로 군집화(clustering) 에 사용된다.
- 머신 러닝 알고리즘 종류에 따라 내부적으로 사용하는 많은 파라미터에 의해 성능이 달라지기도 한다. 그러므로 최적의 파라미터를 찾는 것이 해결해야 하는 과제가 되기도 한다.
- 이런 경우 훈련 데이터를 k개의 부분 집합으로 분할하여 학습과 검증(validation)을 반복하면서 최적의 파라미터를 찾을 수 있다.
- 예컨대 8000개의 훈련 영상을 800개씩 열 개의 부분 집합으로 분할하고 이 중 아홉 개의 부분 집합으로 학습하고 나머지 한 개의 집합을 이용하여 성능을 검증한다. 그리고 검증을 위한 부분 집합을 바꿔가면서 여러 번 학습과 검증을 수행한다.
- 이처럼 훈련 데이터를 k개의 부분 집합으로 분할하여 학습과 검증을 반복하는 작업을 k-폴드 교차 검증(k-fold cross-validation)이라 한다.
- 머신 러닝 알고리즘으로 훈련 데이터를 학습할 경우 훈련 데이터에 포함된 잡음 또는 이상치(outlier)의 영향을 고려해야 한다.
OpenCV 머신 러닝 클래스
- OpenCV는 다양한 머신 러닝 알고리즘을 클래스로 구현하여 제공한다.
- OpenCV에서 제공하는 머신 러닝 클래스는 주로 ml 모듈에 포함되어 있고, cv::ml::StatModel 추상 클래스를 상속받아 만들어진다.
- StatModel 클래스 이름은 통계적 모델(statistical model)을 의미한다.
- StatModel 추상 클래스를 상속 받아 만들어진 머신 러닝 알고리즘 구현 클래스는 아래 그림과 같다.
- StatModel 클래스는 머신 러닝 알고리즘을 학습시키는 StatModel::train() 멤버 함수를 갖고 있다. StatModel 클래스를 상속 받아 만든 머신 러닝 구현 클래스는 각각의 머신 러닝 알고리즘에 해당하는 train()과 predict() 기능을 재정의하고 있다.
- StatModel::train() 함수는 samples에 저장된 다수의 훈련 데이터를 사용하여 머신 러닝 알고리즘을 학습한다.
- 이때 훈련 데이터에 대한 정답 또는 레이블 정보는 response 인자로 전달한다.
- 보통 samples와 responses 인자는 Mat 타입 객체로 전달한다.
- Mat 행렬에 훈련 데이터가 어떤 방식으로 저장되어 있는지를 layout 인자로 설정한다. layout에는 RAW_SAMPLE(행 단위)과 COL_SAMPLE(열 단위) 상수를 지정할 수 있다.
- StatModel 클래스를 상속받은 클래스 객체에서 train() 함수를 호출하면 각 머신 러닝 알고리즘에 해당하는 방식으로 학습을 진행한다.
- 이미 학습된 모델에 대해 테스트 데이터의 응답을 얻고 싶으면 StatModel::predict() 함수를 사용하면 된다.
- StatModel::predict() 함수는 순수 가상 함수로 선언되었으며, 각각의 머신 러닝 알고리즘 구현 클래스는 자신만의 알고리즘을 이용한 예측을 수행하도록 predict() 함수를 재정의하고 있다.
- 일부 머신 러닝 알고리즘 구현 클래스는 predict(0 대신 고유의 예측 함수를 이용하기도 한다.
- OpenCV에서 StatModel 클래스를 상속받아 만들어진 머신 러닝 알고리즘 구현 클래스에 대한 설명은 아래 표에 있다.
| 클래스 이름 |
설명 |
| ANN_MLP |
인공 신경망(artificial neural network) 다층 퍼셉트론(multi-layer perceptrons). 여러 개의 은닉층을 포함한 신경망을 학습시킬 수 있고, 입력 데이터에 대한 결과를 예측할 수 있다. |
| DTrees |
이진 의사 결정 트리(decision trees) 알고리즘. DTrees 클래스는 다시 부스팅 알고리즘을 구현한 ml::Boost 클래스와 랜덤 트리(random tree) 알고리즘을 구현한 ml:RTree 클래스의 부모 클래스 역할을 한다. |
| Boost |
부스팅(boosting) 알고리즘. 다수의 약한 분류기(weak classifier)에 적절한 가중치를 부여하여 성능이 좋은 분류기를 만든다. |
| RTrees |
랜덤 트리(random tree) 또는 랜덤 포르세느(random forest) 알고리즘.입력 특징 벡터를 다수의 트리로 예측하고, 그 결과를 취합하여 분류 또는 회귀를 수행한다. |
| EM |
기댓값 최대화(Expectation Maximization). 가우시안 혼합 모델(Gausssian mixture model)을 이용한 군집화 알고리즘 |
| KNearest |
k 최근접 이웃(k-Nearest Neighbor) 알고리즘. k 최근접 이웃 알고리즘은 샘플 데이터와 인접합 k개의 훈련 데이터를 찾고, 이 중 가장 많은 개수에 해당하는 클래스를 샘플 데이터 클래스로 지정한다. |
| LogisticRegression |
로지스틱 회귀(logistic regression). 이준 분류 알고리즘의 일종 |
| NormalBayesClassifier |
정규 베이즈 분류기. 정규 베이즈 분류기는 각 클래스의 특징 벡터가 정규 분포를 따른다고 가정한다. 따라서 전체 데이터 분포는 가우시안 혼합 모델로 표현 가능하다. 정규 베이즈 분류기는 학습 데이터로부터 각 클래스의 평균 벡터와 공분산 행렬을 계산하고 이를 예측에 사용한다. |
| SVM |
서포트 벡터 머신(support vector machine) 알고리즘. 두 클래스의 데이터를 가장 여유 있게 분리하는 초평며을 구한다. 커널 기법을 이용하여 비선형 데이터 분류에도 사용할 수 있으며, 다중 클래스 분류 및 회귀에도 적용할 수 있다. |
| SVMSDG |
통계적 그래디언트 하향(stochastic gradient descent) SVM. 통계적 그래디언트 하향 방법을 SVM에 적용함으로써 대용량 데이터에 대해서도 빠른 학습이 가능하다. |
k 최근접 이웃
k 최근접 이웃 알고리즘
- k 최근접 이웃(kNN, k-Nearest Neighbor) 알고리즘은 분류 또는 회귀에 사용되는 지도 학습 알고리즘의 하나이다.
- kNN 알고리즘을 분류에 사용할 경우 특징 공간에서 테스트 데이터와 가장 가까운 k개의 훈련 데이터를 찾고, k개의 훈련 데이터 중에서 가장 많은 클래스를 테스트 데이터의 클래스로 지정한다.
- kNN 알고리즘으 ㄹ회귀 문제에 적용할 경우에는 테스트 데이터에 인접합 k개의 훈련 데이터 평균을 테스트 데이터 값으로 설정한다.
- 아래 그림은 kNN 알고리즘 동작 방식에 대한 예시이다.
- 아래 그림은 2차원 평면상에 파란색 사각형과 빨간색 삼각형 두 종류의 데이터가 분포되어 있는데, 파란색과 빨간 점들이 훈련된 데이터이고, 이 훈련된 데이터는 2개의 클래스로 구분되어 있다.
- 각 점들은 (x, y) 좌표로 표현되므로, 이들 데이터는 2차원 특징 곤간에 정의되어 있다고 할 수 있다.
- 여기에 녹색으로 새로운 점을 추가할 경우, 이 점을 파란색으로 분류 할지 빨간색으로 분류할지를 결정해야 하는데, 간단한 방법은 새로 들어온 점과 가장 가까이 있는 점을 찾아 해당 데이터와 같은 클래스로 분류하는 방법이다.
- 아래 그림 상 녹색 점과 가장 가까운 점은 빨간색 삼각형이므로 녹색 점을 빨간색 삼각형과 같은 클래스로 지정할 수 있다.
- 이러한 방법은 최근접 이웃(NN, Nearest Neighbor) 알고리즘이라 한다.
- 그러나 녹색 점 주변에 분포로는 빨간색 삼각형보다 파란색 사각형이 더 많은데, 이와 같은 이유로 녹색점을 파란색 사각형으로 분류하는 방식을 kNN 알고리즘이라고 한다.
- kNN 알고리즘에서 k를 1로 설정하면 최근접 이웃 알고리즘이 된다. 그러므로 보통 k는 1보다 큰 값을 설정하며, k값을 어떻게 설정하느냐에 따라 분류 및 회귀 결과가 달라질 수 있다.
- 최선의 k 값을 결정하는 것은 주어진 데이터에 의존적이며, 보통 k값이 커질수록 잡음 또는 이상치 데이터의 영향이 감소한다. 그러나 k값이 어느 정도 이상으로 커질 경우 오히려 분류 및 회귀 성능이 떨어질 수 있다.
KNearest 클래스 사용하기
- OpenCV에서 k 최근접 이웃 알고리즘은 KNearest 클래스에 구현되어 있다.
- (KNearest의 함수 설명 생략)
- KNearest 객체는 기본적으로 분류를 위한 용도로 사용된다. 만일 KNearest 객체를 분류가 아닌 회귀에 적용하려면 KNearest::setIsClassifier() 멤버 함수에 false를 지정하여 호출하면 된다.
- KNearest 객체를 생성하고 속성을 설정한 후에는 StatModel::train() 함수를 통해 학습을 진행할 수 있는데, KNearest 클래스의 경우에는 train() 함수에서 실제적인 학습이 진행되지는 않으며 단순히 훈련 데이터와 레이블 데이터를 KNearest 클래스 멤버 변수에 모두 저장하는 작업이 이루어진다.
- KNearest 클래스에서 훈련 데이터를 학습한 후 테스트 데이터에 대한 예측을 수행할 때는 KNearest::findNearest() 멤버 함수를 사용한다.
- 이는 StatModel::predict() 보다 KNearest::findNearest() 함수가 예측 결과와 관련된 정보를 더 많이 반환하기 때문이다.
- KNearest::findNearest() 함수는 samples 행렬 각 행에 저장된 테스트 데이터와 가까운 k개의 훈련 데이터를 찾아 분류 또는 회귀 응답을 반환한다.
#include "opencv2/opencv.hpp"
#include <iostream>
using namespace cv;
using namespace cv::ml;
using namespace std;
Mat img;
Mat train, label;
Ptr<KNearest> knn;
int k_value = 1;
void on_k_changed(int, void*);
void addPoint(const Point& pt, int cls);
void trainAndDisplay();
int main(void)
{
img = Mat::zeros(Size(500, 500), CV_8UC3);
knn = KNearest::create();
namedWindow("knn");
createTrackbar("k", "knn", &k_value, 5, on_k_changed);
const int NUM = 30;
Mat rn(NUM, 2, CV_32SC1);
randn(rn, 0, 50);
for (int i = 0; i < NUM; i++)
addPoint(Point(rn.at<int>(i, 0) + 150, rn.at<int>(i, 1) + 150), 0);
randn(rn, 0, 50);
for (int i = 0; i < NUM; i++)
addPoint(Point(rn.at<int>(i, 0) + 350, rn.at<int>(i, 1) + 150), 1);
randn(rn, 0, 70);
for (int i = 0; i < NUM; i++)
addPoint(Point(rn.at<int>(i, 0) + 250, rn.at<int>(i, 1) + 400), 2);
trainAndDisplay();
waitKey();
return 0;
}
void on_k_changed(int, void*)
{
if (k_value < 1)
k_value = 1;
trainAndDisplay();
}
void addPoint(const Point& pt, int cls)
{
Mat new_sample = (Mat_<float>(1, 2) << pt.x, pt.y);
train.push_back(new_sample);
Mat new_label = (Mat_<int>(1, 1) << cls);
label.push_back(new_label);
}
void trainAndDisplay()
{
knn->train(train, ROW_SAMPLE, label);
for (int i = 0; i < img.rows; ++i)
{
for (int j = 0; j < img.cols; ++j)
{
Mat sample = (Mat_<float>(1, 2) << j, i);
Mat res;
knn->findNearest(sample, k_value, res);
int response = cvRound(res.at<float>(0, 0));
if (response == 0)
img.at<Vec3b>(i, j) = Vec3b(128, 128, 255);
else if (response == 1)
img.at<Vec3b>(i, j) = Vec3b(128, 255, 128);
else if (response == 2)
img.at<Vec3b>(i, j) = Vec3b(255, 128, 128);
}
}
for (int i = 0; i < train.rows; i++)
{
int x = cvRound(train.at<float>(i, 0));
int y = cvRound(train.at<float>(i, 1));
int l = label.at<int>(i, 0);
if (l == 0)
circle(img, Point(x, y), 5, Scalar(0, 0, 128), -1, LINE_AA);
else if (l == 1)
circle(img, Point(x, y), 5, Scalar(0, 128, 0), -1, LINE_AA);
else if (l == 2)
circle(img, Point(x, y), 5, Scalar(128, 0, 0), -1, LINE_AA);
}
imshow("knn", img);
}
kNN을 이용한 필기체 숫자 인식
- 20 x 20 숫자 영상 픽셀값 자체를 kNN 알고리즘 입력으로 사용하는 예시
- 5000개의 숫자 영상 데이터의 한 장의 숫자 영상은 20 x 20 픽셀 크기이고, 이 픽셀 값을 모두 일렬로 늘어 놓으면 1 x 400 크기의 행렬로 변환할 수 있다.
- 즉 필기체 숫자 훈련 데이터 하나는 400개의 숫자 값으로 표현되고, 이는 400차원 공간에서의 한 점과 같다.
- digits.png 영상에 있는 각각의 숫자 영상을 1 x 400 행렬로 바꾸고, 이 행렬을 모두 세로로 쌓으면 전체 숫자 영상 데이터를 표현하는 5000 x 400 크기의 행렬을 만들 수 있다. 그리고 이 행렬을 KNearest 클래스의 훈련 데이터로 전달한다.
- kNN 알고리즘으로 필기체 숫자 영상을 학습시키려면 각 필기체 숫자 영상이 나타내는 숫자 값을 레이블 행렬로 함께 전달해야 한다. 이 레이블 행렬의 행 크기는 훈련 데이터 영상 개수와 같고, 열 크기는 1이된다.
- 아래 그림에서 첫 행은 0, 그 다음 행은 1에 대한 데이터이므로 레이블 행렬도 첫 행의 원소는 0으로 설정하고 그 다음 해으이 원소는 1로 설정한다. 그렇게 모든 행의 원소를 설정한 후, KNearest 클래스의 레이블 데이터로 전달한다.
#include "opencv2/opencv.hpp"
#include <iostream>
using namespace cv;
using namespace cv::ml;
using namespace std;
Ptr<KNearest> train_knn();
void on_mouse(int event, int x, int y, int flags, void* userdata);
int main()
{
Ptr<KNearest> knn = train_knn();
if (knn.empty())
{
cerr << "Training failed!" << endl;
return -1;
}
Mat img = Mat::zeros(400, 400, CV_8U);
imshow("img", img);
setMouseCallback("img", on_mouse, (void*)&img);
while(true)
{
int c = waitKey(0);
if (c == 27)
{
break;
}
else if (c == ' ')
{
Mat img_resize, img_float, img_flatten, res;
resize(img, img_resize, Size(20, 20), 0, 0, INTER_AREA);
img_resize.convertTo(img_float, CV_32F);
img_flatten = img_float.reshape(1, 1);
knn->findNearest(img_flatten, 3, res);
cout << cvRound(res.at<float>(0, 0)) << endl;
img.setTo(0);
imshow("img", img);
}
}
return 0;
}
Ptr<KNearrest> train_knn()
{
Mat digits = imread("digits.png", IMREAD_GRAYSCALE);
if (digits.empty())
{
cerr << "Image load failed!" << endl;
return 0;
}
Mat train_images, train_labels;
for (int j = 0; j < 50; j++)
{
for (int i = 0; i < 100; i++)
{
Mat roi, roi_float, roi_flatten;
roi = digits(Rect(i*20, j*20, 20, 20));
roi.convertTo(roi_float, CV_32f);
roi_flatten = roi_float.reshape(1, 1);
train_images.push_back(roi_flatten);
train_labels.push_back(j / 5);
}
}
Ptr<KNearest> knn = KNearest::create();
knn->train(train_images, ROW_SAMPLE, train_labels);
return knn;
}
Point ptPrev(-1, -1);
void on_mouse(int event, int x, int y, int flags, void* userdata)
{
Mat img = *(Mat*)userdata;
if (event == EVENT_LBUTTONDOWN)
{
ptPrev = Point(x, y);
}
else if (event == EVENT_LBUTTONUP)
{
ptPrev = Point(-1, -1);
}
else if (event == EVENT_MOUSEMOVE && (flags & EVENT_FLAG_LBUTTON))
{
line(img, ptPrev, Point(x, y), Scalar::all(255), 40, LINE_AA, 0);
ptPrev = Point(x, y);
imshow("img", img);
}
}
서포트 벡터 머신
서프트 벡터 머신 알고리즘
- 서포트 벡터 머신(SVM, Support, Vector Machine)은 기본적으로 두 개의 클래스로 구성된 데이터를 가장 여유 있게 분리하는 초평면(hyperplane)을 찾는 머신 러닝 알고리즘이다.
- 초평면이란 두 클래스의 데이터를 분리하는 N차원 공간상의 평면을 의미한다. 예컨대 2차원 공간상의 점들을 분리하는 초평면은 단순한 직선 형태로 정의되며, 3차원 공간상의 점들을 분리하는 초평면은 3차원 공간에서의 평면의 방정식으로 표현할 수 있다.
- SVM 알고리즘은 지도 학습의 일종으로 분류와 회귀에 사용될 수 있다.
- 아래 그림은 SVM 알고리즘에 대한 예시이다.
- 아래 그림은 파란색 사각형과 빨간색 삼각형으로 표시된 두 클래스의 점들의 분포를 나타내는데, 이 두 클래스 점들을 구분하기 위한 직선은 매우 다양하게 만들 수 있다.
- 그림 (a)의 1, 2번 직선은 모두 두 종류의 점들을 잘 분리하지만, 1번 직선은 조금만 왼쪽이나 오른쪽으로 이동해도 분리에 실패하게 되고, 2번 직선도 오른쪽으로 조금만 이동하면 분리에 실패하게 된다.
- 이는 1, 2번 직선이 모두 입력 점 데이터에너무 가까이 위치하고 있기 때문인데, 그림 (b)의 3번 직선은 두 클래스 점들 사이를 충분히 여유 있게 분할하고 있어서 그런 문제가 없다.
- 이때 3번 직선에 해당하는 초평면과 가장 가까이 있는 빨간색 또는 파란색 점들과의 거리를 마진(margin)이라 하며, SVM은 이 마진을 최대로 만드는 초평면을 구하는 알고리즘이다.
- SVM은 기본적으로 선형으로 분리 가능한 데이터에 적용할 수 있다.
- 그러나 실생활에서 사용하는 데이터는 선형으로 분리되지 않는 경우가 많으며, 이러한 경우에도 SVM 알고리즘을 적용하기 위해 SVM에서는 커널 트릭(kernel trick)이라는 기법을 사용한다.
- 커널 트릭이란 적절한 커널 함수를 이용하여 입력 데이터 특징 공간 차원을 늘리는 방식이다. 원본 데이터 차원에서는 선형으로 분리할 수 없었던 데이터를 커널 트릭으로 고차원 특징 공간으로 이동하면 선형으로 분리 가능한 형태로 바뀔 수 있다.
- 데이터 특징 공간 차원을 증가시켜서 데이터를 선형 분리하는 예는 다음과 같다.
- 2차원 좌표 평면 상의 점 집합 X = { (0, 0), (1, 1) }과 Y = { (1, 0), (0, 1) }이 있다고 가정하고, 이 두 클래스 점들을 아래 그림 처럼 각각 파란색과 빨간색 점으로 나타냈다.
- 2차원 평면상에서 X, Y 두 클래스 점들을 분리할 수 있는 직선은 존재하지 않는데, 입력 점들의 좌표에 가상의 z축 좌표를
형태로 추가할 경우, X = { (0, 0, 0), (1, 1, 0) }과 Y = { (1, 0, 1), (0, 1, 1) } 형태로 3차원 공간상에서의 점 집합으로 바뀌게 된다.
- 이렇게 차원 공간으로 변경된 X와 Y 점들을 아래 그림의 (b)처럼 그릴 수 있다. 그리고 이 두 클래스 점들은 z = 0.5 평면의 방정식을 이용하여 효과적으로 분리할 수 있다.
- 2차원 평면에서 선형 분리할 수 없었던 X와 Y 데이터 집합이 가상의 차원을 추가함으로써 선형으로 분리될 수 있게 된 것이다.
- SVM 알고리즘에서 사용할 수 있는 커널 함수의 종류는 아래 표와 같다.
- 아래 표에서 가장 널리 사용되는 커널은 방사 기저 함수이며, 이 커널을 사용할 때는
인자 값을 적절히 설정해야 한다.
- 만약 입력 데이터가 선형으로 분리 가능하다면 선형 커널을 사용하는 것이 가장 빠르게 동작한다.
| SVM 커널 |
커널 함수 |
| 선형(linear) |
 |
| 다항식(polynomial) |
 |
| 방사 기저 함수(radial basis function) |
 |
| 시그모이드(sigmoid) |
 |
| 지수 카이 제곱(exponential chi-square) |
 |
| 히스토그램 교차(histogram intersection) |
 |
SVM 클래스 사용하기
- OpenCV에서 SVM 알고리즘은 SVM 클래스에 구현되어 있다. OpenCV에 구현된 SVM 클래스는 오픈소스 라이브러리인 LIBSVM을 기반으로 만들어졌다.
- SVM 클래스는 기본적으로 SVM::Types::C_SVC 타입을 사용하도록 초기화되며 다른 타입을 사용하려면 SVM::setType() 함수를 이용하여 타입을 변경할 수 있다.
- SVM::Types::C_SVC 타입을 사용하는 경우 SVM 알고리즘 내부에서 사용하는 C 파라미터 값을 적절하게 설정해야 하는데, C 값을 작게 설정하면 훈련 데이터 중에 잘못 분류된느 데이터가 있어도 최대 마진을 선택하고, C 값을 크게 설정하면 마진이 작아지더라도 잘못 분류되는 데이터가 적어지도록 분류한다.
- 만약 훈련 샘플 데이터에 잡음 또는 이상치 데이터가 많이 포함된 경우에는 C 파라미터 값을 크게 설정하는 것이 유리하다.
| SVM::Types |
설명 |
파라미터 |
| C_SVC |
C-서포트 벡터 분류. 일반적인 n-클래스 분류 문제에서 사용된다. |
C |
| NU_SVC |
v-서포트 벡터 분류. C_SCV와 비슷하지만 Nu 값 범위가 0-1 사이로 정규화 되어 있다. |
Nu |
| ONE_CLASS |
1-분류 서포트 벡터 머신. 데이터 분포 측정에 사용된다. |
C, Nu |
| EPS_SVR |
 -서포트 벡터 회귀 |
P, C |
| NU_SVR |
v-서포트 벡터 회귀 |
Nu, C |
- SVM 타입 설정 후에 SVM 알고리즘에서 사용할 커널 함수를 지정해야 한다. 함수 지정은 SVM::setKernel() 함수를 이용하면 된다.
| SVM::KernelTYpes |
설명 |
파라미터 |
| LINEAR |
선형 커널 |
|
| POLY |
다항식 커널 |
Degree, Gamma, Coef0 |
| RBF |
방사 기저 함수 커널 |
Gamma |
| SIGMOID |
시그모이드 커널 |
Gamma, Coef0 |
| CHI2 |
지수 카이 제곱 커널 |
Gamma |
| INTER |
히스토그램 교차 커널 |
|
- SVM 타입과 커널 함수 종류를 설정한 후에는 각각의 타입과 커널 함수 정의에 필요한 파라미터를 설정해야 한다.
- SVM 클래스에서 설정할 수 있는 파라미터는 C, Nu, P, Degree, Gamma, Coef0 등이 있으며, 이들 파라미터는 차례대로 1, 0, 0, 0, 1, 0으로 초기화 된다.
- 각각의 파라미터는 파라미터 이름에 해당하는 setXXX()와 getXXX(0 함수를 이용하여 값을 설정하거나 읽어올 수 있다.
- SVM 객체를 생성하고 타입과 커널 함수, 파라미터를 설정한 후에는 StatModel::train() 함수를 이용하여 학습을 시킬 수 있다.
- 그러나 SVM에서 사용하는 파라미터를 적절하게 설정하지 않으면 학습이 제대로 되지 않는데, OpenCV에서는 각각의 파라미터에 대해 설정 가능한 값을 적용해 보고 그중 가장 성능이 좋은 파라미터를 자동으로 찾아 학습하는 SVM::trainAuto() 함수를 제공한다.
- 다만 SVM::trainAuto() 함수는 매우 느리기 때문에 한 번 학습이 완료된 후 선택된 파라미터를 저장했다가 재사용하는 편이 좋다.
- SVM 학습이 완료되었다면 StatModel::predict()를 통해 테스트 데이터에 대한 예측을 수행할 수 있다.
#include "opencv2/opencv.hpp"
#include <iostream>
using namespace cv;
using namespace cv::ml;
using namespace std;
int main(void)
{
Mat train = Mat_<float>({8, 2}, {150, 200, 200, 250, 100, 250, 150, 300, 350, 100, 400, 200, 400, 300, 350, 400});
Mat label = Mat_<int>({8, 1}, {0, 0, 0, 0, 1, 1, 1, 1});
Ptr<SVM> svm = SVM::create();
svm->setType(SVM::Types::C_SVC);
svm->setKernel(SVM::KernelTypes::RBF);
svm->trainAuto(train, ROW_SAMPLE, label);
Mat img = Mat::zeros(Size(500, 500), CV_8UC3);
for (int j = 0; j < img.rows; j++)
{
for (int i = 0; i < img.cols; i++)
{
Mat test = Mat_<float>({1, 2}, {(float)i, (float)j});
int res = cvRound(svm->predict(test));
if (res == 0)
img.at<Vec3b>(j, i) = Vec3b(128, 128, 255);
else
img.at<Vec3b>(j, i) = Vec3b(128, 255, 128);
}
}
for (int i = 0; i < train.rows; i++)
{
int x = cvRound(train.at<float>(i, 0));
int y = cvRound(train.at<float>(i, 1));
int l = label.at<int>(i, 0);
if (l == 0)
cicle(img, Point(x, y), 5, Scalar(0, 0, 128), -1, LINE_AA);
else
cicle(img, Point(x, y), 5, Scalar(0, 128, 0), -1, LINE_AA);
}
imshow("svm", img);
waitKey();
return 0;
}
HOG & SVM 필기체 숫자 인식
- kNN으로 했던 필기체 인식의 SVM 버전
- 각 숫자 영상에서 HOG 특징 벡터를 추출한 후 SVM 알고리즘 입력 데이터로 사용한다.
- HOG 특징 벡터 추출을 위해 HOGDescriptor 클래스를 사용한다.
#include "opencv2/opencv.hpp"
#include <iostream>
using namespace cv;
using namespace cv::ml;
using namespace std;
Ptr<SVM> train_hog_svm(const HOGDescriptor& hog);
void on_mouse(int event, int x, int y, int flags, void* userdata);
int main()
{
HOGDescriptor hog(Size(20, 20), Size(10, 10), Size(5, 5), Size(5, 5), 9);
Ptr<SVM> svm = train_hog_svm(hog);
if (svm.empty())
{
cerr << "Training failed!" << endl;
return -1;
}
Mat img = Mat::zeros(400, 400, CV_8U);
imshow("img", img);
setMoustCallback("img", on_mouse, (void*)&img);
while(true)
{
int c = waitKey(0);
if (c == 27)
{
break;
}
else if (c == ' ')
{
Mat img_resize;
resize(img, img_resize, Size(20, 20), 0, 0, INTER_AREA);
vector<float> desc;
hog.compute(img_resize, desc);
Mat desc_mat(desc);
int res = cvRound(svm->predict(desc_mat.t()));
cout << res << endl;
img.setTo(0);
imshow("img", img);
}
}
return 0;
}
Ptr<SVM> train_hog_svm(const HOGDescriptor& hog)
{
Mat digits = imread("digits.png", IMREAD_GRAYSCALE);
if (digits.empty())
{
cerr << "Image load failed!" << endl;
return 0;
}
Mat train_hog, train_labels;
for (int j = 0; j < 50; j++)
{
for (int i = 0; i < 100; i++)
{
Mat roi = digits(Rect(i*20, j*20, 20, 20));
vector<float> desc;
hog.compute(roi, desc);
Mat desc_mat(desc);
train_hog.push_back(desc_mat.t());
train_labels.push_back(j / 5);
}
}
// 아래 상수값은 SVM::trainAuto()를 통해 구한 값이다.
Ptr<SVM> svm = SVM::create();
svm->setType(SVM::Types::C_SVC);
svm->setKernel(SVM::KernelTypes::RBF);
svm->setC(2.5);
svm->setGamma(0.50625);
svm->train(train_hog, ROW_SAMPLE, train_labels);
return svm;
}
Point ptPrev(-1, -1);
void on_mouse(int event, int x, int y, int flags, void* userdata)
{
Mat img = *(Mat*)userdata;
if (event == EVENT_LBUTTONDOWN)
{
ptPrev = Point(x, y);
}
else if (event == EVENT_LBUTTONUP)
{
ptPrev = Point(-1, -1);
}
else if (event == EVENT_MOUSEMOVE && (flags & EVENT_FLAG_LBUTTON))
{
line(img, ptPrev, Point(x, y), Scalar::all(255), 40, LINE_AA, 0);
ptPrev = Point(x, y);
imshow("img", img);
}
}
노드는 입력 노드이고 오른쪽의
는 출력 노드이다.
의 가중치가 지정되어 있다.
노드는 입력 노드이고 오른쪽의 
는 출력 노드이다.
의 가중치가 지정되어 있다.는 편향(bias)라고 부르며
는 편향(bias)라고 부르며 
로 설정하고, 편항은
로 설정할 수 있다. 이 경우 출력
로 설정하고, 편항은 
로 설정할 수 있다. 이 경우 출력 
형태로 추가할 경우, X = { (0, 0, 0), (1, 1, 0) }과 Y = { (1, 0, 1), (0, 1, 1) } 형태로 3차원 공간상에서의 점 집합으로 바뀌게 된다.
인자 값을 적절히 설정해야 한다. 
-서포트 벡터 회귀
에서 
와 
만큼 떨어진 픽셀과의 밝기 차이를 다음 수식으로 표현하였다.![E(\Delta x, \Delta y) = \sum_{x, y} w(x, y) [I(x + \Delta x, y + \Delta y) - I(x, y)]^{2}](http://s0.wp.com/latex.php?latex=E%28%5CDelta+x%2C+%5CDelta+y%29+%3D+%5Csum_%7Bx%2C+y%7D+w%28x%2C+y%29+%5BI%28x+%2B+%5CDelta+x%2C+y+%2B+%5CDelta+y%29+-+I%28x%2C+y%29%5D%5E%7B2%7D+&bg=ffffff&fg=000&s=2 "E(\Delta x, \Delta y) = \sum_{x, y} w(x, y) [I(x + \Delta x, y + \Delta y) - I(x, y)]^{2}")
는 균일한 값을 갖는 사각형 윈도우 또는 가우시안 형태의 가중치를 갖는 윈도우이다.
함수가 모든 방향으로 값이 크게 나타난다면 점 
![M = \sum_{x, y} w(x, y) \left[ \begin{array}{rr} I_{x} I_{x} & I_{x} I_{y} \\ I_{x} I_{y} & I_{y} I_{y} \end{array} \right]](http://s0.wp.com/latex.php?latex=M+%3D+%5Csum_%7Bx%2C+y%7D+w%28x%2C+y%29+%5Cleft%5B+%5Cbegin%7Barray%7D%7Brr%7D+I_%7Bx%7D+I_%7Bx%7D+%26+I_%7Bx%7D+I_%7By%7D+%5C%5C+I_%7Bx%7D+I_%7By%7D+%26+I_%7By%7D+I_%7By%7D+%5Cend%7Barray%7D+%5Cright%5D+&bg=ffffff&fg=000&s=2 "M = \sum_{x, y} w(x, y) \left[ \begin{array}{rr} I_{x} I_{x} & I_{x} I_{y} \\ I_{x} I_{y} & I_{y} I_{y} \end{array} \right]")
와 
s는 입력 영상 
를 각각 x축 방향과 y축 방향으로 편미분한 결과이다.
라고 할 때, 주변 16개의 픽셀 중에서 그 값이 
보다 큰 픽셀이 9개 이상 연속으로 나타나면 점 p는 어두운 영역이 뾰족하게 돌출되어 있는 코너이다.
보다 작은 픽셀이 9개 이상 연속으로 나타나면 점 p는 밝은 영역이 돌출되어 있는 코너라고 간주한다.
에서의 픽셀 값 크기 비교 테스트 
는 다음과 같이 정의한다.
를 구하면 이진수 
를 얻을 수 있다.
시점에서 바라본 영상 
과 
시점에서 바라본 영상 
사이의 관계를 호모그래피 
로 표현하였다.
과 
형태로 표현할 수 있다.
로 표현하고 목표 평면상의 점 좌표를 
로 표현할 경우 호모그래피 H는 다음 수식을 최소화하는 형태의 행렬이 된다.
는 호모그래피 행렬 H의 원소를 나타내고 다음과 같은 관계를 만족시킨다.![s_{i} \left[ \begin{array}{rrr} x_{i}' \\ y_{i}' \\ 1 \end{array} \right] \sim H \left[ \begin{array}{rrr} x_{i} \\ y_{i} \\ 1 \end{array} \right] = \left[ \begin{array}{rrr} h_{11} & h_{12} & h_{13} \\ h_{21} & h_{22} & h_{23} \\ h_{31} & h_{32} & h_{33} \end{array} \right] \left[ \begin{array}{rrr} x_{i} \\ y_{i} \\ 1 \end{array} \right]](http://s0.wp.com/latex.php?latex=s_%7Bi%7D+%5Cleft%5B+%5Cbegin%7Barray%7D%7Brrr%7D+x_%7Bi%7D%27+%5C%5C+y_%7Bi%7D%27+%5C%5C+1+%5Cend%7Barray%7D+%5Cright%5D+%5Csim+H+%5Cleft%5B+%5Cbegin%7Barray%7D%7Brrr%7D+x_%7Bi%7D+%5C%5C+y_%7Bi%7D+%5C%5C+1+%5Cend%7Barray%7D+%5Cright%5D+%3D+%5Cleft%5B+%5Cbegin%7Barray%7D%7Brrr%7D+h_%7B11%7D+%26+h_%7B12%7D+%26+h_%7B13%7D+%5C%5C+h_%7B21%7D+%26+h_%7B22%7D+%26+h_%7B23%7D+%5C%5C+h_%7B31%7D+%26+h_%7B32%7D+%26+h_%7B33%7D+%5Cend%7Barray%7D+%5Cright%5D+%5Cleft%5B+%5Cbegin%7Barray%7D%7Brrr%7D+x_%7Bi%7D+%5C%5C+y_%7Bi%7D+%5C%5C+1+%5Cend%7Barray%7D+%5Cright%5D+&bg=ffffff&fg=000&s=2 "s_{i} \left[ \begin{array}{rrr} x_{i}' \\ y_{i}' \\ 1 \end{array} \right] \sim H \left[ \begin{array}{rrr} x_{i} \\ y_{i} \\ 1 \end{array} \right] = \left[ \begin{array}{rrr} h_{11} & h_{12} & h_{13} \\ h_{21} & h_{22} & h_{23} \\ h_{31} & h_{32} & h_{33} \end{array} \right] \left[ \begin{array}{rrr} x_{i} \\ y_{i} \\ 1 \end{array} \right]")
와 
사이의 거리가 ransacReprojThreshold 보다 작으면 정상치(inlier)로 간주한다.
에 대한 벡터공간 
위의 선형사상 
에 대하여 다음 두 조건
와 
를 각각 고윳값과 고유벡터라고 한다.
을 곱한 것과 동일한 결과를 가져오는 스칼라 -2가 고윳값이 되며 그때의 벡터가 고유벡터가 된다.
행렬 
가 
는 
일 때,
의 고윳값 찾기
의 핵을 
는 항등사상)
의 고유벡터들로 구성된 
일 때,
, 고유기저 = 
의 고윳값, 고유벡터, 고유기저 구하기
일 때 고유벡터 구하기
, 고유기저 = 
일 때 고유벡터 구하기
, 고유기저 = 
에 대하여 방정식
와 가역행렬 
가 존재하면 행렬 
는 대각화 가능행렬이라고 한다. 또한 이 경우 행렬 
일 때,
이라는 선형사상으로 분해가 가능하다는 뜻이 되기도 한다.
개의 선형독립인 고유벡터를 갖는다.
로부터 행렬 
를 만든다.
는 대각행렬이 된다.
이 대각화 가능한지 확인
, 고유기저 = 
에 대한 
가 
가 인수로 나타나는 횟수를 
라 표현한다.
이 성립하며, 이를 케일리-해밀턴 정리라고 한다. (단, 
는 영행렬)
는 (x, y) 주변 블록 영역의 픽셀값 평균이고 C는 임계값의 크기를 조정하는 상수이다.
의 값 변화에 따른 미분 
는 아래 그림과 같다.
는 1차원 이산함수이고, 
는 이산 값의 간격을 의미한다.
로 정리되며, 이는 자기 자신 바로 앞에 있는 픽셀에서 자기 자신 픽셀 값을 뺀 형태이다.
로 정리되며, 이는 자기 자신 픽셀에서 바로 뒤에 있는 픽셀 값을 뺀 형태이다.
로 정리되며,로 정리되며 자기 자신을 제외하고 바로 앞과 뒤의 픽셀값을 이용하는 미분 근사 방법이다.
를 가로 방향으로 미분한다는 것은 y좌표는 고정한 상태에서 x축 방향으로만 미분 근사를 계산하는 것을 의미하며, 이러한 연산을 x축 방향으로의 편미분(partial derivative)라고 한다.
로 표기한다.
라고 표기하고, x 좌표를 고정한 상태에서 y축 방향으로 미분 근사를 수행하여 구할 수 있다.
가 있을 때, 이 함수의 x축 방향 미분과 y축 방향 미분을 한꺼번에 벡터로 표현한 것을 그래디언트(gradient)라고 하고 다음과 같이 표기한다.![\nabla f = \left[ \begin{array}{rr} f_{x} \\ f_{y} \end{array} \right] = f_{x}i + f_{y}j](http://s0.wp.com/latex.php?latex=%5Cnabla+f+%3D+%5Cleft%5B+%5Cbegin%7Barray%7D%7Brr%7D+f_%7Bx%7D+%5C%5C+f_%7By%7D+%5Cend%7Barray%7D+%5Cright%5D+%3D+f_%7Bx%7Di+%2B+f_%7By%7Dj+&bg=ffffff&fg=000&s=2 "\nabla f = \left[ \begin{array}{rr} f_{x} \\ f_{y} \end{array} \right] = f_{x}i + f_{y}j")
로 표기하고 다음과 같이 구한다.
는 다음 수식으로 구할 수 있다.
와 y축 방향으로의 편미분 
성분을 함께 표시하였으며, 이 두 성분을 이용하여 빨간색 화살표를 그릴 수 있다.
라고 할 경우,
의 L2 노름(L2 norm)이라고 한다.
형태로 계산하기도 하며, 이를 벡터 
, 낮은 임계값을 
라고 할 때,
이다.
와 
는 직선의 모양을 결정하는 상수이다.
를 선택하고 이 점의 좌표를 이용하면 ab 공간에서 빨간색 직선 
를 정의할 수 있다.
를 이용하면 ab 공간에서 보라색 직선 
를 표현할 수 있다.
이며 이는 xy 공간에서 직선의 방정식 
는 원점에서 직선까지의 수직 거리를 나타내고 
공간에서는 삼각함수 그래프 형태의 곡선으로 표현되고 
이다.
가 (a)의 파란색 직선을 나타내는 파라미터가 된다.
사이의 실수를 가질 수 있는데, 이 구간을 180단계나 360단계로 나눌 수 있다. 구간을 촘촘하게 나눌 경우 정밀한 직선 검출이 가능하지만 연산 시간이 늘어날 수 있다.
에 대하여 
인 
인 
인 
인 
의 합성은 
로 쓴다.
일 때, 
를 
의 왼쪽 역사상, 
: 영사상
(단, k는 스칼라)
(단, 
)
(단, $latex v_{0} \in V)
로의 선형사상의 집합을 
라 하고, 다음과 같이 
)
행렬들의 집합을 
라 하고, 두 사상 
를 다음과 같이 정의한다.
![f(L) = [L]_{B_{W}}^{B_{V}} = M](http://s0.wp.com/latex.php?latex=f%28L%29+%3D+%5BL%5D_%7BB_%7BW%7D%7D%5E%7BB_%7BV%7D%7D+%3D+M+&bg=ffffff&fg=000&s=2 "f(L) = [L]_{B_{W}}^{B_{V}} = M")
![g(M) = L_{M} ([L_{M}(v)]_{B_{W}} = M[v]_{B_{v}})](http://s0.wp.com/latex.php?latex=g%28M%29+%3D+L_%7BM%7D+%28%5BL_%7BM%7D%28v%29%5D_%7BB_%7BW%7D%7D+%3D+M%5Bv%5D_%7BB_%7Bv%7D%7D%29+&bg=ffffff&fg=000&s=2 "g(M) = L_{M} ([L_{M}(v)]_{B_{W}} = M[v]_{B_{v}})")
는 
는 
가 
에 대해 ![[v]_{B_{V}} = (k_{1}, k_{2}, ... , k_{n})^{T}](http://s0.wp.com/latex.php?latex=%5Bv%5D_%7BB_%7BV%7D%7D+%3D+%28k_%7B1%7D%2C+k_%7B2%7D%2C+...+%2C+k_%7Bn%7D%29%5E%7BT%7D+&bg=ffffff&fg=000&s=2 "[v]_{B_{V}} = (k_{1}, k_{2}, ... , k_{n})^{T}")
![v \in V, v = 3v_{1} + v_{2} + 2v_{3} \Rightarrow (3, 2, 1)^{T} \Rightarrow [v]_{B_{v}}](http://s0.wp.com/latex.php?latex=v+%5Cin+V%2C+v+%3D+3v_%7B1%7D+%2B+v_%7B2%7D+%2B+2v_%7B3%7D+%5CRightarrow+%283%2C+2%2C+1%29%5E%7BT%7D+%5CRightarrow+%5Bv%5D_%7BB_%7Bv%7D%7D+&bg=ffffff&fg=000&s=2 "v \in V, v = 3v_{1} + v_{2} + 2v_{3} \Rightarrow (3, 2, 1)^{T} \Rightarrow [v]_{B_{v}}")
![[L]_{B_{W}}^{B_{V}} = ([L(v_{1})]_{B_{W}}, [L(v_{2})]_{B_{W}}, ... , [L(v_{n})]_{B_{W}})](http://s0.wp.com/latex.php?latex=%5BL%5D_%7BB_%7BW%7D%7D%5E%7BB_%7BV%7D%7D+%3D+%28%5BL%28v_%7B1%7D%29%5D_%7BB_%7BW%7D%7D%2C+%5BL%28v_%7B2%7D%29%5D_%7BB_%7BW%7D%7D%2C+...+%2C+%5BL%28v_%7Bn%7D%29%5D_%7BB_%7BW%7D%7D%29+&bg=ffffff&fg=000&s=2 "[L]_{B_{W}}^{B_{V}} = ([L(v_{1})]_{B_{W}}, [L(v_{2})]_{B_{W}}, ... , [L(v_{n})]_{B_{W}})")
![L(v_{1}) = \left( \begin{array}{rrr} 1 & 1 \\ 2 & 2 \\ 3 & 3 \end{array} \right) \cdot \left( \begin{array}{rr} 1 \\ 1 \end{array} \right) \Rightarrow [L(v_{1})]_{B_{w}} = \left( \begin{array}{rrr} 2 \\ 4 \\ 6 \end{array} \right) \in \mathbb{R}^{3}](http://s0.wp.com/latex.php?latex=L%28v_%7B1%7D%29+%3D+%5Cleft%28+%5Cbegin%7Barray%7D%7Brrr%7D+1+%26+1+%5C%5C+2+%26+2+%5C%5C+3+%26+3+%5Cend%7Barray%7D+%5Cright%29+%5Ccdot+%5Cleft%28+%5Cbegin%7Barray%7D%7Brr%7D+1+%5C%5C+1+%5Cend%7Barray%7D+%5Cright%29+%5CRightarrow+%5BL%28v_%7B1%7D%29%5D_%7BB_%7Bw%7D%7D+%3D+%5Cleft%28+%5Cbegin%7Barray%7D%7Brrr%7D+2+%5C%5C+4+%5C%5C+6+%5Cend%7Barray%7D+%5Cright%29+%5Cin+%5Cmathbb%7BR%7D%5E%7B3%7D+&bg=ffffff&fg=000&s=2 "L(v_{1}) = \left( \begin{array}{rrr} 1 & 1 \\ 2 & 2 \\ 3 & 3 \end{array} \right) \cdot \left( \begin{array}{rr} 1 \\ 1 \end{array} \right) \Rightarrow [L(v_{1})]_{B_{w}} = \left( \begin{array}{rrr} 2 \\ 4 \\ 6 \end{array} \right) \in \mathbb{R}^{3}")
![L(v_{2}) = \left( \begin{array}{rrr} 1 & 1 \\ 2 & 2 \\ 3 & 3 \end{array} \right) \cdot \left( \begin{array}{rr} 2 \\ 2 \end{array} \right) \Rightarrow [L(v_{2})]_{B_{w}} = \left( \begin{array}{rrr} 4 \\ 8 \\ 12 \end{array} \right) \in \mathbb{R}^{3}](http://s0.wp.com/latex.php?latex=L%28v_%7B2%7D%29+%3D+%5Cleft%28+%5Cbegin%7Barray%7D%7Brrr%7D+1+%26+1+%5C%5C+2+%26+2+%5C%5C+3+%26+3+%5Cend%7Barray%7D+%5Cright%29+%5Ccdot+%5Cleft%28+%5Cbegin%7Barray%7D%7Brr%7D+2+%5C%5C+2+%5Cend%7Barray%7D+%5Cright%29+%5CRightarrow+%5BL%28v_%7B2%7D%29%5D_%7BB_%7Bw%7D%7D+%3D+%5Cleft%28+%5Cbegin%7Barray%7D%7Brrr%7D+4+%5C%5C+8+%5C%5C+12+%5Cend%7Barray%7D+%5Cright%29+%5Cin+%5Cmathbb%7BR%7D%5E%7B3%7D+&bg=ffffff&fg=000&s=2 "L(v_{2}) = \left( \begin{array}{rrr} 1 & 1 \\ 2 & 2 \\ 3 & 3 \end{array} \right) \cdot \left( \begin{array}{rr} 2 \\ 2 \end{array} \right) \Rightarrow [L(v_{2})]_{B_{w}} = \left( \begin{array}{rrr} 4 \\ 8 \\ 12 \end{array} \right) \in \mathbb{R}^{3}")
![L(v_{3}) = \left( \begin{array}{rrr} 1 & 1 \\ 2 & 2 \\ 3 & 3 \end{array} \right) \cdot \left( \begin{array}{rr} 3 \\ 3 \end{array} \right) \Rightarrow [L(v_{3})]_{B_{w}} = \left( \begin{array}{rrr} 6 \\ 12 \\ 18 \end{array} \right) \in \mathbb{R}^{3}](http://s0.wp.com/latex.php?latex=L%28v_%7B3%7D%29+%3D+%5Cleft%28+%5Cbegin%7Barray%7D%7Brrr%7D+1+%26+1+%5C%5C+2+%26+2+%5C%5C+3+%26+3+%5Cend%7Barray%7D+%5Cright%29+%5Ccdot+%5Cleft%28+%5Cbegin%7Barray%7D%7Brr%7D+3+%5C%5C+3+%5Cend%7Barray%7D+%5Cright%29+%5CRightarrow+%5BL%28v_%7B3%7D%29%5D_%7BB_%7Bw%7D%7D+%3D+%5Cleft%28+%5Cbegin%7Barray%7D%7Brrr%7D+6+%5C%5C+12+%5C%5C+18+%5Cend%7Barray%7D+%5Cright%29+%5Cin+%5Cmathbb%7BR%7D%5E%7B3%7D+&bg=ffffff&fg=000&s=2 "L(v_{3}) = \left( \begin{array}{rrr} 1 & 1 \\ 2 & 2 \\ 3 & 3 \end{array} \right) \cdot \left( \begin{array}{rr} 3 \\ 3 \end{array} \right) \Rightarrow [L(v_{3})]_{B_{w}} = \left( \begin{array}{rrr} 6 \\ 12 \\ 18 \end{array} \right) \in \mathbb{R}^{3}")
![\Rightarrow [L]_{B_{w}}^{B_{v}} = \left( \begin{array}{rrr} 2 & 4 & 6 \\ 4 & 8 & 12 \\ 6 & 12 & 18 \end{array} \right) = M \in \mathcal{M}_{3 \times 3}](http://s0.wp.com/latex.php?latex=%5CRightarrow+%5BL%5D_%7BB_%7Bw%7D%7D%5E%7BB_%7Bv%7D%7D+%3D+%5Cleft%28+%5Cbegin%7Barray%7D%7Brrr%7D+2+%26+4+%26+6+%5C%5C+4+%26+8+%26+12+%5C%5C+6+%26+12+%26+18+%5Cend%7Barray%7D+%5Cright%29+%3D+M+%5Cin+%5Cmathcal%7BM%7D_%7B3+%5Ctimes+3%7D+&bg=ffffff&fg=000&s=2 "\Rightarrow [L]_{B_{w}}^{B_{v}} = \left( \begin{array}{rrr} 2 & 4 & 6 \\ 4 & 8 & 12 \\ 6 & 12 & 18 \end{array} \right) = M \in \mathcal{M}_{3 \times 3}")
와 
는 모두 동형사상이다. 또한 두 사상 
![[(L_{1} + L_{2}) (v_{i})]_{B_{w}} = [L_{1}(v_{i})]_{B_{w}} + [L_{2}(v_{i})]_{B_{w}}](http://s0.wp.com/latex.php?latex=%5B%28L_%7B1%7D+%2B+L_%7B2%7D%29+%28v_%7Bi%7D%29%5D_%7BB_%7Bw%7D%7D+%3D+%5BL_%7B1%7D%28v_%7Bi%7D%29%5D_%7BB_%7Bw%7D%7D+%2B+%5BL_%7B2%7D%28v_%7Bi%7D%29%5D_%7BB_%7Bw%7D%7D+&bg=ffffff&fg=000&s=2 "[(L_{1} + L_{2}) (v_{i})]_{B_{w}} = [L_{1}(v_{i})]_{B_{w}} + [L_{2}(v_{i})]_{B_{w}}")
![\Leftrightarrow [L_{1} + L_{2}]_{B_{w}}^{B_{v}} = [L_{1}]_{B_{w}}^{B_{v}} + [L_{2}]_{B_{w}}^{B_{v}}](http://s0.wp.com/latex.php?latex=%5CLeftrightarrow+%5BL_%7B1%7D+%2B+L_%7B2%7D%5D_%7BB_%7Bw%7D%7D%5E%7BB_%7Bv%7D%7D+%3D+%5BL_%7B1%7D%5D_%7BB_%7Bw%7D%7D%5E%7BB_%7Bv%7D%7D+%2B+%5BL_%7B2%7D%5D_%7BB_%7Bw%7D%7D%5E%7BB_%7Bv%7D%7D+&bg=ffffff&fg=000&s=2 "\Leftrightarrow [L_{1} + L_{2}]_{B_{w}}^{B_{v}} = [L_{1}]_{B_{w}}^{B_{v}} + [L_{2}]_{B_{w}}^{B_{v}}")
![[(kL)(v_{i})]_{B_{w}} = k \cdot [L(v_{i})]_{B_{w}}](http://s0.wp.com/latex.php?latex=%5B%28kL%29%28v_%7Bi%7D%29%5D_%7BB_%7Bw%7D%7D+%3D+k+%5Ccdot+%5BL%28v_%7Bi%7D%29%5D_%7BB_%7Bw%7D%7D+&bg=ffffff&fg=000&s=2 "[(kL)(v_{i})]_{B_{w}} = k \cdot [L(v_{i})]_{B_{w}}")
![\Rightarrow [kL]_{B_{w}}^{B_{v}} = k \cdot [L]_{B_{w}}^{B_{v}}](http://s0.wp.com/latex.php?latex=%5CRightarrow+%5BkL%5D_%7BB_%7Bw%7D%7D%5E%7BB_%7Bv%7D%7D+%3D+k+%5Ccdot+%5BL%5D_%7BB_%7Bw%7D%7D%5E%7BB_%7Bv%7D%7D+&bg=ffffff&fg=000&s=2 "\Rightarrow [kL]_{B_{w}}^{B_{v}} = k \cdot [L]_{B_{w}}^{B_{v}}")
![\Leftrightarrow [L_{1}(v_{i})]_{B_{w}} = [L_{2}(v_{i})]_{B_{w}} (\forall i \in {1, 2, ... , n})](http://s0.wp.com/latex.php?latex=%5CLeftrightarrow+%5BL_%7B1%7D%28v_%7Bi%7D%29%5D_%7BB_%7Bw%7D%7D+%3D+%5BL_%7B2%7D%28v_%7Bi%7D%29%5D_%7BB_%7Bw%7D%7D+%28%5Cforall+i+%5Cin+%7B1%2C+2%2C+...+%2C+n%7D%29+&bg=ffffff&fg=000&s=2 "\Leftrightarrow [L_{1}(v_{i})]_{B_{w}} = [L_{2}(v_{i})]_{B_{w}} (\forall i \in {1, 2, ... , n})")
![[M]^{i} := M](http://s0.wp.com/latex.php?latex=%5BM%5D%5E%7Bi%7D+%3A%3D+M+&bg=ffffff&fg=000&s=2 "[M]^{i} := M")
의 
번째 열![[L(v_{i})]_{B_{w}} := [M]^{i}](http://s0.wp.com/latex.php?latex=%5BL%28v_%7Bi%7D%29%5D_%7BB_%7Bw%7D%7D+%3A%3D+%5BM%5D%5E%7Bi%7D+&bg=ffffff&fg=000&s=2 "[L(v_{i})]_{B_{w}} := [M]^{i}")
![surely, [L]_{B_{w}}^{B_{v}} = M](http://s0.wp.com/latex.php?latex=surely%2C+%5BL%5D_%7BB_%7Bw%7D%7D%5E%7BB_%7Bv%7D%7D+%3D+M+&bg=ffffff&fg=000&s=2 "surely, [L]_{B_{w}}^{B_{v}} = M")
![[L_{M_{1} +M_{2}}(v)]_{B_{W}} = (M_{1} + M_{2})[v]_{B_{V}}](http://s0.wp.com/latex.php?latex=%5BL_%7BM_%7B1%7D+%2BM_%7B2%7D%7D%28v%29%5D_%7BB_%7BW%7D%7D+%3D+%28M_%7B1%7D+%2B+M_%7B2%7D%29%5Bv%5D_%7BB_%7BV%7D%7D+&bg=ffffff&fg=000&s=2 "[L_{M_{1} +M_{2}}(v)]_{B_{W}} = (M_{1} + M_{2})[v]_{B_{V}}")
![= M_{1}[v]_{B_{V}} + M_{2}[v]_{B_{V}}](http://s0.wp.com/latex.php?latex=%3D+M_%7B1%7D%5Bv%5D_%7BB_%7BV%7D%7D+%2B+M_%7B2%7D%5Bv%5D_%7BB_%7BV%7D%7D+&bg=ffffff&fg=000&s=2 "= M_{1}[v]_{B_{V}} + M_{2}[v]_{B_{V}}")
![= [L_{M_{1}}(v)]_{B_{V}} + [L_{M_{2}}(v)]_{B_{V}}](http://s0.wp.com/latex.php?latex=%3D+%5BL_%7BM_%7B1%7D%7D%28v%29%5D_%7BB_%7BV%7D%7D+%2B+%5BL_%7BM_%7B2%7D%7D%28v%29%5D_%7BB_%7BV%7D%7D+&bg=ffffff&fg=000&s=2 "= [L_{M_{1}}(v)]_{B_{V}} + [L_{M_{2}}(v)]_{B_{V}}")
![[L_{km}(v)]_{B_{W}} = (kM)[v]_{B_{W}}](http://s0.wp.com/latex.php?latex=%5BL_%7Bkm%7D%28v%29%5D_%7BB_%7BW%7D%7D+%3D+%28kM%29%5Bv%5D_%7BB_%7BW%7D%7D+&bg=ffffff&fg=000&s=2 "[L_{km}(v)]_{B_{W}} = (kM)[v]_{B_{W}}")
![= k \cdot M [v]_{B_{W}}](http://s0.wp.com/latex.php?latex=%3D+k+%5Ccdot+M+%5Bv%5D_%7BB_%7BW%7D%7D+&bg=ffffff&fg=000&s=2 "= k \cdot M [v]_{B_{W}}")
![= k [L_{M}(v)]_{B_{W}}](http://s0.wp.com/latex.php?latex=%3D+k+%5BL_%7BM%7D%28v%29%5D_%7BB_%7BW%7D%7D+&bg=ffffff&fg=000&s=2 "= k [L_{M}(v)]_{B_{W}}")
![\Rightarrow [L_{M_{1}}(v)]_{B_{W}} = [L_{M_{2}}(v)]_{B_{W}}](http://s0.wp.com/latex.php?latex=%5CRightarrow+%5BL_%7BM_%7B1%7D%7D%28v%29%5D_%7BB_%7BW%7D%7D+%3D+%5BL_%7BM_%7B2%7D%7D%28v%29%5D_%7BB_%7BW%7D%7D+&bg=ffffff&fg=000&s=2 "\Rightarrow [L_{M_{1}}(v)]_{B_{W}} = [L_{M_{2}}(v)]_{B_{W}}")
![\Rightarrow M_{1}[v]_{B_{W}} = M_{2}[v]_{B_{W}}](http://s0.wp.com/latex.php?latex=%5CRightarrow+M_%7B1%7D%5Bv%5D_%7BB_%7BW%7D%7D+%3D+M_%7B2%7D%5Bv%5D_%7BB_%7BW%7D%7D+&bg=ffffff&fg=000&s=2 "\Rightarrow M_{1}[v]_{B_{W}} = M_{2}[v]_{B_{W}}")
![\Rightarrow [M_{1}]^{i} = [M_{2}]^{i}, (\forall i)](http://s0.wp.com/latex.php?latex=%5CRightarrow+%5BM_%7B1%7D%5D%5E%7Bi%7D+%3D+%5BM_%7B2%7D%5D%5E%7Bi%7D%2C+%28%5Cforall+i%29+&bg=ffffff&fg=000&s=2 "\Rightarrow [M_{1}]^{i} = [M_{2}]^{i}, (\forall i)")
![\forall L \in \mathcal{L}(V, W), M := ([L(V_{1})]_{B_{W}} [L(V_{i})]_{B_{W}})](http://s0.wp.com/latex.php?latex=%5Cforall+L+%5Cin+%5Cmathcal%7BL%7D%28V%2C+W%29%2C+M+%3A%3D+%28%5BL%28V_%7B1%7D%29%5D_%7BB_%7BW%7D%7D+%5BL%28V_%7Bi%7D%29%5D_%7BB_%7BW%7D%7D%29+&bg=ffffff&fg=000&s=2 "\forall L \in \mathcal{L}(V, W), M := ([L(V_{1})]_{B_{W}} [L(V_{i})]_{B_{W}})")
![Then, [L_{M}(v)]_{B_{W}} = [M]^{i}](http://s0.wp.com/latex.php?latex=Then%2C+%5BL_%7BM%7D%28v%29%5D_%7BB_%7BW%7D%7D+%3D+%5BM%5D%5E%7Bi%7D%C2%A0+&bg=ffffff&fg=000&s=2 "Then, [L_{M}(v)]_{B_{W}} = [M]^{i}")
![= [L(v_{i})]_{B_{W}} (\forall i)](http://s0.wp.com/latex.php?latex=%3D+%5BL%28v_%7Bi%7D%29%5D_%7BB_%7BW%7D%7D+%28%5Cforall+i%29%C2%A0+&bg=ffffff&fg=000&s=2 "= [L(v_{i})]_{B_{W}} (\forall i)")
는 항등사상
는 항등사상
이므로
라 하자
은 선형독립
은 단사 
단사
이면서 
는 다음을 만족한다.
은 단사 
에 대하여
의 해공간
의 영공간 차원
이라 한다.
: 선도 1을 포함하는 열의 개수 = 선도 1의 개수
: 선도 1을 포함하는 행의 개수 = 선도 1의 개수
라 하면
의 선도 1의 개수 
자유변수 개수 
