스트림

• 파일, 네트워크 등에서 데이터를 바이트 단위로 읽고 쓰는 클래스
• Stream class는 상위 기본 클래스
  • FileSteam
  • MemoryStream
  • NetworkStream
  • SqllFileStream
• using System.IO로 선언

FileStream

• 파일 입출력을 다루는 기본 클래스
• byte[] 배열로 데이터를 읽거나 저장함 -> 형변환이 요구됨
• StreamWriter / StreamReader
• BinaryWriter / BinaryReader

  public FileStream(
    string path,        //경로
    FileMode mode,        //Append, Create, CreateNew, Open, OpenOrCreate, Truncate
    FileAccess access    //Read, ReadWrite, Write
  )

텍스트 파일 처리

• StreamWriter, StreamReader
• 텍스트 파일 특징
  • 기본단위: 1바이트
  • 아스키코드: 기반
• C# 인코딩: 아스키코드 -> 유니코드

StreamWriter

• 파일쓰기
• public class StreamWriter : TextWriter

  상속구조

  • System.Object
    • System.MarshalByRefObject
      • System.IO.TextWriter
        • System.IO.StreamWriter

static void Main(string[] args)
{
    //실행파일이 존재하는 Debug 디렉토리에 생성됨
    FileStream fs = new FileStream("test.txt", FileMode.Create);
    StreamWriter sw = new StreamWriter(fs);
    //파일 입출력 처리
    sw.WriteLine(12);
    sw.WriteLine(3.14f);
    sw.Write("Hello World");
    sw.Close();

    //아래와 같이 사용 시 Close() 메서드 사용 불필요, 자동 Close() 실행
    //단순 쓰기용으로 사용한다면 FileStream 불필요, "파일명"만 작성해도 실행가능
    using (StreamWriter sw2 = new StreamWriter(new FileStream("test2.txt", FileMode.Create)))
    {
        //파일 입출력 처리
    }
}

StreamReader

• 파일읽기
• public class StreamReader : TextReader

  상속구조

  • System.Object
    • System.MarshalByRefObject
      • System.IO.TextReader
        • System.IO.StreamReader

static void Main(string[] args)
{
    //단순 읽기용으로 사용한다면 FileStream 불필요, "파일명"만 작성해도 실행가능
    FileStream fs = new FileStream("test.txt", FileMode.Open, FileAccess.Read);
    StreamReader sr = new StreamReader(fs);
    //파일 입출력 처리
    var value = int.Parse(sr.ReadLine());
    var value2 = float.Parse(sr.ReadLine());
    var str1 = sr.ReadLine();
    sr.Close();

    Console.WriteLine("{0}, {1}, {2}", value, value2, str1);
}

string 데이터 분리

• string.Split 활용

  string str = "C언어: 90 C#언어: ,100 컴퓨터.구조: 70";
  

var str_Element = str.Split(',', '.', ' '); foreach(var element in str_Element) Console.WriteLine(element);

C언어: 90 C#언어:

100 컴퓨터 구조: 70 계속하려면 아무 키나 누르십시오 . . .

### 바이너리 파일 읽고 쓰기
- 위와 동일한 형식으로 진행
- 쓰기모드
```cs
using (BinaryWriter bw = new BinaryWriter(new FileStream("test.dat", FileMode.Create)))
{
    //파일 입력 처리
    bw.Write(12);
    bw.Write(3.14f);
    bw.Write("Hello World");
}

• 읽기모드 BinaryReader(Stream, Encoding, Boolean)
  • Stream: 타겟(FileStream)
  • Encoding: 인코딩 설정(default = UTF-8)
  • Boolean: 객체 소멸 시 입력스트림 닫기 여부(default=false)

    int var1;
    float var2;
    string str1;
    

using (BinaryReader br = new BinaryReader(File.Open("test.data", FileMode.Open))) { //파일 입력 처리 var1 = br.ReadInt32(); var2 = br.ReadSingle(); str1 = br.ReadString(); } Console.WriteLine("{0} {1} {2}", var1, var2, str1);

12 3.14 Hello World

# 2. 직렬화(Serialize)
## 직렬화
- 기존의 StreamWriter/StreamReader(바이너리 포함)
  -> 기본 데이터형만 저장 및 읽기 가능
- BinaryFormatter 네임스페이스
  - 구조체, 클래스 저장 및 읽기를 지원함

```cs
[Serializable]
Struct A    //클래스도 사용가능
{
    //파라미터 입력
}

public void Serialize(
    Stream serializationStream,
    object graph
)

//Deserialize은 object형임으로 기본형으로 형변환 필요
public object Deserialize(
    Stream serializationStream
)

역직렬화(deserialize)

• 직렬화 대상에서 제외

  [Serializable]
  class TestClass
  {
    int nValue;
    [NonSerialize]
    string strMessage;
    //내용
  }

직렬화와 역직렬화 예시

• 직렬화 시도 후 직렬화된 데이터 읽기는 정상적으로 출력됨

• 역직렬화로 직렬화가 되지 않은 데이터 읽기는 공백으로 출력됨

  static void 직렬화()
  {
    DATA[] Data = new DATA[2];
    Data[0].var1 = 1;
    Data[0].var2 = 0.5f;
    Data[0].str1 = "Test1";
    Data[1].var1 = 2;
    Data[1].var2 = 1.5f;
    Data[1].str1 = "Test2";
  
    using (FileStream fs1 = new FileStream("test.dat", FileMode.Create))
    {
        BinaryFormatter bf = new BinaryFormatter();
        bf.Serialize(fs1, Data);
    }
  
    DATA[] ResultData;
  
    using (FileStream fs2 = new FileStream("test.dat", FileMode.Open))
    {
        BinaryFormatter bf2 = new BinaryFormatter();
        ResultData = (DATA[])bf2.Deserialize(fs2);
    }
  
    for(int i=0;i<2;i++)
        Console.WriteLine("{0} {1} {2} {3}", 
            ResultData[i].var1, ResultData[i].var2, ResultData[i].str1, 1);
  }

1 0.5 1 2 1.5 1

## 컬렉션의 직렬화
- 같은 데이터형의 임의의 메모리 또는 연속적인 메모리를 다룰 수 있도록 하는 클래스
- ArrayList, List<T\>
- 제네릭(<>)을 이용한 직렬화
```cs
[Serializable]
struct Data
{
    public int data;
    public string str;
    public Data(int data1, string str1)
    {
        data = data1;
        str = str1;
    }
}

static void 제네릭을_이용한_직렬화()
{
    List<Data> ResultList;
    List<Data> DataList = new List<Data>();
    DataList.Add(new Data(7, "test1"));
    DataList.Add(new Data(12, "test2"));
    DataList.Add(new Data(19, "test3"));

    using (FileStream fs1 = new FileStream("test.dat", FileMode.Create))
    {
        BinaryFormatter bf = new BinaryFormatter();
        bf.Serialize(fs1, DataList);
    }

    using (FileStream fs2 = new FileStream("test.dat", FileMode.Open))
    {
        BinaryFormatter bf2 = new BinaryFormatter();
        ResultList = (List<Data>)bf2.Deserialize(fs2);
    }

    for (int i=0;i<ResultList.Count;i++)
        Console.WriteLine("{0} {1}", ResultList[i].data, ResultList[i].str);
}

3. 정리

4. Reference

• 나우캠퍼스-6강-1부, 2부, 3부

• 기본 개념
  • 같은 데이터형 + 변수명 + 순차적인 메모리 나열
• 참조형
  • new를 통해 생성
• Array객체로부터 파생된 참조형
• foreach 사용가능

  형식

  • 데이터형[] 배열명;
  • int[] array_name;
  • int[] array = new int[] {1,2,3};
• Array.Length: 길이 확인

2. 2차원 및 다차원 배열

• 행과 열, 면은 콤마(,)로 구분

  형식

  • 데이터형[차원 수 + 1 만큼 ',' 입력] 배열명;
  • int[,] array_name;
  • int[,,] array_name;

    for (int i = 0; i < 3; i++)
    for (int j = 0; j < 2; j++)
        Console.Write(정수이차원배열1[i, j]);

3. 가변 배열

• 배열 길이가 유동적인 배열

  형식

  • 데이터형[][] 배열명;
  • int[][] array_name;
• 사용 예시

  int[][] array = new int[3][];
  array[0] = new int[] { 1, 2 };
  array[1] = new int[] { 3, 4, 5 };
  array[2] = new int[] { 6, 7, 8, 9 };
  

int[][] array2 = { new int[]{1,2,3 }, new int[]{2,3,4}, new int[]{3,4,5}, };

foreach(var i in array2) // 배열 받아오기 foreach (var j in i) // 배열에서 데이터 받아오기 또는 for문에 i.Length를 사용 Console.WriteLine(j); // 데이터 출력하기

int[][][] array3D = { new int[][] // 2D array at index 0 { new int[]{1, 2, 3}, // Row 0 new int[]{4, 5, 6}, // Row 1 new int[]{7, 8, 9} // Row 2 }, new int[][] { new int[]{1, 2 } }, new int[][] { new int[]{11, 12 }, new int[]{12, 13 }, new int[]{13, 14 }, new int[]{14, 15, 16 } } };

        for (int i = 0; i < array3D.Length; i++)
        {
            for (int j = 0; j < array3D[i].Length; j++)
            {
                Console.Write($"{i}행 {j}열:");
                for (int k = 0; k < array3D[i][j].Length; k++)
                {
                    Console.Write(array3D[i][j][k]);
                    Console.Write(' ');
                }
                Console.WriteLine();

            }
        }

# 4. 배열을 인수로 전달
- 배열과 함수는 참조형이기 때문에 값이 변경된다
## 형식
```cs
int[] array = {1,2,3,4};

void func(int[] arr)
{
    //함수 내용
    //참조형이기 때문에 array를 수정하면
    //원본 array도 수정된다
}
func(array);

5. 배열을 리턴하는 함수

• 배열을 리턴하는 의미
  • 배열이 참조하는 객체의 주소값을 리턴하는 것

    형식

    함수(매개변수)
    {
      //함수 내용 실행
    return Array
    }
    var 받기 = 함수(매개변수)

6. 배열의 메서드

초기화 메서드

• Array.Clear(타겟_배열, 시작_인덱스, 초기화_길이);
  • Array.Clear(numbers, 2, 4); 인덱스 2부터 5까지 0으로 초기화

    배열 복사 메서드

• public Object Clone();
• object형이기 때문에 unboxing이 필요

  int[] nArray1 = {1,2,3,4};
  int[] nCloneArray = (int[])nArray1.Clone();

7. Reference

• 나우캠퍼스-5강-1부, 2부, 3부

단항연산자

• +, -, !, ~, ++, -- 등
• !는 bool형에서만 사용

산술연산자

• *, /, %, +, -
• string에서는 +로 문자열 연결 가능
• 참고사항
  • 수치형 + "문자열" = "문자열"
  • "문자열" + "문자열"은 메모리를 많이 차지한다
    • 문자열은 참조 형식으로 위의 방식을 사용하면 Heap에 3개의 문자열이 메모리를 차지하게 된다.

시프트 연산자와 관계연산자

• <<, >>, <=, >=, >, <, ==, !=

is 연산자

• 형식 호환을 조사하는 연산자
• 변수 is 클래스형|데이터형;
• object와 하위의 다른 데이터형(int, float)는 호환O
• 동일 계층의 데이터형(int, float)끼리는 호환X

  if (objVar is int)
    Console.WriteLine("UnBoxing 호환O");

as 연산자

• 형변환과 변환조사
• 캐스트 연산자의 역할, 불변환은 null리턴
• 결과형 = 참조형, 언박싱, 박싱 as 변환형

  string str2 = objVar as string;
  //objVar를 string형으로 변경할 수 있으면 (string)objVar가 str2에 저장됨
  //형변환을 못하면 null 저장

비트&논리연산자

비트연산자

• &, |, ~, ^
• and, or, not, xor

  논리연산자

• &&, ||, !
• and, or, not

null 병합 연산자

• ??: null 조사
• c = A ?? B
  • A가 null이 아니면 A를 C에 대입
  • A가 null이면 B를 C에 대입

2. 제어문

if ~ else

if (조건1)
    Console.WriteLine("첫번째내용");
else if (조건2)
    Console.WriteLine("두번째내용");
else
    Console.WriteLine("세번째내용");

switch, case, break

• 정수, 문자상수, 문자열 가능
• 모든 case와 default에는 break가 반드시 있어야 함

  switch(데이터)
  {
    case 1:
        Console.WriteLine("첫번째내용");
        break;
    case '1':
        Console.WriteLine("두번째내용");
        break;
    default:
        Conosole.WriteLine("세번째내용");
        break;
  }

3. 반복문

for(변수;조건;증감)

for (int i = 0; i < 10; i++)
    Console.WriteLine("{0}번째 반복시행 중", i);

foreach(변수 in 컨테이너형)

• 읽기전용 함수

  forreach(int i in 정수배열)
    Console.WriteLine(i)

  while 반복문

• while(조건){내용}, do{내용}while(조건)

4. 점프문

• goto, continue, return, break

  goto

• 해당 키워드의 위치로 이동한다
• 과거부터 문법해석과 디버깅을 방해하기 때문에 많이 사용하지 말라고 한다
• 하지만 다중 반복문 등에서 한 번에 빠져나올 수 있는 경우는 사용을 권장한다

  start:
  Console.WriteLine("현재 숫자: " + number);
  number++;
  

if (number <= 5) goto start;

# 5. 예외처리문
## try~catch
```cs
try
{
    //예외가 발생할 수 있는 코드
}
catch(예외처리객체 e)
{
    //예외발생 시 실행코드
}

참고사항

• try문 안에서 초기화한 변수를 try문 밖에서 사용할 수 없다
  • int m; try{m=12;} ... Console.Write(m);은 오류 발생

  • int m=0; try{m=12;} ... Console.Write(m);은 사용 가능

• System.Exception의 파생객체만 사용가능
  • OverFlowException
  • FormatException
  • DivideByZeroException
  • FileNotFoundException
  • IndxOutOfRangeException

trycatchfinally

• finally: 예외 발생과 상관없이 항상 실행되는 구문
• 예외처리에 실패하면 프로그램이 바로 종료, 정지, 문제가 발생하는데 finally구문으로 해당 실행을 강제할 수 있다
  • ex. SQL을 활용하고 나서 finally에 sql 종료구문 추가
  • ex. 영상처리 중 웹캠 종료

throw

• 예외 상황을 임의로 바생시키는 역할

6. 정리

• 대부분의 연산자는 C,C++언어와 같음
• C#에서 새롭게 등장한 연산자
  • is, as, null
• 반복문
  • for, while, do~while, foreach(=python의 for)
• 예외처리문
  • try~catch~finally(=python의 tryexceptionfinally)
  • throw(=python의 raise)

7. Reference

• 나우캠퍼스-4강-1부, 2부

기본 데이터형

• C#의 데이터형 object로부터 파생된 객체
• CTS(Common Type System)에서 정의된 객체

정수형

실수형

• C#의 float는 클래스가 System.Single 이다.

문자(열)형

• C#의 문자형(char)는 2 byte 이고 ''로 정의한다.
  • char 문자 = '굿';
• 문자열형은 ""로 정의한다
  • string a = "Hello World";
• 문자열 출력 추가내용
  • '' 출력 방법
    • @"C:\aaa\aaa\aaa.exe"
    • "C:\aaa\aaa\aaa.exe"

bool 형

var 키워드

• 대입되는 데이터에 따라 데이터형 결정
• ex. foreach(var i in Array){내용;}
• 사용할 수 없는 예
  • null값 초기화, 매개변수X
  • only 지역변수, 클래스 멤버X
  • 연속적으로 초기화하는 경우
    • ex. var m = 10, n = 20;

      var vs object

• var를 사용해서 데이터형이 지정되면 변경 불가능
• object는 변경가능, 하지만 boxing & unboxing이 필요함
  • boxing&unboxing 정리파트 이후에 작성예정

2. 변환

• 기본데이터형.ToString() <=> 기본데이터형.Parse()
• Convert.ToInt32()
• Convert.ToSingle()
• Convert.ToXXXXX()

3. 표준 입력

표준 입력

• 참조 : 표준입력-공식문서
• Console.ReadKey()
• public static ConsoleKeyInfo ReadKey(bool intercept)
  • true: 화면출력안함
  • false: 화면출력(default)
• ConsoleKeyInfo
  • 키의 문자와 Shift, Alt, Ctrl 등 보조키 상태 포함
• ConsoleKeyInfo.Key: 입력된 키 위치 확인
• ConsoleKeyInfo.KeyChar: 대소문자 구분 키 확인

  //ConsoleKeyInfo는 구조체 형식
  

Console.WriteLine("ESC를 누르면 종료합니다"); ConsoleKeyInfo KeyInfo; do { KeyInfo = Console.ReadKey(true); //안보이게 설정 if (KeyInfo.Key == ConsoleKey.A) //A입력시 실행 Console.WriteLine("A를 입력했습니다"); // ESC를 누르면 종료 } while (KeyInfo.Key != ConsoleKey.Escape);

# 4. 사용자 지정형
- struct, enum, class, interface 중 class와 interface는 나중에 배움으로 생략
## struct
- 제한사항
  - 구조체에 선언된 const, static 변수만 초기화 가능
  - 구조체 안에 선언할 수 있는 생성자는 매개변수가 반드시 있어야 함
  - 구조체를 같은 구조체에 대입하게 되면 값이 복사
  - 구조체는 `값 형식`이고 클래스는 `참조 형식`
  - 값 형식이므로 선언만으로 사용 가능
    - new를 사용하면 생성자가 호출되어 기본값으로 초기화 됨
  - 구조체 또는 클래스에 상속X
  - 인터페이스를 상속하여 메서드 구현 가능

```cs
접근지정자 struct 구조체명
{
    // 멤버, 속성, 메서드
}

enum

• 상수를 문자열로 대치하여 선언
• enum 열거형 명칭 {문자열1, 문자열2};
  • 문자열1=10으로 설정하면 다음 데이터는 1씩 증가
  • enum Days {Sun, Mon, ..., Sat};
• 기본은 int형이지만 char형을 제외한 형식 지정가능
  • enum Days:byte{Sun=0, Mon, Tue, ... , Sat};
• 열거형 변수가 아닌 변수에 열거형 값을 대입할 때는 데이터형을 명시할 것

5. 값 형식과 참조 형식

스택(Stack)

• 고정된 크기(정적)의 메모리
• 데이터를 쌓아올리는 구조의 메모리
• 데이터 처리 방식 : Last-In-First-Out(=후입선출)

값 형식

• 메모리에 값을 담는 데이터 형식
• 스택에 할당(즉, 자동으로 제거됨)
  • 지역변수가 stack에 할당됨, 메서드 호출이 완료되면 스택 메모리가 자동으로 회수되고 값이 제거됨
• 기본데이터 형식과 구조체가 여기에 해당됨

큐(Queue)

• C#에서 큐의 사용은 선택적
  • System.Collections.Queue
• 데이터 처리 방식 : First-In-Fist-Out(=선입선출)

힙(Heap)

• 유동적 크기(동적)의 메모리
• 자유롭게 데이터를 저장할 수 있는 메모리

참조 형식

• heap에 데이터를 저장하고 해당하는 메모리를 참조하는 방식
• 처음 변수만 선언하면 값 형식과 달리 메모리가 할당되지 않음
• 힙에 할당(가비지 콜렉터에 의해 제거됨)
• 배열, 클래스, 인터페이스, 델리게이트, 문자열, Object 등이 여기에 해당

Boxing&Unboxing

• Boxing
  • 값 형식 -> 참조 형식으로 변환하는 것
  • stack -> heap

    int num = 42;
    object boxedNum = num; // Boxing

• UnBoxing
  • Boxing된 데이터를 값 형식으로 변환하는 것
  • heap -> stack

    object boxedNum = 42;
    int num = (int)boxedNum; // Unboxing

6. 정리

• 기본 데이터형과 CTS 형식을 익혀둔다.
• 데이터형에 관한 검증 코드를 작성해보자.
• 값 형식과 참조 형식의 차이점을 이해하자.

7. Reference

• 나우캠퍼스-3강-1부, 2부, 3부, 4부, 5부
• 이것이 C#이다

솔루션과 프로젝트

• 프로젝트
  • C#에서 필요로 하는 여러 파일에 대한 정보 및 컴파일 옵션 정보 등 포함
• 솔루션
  • 다수의 프로젝트를 하나의 솔루션 안에서 다룰 수 있음

단일 프로젝트 생성

• 파일 -> 새로 만들기 -> 프로젝트 -> 콘솔 앱(.NET Framework) 선택

2. C# 프로그램 시작

기본구조

자동 생성 코드

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace nowcampus_2_ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
        }
    }
}

코드 구분

• using 부분 -> 프롤로그
• namespace 부분 -> 프로그램 몸체

프롤로그

• using
  • 클래스의 네임스페이스를 선언하는 역할
  • 네임스페이스 명시 없이 클래스 사용

Main

• C#은 하나 이상의 클래스 정의는 필수
• 소스코드가 실행되는 몸체
• static 메서드
  • 클래스로부터 객체를 생성하지 않고 직접 [클래스명. 메서드명] 형식으로 호출하는 메서드

Main(string[] args)

• 프로그램 실행시 추가적으로 입력되는 부분이 args에 배열로 순서대로 입력됨
• ex. 프로그램_실행 Hello world로 입력 시 args[0]='Hello', args[1]='world'가 할당됨

3. 표준 출력

표준 출력

• Console.Write()
  • 내용을 줄바꿈 없이 출력
• Console.WriteLine()
  • 내용 출력 후 줄바꿈(=Console.WriteLine("\n")
• 메서드 원형(Overloading 지원)
  • public static void Write(bool value);
  • public static void Write(string format, Object arg0);
  • public static void WriteLine(bool value);
  • public static void WriteLine(string format, Object arg0);

출력 형식

• Console.Write(변수 or 데이터); -> 데이터 1개 입력
• Console.Write("{0} {1}", 변수1, 변수2); -> 인덱스 지정
• Console.Write($"{변수1} {변수2}"); -> 위치 직접 지정

  Console.WriteLine("Hello World");
  Console.WriteLine("{0} {1}", "Hello", "World");
  Console.WriteLine($"{"Hello World"}");

Hello World Hello World Hello World

## 표준 숫자 서식 문자열
- C : 통화($, \ 등) 표시
- D : 10진수 정수
- E : 지수형 형태 출력
- F : 부동 소수점 출력
  - `$"{13.234234:f3}" = 13.234`
- G : 기본 출력
- N : 콤마 출력
- P : % 단위로 출력
- X : 16 진수 출력

```cs
Console.WriteLine("{0:C} {1:P} {0:X}", 123, 123.45);
-----------------------------------------------------
₩123 12,345.00% 7B

참고 : MSDN-표준 숫자 서식 문자열

4. C# 키워드

C# 키워드

• 총 77개
• C 키워드(26개)
  • break, case, char, const, continue, default, do, double, else, enum, extern, float, for, goto, if, int, long, return, short, sizeof, static, struct, switch, typeof, void, while
• C++ 키워드(19개)
  • bool, catch, class, false, finally, namespace, new, private, protected, explicit, operator, public, this, throw, true, try, using, virtual, volatile
• C# 키워드(32개)
  • abstract, as, base, byte, checked, decimal, delegate, event, fixed, foreach, in, interface, internal, implicit, is, lock, null, object, out, override, params, readonly, ref, sbute, sealed, string, uint, ulong, unchecked, unsafe, ushort, volatile

5. 정리

• C# 프로그래밍 구조를 이해하고 네임스페이스와 클래스의 관계를 이해
• 표준 출력인 Console.Write, Console.WriteLine()을 사용해보고 MSDN에서 다양한 출력 형식을 살펴보자

6. Reference

• 나우캠퍼스-2강-1부, 2부

운영체제와 닷넷 프레임워크

• 과거에 각 운영체제에 닷넷 프레임워크를 추가해서 사용했으나
• 닷넷 프레임워크가 운영체제 안으로 들어가서 대부분의 OS에서 사용가능

구성요소

• 클래스 라이브러리와 CLR(Common Langugage Runtime)

클래스 라이브러리

• BCL(Basic Class Library): 기본 클래스
• Window Form: 윈도우 응용 프로그램 제작을 위한 클래스 라이브러리
• ASP.NET: 웹 클래스 라이브러리
• ADO.NET: 데이터베이스 클래스 라이브러리

CLR(Common Language Runtime)

• 컴파일된 C# 코드(.exe)를 실행하는 역할
• MSIL, IL, Common Intermediate Language, CIL, 중간언어
  • 닷넷 프레임워크의 장점은 대부분의 기기에서 사용가능한 것이다
  • 코드를 컴파일하면 생성되는 코드로 각 CPU와 OS에 맞는 코드를 생성함

*용어 알기

• *.exe, *.dll을 실행파일이 아닌 어셈블리 라고 한다

CTS와 CLS

Common Type System

• 공통 데이터형과 형식 정의
  • int => System.Int32
  • float => System.Single

Common Lanuguage Specifiaction

• 공통 언어 사양 정의
• 닷넷 언어가 지켜야 할 최소 코드 규칙

2. C# 언어에 대한 개요

C# 언어

• C# 언어 = C++ 언어 기반 + java 장점
• 사용범위
  • XML, Web, Network, 데이터베이스, 게임, IoT 등
• C#은 포인터를 거의 사용하지 않는다
  • 객체 생성 new는 있지만 해제는 없다
  • 메모리 관리는 Garbage Collector가 담당

C# 프로그램 실행 과정

3. 정리

• 닷넷 프레임워크의 구성 요쇼와 역할 이해
  • BCL, IL, CLR, JIT, CTS 등...
• 컴파일부터 실행까지의 과정을 이해
• 인문학 서작 읽기 추천
  • 사고력 키우기

4. 닷넷 환경의 컴파일 과정

JIT(Just-In-Time) 컴파일

• C/C++로 작성된 프로그램은 정적인 네이티브 코드(.exe, .dll)를 생성해 배포하기 때문에 빠르다
• Java, C#과 같은 언어들은 컴파일러가 생성한 IL 코드를 가지고 있다가 프로그램 실행 시에 CLR 코드를 해석해서 동적인 네이티브 코드를 생성하게 된다
• 이러한 가상머신에 의한 런타임 컴파일 방식을 JTL 컴파일 이라고 한다
• 그렇기 때문에 첫 수행이 아주 느리고, 이후 수행부터는 빠른 속도를 갖게 된다

AOT(Ahead-Of-Time) 컴파일

• JIT 컴파일 방식의 느린 속도를 해결하기 위해 만들어진 컴파일 방식
• 목표 시스템의 기계어와 무관하게 중간 언어 형태로 배포된 후 목표 시스템에서 인터프리터나 JIT 컴파일 등 기계여 번역을 통해 실행되는 중간 언어를 미리 목표 시스템에 맞는 기계어로 번역하는 방식

5. References

• 나우캠퍼스-1강-1부, 2부
• https://rito15.github.io/posts/cs-dotnet-compile/
• https://ko.wikipedia.org/wiki/AOT_%EC%BB%B4%ED%8C%8C%EC%9D%BC

• 나는 메카트로닉스 학과의 졸업을 앞두고 있으며 머신비전 분야에 관심이 있다.
• 제로베이스 데이터 취업 스쿨을 통해서 Python 기반으로 전반적인 데이터 분석, AI모델링에 대해 학습했다.
• 머신비전 분야에 대해서 확인해보니, 주로 사용하는 언어들은 C++, C#이고 python은 보이지 않았다.
• C++과 C# 둘 중 무엇을 공부해야 할까 고민하다가 python의 클래스와 굉장히 흡사한 C#을 공부하기로 결정하였다.
• PC, PLC 제어 분야로 먼저 취업한 친구에게 듣기로 GUI을 HMI에서 C#으로 모두 바꾸어서 다시 공부해야 한다는 얘기를 듣고 더욱 C#을 공부해야겠다고 다짐했다.
• 학과에서 PLC를 배웠는데, MX-Component와 C#을 이용하면 컨트롤이 매우 쉽다는 것을 이미 경험해서 알고 있다.

2. 학습 플랫폼 선택

• 나는 원래 충남인력개발원의 "OPC-UA 기반 스마트제조 지능형 MES 프로젝트"를 통해서 머신비전 뿐만 아니라 MES에 대한 전반적인 것과 C#, 제조분야의 Python을 이용한 데이터분석까지 학습하려 했으나 인원미달로 _폐강_되었다...
• 전공 때 C를 배웠고, 개인적으로 C++ 조금 학습했고, 부트캠프에서 Python을 배워서 기본은 갖춰져있어서 책으로 독학하려 했는데, 조금 힘들다...
• 혼자 책으로 하는 것이 재미도 좀 떨어지고, 심심하다는 생각에 다른 부트캠프를 찾아보았으나 C#부트캠프의 장소(주로 부산...)와 시간들이 나에게 맞지 않아서, 나우캠퍼스의 공개 영상을 통해서 C#에 대한 것을 학습하고자 한다.

3. C# 활용분야

4. 강의 내용

• C# 언어 기초 문법
• WindowForm 프로그래밍
• 데이터베이스 프로그래밍(Feat. MS-SQL)

5. 희망 취업처

• 제조분야 데이터 분석
• 자동화 머신비전, 머신러닝

6. Reference

• 나우캠퍼스-오리엔테이션

Object Detection

• 사진 속의 모든 객체를 인지하는 문제
• 클래스분류(Classification) + 위치탐색(Localization)
• Boundry Box를 생성해서 객체의 클래스와 위치를 표기
  • 4개의 좌표 생성(상자의 중심점과 폭, 높이 or 상자의 좌상단과 우상단 좌표)
  • YOLO: center_x, center_y, width, height

Single Object

• 이미지에 단일 대상이 존재하는 단일 객체 탐지

Sliding window

• Single Object에서 Multiple Object를 수행하는 경우, 한 이미지에 여러 객체가 존재하는데 이를 하나의 객체로 취급하여 올바른 클래스 분류를 수행할 수 없게 됨
• 해결책: 이미지 내에서 일부 window를 생성하고 그 안에서 Object Detection를 수행
  • 단점: 많은 윈도우를 생성하므로 계산이 너무 많다(고비용, 저속도)

Region Proposal: Selective Search

• 초기에 작은 영역들을 생성한 후, 이를 색깔, 질감, 크기, 위치 등의 특징을 사용하여 유사한 영역들을 합쳐가며 큰 영역 생성
• 이러한 계층적인 결합과정을 통해 객체와 배경의 경계를 찾아내고, 객체가 있을 가능성이 있는 영역(Region of Interest, ROI, 관심영역)을 제안

모델 형태

One-Stage Detector

• Clasification과 Regional Proposal을 동시에 수행하는 방법
• 비교적 빠르지만 정확도가 낮음
• YOLO계열, SSD 출처: 가짜연구소

Two-Stage Detector

• Clasification과 Regional Proposal을 순차적으로 수행하는 방법
• 비교적 느리지만 정확도가 높음
• RCNN계열 출처: 가짜연구소

R-CNN 계열 모델

RCNN

• 기존 이미지에서 Region Proposal 생성(약 2000개)
• 영역을 warp(crop, resize) 작업수행
• CNN으로 feature map 생성
• Regressor로 bounding box 조정, SVM으로 class 예측
  • 클래스 수:예측 수 + 1, (background 분류를 위해 +1)
• 단점
  • 이미지변형이나 손실, 후보영역만큼 CNN을 수행하므로 고비용, 저속도

Fast RCNN

• CNN으로 먼저 feature map을 생성, region proposal을 수행
• MaxPooling 등을 활용해서 ROI에 적용(=RoI Pooling Layer)
• RoI Pooling으로 Feature vector 생성
• FC Layer를 거쳐서 Softmax를 통해 분류, Regressor로 bounding box 조정

Faster RCNN

• Selective Search 부분을 딥러닝으로 바꾼 Region Proposal Network(RPN) 사용
• Feature map에서 CNN 연산시 sliding-window가 찍은 지점마다 Anchor-box로 후보영역을 예측
  • Anchor-box: 미리 지정해놓은 여러 개의 비율과 크기의 Bounding-box
• RPN에서 얻은 후보영역을 IoU순으로 정렬하여 Non-Maximum Suppression(NMS) 알고리즘을 통해 최종 후보영역을 선택
• RoI Pooling을 거치고 이후 Fast R-CNN과 동일하게 진행

YOLO

학습절차

• 입력 이미지를 처음부터 grid로 나누고 각 grid별로 bounding box와 class를 예측, box별 confidence도 함께 예측
• 각 셀은 5*B+C의 데이터 수를 가지고 있음
• 각 cell마다 B=2개의 bbox를 예측해, 7*7*B개의 class score vector를 얻고 Nonmaximum suppression(NMS)로 정제함
• object마다 하나의 bbox를 갖도록 함

Non maximum suppression (NMS)

• 동일한 객체에 대해 겹치는 정도(IOU; Intersection Of Union)가 높은 순서대로 정렬함.
• Score가 가장 높은 경계상자를 기준으로 Threshold를 설정해 후보군을 줄임.

AI

• 인간의 학습 능력, 추론능력, 지각능력 등을 인공적으로 구현한 컴퓨터 시스템

ML

• 컴퓨터에게 인간의 능력을 학습시키는 알고리즘
• 주로 정형 데이터

DL

• 여러 비선형 변환기법의 조합을 통해 높은 수준의 추상화를 시도하는 기계학습 알고리즘의 집합
• 주로 비정형 데이터

ML/DL 프레임워크

Neural Network

• $z = \sum{x_{i}{w_{i}}} + bias$
• 활성화 함수 $\sigma(z)$을 통해서 비선형화
• 참값과 예측값을 비교하여 loss 계산
• optimizer 적용

Activation Function

• 역할 : 비선형화
• 주로 ReLU 사용

Optimizer

• loss를 최소화 하는 weights를 구하는 optimizer

Gradient Descent

• Loss Function이 아래로 볼록한 형태가 이상적인 경우이고, 이 때, weights를 최적화하기 가장 좋다
• Loss function을 미분하여 weights를 갱신한다
• Learning rate가 너무 큰 경우, 진동이 발생
• 반대로 너무 작은 경우, 굉장히 긴 시간의 학습이 필요

Stochastic Gradient Descent (SGD)

• 기존의 GD는 모든 기울기를 계산했었다
• SGD는 확률적으로 기울기를 계산한다

Momentum

• 기울기 일부를 누적하여 관성을 추가함

  velocity = momentum * velocity - learning_rate * gradient
  w = w + velocity

Root Mean Square Propagation (RMSProp)

• AdaGrad는 처음에 크게 학습하고, 점점 작게 학습하는데 과거의 기울기를 제곱하기 때문에 갱신값이 점차 0으로 수렴하는 문제가 있었다
• RMSProp은 기하급수적으로 감소하는 평균 제곱 기울기를 사용
• 각 매개변수의 학습률을 이전 기울기의 평균 제곱근(RMS)으로 나누어 큰 기울기에서는 학습률을 낮추고 작은 기울기에서는 높임

  cache = decay_rate * cache + (1 - decay_rate) * gradient^2
  w = w - (learning_rate / sqrt(cache + epsilon)) * gradient

Adaptive Moment Estimation (Adam)

• Momentum과 RMSProp의 결합
• 적응형 학습 속도 및 관성, 효율적인 수렴
• 딥러닝에서 주로 사용하는 optimizer

  m = beta1 * m + (1 - beta1) * gradient
  v = beta2 * v + (1 - beta2) * gradient^2
  m_hat = m / (1 - beta1^t)
  v_hat = v / (1 - beta2^t)
  w = w - (learning_rate / (sqrt(v_hat) + epsilon)) * m_hat

컴퓨터 비전이란?

• 컴퓨터를 이용하여 정지 영상 또는 동영상으로부터 의미있는 정보를 추출하는 방법을 연구하는 학문
• 사람이 눈으로 사물을 보고 인지하는 작업을 컴퓨터가 수행하게 하는 학문

Computer Vision과 Image Processing

• Computer vision
  • 컴퓨터로 이미지와 영상으로부터 정보를 추출하고 분석하는 분야
• Image Processing
  • 컴퓨터 비전을 위해 영상을 입력받아 화질 개선 등의 전처리를 의미

컴퓨터 비전 응용 분야

• 영상의 화질 개선
• 내용 기반 영상 검색
• 얼굴 검출 및 인식
• 의료영상처리
• 광학 문자 인식
• 머신 비전
• 인공지능 서비스

영상데이터

• 영상이란?

  • 픽셀이 바둑판 모양의 격자에 나열되어 있는 형태(2차원 행렬)
  • pixel : 영상 기본 단위

• 영상의 좌표계

  • 이미지는 가로 x 세로로 표기
  • 행렬은 세로 x 가로로 표기
  • 헷갈릴 수 있으니 주의

• Grayscale Image

  • 흑백사진, 색상 채널 1개
  • 밝기 정보를 256단계로 표현
  • 용량 : width x heigth [Bytes]

• Truecolor Image

  • 컬러사진, 색상채널 3개
  • RGB 성분을 각각 256단계로 표현($256^3=16,777,216$)
  • 용량 : width x heigth x 3[Bytes]

• 하나의 픽셀이 3개의 요소를 갖는 경우(C++)

• 픽셀이 3차원 행렬로 구성되는 경우(Python)

기본 이미지 출력(python)

cv module

import cv2
import sys

img1 = cv2.imread("./data/cat.bmp")  # 데이터 읽기
img2 = cv2.imread("./data/cat.bmp", cv2.IMREAD_GRAYSCALE)  # 데이터 읽기
if img1 is None or img2 is None:
    print("Image load Failed!!")    # 이미지를 못 찾으면 출력
    sys.exit()

cv2.namedWindow("Truecolor", flags=cv2.WINDOW_NORMAL) # "Truecolor" 창 생성
cv2.imshow("Truecolor", img1)       # "Truecolor" 창에 img1 보여주기
cv2.namedWindow("Grayscale")        # "Grayscale" 창 생성
cv2.imshow("Grayscale", img2)       # "Grayscale" 창에 img2 보여주기

cv2.imwrite("cat_grayscale.png", img2) # "cat_grayscale.png"로 img2를 저장

while cv2.waitKey() == ord("q"):    # "q" 입력대기
    break

cv2.destroyAllWindows()             # 모든 창 종료

Matplotlib으로 출력하기

• 컬러 영상 출력하기
• OpenCV는 BGR순서
• plt는 RGB순서 -> cv2.cvtColor() 함수로 색상 순서 변경 필요

  import cv2
  import matplotlib.pyplot as plt
  

imgBGR = cv2.imread('cat_truecolor.png') imgRGB = cv2.cvtColor(imgBGR, cv2.COLOR_BGR2RGB) imgGRAY = cv2.imread('cat_truecolor.png', cv2.IMREAD_GRAYSCALE)

plt.figure(figsize=(12, 3))

BGR

plt.subplot(131) plt.axis("off") plt.imshow(imgBGR) plt.title("imgBGR")

RGB

plt.subplot(132) plt.axis("off") plt.imshow(imgRGB) plt.title("imgRGB")

GRAY

plt.subplot(133) plt.axis("off") plt.imshow(imgGRAY, cmap="gray") plt.title("imgGRAY")

plt.show()

![](https://velog.velcdn.com/images/insung_na/post/150b4610-e7fa-4d47-b221-9e4953c96909/image.png)


## ROI와 마스크 연산
- 관심 영역(ROI)
    - Region of Interest
    - 영상에서 특정 연산을 수행하고자 하는 영역
- 마스크 연산
    - OpenCV에서는 이미지합성을 할 때, 마스크 영상의 0이 아닌 부분을 입력영상에서 추출해서 출력영상과 합성을 한다.
    - 배경과 대상을 구분하는 마스크 영상을 활용
    - 마스크 영상은 `cv2.CV_8UC1`타입이어야 한다
    - 픽셀 값이 0이 아닌 위치에서만 연산이 수행됨

### 마스크 연산 함수
- `cv2.copyTo(src, mask, dst=None) -> dst`
  - src : 입력영상, `cv2.CV_8UC3`
  - mask : 마스크 영상, `cv2.CV_8U`
    - 0이 아닌 픽셀에 대해서만 복사연산 수행
  - dst : 출력영상, `cv2.CV_8UC3`
  - 연산 수행 시 각 인자의 크기가 동일해야 함

### 마스크 영상을 이용한 영상 합성(Python)
```python
import sys
import cv2


# 마스크 영상을 이용한 영상 합성
src = cv2.imread('./data/airplane.bmp', cv2.IMREAD_COLOR)
mask = cv2.imread('./data/mask_plane.bmp', cv2.IMREAD_GRAYSCALE)
dst = cv2.imread('./data/field.bmp', cv2.IMREAD_COLOR)

if src is None or mask is None or dst is None:
    print('Image load failed!')
    sys.exit()

# mask에서 값이 0이 아닌 부분을 src에서 복사해서 dst에 합성
# cv2.copyTo() 실행 시에 모든 요소의 크기가 같아야 함
cv2.copyTo(src, mask, dst)
# dst[mask > 0] = src[mask > 0]

cv2.imshow('src', src)
cv2.imshow('mask', mask)
cv2.imshow('dst', dst)
cv2.waitKey()
cv2.destroyAllWindows()

도형그리기

import numpy as np
import cv2

img = np.full((400, 400, 3), 255, np.uint8)
#img = cv2.imread('cat.bmp')

cv2.line(img, (50, 50), (200, 50), (0, 0, 255), 5)
cv2.line(img, (50, 60), (150, 160), (0, 0, 128))

cv2.rectangle(img, (50, 200, 150, 100), (0, 255, 0), 2)
cv2.rectangle(img, (70, 220), (180, 280), (0, 128, 0), -1)

cv2.circle(img, (300, 100), 30, (255, 255, 0), -1, cv2.LINE_AA)
cv2.circle(img, (300, 100), 60, (255, 0, 0), 3, cv2.LINE_AA)

pts = np.array([[250, 200], [300, 200], [350, 300], [250, 300]])
cv2.polylines(img, [pts], True, (255, 0, 255), 2)

text = 'Hello? OpenCV ' + cv2.__version__
cv2.putText(img, text, (50, 350), cv2.FONT_HERSHEY_SIMPLEX, 0.8, 
            (0, 0, 255), 1, cv2.LINE_AA)

cv2.imshow("img", img)
cv2.waitKey()
cv2.destroyAllWindows()

카메라 출력 및 영상저장

import sys
import cv2


cap = cv2.VideoCapture(0)

if not cap.isOpened():
    print("Camera open Failed!")
    sys.exit()

w = round(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
h = round(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
fps = cap.get(cv2.CAP_PROP_FPS)

fourcc = cv2.VideoWriter_fourcc(*"DIVX") # *'DIVX' == 'D', 'I', 'V', 'X'
delay = round(1000 / fps)

out = cv2.VideoWriter('./data/output.avi', fourcc, fps, (w, h))    # 프레임 단위 영상저장

if not out.isOpened():
    print('File open Failed!')
    cap.release()
    sys.exit()

while True:
    ret, frame = cap.read()

    if not ret:
        break

    gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)    # 흑백
    edge = cv2.Canny(gray, 100, 255)                # 외곽선
    gray_color = cv2.cvtColor(gray, cv2.COLOR_GRAY2BGR) # 저장을 위해 BGR로 변환

    out.write(gray_color)    # 흑백 저장

    cv2.imshow('frame', frame)
    cv2.imshow('gray', gray)
    cv2.imshow('gray_color', gray_color)
    cv2.imshow('edge', edge)

    if cv2.waitKey(delay) == 27:
        break

cap.release()
out.release()
cv2.destroyAllWindows()

명함검출

명함 검출(Python)

import sys
import cv2


# 영상 불러오기
src = cv2.imread('./data/namecard1.jpg')

if src is None:
    print('Image load failed!')
    sys.exit()

# 입력 영상을 그레이스케일 영상으로 변환
src_gray = cv2.cvtColor(src, cv2.COLOR_BGR2GRAY)

# 자동 이진화
_, src_bin = cv2.threshold(src_gray, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)

# 외곽선 검출 및 명함 검출
contours, _ = cv2.findContours(src_bin, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)

for pts in contours:
    # 너무 작은 객체는 무시
    if cv2.contourArea(pts) < 1000:
        continue

    # 외곽선 근사화
    approx = cv2.approxPolyDP(pts, cv2.arcLength(pts, True)*0.02, True)

    # 사각형으로 근사화되면 외곽선 표시
    if len(approx) == 4:
        cv2.polylines(src, [approx], True, (0, 255, 0), 2, cv2.LINE_AA)

cv2.imshow('src', src)
cv2.waitKey()
cv2.destroyAllWindows()

명함 똑바로 펴기

• 데이터 : 강사님의 명함

수동으로 펴기

import sys
import numpy as np
import cv2


# 영상 불러오기
src = cv2.imread('namecard1.jpg')

if src is None:
    print('Image load failed!')
    sys.exit()

# 출력 영상 설정
w, h = 720, 400
srcQuad = np.array([[324, 308], [760, 369], [718, 611], [231, 517]], np.float32)
dstQuad = np.array([[0, 0], [w-1, 0], [w-1, h-1], [0, h-1]], np.float32)
dst = np.zeros((h, w), np.uint8)

pers = cv2.getPerspectiveTransform(srcQuad, dstQuad)
dst = cv2.warpPerspective(src, pers, (w, h))

cv2.imshow('src', src)
cv2.imshow('dst', dst)
cv2.waitKey()
cv2.destroyAllWindows()

자동으로 펴기

import sys
import numpy as np
import cv2

# approx 좌표 순서 지정
def reorderPts(pts):
    idx = np.lexsort((pts[:, 1], pts[:, 0]))  # 칼럼0 -> 칼럼1 순으로 정렬한 인덱스를 반환
    pts = pts[idx]  # x좌표로 정렬

    if pts[0, 1] > pts[1, 1]:
        pts[[0, 1]] = pts[[1, 0]]

    if pts[2, 1] < pts[3, 1]:
        pts[[2, 3]] = pts[[3, 2]]

    return pts


# 영상 불러오기
src = cv2.imread('./data/namecard2.jpg')

if src is None:
    print('Image load failed!')
    sys.exit()

# 출력 영상 설정
w, h = 720, 400
srcQuad = np.array([[0, 0], [0, h], [w, h], [w, 0]], np.float32)
dstQuad = np.array([[0, 0], [0, h], [w, h], [w, 0]], np.float32)
dst = np.zeros((h, w), np.uint8)

# 입력 영상을 그레이스케일 영상으로 변환
src_gray = cv2.cvtColor(src, cv2.COLOR_BGR2GRAY)

# 자동 이진화
_, src_bin = cv2.threshold(src_gray, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)

# 외곽선 검출 및 명함 검출
contours, _ = cv2.findContours(src_bin, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)

for pts in contours:
    # 너무 작은 객체는 무시
    if cv2.contourArea(pts) < 1000:
        continue

    # 외곽선 근사화
    approx = cv2.approxPolyDP(pts, cv2.arcLength(pts, True)*0.02, True)

    # 사각형으로 근사화되면 외곽선 표시
    if len(approx) == 4:
        #cv2.polylines(src, [approx], True, (0, 255, 0), 2, cv2.LINE_AA)
        corners = approx.reshape(4, 2).astype(np.float32)
        srcQuad = reorderPts(corners)


pers = cv2.getPerspectiveTransform(srcQuad, dstQuad)
dst = cv2.warpPerspective(src, pers, (w, h))

cv2.imshow('src', src)
cv2.imshow('dst', dst)
cv2.waitKey()
cv2.destroyAllWindows()

딥러닝모델을 활용한 얼굴검출

• 미리 학습된 딥러닝모델을 사용함

영상에서 얼굴 찾기

OpenCV DNN 얼굴 검출기 입력

• 입력 영상 크기: 300x300
• 픽셀 값 범위: 0 ~ 255
• 색상 채널 순서: BGR
• 평균 픽셀 값: (104, 177, 123)

OpenCV DNN 얼굴 검출기 출력

• shape=(1, 1, 200, 7), dtype=float32
• detect = out[0, 0, :, :]

import sys
import numpy as np
import cv2


model = './data/opencv_face_detector/res10_300x300_ssd_iter_140000_fp16.caffemodel'
config = './data/opencv_face_detector/deploy.prototxt'
#model = 'opencv_face_detector/opencv_face_detector_uint8.pb'
#config = 'opencv_face_detector/opencv_face_detector.pbtxt'

# 카메라 열기
cap = cv2.VideoCapture(0)

if not cap.isOpened():
    print('Camera open failed!')
    sys.exit()

# 모델 불러오기
net = cv2.dnn.readNet(model, config)

if net.empty():
    print('Net open failed!')
    sys.exit()

while True:
    # 카메라 읽기
    ret, frame = cap.read()

    # 이미지 좌우 반전
    frame = cv2.flip(frame, 1)

    if not ret:
        break

    # 2차원 -> 4차원 이미지 생성
    blob = cv2.dnn.blobFromImage(frame, 1, (300, 300), (104, 177, 123))

    # 모델에 이미지 입력
    net.setInput(blob)

    # 모델 실행
    out = net.forward()
    detect = out[0, 0, :, :]

    (h, w) = frame.shape[:2]

    for i in range(detect.shape[0]):
        confidence = detect[i, 2]
        if confidence < 0.5:    # 예측값이 0.5 이하면 무시
            break

        # 바운딩 박스의 좌표
        x1 = int(detect[i, 3] * w)
        y1 = int(detect[i, 4] * h)
        x2 = int(detect[i, 5] * w)
        y2 = int(detect[i, 6] * h)

        # 바운딩 박스 그리기
        cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0))

        # 예측값 출력
        label = f'Face: {confidence:4.2f}'
        cv2.putText(frame, label, (x1, y1 - 1), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 1, cv2.LINE_AA)

    cv2.imshow('frame', frame)

    if cv2.waitKey(1) == 27:  # ESC누르면 종료
        break

cap.release()
cv2.destroyAllWindows()

얼굴 모자이크처리

• 촬영을 하다보면 타인의 개인정보(얼굴, 자동차 번호판, 주민번호 등)을 습득하게 된다.
• 개인정보를 보호하기 위해 이를 모자이크 처리할 필요성이 있다

import sys
import numpy as np
import cv2

model = './data/opencv_face_detector/res10_300x300_ssd_iter_140000_fp16.caffemodel'
config = './data/opencv_face_detector/deploy.prototxt'
#model = 'opencv_face_detector/opencv_face_detector_uint8.pb'
#config = 'opencv_face_detector/opencv_face_detector.pbtxt'

# 카메라 열기
cap = cv2.VideoCapture(0)

if not cap.isOpened():
    print('Camera open failed!')
    sys.exit()

# 모델 불러오기
net = cv2.dnn.readNet(model, config)

if net.empty():
    print('Net open failed!')
    sys.exit()

while True:
    # 카메라 읽기
    ret, frame = cap.read()

    # 이미지 좌우 반전
    frame = cv2.flip(frame, 1)

    if not ret:
        break

    # 2차원 -> 4차원 이미지 생성
    blob = cv2.dnn.blobFromImage(frame, 1, (300, 300), (104, 177, 123))

    # 모델에 이미지 입력
    net.setInput(blob)

    # 모델 실행
    out = net.forward()
    detect = out[0, 0, :, :]

    (h, w) = frame.shape[:2]

    for i in range(detect.shape[0]):
        confidence = detect[i, 2]
        if confidence < 0.5:    # 예측값이 0.5 이하면 무시
            break

        # 바운딩 박스의 좌표
        x1 = int(detect[i, 3] * w)
        y1 = int(detect[i, 4] * h)
        x2 = int(detect[i, 5] * w)
        y2 = int(detect[i, 6] * h)

        face_img = frame[y1:y2, x1:x2]
        fh, fw = face_img.shape[:2]

        # 모자이크 처리
        face_img2 = cv2.resize(face_img, (0, 0), fx=1./16, fy=1./16)
        cv2.resize(face_img2, (fw, fh), dst=face_img, interpolation=cv2.INTER_NEAREST)
        #frame[y1:y2, x1:x2] = cv2.resize(face_img2, (fw, fh), interpolation=cv2.INTER_NEAREST)


        # 바운딩 박스 그리기
        cv2.rectangle(frame, (x1, y1), (x2, y2), (0, 255, 0))

        # # 예측값 출력
        label = f'Face: {confidence:4.2f}'
        cv2.putText(frame, label, (x1, y1 - 1), cv2.FONT_HERSHEY_SIMPLEX, 0.8, (0, 255, 0), 1, cv2.LINE_AA)

    cv2.imshow('frame', frame)

    if cv2.waitKey(1) == 27:  # ESC누르면 종료
        break

cap.release()
cv2.destroyAllWindows()

📌자연어 처리

Transformer

• Attention 기법을 활용하여 CNN, RNN을 사용하지 않는 자연어 처리 모델
• GPT : Transformer의 Decoder를 아키텍처를 활용
• BERT : Transformer의 Encoder를 아키텍처를 활용

자연어처리 task

• 감정 분석
  • ex. 맛있는 사과를 먹었다
• 기계어번역
  • ex. 나는 사과를 먹었다 -> I ate an apple
• QA
  • ex. 지문을 읽고, 질문에 대답
• 마스크 필링
  • ex. 나는 X를 먹었다 -> X에 들어갈 수 있는 단어 찾기

Transformer Architecture

Positional Encoding

• transformer는 병렬 처리이므로 성능이 향상되었으나 RNN에서 가능했던 순서처리가 불가능해짐
• 이를 해결하기 위해 positional encoding 사용
• 각 토큰의 입력 임베딩에 위치 인코딩을 추가함으로써 Transformer 모델은 병렬 처리 구조에도 불구하고 토큰의 순차적 순서를 유지할 수 있게 됨

Multi head attention

• Self-Attention 메커니즘을 이용한 자연어 처리 향상 모듈
• 입력벡터로 query, key, value 벡터를 받음
• 이를 활용하여 attention score를 계산하고 단어별 중요도를 결정할 수 있음

성능향상을 위한 기술

• Skip Connection
  • 한 계층의 출력을 다른 계층의 출력에 직접 추가하는 연결
  • Vanishing Gradient를 완화하기 위해 사용한 방법
• Layer Normalization
  • 각 계층의 출력 정규화
  • 입력 변동의 영향을 줄이고 네트워크의 전반적인 안정성과 성능 향상

기존 모델과 성능비교

요약

• 기계번역 task에서 기존의 연구들 보다 성능적으로 우수
• 병렬적으로 처리가 가능한 모델 -> time complexity 감소
• 이후에 사용되는 Bert, GPT 모델에서 일반화에 강점이 있다는 것이 확인

Transformer Process

• 1. input 임베딩 + Position Encoding (Encoder)
• 2. Q, K, V 생성
• 3. Multi-Head Attention 사용
• 4. Skip-Connection + Layer Normalization
• 5. Self-attention 반복수행
• 6. Encoder의 출력값을 Decoder가 받아서 학습을 진행
• 7. Linear모델과 softmax을 통해서 최종결과(확률)를 도출

Hugging Face

• https://github.com/huggingface/transformers
• NLP분야의 스타트업
• 다양한 트랜스포머 모델(transformer.models)과 학습 스크립트(transformer.Trainer)를 제공하는 모듈
• 개발자가 자연어 처리 애플리케이션과 서비스를 빠르고 효율적으로 구축하고 배포할 수 있도록 함

사용법

• 사용할 Task, Libraries 등 또는 Filter을 설정하고 원하는 모델을 찾기

• 모델 포스팅 글에서 사용법 확인하고 적용하기

• 사이트에서도 간편실행가능

해당 글은 제로베이스데이터스쿨 학습자료를 참고하여 작성되었습니다

1. zip_dataset_load

SQuAD_it

Data download & unzip

!wget https://github.com/crux82/squad-it/raw/master/SQuAD_it-train.json.gz
!wget https://github.com/crux82/squad-it/raw/master/SQuAD_it-test.json.gz

!gzip -dkv SQuAD_it-*.json.gz

데이터 불러오기

!pip install datasets
!pip install transformers
from datasets import load_dataset

data_files = {"train": "./SQuAD_it-train.json", "test": "./SQuAD_it-test.json"}
squad_it_dataset = load_dataset("json", data_files=data_files, field="data")
squad_it_dataset
-------------------------------------------------------------------
DatasetDict({
    train: Dataset({
        features: ['paragraphs', 'title'],
        num_rows: 442
    })
    test: Dataset({
        features: ['paragraphs', 'title'],
        num_rows: 48
    })
})

drugsCom_raw

데이터 로드

!wget "https://archive.ics.uci.edu/ml/machine-learning-databases/00462/drugsCom_raw.zip"
!unzip drugsCom_raw.zip
data_files = {"train": "drugsComTrain_raw.tsv", "test":"drugsComTest_raw.tsv"}
drug_dataset = load_dataset("csv", data_files=data_files, delimiter="\t")
drug_dataset
-----------------------------------------------------------------
DatasetDict({
    train: Dataset({
        features: ['Unnamed: 0', 'drugName', 'condition', 'review', 'rating', 'date', 'usefulCount'],
        num_rows: 161297
    })
    test: Dataset({
        features: ['Unnamed: 0', 'drugName', 'condition', 'review', 'rating', 'date', 'usefulCount'],
        num_rows: 53766
    })
})

전처리

drug_dataset = drug_dataset.rename_column(  # 칼럼명 변경
    original_column_name="Unnamed: 0", new_column_name="patient_id"
)
drug_dataset
-------------------------------------------------------------------
DatasetDict({
    train: Dataset({
        features: ['patient_id', 'drugName', 'condition', 'review', 'rating', 'date', 'usefulCount'],
        num_rows: 161297
    })
    test: Dataset({
        features: ['patient_id', 'drugName', 'condition', 'review', 'rating', 'date', 'usefulCount'],
        num_rows: 53766
    })
})

데이터 소문자화

def lowercase_condition(example):
  return {"condition": example["condition"].lower()}

drug_dataset = drug_dataset.filter(lambda x: x["condition"] is not None) # Nonetype 제거
drug_dataset.map(lowercase_condition) # 데이터를 소문자로 변경

리뷰 길이 제한

def compute_review_length(example):
  return {"review_length": len(example["review"].split())}

drug_dataset = drug_dataset.map(compute_review_length)
drug_dataset = drug_dataset.filter(lambda x: x["review_length"] > 30) # 리뷰가 너무 긴 데이터는 필터링
print(drug_dataset.num_rows)
-----------------------------------------------
{'train': 138514, 'test': 46108}

1 batch

import html

new_drug_dataset = drug_dataset.map(
    lambda x: {"review": [html.unescape(o) for o in x["review"]]}, batched=True
)
new_drug_dataset
-------------------------------------------------------------------------
DatasetDict({
    train: Dataset({
        features: ['patient_id', 'drugName', 'condition', 'review', 'rating', 'date', 'usefulCount', 'review_length'],
        num_rows: 138514
    })
    test: Dataset({
        features: ['patient_id', 'drugName', 'condition', 'review', 'rating', 'date', 'usefulCount', 'review_length'],
        num_rows: 46108
    })
})

AutoTokenizer

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")

def tokenize_and_split(examples):
  return tokenizer(
      examples["review"],
      truncation=True,
      max_length=128,
      return_overflowing_tokens=True  # 길이를 넘어가는 토큰 반환 여부
  )
len(drug_dataset["train"][0]['review'].split()) # 전체 문장을 띄어쓰기로 분할한 수
----------------------
141

result = tokenize_and_split(drug_dataset["train"][0])
[len(inp) for inp in result["input_ids"]]       # max length 내부와 초과한 대상
--------------------------
[128, 49]

2. Model

from transformers import AutoTokenizer

checkpoint = "distilbert-base-uncased-finetuned-sst-2-english"  # 사용할 모델
tokenizer = AutoTokenizer.from_pretrained(checkpoint)           # 모델의 tokenizer 로딩

raw_inputs = [
    "I've been waiting for a HuggingFace course my whole life.",
    "I hate this so much!",
]

inputs = tokenizer(raw_inputs, padding=True, truncation=True, return_tensors="pt")  # input을 숫자로 토큰화
inputs["input_ids"]
-----------------------------------------------------------------------------------
tensor([[  101,  1045,  1005,  2310,  2042,  3403,  2005,  1037, 17662, 12172,
          2607,  2026,  2878,  2166,  1012,   102],
        [  101,  1045,  5223,  2023,  2061,  2172,   999,   102,     0,     0,
             0,     0,     0,     0,     0,     0]])

inputs["attention_mask"]    # 문장길이를 맞추기 위해 0으로 패딩
-------------------------------------------------------------
tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
        [1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0]])

분류모델

from transformers import AutoModelForSequenceClassification
model = AutoModelForSequenceClassification.from_pretrained(checkpoint)
model.config.id2label
---------------------------------------------
{0: 'NEGATIVE', 1: 'POSITIVE'}

outputs = model(**inputs)
outputs
-----------------------------------------------------------------------
SequenceClassifierOutput(loss=None, logits=tensor([[-1.5607,  1.6123],
        [ 4.1692, -3.3464]], grad_fn=<AddmmBackward0>), hidden_states=None, attentions=None)

지문에 대한 긍정 부정 분류

• 첫번째 문장은 긍정
• 두번째 문장은 부정

  import torch
  

predictions = torch.nn.functional.softmax(outputs.logits, dim=-1) predictions

tensor([[4.0195e-02, 9.5981e-01], [9.9946e-01, 5.4418e-04]], grad_fn=)

## BertModel Config Modify
### Config 불러오기
```python
from transformers import BertConfig, BertModel

config = BertConfig()   # default 파라미터
config
----------------------------------------------------
BertConfig {
  "attention_probs_dropout_prob": 0.1,
  "classifier_dropout": null,
  "hidden_act": "gelu",
  "hidden_dropout_prob": 0.1,
  "hidden_size": 768,
  "initializer_range": 0.02,
  "intermediate_size": 3072,
  "layer_norm_eps": 1e-12,
  "max_position_embeddings": 512,
  "model_type": "bert",
  "num_attention_heads": 12,
  "num_hidden_layers": 12,
  "pad_token_id": 0,
  "position_embedding_type": "absolute",
  "transformers_version": "4.28.1",
  "type_vocab_size": 2,
  "use_cache": true,
  "vocab_size": 30522
}

모델에 config 적용

model = BertModel(config)
model
------------------------------------------------------
BertModel(
  (embeddings): BertEmbeddings(
    (word_embeddings): Embedding(30522, 768, padding_idx=0)
    (position_embeddings): Embedding(512, 768)
    (token_type_embeddings): Embedding(2, 768)
    (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
    (dropout): Dropout(p=0.1, inplace=False)
  )
  (encoder): BertEncoder(
    (layer): ModuleList(
      (0-11): 12 x BertLayer(
        (attention): BertAttention(
          (self): BertSelfAttention(
            (query): Linear(in_features=768, out_features=768, bias=True)
            (key): Linear(in_features=768, out_features=768, bias=True)
            (value): Linear(in_features=768, out_features=768, bias=True)
            (dropout): Dropout(p=0.1, inplace=False)
          )
          (output): BertSelfOutput(
            (dense): Linear(in_features=768, out_features=768, bias=True)
            (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)
            (dropout): Dropout(p=0.1, inplace=False)
          )
        )
        (intermediate): BertIntermediate(
...
  (pooler): BertPooler(
    (dense): Linear(in_features=768, out_features=768, bias=True)
    (activation): Tanh()
  )
)

Config 수정해보기

config.hidden_size = 48    # 786 -> 48
model = BertModel(config)
model
-----------------------------------------------------------
BertModel(
  (embeddings): BertEmbeddings(
    (word_embeddings): Embedding(30522, 48, padding_idx=0)
    (position_embeddings): Embedding(512, 48)
    (token_type_embeddings): Embedding(2, 48)
    (LayerNorm): LayerNorm((48,), eps=1e-12, elementwise_affine=True)
    (dropout): Dropout(p=0.1, inplace=False)
  )
  (encoder): BertEncoder(
    (layer): ModuleList(
      (0-11): 12 x BertLayer(
        (attention): BertAttention(
          (self): BertSelfAttention(
            (query): Linear(in_features=48, out_features=48, bias=True)
            (key): Linear(in_features=48, out_features=48, bias=True)
            (value): Linear(in_features=48, out_features=48, bias=True)
            (dropout): Dropout(p=0.1, inplace=False)
          )
          (output): BertSelfOutput(
            (dense): Linear(in_features=48, out_features=48, bias=True)
            (LayerNorm): LayerNorm((48,), eps=1e-12, elementwise_affine=True)
            (dropout): Dropout(p=0.1, inplace=False)
          )
        )
        (intermediate): BertIntermediate(
...
  (pooler): BertPooler(
    (dense): Linear(in_features=48, out_features=48, bias=True)
    (activation): Tanh()
  )
)

model 저장하기

model.save_pretrained("./test")

3. Tokenizer

tokenizer가 적절하지 못하면

• tokenzier의 사용모델(환경)에 적절한 것을 사용하여야 한다
• ex. A데이터셋을 기반으로 학습하였는데 B데이터셋을 사용한 경우
• 인식하지 못하면 '[UNK]'
• 자주 사용하는 접두어, 접미어를 학습한 경우 '##'같은 것이 생성됨

  tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
  sequence = "Using a Transformer network is simple"
  tokens = tokenizer.tokenize(sequence)
  

print(tokens)

['Using', 'a', 'Trans', '##former', 'network', 'is', 'simple']

- 토큰화가 적합하지 않으면 의미없는 토큰으로 분리될 수 있음
```python
sequence = "Using a Transformer network is manual, KT-12312"
tokens = tokenizer.tokenize(sequence)

print(tokens)
--------------------------------------------
['Using', 'a', 'Trans', '##former', 'network', 'is', 'manual', ',', 'K', '##T', '-', '123', '##12']

Convert와 Decode

ids = tokenizer.convert_tokens_to_ids(tokens)
ids
-------------------------------------------------
[7993, 170, 13809, 23763, 2443, 1110, 9506, 117, 148, 1942, 118, 13414, 11964]

tokenizer.decode(ids)
------------------------------------------
'Using a Transformer network is manual, KT - 12312'

4. Training

• dataloader -> model -> optimizer -> loss -> training

  from transformers import AutoTokenizer, AutoModelForSequenceClassification
  import torch
  

checkpoint = 'distilbert-base-uncased-finetuned-sst-2-english' # 사용할 모델명 tokenizer = AutoTokenizer.from_pretrained(checkpoint) # 모델의 토큰화 model = AutoModelForSequenceClassification.from_pretrained(checkpoint) # 모델 로딩

sequence = "I've been waiting for a HuggingFace course my whole life." # text

tokens = tokenizer.tokenize(sequence) # text -> token ids = tokenizer.convert_tokens_to_ids(tokens) # token -> ids

inputs_ids = torch.tensor([ids]) print("input IDs:\n", inputs_ids, end="\n\n")

output = model(inputs_ids) print("Logits:", output.logits, end="\n\n")

predictions = torch.nn.functional.softmax(outputs.logits, dim=-1) print("Predicts:\n", predictions)

input IDs: tensor([[ 1045, 1005, 2310, 2042, 3403, 2005, 1037, 17662, 12172, 2607, 2026, 2878, 2166, 1012]])

Logits: tensor([[-2.7276, 2.8789]], grad_fn=)

Predicts: tensor([[4.0195e-02, 9.5981e-01], [9.9946e-01, 5.4418e-04]], grad_fn=)

### 다중 데이터셋 학습
```python
batched_ids = [
    [200, 200, 200],
    [200, 200, tokenizer.pad_token_id],
]

attention_mask = [
    [1, 1, 1],
    [1, 1, 0],
]

outputs = model(torch.tensor(batched_ids), attention_mask=torch.tensor(attention_mask))
print(outputs.logits)
-------------------------------------------------
tensor([[ 1.5694, -1.3895],
        [ 0.5803, -0.4125]], grad_fn=<AddmmBackward0>)

데이터 로드

from datasets import load_dataset
from transformers import AutoTokenizer, DataCollatorWithPadding

raw_datasets = load_dataset("glue", "mrpc") # 데이터셋 로딩
checkpoint = "bert-base-uncased"            # 불러올 모델명
tokenizer = AutoTokenizer.from_pretrained(checkpoint)   # 모델 토큰화 로딩

raw_datasets['train'].features
-------------------------------------------------------
{'sentence1': Value(dtype='string', id=None),
 'sentence2': Value(dtype='string', id=None),
 'label': ClassLabel(names=['not_equivalent', 'equivalent'], id=None),
 'idx': Value(dtype='int32', id=None)}

전처리

def tokenize_function(example):
    return tokenizer(example["sentence1"], example["sentence2"], truncation=True)

tokenized_datasets = raw_datasets.map(tokenize_function, batched=True)  # 토큰화

data_collator = DataCollatorWithPadding(tokenizer=tokenizer)    # 토큰화 자동패딩

tokenized_datasets = tokenized_datasets.remove_columns(["sentence1", "sentence2", "idx"])   # 불필요칼럼제거
tokenized_datasets = tokenized_datasets.rename_column("label", "labels")    # 칼럼명 수정
tokenized_datasets.set_format("torch")    # 형식 "torch"로 변환
tokenized_datasets["train"].column_names
-------------------------------------------------------------
['labels', 'input_ids', 'token_type_ids', 'attention_mask']

데이터 로더 생성

from torch.utils.data import DataLoader

train_dataloader = DataLoader(
    tokenized_datasets["train"], shuffle=True, batch_size=8, collate_fn=data_collator
)
test_dataloader = DataLoader(
    tokenized_datasets["validation"], batch_size=8, collate_fn=data_collator
)

for batch in train_dataloader:
    break
{k: v.shape for k, v in batch.items()}
-------------------------------------------------------
{'labels': torch.Size([8]),
 'input_ids': torch.Size([8, 66]),
 'token_type_ids': torch.Size([8, 66]),
 'attention_mask': torch.Size([8, 66])}

모델링

• True or False 이므로 num_labels=2

  from transformers import AutoModelForSequenceClassification
  

model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)

### 스케쥴러
```python
from transformers import get_scheduler

num_epochs = 3
num_training_steps = num_epochs * len(train_dataloader)
lr_scheduler = get_scheduler(
    "linear",
    optimizer=optimizer,
    num_warmup_steps=0,
    num_training_steps=num_training_steps
)
print(num_training_steps)
-----------------------------------------------
1377

CUDA 설정

• 실습환경: 코랩

  import torch
  

is_cuda = "cuda" if torch.cuda.is_available() else "cpu" device = torch.device(is_cuda) model.to(device) device

device(type='cuda')

## 모델 학습
```python
from tqdm import tqdm

progress_bar = tqdm(range(num_training_steps))

model.train()
for epoch in range(num_epochs):
    for batch in train_dataloader:
        batch = {k: v.to(device) for k, v in batch.items()}
        outputs = model(**batch)
        loss = outputs.loss
        loss.backward()

        optimizer.step()
        lr_scheduler.step()
        optimizer.zero_grad()
        progress_bar.update(1)
-----------------------------------------------------------------
100%|██████████| 1377/1377 [01:06<00:00, 21.74it/s]

모델 평가

from datasets import load_metric

metric = load_metric("glue", "mrpc")
model.eval()
for batch in test_dataloader:
    batch = {k: v.to(device) for k, v in batch.items()}
    with torch.no_grad():
        outputs = model(**batch)

    logits = outputs.logits
    predictions = torch.argmax(logits, dim=-1)
    metric.add_batch(predictions=predictions, references=batch["labels"])

metric.compute()
-----------------------------------------------------------
{'accuracy': 0.8578431372549019, 'f1': 0.8989547038327526}

해당 글은 제로베이스데이터스쿨 학습자료를 참고하여 작성되었습니다

HuggingFace

• https://github.com/huggingface/transformers
• NLP분야의 스타트업
• 다양한 트랜스포머 모델(transformer.models)과 학습 스크립트(transformer.Trainer)를 제공하는 모듈
• 개발자가 자연어 처리 애플리케이션과 서비스를 빠르고 효율적으로 구축하고 배포할 수 있도록 함

Pipeline

• 특정 작업을 수행하거나 특정 목표를 달성하기 위해 선형 또는 순차적 방식으로 연결된 일련의 프로세스
• preprocess -> 모델 -> post process 생성
• 최초 실행시 모델 다운로드
• pipeline(task, model, config, tokenizer, ...)
  • task : 내가 원하는 작업(ex. 'sentiment-analysis', 'zero-shot-classification', ...)
  • model : 사용모델 (Default=task에 적절한 모델 할당)

    !pip install transformers
    !pip install datasets
    

from transformers import pipeline

## 감정분석
- 해당 문장이 긍정인지 부정인지 판별
```python
classifier = pipeline('sentiment-analysis')
classifier.model
classifier("I've been waiting for a HuggingFace course my whole life.")
-------------------------------------------------------
[{'label': 'POSITIVE', 'score': 0.9598049521446228}]

Zero-shot 분류

• Zero-shot-Learning : 모델이 이전에 본 적이 없는 개체나 개념을 인식하도록 훈련되는 기계 학습
• Zero-shot-Classification : 해당 클래스에 대한 명시적인 훈련 없이 이전에 본 적이 없는 클래스 분류

  classifier = pipeline("zero-shot-classification")   # Default Model = facebook/bart-large-mnli
  classifier(
    "This is a course about the transformers library",          # 문제
    candidate_labels = ["education", "politics", "business"],    # 정답보기
  )

{'sequence': 'This is a course about the transformers library', 'labels': ['education', 'business', 'politics'], 'scores': [0.9192408919334412, 0.060778193175792694, 0.01998087950050831]}

```python
classifier(
    "This is a course about the transformers library",          # 문제
    candidate_labels = ["course", "library", "game", "This"],    # 정답보기
)
----------------------------------------------------------------
{'sequence': 'This is a course about the transformers library',
 'labels': ['course', 'library', 'This', 'game'],
 'scores': [0.732907235622406,
  0.19588284194469452,
  0.06776876002550125,
  0.003441136097535491]}

생성모델

• 문제로 주어진 문장을 기반으로 그 다음 문장을 생성

  generator = pipeline("text-generation")    # Default Model = gpt2
  generator("In this course, we will teach you how to ")

[{'generated_text': 'In this course, we will teach you how to \xa0create simple, beautiful, dynamic design diagrams, and how to create them with a variety of basic software tools. We will make use of our favorite tools like Sketch, L.A. Sketch'}]

### 세부조정
- num_return_sequences : 문장갯수
- max_length : 문장 길이
```python
generator("In this course, we will teach you how to ", num_return_sequences=5, max_length=20)
---------------------------------------------------------------------
[{'generated_text': 'In this course, we will teach you how to \xa0communicate with fellow listeners.\n2'},
 {'generated_text': 'In this course, we will teach you how to \xa0install the new web application for PHP 5'},
 {'generated_text': 'In this course, we will teach you how to \xa0understand the most basic \xa0of'},
 {'generated_text': 'In this course, we will teach you how to \xa0compete with the enemy. By taking'},
 {'generated_text': 'In this course, we will teach you how to \xa0explicitly use the\xa0cargo'}]

list_ = ["In this course, we will teach you how to ", "This is a course about the transformers library"]

for sentence in list_:
    print(generator(sentence, num_return_sequences=1, max_length=20))
--------------------------------------------------------------------------------------------
[{'generated_text': 'In this course, we will teach you how to \xa0help others get involved in social media.'}]
[{'generated_text': 'This is a course about the transformers library.\n\nThis is part of the Meej'}]

HuggingFace 사이트에 있는 모델사용

• 사용할 Task, Libraries 등 또는 Filter을 설정하고 원하는 모델을 찾기
• 모델 포스팅 글에서 사용법 확인하고 적용하기

generator = pipeline("text-generation", model="huggingtweets/dril")
generator("My dream is ", num_return_sequences=5)
-------------------------------------------------------------------------------------------------
[{'generated_text': 'My dream is ive invented. ive invented what is basically the most popular movie ever made and I need over $10,000 to make it go away. Thank you.'},
 {'generated_text': 'My dream is ive been to be the next "Powerball jack"'},
 {'generated_text': 'My dream is ive come to the realization that i have the power of unlimited consciousness. I would get a brain if i could simply convince all the guys in the house where i live to stop smoking pot that i can still tell the difference between a man and a woman and I would become completely Normal'},
 {'generated_text': "My dream is ive gotten over 1000 jobs. That's what my self believes. Ive fucked over 1000 people"},
 {'generated_text': 'My dream is \ue001� That the \ue003� of humanity \ue006nh is To See The \ue006nht That Is As The \ue001� Of My Dream.'}]

• 사이트에서도 실행가능

Mask Filling

• <mask>에 들어갈 단어 맞추기

  unmasker = pipeline("fill-mask")    # Default Model = distilroberta-base
  unmasker("This coures will teach you all about <mask> models", top_k=5)

[{'score': 0.040895454585552216, 'token': 745, 'token_str': ' building', 'sequence': 'This coures will teach you all about building models'}, {'score': 0.03127061203122139, 'token': 30412, 'token_str': ' mathematical', 'sequence': 'This coures will teach you all about mathematical models'}, {'score': 0.025371771305799484, 'token': 774, 'token_str': ' role', 'sequence': 'This coures will teach you all about role models'}, {'score': 0.01844116672873497, 'token': 265, 'token_str': ' business', 'sequence': 'This coures will teach you all about business models'}, {'score': 0.015211271122097969, 'token': 3034, 'token_str': ' computer', 'sequence': 'This coures will teach you all about computer models'}]

## 그룹 엔티티
- 학습되지 않은 단어의 클래스 찾기
- Sylvain: Person, Hugging Face: Organization, Brooklyn: Location
```python
ner = pipeline("ner", grouped_entities=True) # Default Model = dbmdz/bert-large-cased-finetuned-conll03-english
ner("My name is Sylvain and I work at Hugging Face in Brooklyn.")
--------------------------------------------------------------------------------
[{'entity_group': 'PER',
  'score': 0.9981694,
  'word': 'Sylvain',
  'start': 11,
  'end': 18},
 {'entity_group': 'ORG',
  'score': 0.9796019,
  'word': 'Hugging Face',
  'start': 33,
  'end': 45},
 {'entity_group': 'LOC',
  'score': 0.9932106,
  'word': 'Brooklyn',
  'start': 49,
  'end': 57}]

QnA

• Query text : 나는 집에 들어갔다. 그런데 배고파서 햄버거를 먹었다
• Question : 누가 햄버거를 먹었나?
• Answer : 나

  question_answer = pipeline("question-answering") # Default Model = distilbert-base-cased-distilled-squad
  question_answer(
    question="what's my name?",
    context="My name is Sylvain and I work at Hugging Face in Brooklyn.",
  )

{'score': 0.9988495111465454, 'start': 11, 'end': 18, 'answer': 'Sylvain'}

## summary
- 한계점 : 긴 문장에서 일부분을 추출해서 요약
```python
summarizer = pipeline("summarization") # Default Model = sshleifer/distilbart-cnn-12-6
summarizer(
    """
    National Commercial Bank (NCB), 
    Saudi Arabia’s largest lender by assets, 
    agreed to buy rival Samba Financial Group for $15 billion in the biggest banking takeover this year.
    NCB will pay 28.45 riyals ($7.58) for each Samba share, according to a statement on Sunday, 
    valuing it at about 55.7 billion riyals. NCB will offer 0.739 new shares for each Samba share, 
    at the lower end of the 0.736-0.787 ratio the banks set when they signed an initial framework 
    agreement in June.The offer is a 3.5% premium to Samba’s Oct. 8 closing price of 27.50 riyals and 
    about 24% higher than the level the shares traded at before the talks were made public. Bloomberg 
    News first reported the merger discussions.The new bank will have total assets of more than $220 billion, 
    creating the Gulf region’s third-largest lender. The entity’s $46 billion market capitalization nearly matches 
    that of Qatar National Bank QPSC, which is still the Middle East’s biggest lender with about $268 billion of 
    assets.
    """
)
---------------------------------------------------------------------------------------------------------------------------
[{'summary_text': " Saudi Arabia's largest lender National Commercial Bank agrees to buy rival Samba Financial Group for $15 billion . NCB will pay 28.45 riyals ($7.58) for each Samba share, valuing it at about 55.7 billion . The new bank will have total assets of more than $220 billion, creating the Gulf region’s third-largest lender ."}]

해당 글은 제로베이스데이터스쿨 학습자료를 참고하여 작성되었습니다

Few, Zero short learning & Transfer learning

자연어 데이터의 불완전성

• 특정 자연어 Task를 해결하기 위해서는 다양한 Label이 요구됨. 특히, format도 매우 복잡함
• input data는 굉장히 많은데 label이 적음
• 수많은 텍스트 데이터들이 레이블이 없이 존재함(ex. 의료 데이터셋)

pre-training

• 레이블이 지정되지 않은 데이터 세트에서 훈련하여 심층 신경망의 매개변수를 초기화하는 기술

Fine tunning

• 사전 학습된 모델을 새로운 문제에 적용하기 위해 일부 가중치를 조절하는 학습 과정

Transfer learning

• 일본어-영어, 한국-일본어 간의 번역 데이터는 많으나 한국-영어 데이터는 적을 경우
• 영어->일본어 데이터셋에서 문맥 벡터를 잘 뽑아내는 모델을 학습한 후 영어->한국어 데이터셋에 적용

Few shot, zero shot learning

• Query image : 추론할 입력 데이터
• Training set : 모델이 학습하는 데이터 셋
• Support set : 추론해야 하는 셋
  • support set의 종류 수를 way, 사진 수를 shot으로 표현함

GPT-1

• Gpt1, Bert, Gpt2, Gpt3 순으로 연구됨
• Generative Pre-Training
• 비지도학습 기반의 pre-training과 지도학습 기반의 fine-tunning을 결합한 semi-supervised learning
• 그래서 다양한 자연어 task에서 fine-tunning만으로도 좋은 성능을 보이는 범용적인 자연어 representation을 학습하는 것
• 2 stage로 구성되어 있으며 transformer의 decoder 구조를 사용함
• 기존 RNN 대비 좋은 성능을 보였으며 일반화 성능 확인

Stage1: pre-training

• 문장 $u$가 구성되어 있고 서브단어 $u_i$로 각 확률들을 계산
• $h_0$=초기화, $W_e$=워드 임베딩, $U$=단어(쿼리), $W_p$=포지션 임베딩

Stage2: fine-tuning

• $x$=문장의 토큰들, $y$=label

Task-specific input transformations

• 기존: Task specific 구조에 기반한 학습, 구조에 종속되기 때문에 task가 변할 때 마다 많은 커스터마이즈를 요구
• GPT-1 : Pre-training model 적용될 수 있도록 input구조를 convert

GPT-1의 성능

• LM -> 큰 데이터셋 에서는 좋은 결과 but 작은 데이터셋에서는 아님

• Layer 가 증가함에 따라 정확도가 높아지는 것을 확인

• LSTM과 비교하여 다양한 task에서 일반화 성능 확인

BERT

• Bidirectional Encoder Representations from Transformer
• Wiki & book data 와 같은 대용량 unlabeled data로 pre-training 시킨 후, 특정 task 에 transfer learning 을 함
• GPT와의 차이? -> unidirectional(GPT) vs bidirectional(BERT)
• GPT와는 달리 새로운 네트워크를 붙이지 않고 fine-tunning 만을 진행함
• GPT-1 : Unsupervised pre-training -> BERT : Masked Language Model(MLM) & Next sentence prediction
• Next sentence prediction
  • 문장간 관계를 알아내기 위한 task, 두 문장이 실제 corpus 에서 이어져 있는지 아닌지 확인
  • 50% 는 실제 이어져 있는 문장
• Pre-training 프로세스는 GPT-1과 같음

BERT와 GPT

Mask Language Model(MLM)

• [MASK] 비율 : 15%
• Tokenization : Wordpiece
• LM 의 left-to-right 와는 달리, [MASK] 를 추론하는 task 수행
• Fine tunning 에는 사용되지 않음

MASK 생성 과정

• 80% : token 을 [MASK]로 변환
• 10% : token 을 임의의 단어로 변경
• 10% : 원래의 단어 token 으로 둠

Pre-trained 되는 transformer encode의 입장에서는 contextual representation 학습

BERT의 input

BERT의 fine-tuning

• Sequence-level classification
  • [CLS] token 의 output 사용
  • CLS output 에 W matrix 를 곱해주고 softmax를 취해 준다.
• Span-level, token-level prediction

BERT의 성능

GLUE

• 다양한 task를 모아놓아 종합적인 자연어 이해 능력 테스트가 가능한 벤치마크
• BERT는 대부분의 task에 SOTA(State-of-the-art)
• 특히 데이터 크기가 작아도 fine-tunning 후에는 좋은 성능

SQuAD

• GLUE는 sequence classification
• SQuAD 는 질문 과 지문이 주어지고, substring 인 정답 찾기
• 질문 A, 지문 B 지문에서 substring 찾기 문제
• Start vector와 end vector의 dot product를 하여 찾기

SWAG

• Grounded common-sense inference
• 문장이 주어지고, 가장 잘 이어지는 문장 찾기
• 주어진 문장 A, 가능한 문장들 B

CoNLL-2003

• 각각의 단어가 어떤 형식인지
• Person, Organization, Location …
• 토큰마다 classifier 붙이기

Ablation studies

• Pre-train 을 하나라도 제거하면 성능 감소가 일어남

• No NSP -> 자연어 추론 계열(NLI)에서 성능 감소 폭 큼

• MLM 대신 LTR -> 성능이 매우 감소함

• 모델 사이즈가 커질수록 성능 향상

• MLM이 많은 training이 필요하지만 성능향상 확인

GPT-2

• Fine-tunning 없이도 우리는 가능하게 하고 싶다.

• 모델 자체는 GPT-1과 크게 차이 없음

• Zero shot learning

  • Model이 바로 downstream task에 적용함 (few shot: 몇 번 보고 적용함 )

• WebText 데이터을 구축

  • 이 대용량 데이터셋에 LM 모델을 학습했을 때 supervision 없이도 다양한 task 처리

• Byte pair Encoding을 활용 하여 Out of Vocabulary 문제 해결

Zero shot 적용방법

• 문장의 긍/부정 -> what do you think about this sentence ? 같은 질문 추가
• 문장 요약 -> What is the summary of … ? 추가
• 번역 -> what is translated sentence in Korean? 추가

Byte pair Encoding

Word Piece model (BERT)

• Jet은 자주 등장하지 않아서 J et 로 나눔
• 모든 단어 시작에는 _

Byte-pair encoding(BPE)

GPT-2의 성능

• Zero shot 임에도 불구하고 8개중 7개에서 SOTA
• 특히, PTB,Wikitext-2 와 같은 적은 데이터셋에서 좋은 성능

GPT-3

• GPT-2 대비 Self-attention layer를 굉장히 많이 쌓아 parameter 수를 대폭 늘림
• GPT-2에서 사용하는 Zero shot learning framework의 확장

shot learing

Transformer

• Transformer : 예측 K값 이전의 모든 입력 데이터을 예측에 활용
  • 입력 데이터의 크기가 크면 계산량이 매우 많아짐
• Sparse Transformers : 입력 데이터의 일부분만 활용
  • 계산 효율성을 높이고, 불필요한 계산을 줄일 수 있음
  • GPT3가 strided와 fixed 사용

전체 요약

해당 글은 제로베이스데이터스쿨 학습자료를 참고하여 작성되었습니다

관련연구: Computer Vision

Visual Transformer(ViT)

• AN IMAGE IS WORTH 16X16 WORDS: TRANSFORMERS FOR IMAGE RECOGNITION AT SCALE, ICLR 2021
• Vit는 Transformer를 사용하여 이미지 인식에 적용한 연구
• 컴퓨터 비전 분야에서는 Convolution 연산을 이용한 방법이 아직까지 대중적

Inductive bias(귀납편향)

• 데이터가 공간적으로 변화해도 불변하는 것
• ViT는 귀납편향없이 성능향상을 보임

Key idea

• positional encoding에서 이미지를 분할하고 분할 대상을 각각의 토큰으로 판단하여 수행

Vit Forwarding

타모델과 비교

• JFT300M dataset으로 pretrain 시키고 테스트
  • 이미지 약 3억개 사용(용량 : 18PB)
• 자동으로 low-level의 특성을 학습하는 embedding filter
• Positional embdding 이후의 이미지와 패치와의 유사도
• Attention이 얼마나 먼 패치를 할당하고 있는지 (receptive field와 유사)

DETR

• End-to-End Object Detection with Transformers, ECCV 2020
• Object Detection 문제를 direct set prediction으로 푸는 모델
• 기존의 Detection 에서 생기는 non-maximum suppression (NMS) 문제를 해결
• Transformer 기반의 prediction

NMS Problem

• 기존 방법은 non-maximum suppression (NMS) 문제를 해결하기 위해 post processing 필요
• DETR은 transformer 를 활용한 end-to-end 방식

DETR 모델 절차

• CNN을 입력받아서 positional Encoding 수행
• Encoder을 거치고 Decoder 수행
• Decoder에서 대상에 대해서 하나의 Bounding box가 할당되도록 birpartite mathing 사용

bipartite matching

• NMS 해결 -> 각각의 실제 레이블에 대해서 하나만 할당
• 오브젝트가 없다면 확률을 계산하지 않고
• 오브젝트가 있다면 바운딩 박스의 확률을 계산하고 최적의 박스를 찾는다

Python Code

관련연구: 시계열 데이터

BETS

• Informer: Beyond Efficient Transformer for Long Sequence TimeSeriesForecasting (AAAI'21 Best Paper)
• 기존의 시계열 데이터 처리는 LSTM을 많이 사용
• BETS는 일반적으로 훨씬 긴 시계열을 예측하는 시계열 데이터
• Transformer 의 attention layer 는 matrix 연산임 -> 계산인 size의 제곱만큼 증가

해당 글은 제로베이스데이터스쿨 학습자료를 참고하여 작성되었습니다

Transformer

Transformer Architecture

Positional Encoding

• transformer는 병렬 처리이므로 성능이 향상되었으나 RNN에서 가능했던 순서처리가 불가능해짐
• 이를 해결하기 위해 positional encoding 사용
• 각 토큰의 입력 임베딩에 위치 인코딩을 추가함으로써 Transformer 모델은 병렬 처리 구조에도 불구하고 토큰의 순차적 순서를 유지할 수 있게 됨

Multi head attention

• Self-Attention 메커니즘을 이용한 자연어 처리 향상 모듈
• 입력벡터로 query, key, value 벡터를 받음
• 이를 활용하여 attention score를 계산하고 단어별 중요도를 결정할 수 있음

성능향상을 위한 기술

• Skip Connection
  • 한 계층의 출력을 다른 계층의 출력에 직접 추가하는 연결
  • Vanishing Gradient를 완화하기 위해 사용한 방법
• Layer Normalization
  • 각 계층의 출력 정규화
  • 입력 변동의 영향을 줄이고 네트워크의 전반적인 안정성과 성능 향상

기존 모델과 성능비교

요약

• 기계번역 task에서 기존의 연구들 보다 성능적으로 우수
• 병렬적으로 처리가 가능한 모델 -> time complexity 감소
• 이후에 사용되는 Bert, GPT 모델에서 일반화에 강점이 있다는 것이 확인

Positional Encoding

필요한 이유

• 기존의 RNN 기반의 방법 경우, context 벡터를 추출해서 사용함
• 이러한 추출을 하기 위해서는 문장의 단어들을 순차적으로 처리해야 했음
• 디코더도 마찬가지로 순차적으로 처리되었고 문장의 순서를 고려하게 됨
• 반면 Transformer 의 입력 Q 의 경우 행렬 연산을 통해 입력 벡터로 변환되어 Multi-head attention 모듈에 들어감
• 문장의 순서에 대한 정보를 넣어줄 필요성이 생김

어떻게 부여해야 하는가

• 단어 순서대로 숫자 카운팅 -> 숫자가 너무 빨리 커져서 weight 학습이 어려우므로 X
• 카운팅 후 정규화 -> weight 학습은 안정적이지만, 단어가 추가되면 같은 값 할당 불가능하므로 X
• 단어 순서대로 벡터표현 -> 단어 순서끼리의 거리가 달라지므로 X
• Sinusodial Encoding 사용
  • i=depth, p=position
  • 삼각함수 sin, cos 사용
  • rotaion matrix로 인해 적절한 상대거리를 얻게 됨 Reference : skyjwoo의 position_encoding 포스팅

Python Code

def positional_encoding(max_position, d_model, min_freq=1e-4):
    position = np.arange(max_position)
    freqs = min_freq**(2*(np.arange(d_model)//2)/d_model)
    pos_enc = position.reshape(-1,1)*freqs.reshape(1,-1)
    pos_enc[:,::2] = np.cos(pos_enc[:, ::2])    # 짝수만 cos
    pos_enc[:, 1::2] = np.sin(pos_enc[:, 1::2]) # 홀수만 sin
    return pos_enc

Multi-head Self-attention

설명

• Query, Key, Value attention을 기반으로 Scaled Dot-pordict attention을 사용함

• 기존의 attention 기법의 경우 Key와 Query만 존재

• 그러나 Transformer의 attention의 경우 Value까지 존재

• 문장을 이해할 때 단어들은 서로 영향을 끼치며 그 강도는 다르다

• 단어에 대한 벡터(Q)는 주어진 단어들에 대해서 유사한 정도(K)만큼 고려하고 각 주어진 단어들은 V만큼의 중요도를 갖는다

Attention

k번째 단어만 고려하여 Q, V, K 계산

"I love you"라는 문장으로 예시를 들면 input linear embedding을 통해 각 단어에 대한 Q,K,V 행렬로 변환한다

softmax을 Q, K에 대해 적용한다

• Query 로 단어를 주었을 때
• 이 단어와 유사한 Key 값을 더욱더 attention 을 주고
• 이 key 값의 중요도에 따라서 Value 값을 준다.

softmax(Q,K)결과에 V를 곱해서 Attention 획득

• Attention 매트릭스가 Query의 차원수와 동일해짐
• 계속해서 같은 차원으로 Self-attention 수행이 가능하게 된다

Mask Matrix

• $QK^T$에 mask값으로 0에 가까운 값을 주어서 특정 단어는 무시할 수 있도록 함

• 처음 쿼리의 차원수 head의 개수만큼 나눠주기 때문에 최종적으로 입력의 차원수와 같게 된다

Python Code

• reference : 참조한 깃허브

  import torch
  import torch.nn as nn
  

class MultiHeadAttentionLayer(nn.Module): def init(self, hidden_dim, n_heads, dropout_ratio, device): super().init()

    assert hidden_dim % n_heads == 0

    self.hidden_dim = hidden_dim # 임베딩 차원
    self.n_heads = n_heads # 헤드(head)의 개수: 서로 다른 어텐션(attention) 컨셉의 수
    self.head_dim = hidden_dim // n_heads # 각 헤드(head)에서의 임베딩 차원

    self.fc_q = nn.Linear(hidden_dim, hidden_dim) # Query 값에 적용될 FC 레이어
    self.fc_k = nn.Linear(hidden_dim, hidden_dim) # Key 값에 적용될 FC 레이어
    self.fc_v = nn.Linear(hidden_dim, hidden_dim) # Value 값에 적용될 FC 레이어

    self.fc_o = nn.Linear(hidden_dim, hidden_dim)

    self.dropout = nn.Dropout(dropout_ratio)

    self.scale = torch.sqrt(torch.FloatTensor([self.head_dim])).to(device)

def forward(self, query, key, value, mask = None):

    batch_size = query.shape[0]

    # query: [batch_size, query_len, hidden_dim]
    # key: [batch_size, key_len, hidden_dim]
    # value: [batch_size, value_len, hidden_dim]

    Q = self.fc_q(query)
    K = self.fc_k(key)
    V = self.fc_v(value)

    # Q: [batch_size, query_len, hidden_dim]
    # K: [batch_size, key_len, hidden_dim]
    # V: [batch_size, value_len, hidden_dim]

    # hidden_dim → n_heads X head_dim 형태로 변형
    # n_heads(h)개의 서로 다른 어텐션(attention) 컨셉을 학습하도록 유도
    Q = Q.view(batch_size, -1, self.n_heads, self.head_dim).permute(0, 2, 1, 3)
    K = K.view(batch_size, -1, self.n_heads, self.head_dim).permute(0, 2, 1, 3)
    V = V.view(batch_size, -1, self.n_heads, self.head_dim).permute(0, 2, 1, 3)

    # Q: [batch_size, n_heads, query_len, head_dim]
    # K: [batch_size, n_heads, key_len, head_dim]
    # V: [batch_size, n_heads, value_len, head_dim]

    # Attention Energy 계산
    energy = torch.matmul(Q, K.permute(0, 1, 3, 2)) / self.scale

    # energy: [batch_size, n_heads, query_len, key_len]

    # 마스크(mask)를 사용하는 경우
    if mask is not None:
        # 마스크(mask) 값이 0인 부분을 -1e10으로 채우기
        energy = energy.masked_fill(mask==0, -1e10)

    # 어텐션(attention) 스코어 계산: 각 단어에 대한 확률 값
    attention = torch.softmax(energy, dim=-1)

    # attention: [batch_size, n_heads, query_len, key_len]

    # 여기에서 Scaled Dot-Product Attention을 계산
    x = torch.matmul(self.dropout(attention), V)

    # x: [batch_size, n_heads, query_len, head_dim]

    x = x.permute(0, 2, 1, 3).contiguous()

    # x: [batch_size, query_len, n_heads, head_dim]

    x = x.view(batch_size, -1, self.hidden_dim)

    # x: [batch_size, query_len, hidden_dim]

    x = self.fc_o(x)

    # x: [batch_size, query_len, hidden_dim]

    return x, attention

# Layer Normalization
## Batch norm vs Layer norm
- Batch nrom : sample들의 feature별 평균과 분산 -> batch size에 따라서 성능변화가 심함
Layer nrom : 각 batch에 대해서 feature들의 평균과 분산
![](https://velog.velcdn.com/images/insung_na/post/c310d474-4e5e-4fa8-b1bb-adb81dfd6060/image.png)
![](https://velog.velcdn.com/images/insung_na/post/fc35700a-3197-487e-a073-1a60b1e3c210/image.png)

### Python Code
```python
class LayerNorm(nn.Module):
    def __init__(self, d_model, eps=1e-8):
        super(LayerNorm, self).__init__()
        self.gamma = nn.Parameter(torch.ones(d_model))
        self.beta = nn.Parameter(torch.zeros(d_model))
        self.eps = eps

    def forward(self, x):
        mean = x.mean(-1, keepdim=True)
        std = x.std(-1, keepdim=True)
        return self.gamma * (x - mean) / (std + self.eps) + self.beta

Final Summary

1. input 임베딩 + Position Encoding (Encoder)
2. Q, K, V 생성
3. Multi-Head Attention 사용
4. Skip-Connection + Layer Normalization
5. Self-attention 반복수행
6. Encoder의 출력값을 Decoder가 받아서 학습을 진행
7. Linear모델과 softmax을 통해서 최종결과(확률)를 도출

딥러닝 역사

ML vs DL

딥러닝 구성

딥러닝

뉴런

• 구성요소 : 입력, 가중치, 활성화함수, 출력
• 가중치를 업데이트
• 처음에는 초기화를 통해 랜덤값을 넣고, 학습을 통해 가중치를 수렴시킴

레이어와 망(net)

• 뉴런이 모여서 layer를 구성하고, 망(net)이 됨

딥러닝

• 신경망이 깊어(많아)지면 깊은 신경망 Deep Learning이 됨

CNN

Dropout

역전파

• XOR문제의 해결을 위해 등장한 역전파
• 출력층부터 delta를 계산해서 은닉층으로 전달한다

연쇄법칙(Chain Rule)

활성함수

softmax

• $softmax(x_i) = e^{x_i} / \sum_{j=1}^{n} e^{x_j}$
• 입력받은 값을 출력으로 0~1사이의 값으로 모두 정규화하며 출력 값들의 총합은 항상 1이 되는 특성을 가진 함수

ReLU

• $f(x) = max(0, x)$
• +/-가 반복되는 신호에서 -흐름을 차단

  sigmoid의 한계

  

Vanishing Gradient problem

ReLU

• Rectified Linear Units
• 은닉층은 대부분 ReLU를 사용

softmax

• 카테고리들 중 확률이 가장 높은 대상을 정답으로 판단

활성화 함수 미분값

옵티마이저

해당 글은 제로베이스데이터스쿨 학습자료를 참고하여 작성되었습니다

1. Pytorch_basic

import torch
x = torch.tensor(3.5)

기울기 계산

x = torch.tensor(3.5, requires_grad=True)

print(x)
y = (x-1) * (x-2) * (x-3)

print(y)
y.backward()    # 미분계산
x.grad          # x의 기울기
---------------------------------------------------
print(x) : tensor(3.5000, requires_grad=True)
print(y) : tensor(1.8750, grad_fn=<MulBackward0>)
x.grad : tensor(5.7500)

연쇄법칙(Chain Rule)

a = torch.tensor(2., requires_grad=True)
b = torch.tensor(1., requires_grad=True)

x = 2*a + 3*b
y = 5*a*a + 3*b**3
z = 2*x + 3*y
z.backward()    # 미분실행
a.grad          # a의 미분값
-----------------------------------
tensor(64.)

2. 보스턴 집값 예측

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

데이터 로드

from sklearn.datasets import fetch_openml
import pandas as pd

X, y = fetch_openml('boston', return_X_y=True, parser='auto', version=1)
df = X
df['TARGET'] = y
df.tail()

칼럼 선정

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
cols = ["TARGET", "INDUS", "RM", "LSTAT", "NOX", "DIS"]
data = torch.tensor(df[cols].values).float()
data.shape
-----------------------------------------------------------
torch.Size([506, 6])

특성과 라벨로 분리

x = data[:, 1:]
y = data[:, :1]

print(x.shape, y.shape)
--------------------------------
torch.Size([506, 5]) torch.Size([506, 1])

하이퍼파라미터

n_epochs = 2000
learning_rate = 1e-3
print_interval = 100

모델 학습

model = nn.Linear(x.size(-1), y.size(-1))

# SGD(stochastic gradient descent, 확률적 경사하강법)
optimizer = optim.SGD(model.parameters(), lr=learning_rate)

for i in range(n_epochs):
    y_hat = model(x)
    loss = F.mse_loss(y_hat, y)

    optimizer.zero_grad()   # optimizer 초기화
    loss.backward()     # 미분

    optimizer.step()    # 파라미터 업데이트

    if (i+1)%print_interval==0:
        print("Epoch %d: loss=%.4e" %(i+1, loss))
-----------------------------------------------------
Epoch 100: loss=4.4202e+01
Epoch 200: loss=3.7470e+01
...
Epoch 1900: loss=2.8987e+01
Epoch 2000: loss=2.8986e+01

모델 학습결과

df = pd.DataFrame(torch.cat([y, y_hat], dim=1).detach_().numpy(), columns=["y", "y_hat"])
sns.pairplot(df, height=5)
plt.show()

3. 유방암 예측

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.datasets import load_breast_cancer
cancer = load_breast_cancer()

# print(cancer.DESCR)

데이터 정리

df = pd.DataFrame(cancer.data, columns=cancer.feature_names)
df['class'] = cancer.target
df.tail()

칼럼 선정

cols = ['mean radius', 'mean texture',
        'mean smoothness', 'mean compactness', 'mean concave points',
        'worst radius', 'worst texture',
         'worst smoothness', 'worst compactness', 'worst concave points',
         'class']

for c in cols[:-1]:
    sns.histplot(df, x=c, hue=cols[-1], bins=50, stat="probability")
    plt.show()    # 이미지 다수 생략

데이터 분리

data = torch.from_numpy(df[cols].values).float()

x = data[:, :-1]
y = data[:, -1:]

print(x.shape, y.shape)
-----------------------------------------------------
torch.Size([569, 10]) torch.Size([569, 1])

하이퍼파라미터

n_epochs = 200000
learning_rate = 1e-2
print_interval = 10000

모델링

class MyModel(nn.Module):
    def __init__(self, input_dim, output_dim):
        super(MyModel, self).__init__()
        self.input_dim, self.output_dim = input_dim, output_dim
        self.linear = nn.Linear(input_dim, output_dim)
        self.act = nn.Sigmoid()

    def forward(self, x):
        y = self.act(self.linear(x))

        return y

model = MyModel(input_dim=x.size(-1),
                output_dim=y.size(-1))
crit = nn.BCELoss() # Binary Cross Entropy

optimizer = optim.SGD(model.parameters(), lr=learning_rate)

모델 학습

for i in range(n_epochs):
    y_hat = model(x)
    loss = crit(y_hat, y)

    optimizer.zero_grad()
    loss.backward()

    optimizer.step()

    if (i+1)%print_interval==0:
        print(f"Epoch {i+1}: loss={loss.item():.4f}")
---------------------------------------------------------
Epoch 10000: loss=0.2796
Epoch 20000: loss=0.2299
...
Epoch 190000: loss=0.1167
Epoch 200000: loss=0.1156

모델 학습결과

correct_cnt = (y == (y_hat > .5)).sum()
total_cnt = float(y.size(0))

print("Accuracy: %.4f" %(correct_cnt/total_cnt))
---------------------------------------------------
Accuracy: 0.9649

df = pd.DataFrame(torch.cat([y, y_hat], dim=1).detach().numpy(), columns=["y", "y_hat"])
sns.histplot(df, x="y_hat", hue="y", bins=50, stat="probability")
plt.show()

4. MNIST

import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms

import matplotlib.pyplot as plt
%matplotlib inline

Set Cuda

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("Current device is", device)
----------------------------------------------------------------------
Current device is cpu

Datasets Load

import os
# os.listdir("../data")
train_data = datasets.MNIST(root="../data",   # data save path
                            train=True,       # train data
                            download=True,    # download on
                            transform=transforms.ToTensor())

test_data = datasets.MNIST(root="../data",    # data save path
                            train=False,      # test data
                            transform=transforms.ToTensor())

print("number of training data: ", len(train_data))
print("number of test data: ", len(test_data))
-----------------------------------------------------------------
number of training data:  60000
number of test data:  10000

Data Check

image, label = train_data[0]
image.shape, image.squeeze().shape
# 첫번째 차원이 channel
------------------------------------------------
(torch.Size([1, 28, 28]), torch.Size([28, 28]))

plt.imshow(image.squeeze().numpy(), cmap="gray")
plt.title("label : %s" %label)
plt.show()

Mini batch configure

batch_size = 50
learning_rate = 0.0001
epoch_num = 15

train_loader = torch.utils.data.DataLoader(dataset = train_data,
                                           batch_size=batch_size,
                                           shuffle=True)

test_loader = torch.utils.data.DataLoader(dataset = test_data,
                                           batch_size=batch_size,
                                           shuffle=True)

first_batch = train_loader.__iter__().__next__()
print("{:15s} | {:<25s} | {}".format("name", "type", "size"))
print("{:15s} | {:<25s} | {}".format("Num of Batch", "", len(train_loader)))
print("{:15s} | {:<25s} | {}".format("first_batch", str(type(first_batch)), len(first_batch)))
print("{:15s} | {:<25s} | {}".format("first_batch[0]", str(type(first_batch[0])), first_batch[0].shape))
print("{:15s} | {:<25s} | {}".format("first_batch[1]", str(type(first_batch[1])), first_batch[1].shape))
-----------------------------------------------------------------------------------------------------------
name            | type                      | size
Num of Batch    |                           | 1200
first_batch     | <class 'list'>            | 2
first_batch[0]  | <class 'torch.Tensor'>    | torch.Size([50, 1, 28, 28])
first_batch[1]  | <class 'torch.Tensor'>    | torch.Size([50])

Modeling

• nn.Linear(3136, 1000)으로 설정되어 있다

• (28,28) -> MaxPooling2d 2번 -> (7,7) 여기에 channel_cnt를 곱함

• 하지만 연결계층의 입력크기는 일반적으로 특징을 잘 포착할 수 있을 만큼 크게 선택됨

• 입력크기 너무 크면 과적합, 작으면 정보를 모두 포착하지 못해서 올바른 학습불가

• 따라서 시행착오를 통해서 최적의 입력크기를 찾아야한다

  class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, 3, 1, padding="same")
        self.conv2 = nn.Conv2d(32, 64, 3, 1, padding="same")
        self.dropout = nn.Dropout2d(0.25)
  
        self.fc1 = nn.Linear(3136, 1000)
        self.fc2 = nn.Linear(1000, 10)
  
    def forward(self, x):
        x = self.conv1(x)
        x = F.relu(x)
        x = F.max_pool2d(x,2)
  
        x = self.conv2(x)
        x = F.relu(x)
        x = F.max_pool2d(x,2)
  
        x = self.dropout(x)
        x = torch.flatten(x,1)
  
        x = self.fc1(x)
        x = F.relu(x)
        x = self.fc2(x)
        output = F.log_softmax(x, dim=1)
  
        return output

  model = CNN().to(device)
  optimizer = optim.Adam(model.parameters(), lr=learning_rate)
  criterion = nn.CrossEntropyLoss()

  Model Learning

  from time import time
  

model.train() i = 1 for epoch in range(epoch_num): start_time_each_epoch = time() for data, target in train_loader: data = data.to(device) target = target.to(device) optimizer.zero_grad() output = model(data) loss = criterion(output, target) loss.backward() optimizer.step() if i%1000==0: print("Time: %.3f\tTrain Step: %d\tLoss: %.3f\t" %(time() - start_time_each_epoch, i, loss.item())) i+=1

Time: 81.436 Train Step: 1000 Loss: 0.191
Time: 69.932 Train Step: 2000 Loss: 0.033
Time: 53.119 Train Step: 3000 Loss: 0.014
Time: 52.150 Train Step: 4000 Loss: 0.132
Time: 22.078 Train Step: 5000 Loss: 0.192
Time: 136.500 Train Step: 6000 Loss: 0.178
Time: 114.181 Train Step: 7000 Loss: 0.048
Time: 90.783 Train Step: 8000 Loss: 0.018
Time: 68.979 Train Step: 9000 Loss: 0.020
Time: 43.789 Train Step: 10000 Loss: 0.005
Time: 20.056 Train Step: 11000 Loss: 0.055
Time: 97.013 Train Step: 12000 Loss: 0.000
Time: 78.883 Train Step: 13000 Loss: 0.027
Time: 62.891 Train Step: 14000 Loss: 0.005
Time: 47.510 Train Step: 15000 Loss: 0.003
Time: 31.382 Train Step: 16000 Loss: 0.000
Time: 15.918 Train Step: 17000 Loss: 0.001
Time: 95.073 Train Step: 18000 Loss: 0.018

## Model Eval
```python
model.eval()
correct = 0

for data, target in test_loader:
    data = data.to(device)
    target = target.to(device)
    output = model(data)
    prediction = output.data.max(1)[1]
    correct += prediction.eq(target.data).sum()

print("Test set: Accuracy: %.2f" %(100.*correct / len(test_loader.dataset)))
------------------------------------------------------------------------------
Test set: Accuracy: 99.08

해당 글은 제로베이스데이터스쿨 학습자료를 참고하여 작성되었습니다

OX Classification

1. 개요

• 딥러닝 기초 이진분류에 대해 학습한다
• 데이터셋 : OX Images
• 데이터셋을 얻지 못했다
  • 결과는 학습자료를 보고, 코드만 입력하면서 학습한다

    2. 데이터 수집

• 데이터셋 없음
• 코드만 입력

  3. 데이터 전처리

• 이미지 불러오기(실행X)
• train_test별로 크기 조정
• 이미지 제네레이터

  3-1. 이미지 조정

  from glob import glob
  

train_raw_path = "./train_raw/O/*." train_raw_O_list = glob(train_raw_path) train_raw_O_list

![](https://velog.velcdn.com/images/insung_na/post/883f5585-307b-4bf5-b111-969bf07eb34a/image.png)

#### img_resize
![](https://velog.velcdn.com/images/insung_na/post/84a4afa1-0a65-4ae0-943b-e627edfe5ea3/image.png)

```python
# !pip install scikit-image
from skimage.transform import rescale, resize
from skimage import color
from skimage.io import imread, imsave
import matplotlib.pyplot as plt
import numpy as np

def img_resize(img):
    img = color.rgb2gray(img)
    return resize(img, (28,28))

train_O

from tqdm.notebook import tqdm

def convert_train_O():
    train_raw_O_list = glob(train_raw_path)
    for each in tqdm(train_raw_O_list):
        img = imread(each)
        img_resized = img_resize(img)
        save_name = "./train/O/" + each.split("/")[-1][:-4] + ".png"    # rename
        imsave(save_name, np.round(img_resized*255).astype(int))

convert_train_O()

train_X

from tqdm.notebook import tqdm

train_raw_path = "./train_raw/X/*."
def convert_train_X():
    train_raw_X_list = glob(train_raw_path)
    for each in tqdm(train_raw_X_list):
        img = imread(each)
        img_resized = img_resize(img)
        save_name = "./train/X/" + each.split("/")[-1][:-4] + ".png"    # rename
        imsave(save_name, np.round(img_resized*255).astype(int))

convert_train_X()

test_O

from tqdm.notebook import tqdm

test_raw_path = ""
def convert_test_O():
    test_raw_O_list = glob(test_raw_path)
    for each in tqdm(test_raw_O_list):
        img = imread(each)
        img_resized = img_resize(img)
        save_name = "./test/O/" + each.split("/")[-1][:-4] + ".png"    # rename
        imsave(save_name, np.round(img_resized*255).astype(int))

convert_test_O()

test_X

from tqdm.notebook import tqdm

test_raw_path = ""
def convert_test_X():
    test_raw_X_list = glob(test_raw_path)
    for each in tqdm(test_raw_X_list):
        img = imread(each)
        img_resized = img_resize(img)
        save_name = "./test/X/" + each.split("/")[-1][:-4] + ".png"    # rename
        imsave(save_name, np.round(img_resized*255).astype(int))

convert_test_X()

3-2. Image_generator

import numpy as np
from keras.models import Sequential
from keras.layers import Dense, Flatten
from keras.layers.convolutional import Conv2D, MaxPooling2D
from keras.preprocessing.image import ImageDataGenerator
import keras

np.random.seed(13)
train_datagen = ImageDataGenerator(rescale=1./255)

train_generator = train_datagen.flow_from_directory("./train", target_size=(28,28), batch_size=3, class_mode="categorical")

test_datagen = ImageDataGenerator(rescale=1./255)

test_generator = test_datagen.flow_from_directory("./test", target_size=(28,28), batch_size=3, class_mode="categorical")

4. 모델링

model = Sequential()
model.add(Conv2D(32, kernel_size=(3,3), activation="relu", input_shape=(28,28,3)))
model.add(Conv2D(64, kernel_size=(3,3), activation="relu"))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Flatten())
model.add(Dense(128, activation="relu"))
model.add(Dense(2, activation="softmax"))

model.compile(loss="categorical_crossentropy", optimizer="adam", metrics=["accuracy"])

hist = model.fit_generator(train_generator, steps_per_epoch=15, epochs=50, validation_data=test_generator, validation_steps=5)
plt.figure(figsize=(12,6))
plt.plot(hist.history["loss"], label="loss")
plt.plot(hist.history["val_loss"], label="val_loss")
plt.plot(hist.history["accuracy"], label="accuracy")
plt.plot(hist.history["val_accuracy"], label="val_accuracy")
plt.legend()
plt.show()

5. 모델 평가

scores = model.evalute(test_generator, steps=5)

print("%s: %.2f%%" %(model.metrics_names[1], scores[1]*100))    # 100.0%

model.predict(test_generator)
n = 1

def show_prediction_result(n):
    img = imread(test_generator.filepaths[n])
    pred = model.predict(np.expand_dims(color.gray2rgb(img), axis=0))
    title = "Predict : " + str(np.argmax(pred))
    plt.imshow(img/255., cmap="gray")
    plt.title(title)
    plt.show()

show_prediction_result(n)
show_prediction_result(40)

해당 글은 제로베이스데이터스쿨 학습자료를 참고하여 작성되었습니다

Find Mask man

• 출처 : https://www.kaggle.com/datasets/ashishjangra27/face-mask-12k-images-dataset

  Module Import

  import numpy as np
  import pandas as pd
  import os
  import glob
  import matplotlib.pyplot as plt
  import seaborn as sns
  import tensorflow as tf
  from tensorflow.keras import Sequential, models, layers, models
  from tensorflow.keras.layers import Flatten, Dense, Conv2D, MaxPool2D
  from sklearn.model_selection import train_test_split
  from sklearn.metrics import classification_report, confusion_matrix

  Data collecting

  데이터 경로와 목록 저장

  path = "../data/Face Mask Dataset/"
  dataset = {"image_path":[], "mask_status":[], "where":[]}
  

for where in os.listdir(path): for status in os.listdir(path + "/" + where): for image in glob.glob(path + "/" + where + "/" + status + "/" + "*.png"): dataset["image_path"].append(image) dataset["mask_status"].append(status) dataset["where"].append(where)

dataset = pd.DataFrame(dataset) dataset.head()

![](https://velog.velcdn.com/images/insung_na/post/6bcadb20-a8fe-422d-bf4b-0813048e75af/image.png)

### 데이터 확인
```python
print("With Mask:", dataset.value_counts("mask_status")[0])
print("Without Mask:", dataset.value_counts("mask_status")[1])

sns.countplot(x=dataset["mask_status"])
-----------------------------------------
With Mask: 5909
Without Mask: 5883

import cv2

plt.figure(figsize=(15,10))
for i in range(9):
    random = np.random.randint(1, len(dataset))
    plt.subplot(3, 3, i+1)
    plt.imshow(cv2.imread(dataset.loc[random, "image_path"]))
    plt.title(dataset.loc[random, "mask_status"], size=15)
    plt.xticks([]); plt.yticks([])
plt.show()

train_df = dataset[dataset["where"]=="Train"]
test_df = dataset[dataset["where"]=="Test"]
valid_df = dataset[dataset["where"]=="Validation"]

plt.figure(figsize=(15, 5))
plt.subplot(131)
sns.countplot(x=train_df["mask_status"])
plt.title("Train Dataset", size=10)

plt.subplot(132)
sns.countplot(x=test_df["mask_status"])
plt.title("test Dataset", size=10)

plt.subplot(133)
sns.countplot(x=valid_df["mask_status"])
plt.title("Validation Dataset", size=10)

Data preprocessing

인덱스 초기화

train_df = train_df.reset_index(drop=True)
train_df.head()

이미지 전처리

data = []
image_size = 150

for i in range(len(train_df)):
    # Converting the image into grayscale
    img_array = cv2.imread(train_df["image_path"][i], cv2.IMREAD_GRAYSCALE)

    # Resizing the array
    new_image_array = cv2.resize(img_array, (image_size, image_size))

    # Encoding the image with the label
    if train_df["mask_status"][i] == "WithMask":
        data.append([new_image_array, 1])
    else:
        data.append([new_image_array, 0])

np.random.shuffle(data)    # 순서를 학습하지 못하도록 shuffle

전처리 데이터 확인

fig, ax = plt.subplots(2, 3, figsize=(10,6))

for row in range(2):
    for col in range(3):
        image_index = row * 100 + col

        ax[row, col].axis("off")
        ax[row, col].imshow(data[image_index][0], cmap="gray")

        if data[image_index][1] == 0:
            ax[row, col].set_title("Without Mask")
        else:
            ax[row, col].set_title("With Mask")

Modeling

모델 학습

X = []
y = []
for image in data:
    X.append(image[0])
    y.append(image[1])

X = np.array(X)
y = np.array(y)

X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=13)
model = models.Sequential([
    layers.Conv2D(32, kernel_size=(5,5), strides=(1,1), padding="same", activation="relu", input_shape=(150,150,1)),
    layers.MaxPooling2D(pool_size=(2,2), strides=(2,2)),
    layers.Conv2D(64, kernel_size=(2,2), padding="same", activation="relu"),
    layers.MaxPooling2D(pool_size=(2,2)),
    layers.Dropout(0.25),
    layers.Flatten(),
    layers.Dense(1000, activation="relu"),
    layers.Dense(1, activation="sigmoid")              
])

model.compile(optimizer="adam", loss=tf.keras.losses.BinaryCrossentropy(), metrics=["accuracy"])

X_train = X_train.reshape(X_train.shape[0], X_train.shape[1], X_train.shape[2], 1)
X_val = X_val.reshape(X_val.shape[0], X_val.shape[1], X_val.shape[2], 1)
history = model.fit(X_train, y_train, epochs=4, batch_size=32)
---------------------------------------------------------------------------------------------------
Epoch 1/4
250/250 [==============================] - 317s 1s/step - loss: 25.5447 - accuracy: 0.8960
Epoch 2/4
250/250 [==============================] - 393s 2s/step - loss: 0.0632 - accuracy: 0.9758
Epoch 3/4
250/250 [==============================] - 379s 2s/step - loss: 0.0300 - accuracy: 0.9894
Epoch 4/4
250/250 [==============================] - 391s 2s/step - loss: 0.0185 - accuracy: 0.9933

Colab GPU 사용시 학습속도

모델 평가

모델 성능 확인

model.evaluate(X_val, y_val)
-----------------------------------------------------------------------------------------
63/63 [==============================] - 16s 253ms/step - loss: 0.1214 - accuracy: 0.9660
[0.12140300869941711, 0.9660000205039978]

prediction = (model.predict(X_val) > 0.5).astype("int32")

print(classification_report(y_val, prediction))
print(confusion_matrix(y_val, prediction))
----------------------------------------------------------------------------------------
63/63 [==============================] - 14s 222ms/step
              precision    recall  f1-score   support

           0       0.96      0.97      0.97      1032
           1       0.97      0.96      0.96       968

    accuracy                           0.97      2000
   macro avg       0.97      0.97      0.97      2000
weighted avg       0.97      0.97      0.97      2000

[[1001   31]
 [  37  931]]

틀린데이터 확인

wrong_result = []

for n in range(y_val.shape[0]):
    if prediction[n] != y_val[n]:
        wrong_result.append(n)

len(wrong_result)
-------------------------------------------------
68

import random

samples = random.choices(population=wrong_result, k=6)

plt.figure(figsize=(14, 12))

for idx, n in enumerate(samples):
    plt.subplot(2, 3, idx+1)
    plt.imshow(X_val[n].reshape(150, 150),interpolation="nearest")
    plt.title(prediction[n])
    plt.axis("off")

해당 글은 제로베이스데이터스쿨 학습자료를 참고하여 작성되었습니다

CNN_Feature_Maps

사용 데이터 및 모델

MNIST Load

import tensorflow as tf

mnist = tf.keras.datasets.mnist

(X_train, y_train),(X_test, y_test) = mnist.load_data()
X_train, X_test = X_train / 255.0, X_test / 255.0

X_train = X_train.reshape((60000, 28, 28, 1))
X_test = X_test.reshape((10000, 28, 28, 1))

Simple Modeling

from tensorflow.keras import layers, models

model = models.Sequential([
    layers.Conv2D(3, kernel_size=(3, 3), strides=(1,1), padding="same", activation="relu", input_shape=(28,28,1)),
    layers.MaxPooling2D(pool_size=(2,2), strides=(2,2)),
    layers.Dropout(0.25),
    layers.Flatten(),
    layers.Dense(1000, activation="relu"),
    layers.Dense(10, activation="softmax")              
])

model.summary()
--------------------------------------------------------------------
Model: "sequential"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 conv2d (Conv2D)             (None, 28, 28, 3)         30        

 max_pooling2d (MaxPooling2D  (None, 14, 14, 3)        0         
 )                                                               

 dropout (Dropout)           (None, 14, 14, 3)         0         

 flatten (Flatten)           (None, 588)               0         

 dense (Dense)               (None, 1000)              589000    

 dense_1 (Dense)             (None, 10)                10010     

=================================================================
Total params: 599,040
Trainable params: 599,040
Non-trainable params: 0
_________________________________________________________________

layer 조회

model.layers
--------------------------------------------------------------------
[<keras.layers.convolutional.conv2d.Conv2D at 0x1428ca6d310>,
 <keras.layers.pooling.max_pooling2d.MaxPooling2D at 0x1428d08ead0>,
 <keras.layers.regularization.dropout.Dropout at 0x1428e790150>,
 <keras.layers.reshaping.flatten.Flatten at 0x1428e7b2a90>,
 <keras.layers.core.dense.Dense at 0x1428e7b3690>,
 <keras.layers.core.dense.Dense at 0x1428e793a10>]

아직 학습하지 않은 Conv 레이어의 weigths

conv = model.layers[0]
conv_weights = conv.weights[0].numpy()
conv_weights.mean(), conv_weights.std()
------------------------------------------
(0.012864082, 0.23187771)

weights 분포도

import matplotlib.pyplot as plt

plt.hist(conv_weights.reshape(-1, 1))
plt.xlabel("weights")
plt.ylabel("count")
plt.show()

학습 전 conv filter

fig, ax = plt.subplots(1, 3, figsize=(15, 5))
for i in range(3):
    ax[i].imshow(conv_weights[:,:,0,i], vmin=-0.5, vmax=0.5)
    ax[i].axis("off")

plt.show()

모델 학습

model.compile(optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"])
hist = model.fit(X_train, y_train, epochs=5, verbose=1, validation_data = (X_test, y_test))

학습 후 conv filter

fig, ax = plt.subplots(1, 3, figsize=(15, 5))
for i in range(3):
    ax[i].imshow(conv_weights[:,:,0,i], vmin=-0.5, vmax=0.5)
    ax[i].axis("off")

plt.show()

FeatureMaps

FeatureMaps에 사용할 데이터

plt.imshow(X_train[0], cmap="gray")

FeatureMaps 생성

inputs = X_train[0].reshape(-1, 28, 28, 1)
conv_layer_output = tf.keras.Model(model.input, model.layers[0].output)

feature_maps = conv_layer_output.predict(inputs)

feature_maps

def draw_feature_maps(n):
    inputs = X_train[n].reshape(-1, 28, 28, 1)
    feature_maps = conv_layer_output.predict(inputs)

    fig, ax = plt.subplots(1,4, figsize=(15,5))
    ax[0].imshow(feature_maps[0,:,:,0], cmap="gray")

    for i in range(1, 4):
        ax[i].imshow(feature_maps[0,:,:,i-1])
        ax[i].axis("Off")
    plt.show()

draw_feature_maps(1)

draw_feature_maps(4)

채널 증가

• 입력 수 3 -> 8

  from tensorflow.keras import layers, models
  

model1 = models.Sequential([ layers.Conv2D(8, kernel_size=(3,3), strides=(1,1), padding="same", activation="relu", input_shape=(28,28,1)), layers.MaxPooling2D(pool_size=(2,2), strides=(2,2)), layers.Dropout(0.25), layers.Flatten(), layers.Dense(1000, activation="relu"), layers.Dense(10, activation="softmax")
])

model1.compile(optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"]) hist = model1.fit(X_train, y_train, epochs=5, verbose=1, validation_data = (X_test, y_test))

Epoch 1/5 1875/1875 [==============================] - 46s 24ms/step - loss: 0.1633 - accuracy: 0.9499 - val_loss: 0.0579 - val_accuracy: 0.9810 Epoch 2/5 1875/1875 [==============================] - 45s 24ms/step - loss: 0.0680 - accuracy: 0.9784 - val_loss: 0.0442 - val_accuracy: 0.9856 Epoch 3/5 1875/1875 [==============================] - 47s 25ms/step - loss: 0.0460 - accuracy: 0.9854 - val_loss: 0.0403 - val_accuracy: 0.9876 Epoch 4/5 1875/1875 [==============================] - 50s 26ms/step - loss: 0.0350 - accuracy: 0.9884 - val_loss: 0.0353 - val_accuracy: 0.9881 Epoch 5/5 1875/1875 [==============================] - 52s 28ms/step - loss: 0.0270 - accuracy: 0.9909 - val_loss: 0.0422 - val_accuracy: 0.9870

### feature_maps
```python
conv_layer_output = tf.keras.Model(model1.input, model1.layers[0].output)

def draw_feature_maps(n):
    inputs = X_train[n].reshape(-1, 28, 28, 1)
    feature_maps = conv_layer_output.predict(inputs)

    fig, ax = plt.subplots(1,9, figsize=(15,5))
    ax[0].imshow(feature_maps[0,:,:,0], cmap="gray")

    for i in range(1, 9):
        ax[i].imshow(feature_maps[0,:,:,i-1])
        ax[i].axis("Off")
    plt.show()

draw_feature_maps(1)

draw_feature_maps(9)