■ Wilk's Lambda

1. Wilk's Lambda 란[1]

검증 통계치(test statistics)에서 많이 사용되는 검정 통계량

Wilks lambda ranges from 0 –  1 and the lower the Wilks lambda, the larger the between group 

dispersion.  A small (close to 0) value of Wilks' lambda means that the groups are well separated. A large (close to 1) value of Wilks' lambda  means that the groups are poorly separated.

- 0 ~ 1 사이의 값을 가짐

- 1에 가까우면 그룹들이 잘 분류되지 않음

- 0에 가까우면 그룹들이 잘 분류됨

2. Wilk's Lambda 식 (Λ)

2.1 각 수식에 대한 개념

W: Within-groups sum of squares and cross-products matrix :: 그룹 내 제곱합과 대칭 행렬[2]  

      --> 클래스 내 분산과 같음

B: Between-groups sum of squares and cross-products matrix

      --> 클래스 간 분산과 같음

T: Total sum of squares and cross-products matrix

[note] the cross product matrix X' X is a symmetric matrix.

        - 2 참조 사이트에 가면 sum of square 에 대한 개념과 cross-product matrix에 대한 개념을 이해할 수 있음 

2.2 각 요소에 대한 개념

g: is the number of group(그룹(클래스)의 수)

ni: is the number of observations in the ith group(i 번재 그룹에 속하는 패턴들의 수)

/Xi: The mean vector of the ith group(i 번째 그룹의 평균)

/X: The mean vector of the all the observations(전체 평균)

Xij: The jth multivariate observation in the ith group(i 번째 그룹에서 j 번째 나타난 다변량 관측 값; i행에 j번째 값)

2.3 수식 설명

그림에서 볼 수 있듯이 클래스간 분산(B)를 분모로 넣고 클래스내 분산(W)를 분자로 나누었을 경우 생각해 보면

- 클래스 내 분산이 작고, 클래스간 분산이 크면: 분류 하기 쉬움(결과 값이 작아짐)

- 클래스 내 분산이 크고, 클래스간 분산이 작으면: 분류 하기 어려움(결과 값이 커짐)

즉, Wilk's Lambda 수식에서 Lambda(Λ)의 값이 작을 수록 판별하기 수월한 능력을 가진다라고 이야기 할 수 있음. 

3. 예제 

레퍼런스 2번에 있는 값들을 사용하여 계산해 보자. 초점은 어떻게 Wilk's Lambda를 계산하는가 이다.

step 1: 먼저 아래와 같이 다시 메트릭스를 구성하자.(보기 편하게)

step 2: 관련 변수 값 구하기 

A) 평균

B) 전체 평균

Step 3: T 값 구하기

A) 각 raw 데이터에 컬럼 전체 평균을 빼줌( raw data - mean of each column)

- 이름을 Tmatrix 라고 임의로 지정

B) T 값 구하기: Tmatrix' * Tmatrix

여기서 '는 전치행렬(transposed matrix)

수행결과: T=

Step 4: W 값 구하기

A) 각 그룹별로 그룹 평균 빼기

B) 각 그룹별(클래스내) 분산 구하기 

CovG1 = Formuldation1' * Formuldation1

CovG2 = Formuldation2' * Formuldation2

CovG3 = Formuldation3' * Formuldation3

covG1 =

 0.0307 0.1845

 0.1845 1.1223

covG2 =

 0.0423 0.2619

 0.2619 1.6442

covG3 =

 0.0927 0.4203

 0.4203 1.9419

C) 각 그룹 분산 더하기 최종 W 계산

covTotal =

    0.1657    0.8667

    0.8667    4.7084

Step 4: Wilk's Lambda 계산

Λ = |W|/|T|

W = 0.029

T = 0.033

Λ = 0.029/0.033 = 0.879

이상. Wilk's Lambda 의 값이 1의 값에 근접하고 있다. 때문에 Cmax와 AUC를 통해 뚜렷하게 목표로하는 대상을 구분하기 어렵다. 

:: 오랜만에 쓰는군... 역시나 쉽지 않아.

4. 구현 결과

Reference

[1] http://www.ijpsi.org/VOl(2)1/Version_3/G0213644.pdf

[2] http://stattrek.com/matrix-algebra/sums-of-squares.aspx

■ Generate distinctly different RGB colors in graphs

그래프에 뚜렷한 구분을 가지는 RGB 색상 만들기 

- 머.... 그래프 작업에 필수적인 요소이지만 미뤄왔던 일이다. 오늘도 할일은 있지만 해결하고 가야겠지...돈도 안주는 일인데 하자니...땍!!!

우선 진행해 보자. 먼저 자료를 찾았다. 

http://stackoverflow.com/questions/309149/generate-distinctly-different-rgb-colors-in-graphs

위 링크를 따라가보면 이글 제목과 같이 질문을 올렸다. 

질문을 정리하면 

"아놔 랜덤으로 뚜렷하게 구분되는 RGB 색상을 어떻게 만들어??"

답변을 보면 다음과 같다. 

You have three colour channels 0 to 255 R, G and B.

너는 3개의 RGB 채널을 가지고 있어

First go through: 먼저 다음과 같이 가자

0, 0, 255
0, 255, 0
255, 0, 0

Then go through: 그리고 다음과 같이 가는거야

0, 255, 255
255, 0, 255
255, 255, 0

Then divide by 2 => 128 and start again: 그리고 2로 나누자고 ==> 128이지? 그럼 또 나눠

0, 0, 128
0, 128, 0
128, 0, 0
0, 128, 128
128, 0, 128
128, 128, 0

Divide by 2 => 64 : 자 그럼 64야 

Next time add 64 to 128 => 192 : 자 다음으로 64와 128을 더해 그럼 192잖아 

follow the pattern.위와 같은 패턴을 따라봐

Straightforward to program and gives you fairly distinct colours. ; 프로그램하는것도 간단하고, 너에게 뚜렷한 RGB 색상을 주게 될꺼얌~~~

EDIT: Request for code sample: 코드 샘플에 대한 요청(유후~~~)

Also - adding in the additional pattern as below if gray is an acceptable colour:

그레이 색상을 허용하려면 아래와 같이 추가적인 패턴을 넣어봐

255, 255, 255
128, 128, 128 

There are a number of ways you can handle generating these in code.

여기 코드에는 RGB 색상을 만들기 위해 여러가지 방법이 있다오~~

The Easy Way:: 쉬운 방법이야!!!

If you can guarantee that you will never need more than a fixed number of colours, just generate an array of colours following this pattern and use those: 그냥 배열을 만들어서 쓰셈~~!!

    static string[] ColourValues = new string[] { 
        "FF0000", "00FF00", "0000FF", "FFFF00", "FF00FF", "00FFFF", "000000", 
        "800000", "008000", "000080", "808000", "800080", "008080", "808080", 
        "C00000", "00C000", "0000C0", "C0C000", "C000C0", "00C0C0", "C0C0C0", 
        "400000", "004000", "000040", "404000", "400040", "004040", "404040", 
        "200000", "002000", "000020", "202000", "200020", "002020", "202020", 
        "600000", "006000", "000060", "606000", "600060", "006060", "606060", 
        "A00000", "00A000", "0000A0", "A0A000", "A000A0", "00A0A0", "A0A0A0", 
        "E00000", "00E000", "0000E0", "E0E000", "E000E0", "00E0E0", "E0E0E0", 
    };

The Hard Way:: 흠 좀 어렵겠군!!! +___+ 췌 

If you don't know how many colours you are going to need, the code below will generate up to 896 colours using this pattern. (896 = 256 * 7 / 2) 256 is the colour space per channel, we have 7 patterns and we stop before we get to colours separated by only 1 colour value.

얼마나 많은 RGB 컬러가 필요할지 모르지? 아래 코드는 896개의 색상을 만드는 소스 코드야~. 256은 채널당 색공간(colour space) 이야, 우리는 7개의 패턴을 가지고 있엉, 우리는 오직 1 색공간에 의해 나뉘지는  색을 가지기 전에 그만 둘것이야(먼 예기야~ 흠 아무래도 나뉘지지 않게 되면 정지 요런 느낌!!???) 소스 코드 보면 분명해지겠지 

I've probably made harder work of this code than I needed to. First, there is an intensity generator which starts at 255, then generates the values as per the pattern described above. The pattern generator just loops through the seven colour patterns.

나도 이게 필요해서 열심히 만들었어. 처음, intensity generator(255에서 시작하는)가 있어, 그리고 위에 묘사된 패턴별로 값들을 만들엉. 패턴 발생기는 7개의 패턴을 따라 루프를 도는거만 하징..

아놔 C# 이넹 난 C/C++ 코드가 필요한뎅 ㅠㅠ 으아앙

할 수 없지... 변환해서 써보자 

using System;

class Program {
    static void Main(string[] args) {
        ColourGenerator generator = new ColourGenerator();
        for (int i = 0; i < 896; i++) {
            Console.WriteLine(string.Format("{0}: {1}", i, generator.NextColour()));
        }
    }
}

public class ColourGenerator {

    private int index = 0;
    private IntensityGenerator intensityGenerator = new IntensityGenerator();

    public string NextColour() {
        string colour = string.Format(PatternGenerator.NextPattern(index),
            intensityGenerator.NextIntensity(index));
        index++;
        return colour;
    }
}

public class PatternGenerator {
    public static string NextPattern(int index) {
        switch (index % 7) {
        case 0: return "{0}0000";
        case 1: return "00{0}00";
        case 2: return "0000{0}";
        case 3: return "{0}{0}00";
        case 4: return "{0}00{0}";
        case 5: return "00{0}{0}";
        case 6: return "{0}{0}{0}";
        default: throw new Exception("Math error");
        }
    }
}

public class IntensityGenerator {
    private IntensityValueWalker walker;
    private int current;

    public string NextIntensity(int index) {
        if (index == 0) {
            current = 255;
        }
        else if (index % 7 == 0) {
            if (walker == null) {
                walker = new IntensityValueWalker();
            }
            else {
                walker.MoveNext();
            }
            current = walker.Current.Value;
        }
        string currentText = current.ToString("X");
        if (currentText.Length == 1) currentText = "0" + currentText;
        return currentText;
    }
}

public class IntensityValue {

    private IntensityValue mChildA;
    private IntensityValue mChildB;

    public IntensityValue(IntensityValue parent, int value, int level) {
        if (level > 7) throw new Exception("There are no more colours left");
        Value = value;
        Parent = parent;
        Level = level;
    }

    public int Level { get; set; }
    public int Value { get; set; }
    public IntensityValue Parent { get; set; }

    public IntensityValue ChildA {
        get {
            return mChildA ?? (mChildA = new IntensityValue(this, this.Value - (1<<(7-Level)), Level+1));
        }
    }

    public IntensityValue ChildB {
        get {
            return mChildB ?? (mChildB = new IntensityValue(this, Value + (1<<(7-Level)), Level+1));
        }
    }
}

public class IntensityValueWalker {

    public IntensityValueWalker() {
        Current = new IntensityValue(null, 1<<7, 1);
    }

    public IntensityValue Current { get; set; }

    public void MoveNext() {
        if (Current.Parent == null) {
            Current = Current.ChildA;
        }
        else if (Current.Parent.ChildA == Current) {
            Current = Current.Parent.ChildB;
        }
        else {
            int levelsUp = 1;
            Current = Current.Parent;
            while (Current.Parent != null && Current == Current.Parent.ChildB) {
                Current = Current.Parent;
                levelsUp++;
            }
            if (Current.Parent != null) {
                Current = Current.Parent.ChildB;
            }
            else {
                levelsUp++;
            }
            for (int i = 0; i < levelsUp; i++) {
                Current = Current.ChildA;
            }

        }
    }
}

■ Linear Discriminant Analysis(LDA) - C-Classes

이전 글을 두개의 클래스를 판별하는 LDA에 대해서 알아 봤다. 그럼 여러개(C개)의 클래스를 어떻게 판별할 수 있을까? 접근은 2개의 클래스 판별 LDA 방법과 유사하다.

n-feature vectors를 가졌다면 다음과 같이 표현할 수 있다. 

여기서 Y는 출력벡터, X는 입력벡터, W는 변환행렬이다. 

- 즉 mxn입력 백터에 C개의 클래스를 LDA 분석을 하면 출력벡터는 c-1 by n개의 배열이 된다. 이에 중요한점은 각 클래스 마다 최적의 변환행렬을 계산해야 한다.

C개의 클래스를 가지는 입력 벡터를 LDA 분석하기 위한 단계는 다음과 같다.

1. 원래 데이터 차원에서 통계 계산

step 1: 클래스 내 분산 구하기 

step 2: 클래스 간 분산 구하기

2. 투영된 데이터 차원에서 통계 계산

step 1: 평균 벡터 구하기

step 2: 클래스 내 분산 구하기

step 3: 클래스 간 분산 구하기

3. 목적행렬을 통한 최적 변환 행렬 찾기 

는 최적 변환 행렬임

- 최적 변환 행렬은 일반적인 고유값 문제 해결로 얻을 수 있는 최고 고유값에 해당하는 고유벡터가 됨

- C개의 클래스는 C-1개의 변환행렬을 가짐

4. 차원 축소

추가적으로 LDA 접근은 두 가지 방법으로 나뉘어짐

- 클래스 종속:  각 클래스 마다 변환행렬 생성

- 클래스 독립: 하나의 변환행렬 생성

5. 예제 

LDA에 쓸 3개의 클래스 샘플 생성

위 코드 수행시 아래와 같이 출력됨

LDA matlab 코드는 다음과 같다. 

검은색이 고유값이 큰 고유벡터 값으로 판별되는 LD1 축이 되고, 다음 고유값에 따른 LD2 축이 보라색 선이 된다.  코드안에 차원축소를 한 데이터에 대해 PDF 분석 코드가 있다. 화면에 찍어야 하는데 그건 잘 모르겠다. 

우선 LDA에 대해서 어떻게 접근해야 하는지 이제 좀 감이 잡힌다. 다시 LDA 전체 matlab 소스 코드를 첨부한다. 

[1] http://www.di.univr.it/documenti/OccorrenzaIns/matdid/matdid437773.pdf

[2] http://www.bytefish.de/blog/pca_lda_with_gnu_octave/

■ Linear Discriminant Analysis(LDA) - 2 classes

선형판별분석

1. 개념

- 클래스간 분산(between-class scatter)과 클래스내 분산(within-class scatter)의 비율을 최대화 하는 방식으로 특징벡터의 차원을 축소하는 기법

- 즉, 한 클래스 내에 분산을 좁게 그리고 여러 클래스간 분산은 크게 해서 그 비율을 크게 만들어 패턴을 축소하게 되면 잘 분류할 수 있겠구나!!

- LDA 판별에 있어서 아래 두 그림은 좋은 그리고 나쁜 클래스 분류에 대해 묘사하고 있다.

rate 값이 클수록 판별하기 좋은데 위 그림 중 왼쪽은 rate값이 크고 오른쪽 그림은 작다.

즉, rate 값이 클수록 판별하기 좋고, rate값이 작으면 판별하기 어렵다.

이렇게 rate값을 크게 만들기 위해 기준선을 잘 잡는게 중요하다. 다음 그림을 보며 이해하자.

위 그림에 보면 BAD 축을을 기준으로 1차원 매핑을 하게 되면 각 클래스를 판별하기 어렵다. 위에 rate 구하는 공식에 클래스간 분산과 클래스내 분산 비율이 작아진것이다. 반대로 GOOD 1차원 축을 보면 rate가 큰것을 예상할 수 있으며, 고로 판별하기 쉬울것이라는 생각이 든다.

====(2개의 클래스 LDA 분석)

2. LDA에서 차원 축소에 판별척도(잘 분류된 정도) 계산방법

LDA에서 좋은 판별 기준을 결정하기 위해 목적함수를 사용한다.(평가함수로도 불린다.)

- objective function = criterion function = 평가함수 / 목적함수 

- 이러한 함수의 결과는 LDA 분류의 척도로써 사용된다. 

두 가지 목적함수가 있다.

가. 일반적인 목적함수

은 축소된(projected space:사영된 공간) 차원 데이터 y의 평균벡터 

은 축소되지 않은(original space: 본래 공간) 차원 데이터 x의 평균벡터

변환 행렬의 전치행렬임

위 척도 J(W)는 클래스간 분산을 고려하지 않고 평균만을 고려했기에 좋은 척도가 아니라고 한다. 

이에 Fisher이라는 사람이 다음과 같은 함수를 만듬

나. Fisher's criterion function 

여기서 는 클래스내 분산(Within-Class scatter matrix) 임

는 클래스간 분산(Between-Class scatter matrix) 임 

은 축소된(projected space:사영된 공간) 차원 데이터의 해당 클래스내 분산

변환 행렬의 전치행렬임

 그림과 같이 글래스간 분산도 고려하여 평균차이에 대한 비율로 척도를 계산함

- 이 값이 크면 클수록 좋음

3. 최적 분류를 위한 변환행렬 찾기

그럼 최고 좋은 값을 가지는 즉, 분류를 가장 잘 할수 있는 변환행렬은 어떻게 구할까? 이에 Fisher 선생님이 다음과 같은 공식을 만들었다. 

3.1 Fisher’s Linear Discriminant(1936)

최적의 변환 행렬 을 계산하기 위한 수식은 다음과 같다. 

- 최적의 변환 행렬을 만들기 위해 Fisher's criterion function 을 미분하여 0의 값을 가지게 수식을 수정한 결과이다. 미분값이 0 이면 기울기가 0라는것이다. 즉 최고점(global maximum point)이라는 점!!

- 여기에 일반화된 고유값 문제 해결을 통해 최적의 변환행렬을 계산해냄 

참고

argmax(p(x)) : p(x)를 최대가 되게하는 x 값 

max(p(x)) p(x) 중 최대값 

argmin(p(x)) : p(x)를 최소가 되게하는 x 값 

min(p(x)) : p(x) 중 최소값

4. 2개의 클래스를 LDA 분석하기 - Matlab

step 1: 전체 및 각 클래스 평균 계산

step 2: 각 클래스 내 분산 계산

step 3: 클래스 간 분산 계산

step 4: 고유값 및 고유벡터 계산

step 5: 고유값 정렬(sorting)

step 6: 차원 축소(reduction)

- 최고의 고유값을 가지는 고유벡터와 원행렬을 곱하면 된다. 

Colored By Color Scripter™

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

X = [4 2;2 4;2 3;3 6;4 4;9 10;6 8;9 5;8 7;10 8]; %입력 데이터 c = [  1;  1;  1;  1;  1;   2;  2;  2;  2;  2;];  %입력 데이터 그룹 분류   c1 = X(find(c==1),:) %클래스 1에 해당하는 입력 데이터 매핑  c2 = X(find(c==2),:) %클래스 2에 해당하는 입력 데이터 매핑   figure; %그림 그리자   hold on; %잡고 있으려므나~~   p1 = plot(c1(:,1), c1(:,2), 'ro', 'markersize',10, 'linewidth', 3);  %클래스 1 좌표 찍으렴 p2 = plot(c2(:,1), c2(:,2), 'go', 'markersize',10, 'linewidth', 3) %클래스 2 좌표 찍으렴   xlim([0 11]) %그래프 x의 좌표를 범위를 0-11까지 늘리자 ylim([0 11]) %그래프 y의 좌표를 범위를 0-11까지 늘리자   classes = max(c) %클래스가 몇개인지 보자구웃 mu_total = mean(X) %전체 평균 계산 mu = [ mean(c1); mean(c2) ] %각 클래스 평균 계산 Sw = (X - mu(c,:))'*(X - mu(c,:))  %클래스 내 분산 계산 Sb = (ones(classes,1) * mu_total - mu)' * (ones(classes,1) * mu_total - mu) %클래스간 분산 계산   [V, D] = eig(Sw\Sb) %고유값(V) 및 고유벡터(D)   % sort eigenvectors desc [D, i] = sort(diag(D), 'descend'); %고유값 정렬 V = V(:,i);   % draw LD lines scale = 5 pc1 = line([mu_total(1) - scale * V(1,1) mu_total(1) + scale * V(1,1)], [mu_total(2) - scale * V(2,1) mu_total(2) + scale * V(2,1)]);   set(pc1, 'color', [1 0 0], 'linestyle', '--')%가장 큰 고유값을 가지는 선형판별 축 그리자      scale = 5 pc2 = line([mu_total(1) - scale * V(1,2) mu_total(1) + scale * V(1,2)], [mu_total(2) - scale * V(2,2) mu_total(2) + scale * V(2,2)]);   set(pc2, 'color', [0 1 0], 'linestyle', '--')%두번째 고유값을 가지는 선형판별 축 그리자

보면 빨강색 선이 가장 좋은 LD 축이 되고 녹색이 나쁜 LD 축이 된다. 

그럼 가장 좋은 LD1축으로 투영을 시켜 보자 . 위 코드 상태에서 바로 아래와 같이 명령어를 입력하면 된다. 

 위 예제는 2개의 클래스를 가지고 LDA 분석하는 방법들이다. 

[1] http://www.di.univr.it/documenti/OccorrenzaIns/matdid/matdid437773.pdf

[2] http://www.bytefish.de/blog/pca_lda_with_gnu_octave/