#include <semaphore.h>

sem_init()

• 익명 세마포어 만듦

  int sem_init(sem_t *sem, int pshared, unsigned int value);
  

sem_init(&sem_name, 0, 1);

- **sem** : 초기화할 세마포어 객체
- **pshared** : 0이 아니면 프로세스들 간에 세마포어 공유, 0이면 프로세스 내부에서만 사용
- **value** : 세마포어 초기값

### sem_wait()
- 세마포어를 얻을 때까지 기다림 (잠금)
- 만약 세마포어 값이 0보다 크면 프로세스는 세마포어를 얻고 세마포어 감소 후 즉시 반환
- 세마포어 값이 0이면 세마포어가 0보다 커지거나 시그널이 발생할 때까지 대기
```c
sem_wait(&sem_name);

sem_post()

• 세마포어 되돌려주며 세마포어 값이 하나 증가함 (잠금 해제)

  sem_post(&sem_name);

sem_getvalue()

• 세마포어의 정보를 가져오며 현재 세마포어의 값을 sval로 넘겨 알려줌

  int sem_getvalue(sem_t *sem, int *sval);
  

sem_getvalue(&sem_name, &i);

### sem_destroy()
- 익명 세마포어 파기
```c
sem_destroy(&sem_name);

💁🏻‍♀️Mutex 와 semaphore의 차이는?

1) - 세마포어는 공유 자원에 세마포어의 변수만큼의 프로세스(또는 스레드)가 접근 가능 - 뮤텍스는 단 1개의 프로세스(또는 스레드)만 접근 가능 2) - 현재 수행중이 아닌 다른 프로세스가 세마포어 해제 가능 - 뮤텍스는 lock을 획득한 프로세스가 반드시 그 lock을 해제해야함

#include <ptrhead.h>

pthread_mutex_init()

• 정적 초기화

  pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

• 동적 초기화

  pthread_mutex_t mutex;
  pthread_mutex_init(&mutex, NULL);

pthread_mutex_lock()

• critical section(임계구역) 진입시 잠금

  pthread_mutex_lock(&mutex);

pthread_mutex_unlock()

• critical section(임계구역) 나올 때 잠금 풀기

  pthread_mutex_unlock(&mutex);

중요한 점은 한 스레드에서 lock을 걸고 critical section에 들어가 있는데 다른 스레드에서 lock을 호출하면 그 스레드는 이전의 스레드가 critical section을 나올 때까지 (unlock할 때까지) 기다려야함

pthread_mutex_trylock()

• lock을 얻을 수 없을 경우 해당 code에서 block되지 않고 바로 error code를 return (pthread_mutex_lock의 비봉쇄버전)
• EBUSY : mutex가 잠겨있어서 잠금을 얻을 수 없음
• EINVAL : mutex가 잘못 초기화 됨

  pthread_mutex_trylock(&mutex);

pthread_mutex_destry()

• 더이상 mutex를 사용할 일이 없다면 반드시 mutex 객체 삭제하고 자원 되돌려줌 (free)
• 만약 mutex 자원을 사용하는 스레드가 하나라도 존재한다면 error

  pthread_mutex_destroy(&mutex);

3장에서는 표준 c 라이브러리를 통해 파일을 작업하는 것을 설명한다.

1. 사용자 버퍼 입출력

블록 크기

• 파일 시스템의 최소 저장 단위는 블록임.
• 모든 입출력 연산은 블록 크기의 정수배.

❗️하지만 보통 사용자 application에서는 필드나 문자열 등의 입출력 연산이 필요한 경우가 대부분임. ❗️시스템 콜을 이용하여 파일 입출력 작업을 하면 호출할 때마다 커널을 통해 입출력을 수행하여 시스템 효율이 떨어질 수 있음. ❗️따라서, 사용자 application code 레벨에서 인위적으로 버퍼링을 구현하는데, 이미 있는 사용자 버퍼링 구현체를 가져다 씀 (표준 입출력 라이브러리나 표준 c++ iostream).

2. 파일 열기

표준 입출력에서는 파일 디스크립터 대신 파일 포인터를 사용. 파일 포인터는 c 라이브러리 내부에서 파일 디스크립터로 맵핑됨.

fopen()

읽거나 쓰기 위해 fopen()을 사용해서 파일을 엶.

#include <stdio.h>

FILE * fopen (const char *path, const char *mode);

• 파일 path를 mode에 따라 원하는 용도로 새로운 스트림을 만듦.
• mode (예시)
  • r: 읽기 목적으로 파일을 엶.
  • w: 쓰기 목적으로 파일을 엶.
  • a: 덧붙이기 상태에서 쓰기 목적으로 파일을 엶. ...

fdopen()

이미 열린 파일 디스크립터(fd)를 통해 스트림을 만듦.

#include <stdio.h>

FILE * fdopen (int fd, const char *mode);

• mode는 fopen()과 동일.

3. 스트림 닫기

fclose()

#include <stdio.h>

int fclose (FILE *stream);

• 버퍼에 쌓여있지만 아직 스트림에 쓰지 않은 데이터를 먼저 처리.

fcloseall()

#define _GNU_SOURCE
#include <stdio.h>

int fcloseall (void);

• 표준 입력, 출력, 에러를 포함하여 현재 프로세스와 관련된 모든 스트림을 닫음.

4. 스트림에서 읽기

한 번에 한 문자씩 읽기: fgetc()

#include <stdio.h>

int fgetc (FILE *stream);

• stream에서 다음 문자를 읽고 unsigned char 타입을 int 타입으로 변환해서(EOF나 에러를 알려주기 위해) 반환.

한 줄씩 읽기: fgets()

#include <stdio.h>

char * fgets (char *str, int size, FILE *stream);

• stream에서 size보다 하나 적은 내용을 읽어서 결과를 str에 저장.
• 마지막 바이트를 읽은 후 버퍼 마지막에 null 문자(\0) 저장.
• EOF나 '\n'을 만나면 읽기 중단함, 만일 '\n' 읽으면 str에 '\n' 저장.

바이너리 데이터 읽기: fread()

c 구조체 같은 복잡한 바이너리 데이터를 읽을 때 사용.

#include <stdio.h>

size_t fread (void *buf, size_t size, size_t nr, FILE *stream);

• stream에서 각각 크기가 size 바이트인 element를 nr개를 읽어서 buf가 가리키는 버퍼에 저장.

5. 스트림에 쓰기

한 번에 한 문자만 쓰기: fputc()

#include <stdio.h>

int fputc (int c, FILE *stream);

• c로 지정한 바이트를 (unsigned char로 변환한 후에) stream이 가리키는 스트림에 씀.

문자열 기록하기: fputs()

#include <stdio.h>

int fputs (const char *str, FILE *stream);

• str이 가리키는 NULL로 끝나는 문자열 전부를 stream이 가리키는 스트림에 기록.

바이너리 데이터 기록하기: fwrite()

#include <stdio.h>

size_t fwrite (void *buf, size_t size, size_t nr, FILE *stream);

• buf가 가리키는 데이터에서 size 크기의 element nr개를 stream에 씀.

6. 스트림 탐색하기

fseek()

#include <stdio.h>

int fseek (FILE *stream, long offset, int whence);

• lseek() 시스템 콜과 동일한 기능.
• offset과 whence에 따라 stream에서 파일 위치를 조작.

7. 스트림 비우기

여기 3장에서 설명하는 함수들은 모두 c라이브러리가 관리하는 버퍼를 사용하는데 이 버퍼는 사용자 영역에 위치함. 커널이 유지하는 버퍼는 커널영역에 위치함. fflush()는 사용자 버퍼를 커널로 비워서 스트림에 쓴 모든 데이터가 write()를 통해 실제로 디스크에 기록되도록 만드는 인터페이스.

fflush()

#include <stdio.h>

int fflush (FILE *stream);

• stream에 있는 쓰지 않은 데이터를 커널로 비움.
• 한마디로 사용자 버퍼에 있는 데이터를 커널 버퍼로 쓰는 것임. 이는 사용자 버퍼를 사용하지 않고 write() 를 직접 사용하는 효과와 동일.

8. 스레드 세이프

스레드 세이프(Thread-safe) 는 멀티 스레드 프로그래밍에서 일반적으로 어떤 함수나 변수, 혹은 객체가 여러 스레드로부터 동시에 접근이 이루어져도 프로그램의 실행에 문제가 없음을 뜻한다. _위키피디아

❗️멀티스레드 환경에서 동작해도 원래 의도한 대로 동작하는 것을 스레드세이프 하다고 할 수 있음. ❗️스레드를 지원하는 운영체제는 락 메커니즘을 지원하는데, 표준 입출력은 이를 활용해 단일 프로세스 내의 여러 스레드가 동시에, 심지어는 같은 스트림에 대해서 표준 입출력을 호출할 수 있도록 함. ❗️락을 걸면 critical section(다른 스레드의 간섭 없이 실행할 수 있는 코드)을 설정할 수 있음.

flockfile()

락을 거는 함수

#include <stdio.h>

void flockfile (FILE *stream);

• stream의 락이 해제될 때까지 기다린 후에 락 counter를 올리고 락을 얻은 다음, 스레드가 stream을 소유하도록 만듦.

funlockfile()

락을 해제하는 함수

#include <stdio.h>

void funlockfile (FILE *stream);

• stream과 연관된 락 counter를 하나 줄임.
• 만일 락 counter가 0이 되면 현재 스레드는 stream의 소유권을 포기해서 다른 스레드가 락을 얻을 수 있도록 함.

2장부터 4장까지는 파일에 대해 다루는데, 2장에서는 파일 입출력의 기본을 알아보고 파일을 다루는 가장 기본적이고 간단한 방법인 시스템 콜(syscall)에 대해 이야기한다.

1. OS

• OS = Kernel+ Shell

  • 커널은 운영체제의 핵심으로 운영체제가 수행하는 모든 것이 저장됨.
  • 쉘은 리눅스 환경에서 일반적으로 쓰는 명령어들을 읽어들여 해석하고 결과를 출력해주는 역할을 함.

• 사용자 영역과 커널 영역이 나뉘어져 있고 각 영역엔 버퍼가 있음.

  • syscall을 통해 파일 입출력을 하게 되면 커널을 통해 입출력을 수행함.
  • 예를 들어 open() 이라는 시스템콜을 호출하면, kernel 모드에 들어가서 시스템 콜에 대한 명령어를 수행함.

2. 파일 디스크립터(fd)

• 본격적으로 시스템 콜을 보기 전에 파일 디스크립터(fd)에 대한 개념을 간단하게 살펴보자면,
  • 프로세스마다 각각 파일 디스크립터 테이블을 가지고 있음. 이 테이블은 사용자 영역과 커널 영역 모두에서 프로세스 내에서 고유한 식별자로 사용됨.
  • 커널은 프로세스 별로 열린 파일 목록인 파일 테이블을 관리함.
  • 파일을 열면 파일 디스크립터가 반환되고 이 파일 디스크립터를 이용하여서 관련 시스템 콜의 다양한 연산을 수행.
  • 프로세스는 최소한 0,1,2 세 가지 파일 디스크립터를 열어둠

3. 파일 열기

파일을 읽고 쓰기 전에 open()이나 creat() 시스템 콜을 사용해서 파일을 열어야 한다.

Open()

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int open (const char *name, int flags);
int open(const char *name, int flags, mode_t mode);

• 파일을 열고 파일 디스크립터를 얻음.
• 경로 이름이 name인 파일을 파일 디스크립터에 맵핑하고, 성공하면 이 파일 디스크립터를 반환함.
• Open() flags
  • O_RDONLY(읽기 전용 모드), O_WRONLY(쓰기 전용 모드), O_RDWR(읽기/쓰기 모드) 중 하나를 포함해야함.
  • flags 매개 변수에 비트 OR연산으로 값을 더 추가해서 열기 동작 변경 가능 (예시)
  • O_APPEND: 덧붙이기 모드로 파일을 엶.
  • O_CREAT: name에 적은 파일이 없으면 파일을 새로 만듦.
  • O_TRUNC: 파일이 존재하고, 일반 파일이며 flags 인자에 쓰기가 가능하도록 명시되어 있으면 파일 길이를 0으로 자름. ...
• mode
  • 파일의 접근 권한 설정 (예시)
  • S_IRWXU: 소유자에게 읽기, 쓰기, 실행 권한 있음.
  • S_IRWXG: 그룹에게 읽기, 쓰기, 실행 권한 있음.
  • S_IRWXO: 그 외 모든 사용자에게 읽기, 쓰기, 실행 권한 있음. ...

creat()

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int creat (const char *name, mode_t mode);

• O_WRONLY | O_CREAT | O_TRUNC 조합이 일반적이라 아예 이런 동작 방식을 지원하는 creat() 시스템 콜을 만듦.

4. 읽기

가장 대표적인 읽기 메커니즘은 POSIX.1에 정의된 read() 시스템 콜을 사용하는 것.

read()

#include <unistd.h>

ssize_t read (int fd, void *buf, size_t len);

• fd가 참조하는 파일의 현재 파일 offset에서 len 바이트만큼 buf로 읽어 들임.
• 성공시 buf에 쓴 바이트 숫자를 반환. 실패시 -1 반환.
• 읽을 데이터가 충분하면 한 번에 len 바이트만큼 읽지만, 읽을 데이터가 len 바이트 보다 더 적을 경우 더 적게 읽기도 함.

5. 쓰기

파일에 데이터를 기록하기 위해 사용하는 가장 기본적이며 일반적인 시스템 콜은 write()임.

write()

#include <unistd.h>

ssize_t write (int fd, const void *buf, size_t count);

• count 바이트 만큼 파일 디스크립터 fd가 참조하는 파일의 현재 파일 위치에 시작지점이 buf인 내용을 기록.
• read()와 비슷하게 동작.

6. 파일 닫기

파일 디스크립터로 읽고 쓰는 작업을 마치고 나면 close() 시스템 콜을 이용해서 파일 맵핑을 끊어야 함.

close()

#include <unistd.h>

int close (int fd);

• 열려있는 파일 디스크립터 fd에 연관된 파일과의 맵핑을 해제하며 프로세스에서 파일을 떼어냄.
• 해제된 파일 디스크립터는 더이상 유효하지 않음.

  코드를 입력하세요

  7. 탐색하기

  파일 디스크립터에 연결된 파일의 오프셋을 특정 값으로 지정함.

  lseek()

  #include <sys/types.h>
  #include <unistd.h>
  

off_t lseek(int fd, off_t pos, int origin);

- `origin` 인자
    - **SEEK_CUR**: `fd`의 파일 오프셋을 현재 오프셋에서 `pos`를 더한 값으로 설정.
    - **SEEK_END**: `fd`의 파일 오프셋을 현재 파일 크기에서 `pos`를 더한 값으로 설정.
    - **SEEK_SET**: `fd`의 파일 오프셋을 `pos` 값으로 설정.

### 8. 동기식 입출력
애플리케이션에서 직접 데이터가 디스크에 기록되는 시점을 제어하고 싶을 때가 있음. 이런 때를 위해 리눅스 커널에서는 성능을 희생하는 대신 입출력을 동기화하는 옵션 제공.
#### fsync()
```c
#include <unistd.h>

int fsync (int fd);

• 파일 디스크립터 fd에 맵핑된 파일의 모든 변경점을 디스크에 기록.
• 이때 파일 디스크립터 fd는 반드시 쓰기 모드로 열려야 함.

9. 다중 입출력

애플리케이션이 여러 개의 파일 디스크립터를 동시에 블록하고 그중 하나라도 블록되지 않고 읽고 쓸 준비가 되면 알려주는 기능. 어떤 파일 디스크립터에 이벤트가 발생했는 지 주기적으로 확인.

select()

#include <sys/select.h>

int select (int n, fd_set *readfds, fd_set *writefds, fd_set, *exceptfds, struct timeval *timeout);

FD_CLR (int fd, fd_set *set);
FD_ISSET (int fd, fd_set *set);
FD_SET (int fd, fd_set *set);
FD_ZERO (fd_set *set);

• 파일 디스크립터가 입출력을 수행할 준비가 되거나 옵션으로 정해진 시간이 경과할 때까지만 블록됨.
• 검사 대상 파일 디스크립터는 세 가지 집합으로 나뉘어 각각 다른 이벤트를 기다림.
  • readfds: 데이터 읽기가 가능한지(블록되지 않고 read() 작업이 가능한지) 파악
  • writefds: 블록되지 않고 write() 작업이 가능한지 감시
  • exceptfds: 예외가 발생했거나 대역을 넘어서는 데이터가 존재하는지 감시
• select()에서 사용하는 파일 디스크립터 집합은 직접 조작하지 않고 매크로를 사용해서 관리
  • FD_ZERO: 지정한 집합 내의 모든 파일 디스크립터 제거 (항상 select() 호출 전에 사용)
  • FD_SET: 주어진 집합에 파일 디스크립터를 추가
  • FD_CLR: 주어진 집합에서 파일 디스크립터 하나 제거

poll()

#include <poll.h>

int poll (struct pollfd *fds, nfds_t nfds, int timeout);

• select()의 몇 가지 결점을 보완하지만, 여전히 습관이나 이식성의 이유로 select()를 더 많이 사용함.
• fds가 가리키는 단일 pollfd 구조체 배열을 nfds 개수만큼 사용.
• pollfd 구조체

  #include <poll.h>
  

struct pollfd{ int fd; //파일 디스크립터 short events; //감시할 이벤트 short revents; //발생한 이벤트

Ch1 핵심 개념 소개

• system call(syscall): 사용자 영역에서 커널 내부로 들어가기 위한 함수 호출로 read()나 write() 등이 있음.

• API와 ABI

  • API: 소프트웨어의 소스 코드 레벨에서, 즉 프로그래밍 언어 레벨에서 인터페이스 제공
  • ABI: 바이너리 레벨에서 인터페이스 제공

• POSIX: os의 표준이라고 할 수 있음. (상식적으로) 스레드나 유틸리티 등을 정의함. 강제성은 없음.

• 리눅스는 모든 것이 파일이므로 모든 인터렉션은 파일을 읽고 쓰는 것

  • 리눅스에서 파일이 매우 중요!!!
  • file descriptor(fd)로 컨트롤
  • 일반 파일, 디렉토리, 링크 등 모두 다 파일 형태임

• inode: 파일 시스템 내에서만 고유한 정수값

• 하드링크(Hard link): 동일한 inode에 대한 여러가지 파일 이름 mapping. (바로가기 느낌)

• 심볼릭링크(Symbolic link): 여러 파일 시스템에 걸쳐 사용할 수 있도록 제공. (서로가 같은 것을 공유하는 같이 업데이트하는 느낌)

• 스레드(Thread): 프로세스 내에서의 흐름. 코드시퀀스의 집합들. 프로세스 내부에서 실행하는 단위.

  • 각 프로세스는 스레드 하나 이상을 가짐. (하나: 싱글 스레드, 여러개: 멀티 스레드)

• 시그널(Signal): 인터럽트(interrupt)를 갑자기 발생시켜서 어떠한 사건(Event)을 발생시킴(예를 들면 ctrl+c(복사) 같은거)

이 글은 20-2학기 머신러닝 수업에서 진행한 term project에 관해 정리한 글이다. 나는 Parkinsons telemonitoring에 관한 dataset을 선택하여 프로젝트를 진행하였다. 옥스포드 대학교의 Atanasios Tsanas와 Max Little, 그리고 10개의 미국 메디컬센터, 인텔 기업이 함께 이 dataset을 만들었다. 원래 이 연구는 다양한 선형 및 비선형 회귀 방법을 사용하여 통합 파킨슨병 등급 척도(UPDRS)로 임상의사의 파킨슨병 증상 점수를 예측했으며, 나는 여기서 딥러닝 DNN 모델을 통해 UPDRS 점수를 예측하는 프로젝트를 진행하였다.

Information of data

이 dataset은 초기 파킨슨병을 앓고 있는 42명의 생체 의학 음성 측정 범위로 구성되어 있다. 다음은 dataset에 포함된 모든 변수의 이름과 해당 사용에 대한 설명이다. 'parkinsons_updrs.data'에는 22개의 특성과 5875개의 인스턴스가 있다. 그 중 motor_UPDRS 및 total_UPDRS는 target variables이다. motor_UPDRS는 환자들의 motor UPDRS 점수이고, total_UPDRS는 환자들의 total UPDRS 점수이다. subject# 는 각 주체를 고유하게 식별하는 정수이다. 한 마디로 각 개인마다 고유 번호가 있다. 나이는 각 주체의 연령이며, 성별은 각 주체의 성별입니다. ('0'은 남성, '1'은 여성) test_time은(는) 평가판에 채용된 이후 시간이고 정수 부분은 채용 후 일수입니다. Jitter(%), Jitter(Abs), Jitter:RAP, Jitter:PPQ5, Jitter:DDP는 기본 주파수의 변동에 대한 몇 가지 측정값이다. Shimmer, Shimmer(dB), Shimmer:APQ3, Shimmer:APQ5, Shimmer:APQ11, Shimmer:DDA는 진폭의 변동에 대한 몇 가지 측정치이다. NHR, HNR은 음성의 톤 성분에 대한 소음 비율 측정치이다. PRDE는 비선형 동적 복잡도 측정이다. DFA는 신호 프랙탈 스케일링의 지수이다. PPE는 기본 주파수 변동에 대한 비선형 측정이다.

전체 데이터를 훈련 데이터(70%)와 테스트 데이터(30%)로 분할하였고, 데이터의 스케일이 크게 다를 경우 문제가 발생하지 않도록 데이터를 정규화하였다.

파이토치의 Dataset과 Dataloader를 통해 대량의 학습을 batch 단위로 처리하여 손실을 줄일 수 있다. 따라서 dataset을 훈련(train) dataset과 테스트(test) dataset으로 나누는 두 가지 클래스를 만들었다: ParkinsonsTrainDataset, ParkinsonsTestDataset. 만들어진 Dataloader는 크게 세 부분으로 나뉜다.

1. init(self) 는 데이터를 읽거나 다운로드 하는 부분이다.

2. getitem(self, index) 는 인덱스에 해당하는 항목을 넘기는 부분이다.

3. len(self) 는 데이터의 크기를 전달하는 부분이다.

class ParkinsonsTrainDataset(Dataset):
    def __init__(self):
        xy = np.loadtxt('./parkinsons_updrs.data',
                        delimiter=',', skiprows=1, dtype=np.float32)
        train_len = int(xy.shape[0] * 0.7)
        train_xy = xy[:train_len]
        self.len = train_xy.shape[0]
        y_label_indx = [5, 6]
        self.train_x = np.delete(train_xy, y_label_indx, axis=1)
        self.train_x = torch.from_numpy(self.train_x)
        self.train_y = torch.from_numpy(train_xy[:, y_label_indx[0]: y_label_indx
        [1] + 1])

        self.train_x, mu, sigma = normalize(self.train_x)
        self.train_y, mu, sigma = normalize(self.train_y)

    def __getitem__(self, index):
        return self.train_x[index], self.train_y[index]

    def __len__(self):
        return self.len

훈련할 dataloader와 테스트할 dataloader를 만들 때 각 dataset으로 만든 클래스를 넘겨준다.

train_dataset = ParkinsonsTrainDataset()
test_dataset = ParkinsonsTestDataset()

train_loader = DataLoader(dataset=train_dataset,
                          batch_size=32,
                          shuffle=True,
                          num_workers=0, drop_last=True)
test_loader = DataLoader(dataset=test_dataset,
                          batch_size=32,
                          num_workers=0)

Approach

나는 회귀와 함께 여러 FC(Full Connected) 계층으로 구성된 심층 신경망(DNN) 모델에서 학습한 후 UPDRS 점수를 예측했다.

심층 신경망(DNN)은 입력 계층과 출력 계층 사이의 여러 숨겨진 계층으로 구성된 인공 신경망으로, 학습 결과를 개선하기 위해 숨겨진 계층을 크게 증가시킨다. DNN은 dropout, Rectified Linear Unit(ReLU)과 같은 방법이 적용됨에 따라 딥 러닝의 핵심 모델로 사용되고 있다. DNN은 더 적은 수의 장치만이 복잡한 데이터를 모델링할 수 있도록 한다.

나는 hidden nodes를 300, input nodes는 20, output nodes는 2로 정하였다. 또한 평균 제곱 오차(MSE)와 optimizer를 사용하기 위해 손실 함수를 정하였다. model.parameters()를 호출하여 SGD를 사용하면 모델의 계층이 학습할 파라미터를 넘겨준다. 여기서 러닝레이트는 0.0001 정하였다.

class Model(nn.Module):
    def __init__(self):
        super(Model, self).__init__()
        self.l1 = nn.Linear(20, 300) 
        self.relu = nn.ReLU()
        self.l2 = nn.Linear(300, 2)  

    def forward(self, x):
        out1 = self.l1(x)
        out2 = self.relu(out1)
        out = self.l2(out2)
        return out

model = Model()

criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.0001)

Training

이제 예측하기 전에 모델을 훈련시키는 과정이 필요하다. 그런데 total_UPDRS 손실과 motor_UPDRS 손실 사이에 큰 스케일 차이가 있었다. 따라서 motor_UPDRS 손실에 가중치(3)를 곱해주었다.

for epoch in range(30):
    for i, data in enumerate(train_loader):
        inputs, labels = data

        y_pred = model(inputs)

        motor_updrs_mse = criterion(y_pred[:, 0], labels[:, 0])
        total_updrs_mse= criterion(y_pred[:, 1], labels[:, 1])

        total_loss = 3 * motor_updrs_mse + total_updrs_mse

        print(f'Epoch {epoch + 1} | Step: {i+1} | Loss: {total_loss.item():.4f}')

        optimizer.zero_grad()
        total_loss.backward()
        optimizer.step()

Prediction

After training, the result of average of all UPDRS mse, Motor_UPDRS mse and Total_UPDRS mse is below. 훈련 후 모든 UPDRS mse, motor_UPDRS의 mse, total_UPDRS의 mse는 아래와 같다. 모델링할 때마다 모든 UPDRS mse 값이 계속 많이 바뀌어서 초기 값을 고정해주었다.

torch.manual_seed(1234)

첫번째 그래프는 motor_UPDRS를 예측한 결과를 나타내는 그래프이고, 두번째 그래프는 toal_UPDRS를 예측한 결과를 나타내는 그래프이다. 그래프를 보면 total_UPDRS는 매우 잘 예측이 되지만, motor_UPDRS는 살짝 불완전하게 예측이 잘 안되는 부분이 있는 것을 확인할 수 있다. 나중에 결론 부분에서 다시 언급을 할 예정이지만, 나는 이러한 motor_UPDRS의 예측 성능을 높이기 위해 여러가지 노력을 하였다.

Conclusion

솔직히 이 프로젝트를 하는 과정이 쉽지는 않았다. 딥러닝을 처음 접해보면서 혼자서 이렇게 프로젝트를 진행하는 것도 처음이었기 때문에, 이러한 결과들을 도출해내기까지 나에게는 많은 시간과 노력이 필요했다. 처음에는 데이터 정규화 과정을 거치지 않고 모델링 한 후 예측을 시도했더니 스케일이 너무 크고 차이가 심해서 제대로 예측이 안되었다. 특히 total_UPDRS의 손실이 motor_UPDRS의 손실보다 심하게 작았기 때문에 total_UPDRS를 잘 예측하기가 힘들었다. 이 과정을 통해 데이터 정규화의 중요성을 깨달았다. (아래 그래프는 정규화하지 않은 채 예측한 total_UPDRS이다)

데이터를 정규화한 후 어느 정도 예측이 가능한 것처럼 보였지만, motor_UPDRS와 total_UPDRS 둘 다 잘 예측하기 위한 적절한 기준점을 찾기가 어려웠다. 정규화를 통해 값이 어느 정도 매끄러워졌지만, motor_UPDRS의 스케일에서 예측이 필요했기 때문에(?) motor_UPDRS의 손실에 가중치를 곱할 수 밖에 없었고, 그제서야 예측이 잘 되었다.

Entire Code

Reference

Telemonitoring of Parkinson's disease progression by non-invasive speech tests. (n.d.). Retrieved December 26, 2020, from https://www.neuraldesigner.com/learning/examples/parkinsons-disease-telemonitoring