또한, 해당 내용 말고도 자료구조와 C++ 클래스와 관련된 내용도 멘토링을 진행했었지만, 더 좋은 포스트들이 많을 듯해서 이 포스트를 마지막으로 하려고 한다.

1. WSL 설치

Windows에서 Linux 개발환경을 쉽게 만들고, Linux 명령어와 도구를 사용하기 위해 WSL로 Ubuntu(Linux 배포판)를 설치한다. 또한, Linux 환경에서는 복잡하게 MingGW 설치없이 C/C++ 컴파일을 진행할 수 있다.

🔗 WSL 설치 메뉴얼

먼저 WSL을 설치하기 전에 Linux용 Windows 하위 시스템을 활성화해야 한다.

Windows 기능 켜기/끄기에 들어가서 활성화한다.

명령 프롬프트를 관리자 권한으로 실행하고 아래 명령어 입력해, WSL을 설치한다.

wsl --install

계정의 비밀번호를 입력할 때는 화면에 글씨가 표시되지 않는 것이 정상이니 당황하지 않도록 하자.

Microsoft Store에서 Ubuntu를 검색해, Ubuntu 터미널 환경을 설치하고 실행한다.

파일탐색기에서는 Linux > Ubuntu > home > (사용자명)으로 접근할 수 있다. 파일탐색기에서 편하게 파일 이동 및 복붙이 가능하다.

VSCode에서 WSL 원격 연결

2. Linux 명령어

Linux는 GUI(Graphical User Interface) 환경이 아닌 터미널 환경에서 사용하게 되는 경우가 훨씬 많다. WSL에서는 파일 탐색기를 통해 아래 작업들을 수행할 수도 있지만, SSH를 이용해 원격 서버에 접속할 경우에는 이런 기능을 사용할 수 없다. 따라서 기본적인 Linux 명령어들을 익혀보자.

3. Vim 편집기

Linux는 터미널 환경에서 작업하게 되는 경우가 많다. Vim은 이러한 터미널 환경에서 사용하는 코드 편집기이다. 본인은 Vim이 싫어서 매번 VSCode 쓰고 있긴 하지만…

sudo apt update
sudo apt install vim

vim --version 명령어로 정상적으로 설치가 완료되었는지 확인한다.

아래 명령어로 파일을 Vim 편집기로 열 수 있다.

vim [파일명, 예) main.c]

*파일이 없는 경우에는 자동으로 파일을 생성한 뒤에 Vim 편집기로 연다.

Vim 편집기는 크게 두 가지 모드, 명령어 모드와 입력 모드로 나뉘어진다. 기본 상태는 명령어 모드이며, i키를 눌러 입력 모드에 진입할 수 있다. 반대로 명령어 모드로 돌아가려면 ESC 키를 누른다.

Vim 명령어

명령어 모드에서 사용하는 주요 명령어를 소개하겠다.

간단한 실습을 위해, main.c에 아래 코드를 작성하고 저장한다.

#include <stdio.h>

int main() {
    // ANSI 색 코드 배열 (빨 주 노 초 파 남 보)
    const char* colors[] = {
        "\033[31m", // 빨강
        "\033[33m", // 주황
        "\033[93m", // 노랑 (밝은 노랑)
        "\033[32m", // 초록
        "\033[34m", // 파랑
        "\033[36m", // 남색 (청록)
        "\033[35m"  // 보라
    };

    for (int i = 0; i < 7; i++) {
        printf("%s★ ", colors[i]);
    }
    printf("\033[0m\n");

    return 0;
}

작성한 C언어 소스코드를 컴파일하기 위해, 아래 명령어를 실행해 GCC를 설치한다.

sudo apt update
sudo apt install build-essential

이후, gcc --version명령어를 실행하여 제대로 설치가 완료되었는지 확인한다.

gcc -o main main.c 로 컴파일을 진행하며, ./main 으로 실행 파일을 실행한다.

*gcc는 C언어의 컴파일러이며, -o [파일명] 옵션을 사용하여 컴파일 결과로 생성될 실행 파일 이름을 지정할 수 있다.

🔗 (선택) Vim Plug-in 설치

4. Makefile

Makefile은 여러 소스 파일 간의 의존 관계를 정의하여, make라는 단 하나의 명령어만으로 소스 코드 전체를 간단하게 컴파일할 수 있게 해준다. 또한, 변경된 파일만을 다시 컴파일함으로써 빌드 시간을 단축시킬 수 있다.

Makefile은 C/C++ 프로젝트에서 널리 사용되며, gcc, g++, ld 명령어를 반복해서 직접 입력하지 않아도 되기 때문에 자동화된 빌드 관리 도구로 유용하다.

이번에도 간단한 실습을 위해, func.h, func.c, main.c 파일을 생성한다.

func.h 파일의 내용: (func.c에서 정의된 함수들을 다른 파일에서 사용할 수 있도록 선언해 놓은 헤더 파일)

void printHello();
void printName(char *name);
void printIntro(int age, char *region);
void printThx();

func.c 파일의 내용

#include <stdio.h>
#include "func.h"

void printHello()
{
    printf("안녕하세요!\n");
    printf("만나서 반갑습니다~\n");
}

void printName(char *name)
{
    printf("제 이름은 %s입니다.\n", name);
}

void printIntro(int age, char *region)
{
    printf("저는 %d살이고, %s 지역에서 살다가 왔습니다.\n", age, region);
}

void printThx()
{
    printf("잘 부탁드립니다!!!\n");
}

main.c 파일의 내용

#include "func.h"

int main()
{
    char name[] = "홍길동";
    int age = 20;
    char region[] = "동에 번쩍 서에 번쩍";

    printHello();
    printName(name);
    printIntro(age, region);
    printThx();

    return 0;
}

C언어의 컴파일 진행 과정

1. 전처리 (Preprocessing)

   • #include, #define, #ifdef 같은 전처리 지시문을 처리한다.

   • 헤더 파일(<stdio.h>)을 포함하며, 매크로 치환을 진행한다.

     • #include <stdio.h> 에 printf 함수의 선언이 존재하며 이를 바탕으로 컴파일 단계에서 문법 검사를 진행한다.

   • .c 파일을 전처리한 결과로 .i 파일이 생성된다.

2. 컴파일 (Compilation)

   • .i 파일을 어셈블리 코드(.s)로 변환한다.

   • 문법 검사와 중간 코드를 생성하는 것을 포함한다.

3. 어셈블 (Assembly)

   • 어셈블리 코드(.s)를 기계어(.o, 오브젝트 파일)로 번역한다.

4. 링크 (Linking)

   • 여러 .o 파일 또는 라이브러리(.a/.so)를 결합한다.

     • 링커가 printf의 정의를 glibc(예: /usr/lib/.../libc.so)에서 찾아 연결한다.

   • 프로그램의 시작 주소(entry point)를 확인하고 그 위치를 실행 파일에 기록하기 위해, main 함수의 위치를 확인한다.

Makefile 작성

소스 코드가 고작 3개 정도일 경우, gcc -o program main.c func.c 와 같은 명령어를 통해 간단히 컴파일해도 크게 문제가 없다.

그러나 컴파일은 많은 자원을 소모하는 작업이며, 소스 코드가 수십 개에 달하는 경우, 단일 명령어로 모든 파일을 매번 다시 컴파일하는 것은 매우 비효율적이다. 특히 수정되지 않은 파일까지 매번 다시 컴파일하게 되면 컴파일 시간이 불필요하게 증가하게 된다.

이때 Makefile로, 변경된 파일만을 골라서 컴파일할 수 있어 전체 컴파일 시간을 크게 줄일 수 있다.

Makefile 기본 문법

<target>: <dependencies>
    <recipe>

• target
  • 생성할 파일의 이름 (예: main.o, program)이거나,
  • 특정 동작의 이름 (예: clean, all)일 수 있다.
  • make <target> 명령을 실행하면 이 target에 해당하는 작업이 수행된다.
• dependencies
  • target을 만들기 위해 필요한 파일 목록(의존성)이다.
  • 의존성에 포함된 파일 중 하나라도 수정되면, 해당 target에 해당하는 작업이 다시 수행된다.
• recipe
  • 실제로 실행할 Shell 명령어들이다. (예: gcc, mv, rm 등)
  • 반드시 들여쓰기를 해야하며, 이 들여쓰기는 반드시 공백이 아닌 Tab문자여야 한다.
    

Makefile 변수

TARGET = program
CXX = gcc

$(TARGET): main.c func.c func.h
    $(CXX) -o $(TARGET) main.c func.c

반복적으로 사용되는 값을 하나의 이름으로 정의하여, 유지보수와 가독성을 높일 수 있도록 도와준다.

변수는 변수이름 = 값 형태로 정의하며, 사용할 때는 $(변수이름) 형태로 참조한다.

Makefile 자동 변수

TARGET = program
CXX = gcc

$(TARGET): main.o func.o
    $(CXX) -o $@ $^

main.o: main.c func.h
    $(CXX) -c main.c

func.o: main.c func.h
    $(CXX) -c func.c

• $@: targer의 이름
• $^: 모든 의존성 목록
• $?: target보다 더 최근에 수정된 의존성 목록
  
  

실습에 사용할 Makefile 파일 내용

TARGET = program
CXX = gcc

$(TARGET): main.o func.o
    $(CXX) -o $@ $^

main.o: main.c func.h
    $(CXX) -c main.c

func.o: func.c func.h
    $(CXX) -c func.c

clean:
    rm -f *.o $(TARGET)

위의 Makefile이 C 언어 프로젝트에서 일반적으로 사용되는 형태로, 소스 파일들을 오브젝트 파일로 컴파일한 후 링크하여 실행 파일을 생성하는 과정을 간단히 정의하였다.

아래의 Makefile은 C언어 컴파일의 각 단계를 명확히 확인할 수 있도록 작성하였다.

TARGET = program
CXX = gcc

all: $(TARGET)

# 1. 전처리 단계 (.c → .i)
main.i: main.c func.h
    $(CXX) -E main.c -o $@

func.i: func.c func.h
    $(CXX) -E func.c -o $@

# 2. 컴파일 단계 (.i → .s)
main.s: main.i
    $(CXX) -S main.i -o $@

func.s: func.i
    $(CXX) -S func.i -o $@

# 3. 어셈블 단계 (.s → .o)
main.o: main.s
    $(CXX) -c main.s -o $@

func.o: func.s
    $(CXX) -c func.s -o $@

# 4. 링크 단계 (.o → 실행 파일)
$(TARGET): main.o func.o
    $(CXX) $^ -o $@

clean:
    rm -f *.i *.s *.o $(TARGET)

Makefile 실행

make <target>명령어를 사용하면, 해당 target에 정의된 작업을 수행할 수 있으며, make만 입력하면, Makefile 내에서 가장 먼저 정의된 target 이 기본적으로 실행된다.

5. (선택) Anaconda 설치

🔗 Anaconda 설치

1. 우클릭하여 다운로드 링크를 복사하고, Ubuntu 터미널을 열어 아래 명령어를 입력한다.

    wget [다운로드 링크]

   
   

2. 다운로드 받은 Anaconda sh 파일을 sh로 실행한다.

    sh [다운로드 받은 파일, 예) Anaconda3-2024.06-1-Linux-x86_64.sh]

   
   

3. conda 명령어 설정을 하기 위해, vi ~/.bashrc로 .bashrc 파일을 열고, 파일의 맨 마지막에 아래 코드를 작성한다.

    export PATH=~/anaconda3/bin:~/anaconda3/condabin:$PATH

   
   

4. source ~/.bashrc로 수정한 내용을 적용하고, conda -V로 버전을 확인한다.

[참고] conda 가상환경 만들기

conda create -n [이름] python=[버전]로 원하는 Python 버전의 가상환경을 만든다.

conda update -n base -c defaults conda로 conda를 업데이트하고,

conda activate [이름]로 가상 환경에 접속한다.

conda deactivate로 가상 환경에서 나갈 수 있다.

1. VSCode 설치

IDE는 통합 개발 환경(Integrated Development Environment)을 뜻하며, 프로그래밍을 효율적으로 할 수 있도록 도와주는 소프트웨어 애플리케이션이며, 대표적으로, Visual Studio, Visual Studio Code(VSCode), eclipse, IntelliJ IDEA, Android Studio 등이 있다.

Visual Studio는 C/C++ 개발에서 주로 사용하며, VSCode는 Visual Studio 가벼운 버전으로 볼 수 있다. 다만, VSCode에서 C/C++ 컴파일을 진행하려면 추가적인 설정이 필요하다.

VSCode는 Python 개발, 프론트엔드 웹 개발(HTML, CSS, TS 등)에도 주로 활용되는 등 활용 범주가 굉장히 넓고 여러 확장들이 존재하며, WSL, SSH, Docker, Github 등와 연동해서 사용하는 데도 편리하다.

eclipse는 2학년 때 주로 수강하는 ‘JAVA 프로그래밍 실습’ 수업에서 사용하게 될 Java를 기반으로 하는 IDE이다. 그러나 본인은 IntelliJ IDEA(Java, Kotlin)를 더 편하게 사용한 경험이 있다.

Android Studio는 3학년에 주로 수강하는 ‘모바일 앱 프로그래밍 실습’ 수업에서 사용하게 될 IDE이다. IntelliJ IDEA를 기반으로 만들어졌다고 한다.

🔗 VSCode 설치

VSCode 확장 설치

1. 한국어 언어 확장 설치

2. Python 확장 설치

   • (선택) Black Formatter 설치

3. C/C++ 확장 설치

4. Makefile 확장 설치
   

2. Anaconda 설치

Anaconda는 Python 패키지와 환경을 쉽게 관리할 수 있도록 한다. 또한, Jupyter Notebook(.ipynb )을 쉽게 설치할 수 있는 방법이기도 하다.

신입생 프로그래밍언어(Python) 사전교육에 참여하였다면 이미 설치가 되어있을 것이다.

특히 인공지능 분야에서 각 모델에 맞는 Python 버전 및 패키지 버전 (예. python 3.11.11, numpy =1.25.0, tensorflow=2.15.0 등)이 설치된 가상환경을 만들어 편리하게 사용하기 위해 사용한다.

데이터 분석에 있어서도 Jupyter Notebook은 각 셀을 개별적으로 실행하면서, 데이터 전처리, 시각화, 모델링 등을 단계별로 수행하고 결과를 바로 확인할 수 있다는 점에서 매우 편리하게 활용되고 있다. 또한, Markdown 문서도 지원하고 있다. 🔗 Markdown 문법 설명

🔗Anaconda 설치

Python이 이미 설치되어 있는 경우, Anaconda와 충돌이 날 수 있으므로 Python을 삭제하고나서 Anaconda를 설치하거나, 그냥 Python이 설치되어 있다는 것에 만족하고 Anaconda를 설치하지 않는 방법이 있다.

cmd에서 python --version명령어를 실행하여 제대로 설치가 완료되었는지 확인한다.

VSCode에서 간단한 python 코드 작성 후, 우측 상단의 실행 버튼을 눌러 코드를 실행할 수 있다.

3. MinGW(Minimalist GNU for Windows) 설치

MinGW는 GNU gcc 컴파일러(C언어 컴파일)를 Windows 환경에서 사용할 수 있도록 만든 도구이다.

VSCode Debugging 도구를 사용할 생각이 없다면 굳이 설치하지 않아도 괜찮다. WSL에서 GCC를 활용해서도 C언어 컴파일이 가능하기 때문이다. (다음 자료 내용)

🔗MinGW-w64 설치

다운받은 .zip 파일을 압축 해제하고, mingw64 폴더를 C 드라이브(C:\mingw64)로 이동시킨다.

환경변수 검색 후, 시스템 환경 변수 편집 클릭

Path 선택 후, 편집 클릭

새로 만들기 클릭 후, C:\mingw64\bin 입력

cmd에서 gcc --version명령어를 실행하여 제대로 설치가 완료되었는지 확인한다.

4. VSCode에서 C/C++ 컴파일

C/C++을 사용할 폴더를 열고 (예. C), 내부에 .vscode 폴더(VSCode 설정 파일들을 저장하는 곳)를 생성한다. 이후, 해당 폴더 내부에 각각 c_cpp_properties.json 파일과 tasks.json 파일을 생성한다.

※ 이때, 폴더의 경로에 한국어가 있으면 오류가 발생한다. (예. 사용자명이 한국어인 경우)

c_cpp_properties.json 파일 내용

{
    "configurations": [
        {
            "name": "Win32",
            "includePath": [
                "${workspaceFolder}/**"
            ],
            "defines": [
                "_DEBUG",
                "UNICODE",
                "_UNICODE"
            ],
            "windowsSdkVersion": "10.0.22000.0",
            "compilerPath": "C:/mingw64/bin/g++.exe",
            "cStandard": "c17",
            "cppStandard": "c++17",
            "intelliSenseMode": "windows-gcc-x64"
        }
    ],
    "version": 4
}

tasks.json 파일 내용

{
    "version": "2.0.0",
    "runner": "terminal",
    "type": "shell",
    "echoCommand": true,
    "presentation": {
        "reveal": "always"
    },
    "tasks": [
        {
            "label": "save and compile for C++",
            "command": "g++",
            "args": [
                "${file}",
                "-g",
                "-o",
                "${fileDirname}/${fileBasenameNoExtension}"
            ],
            "group": "build",
            "problemMatcher": {
                "fileLocation": [
                    "relative",
                    "${workspaceRoot}"
                ],
                "pattern": {
                    "regexp": "^(.*):(\\d+):(\\d+):\\s+(warning error):\\s+(.*)$",
                    "file": 1,
                    "line": 2,
                    "column": 3,
                    "severity": 4,
                    "message": 5
                }
            }
        },
        {
            "label": "save and compile for C",
            "command": "gcc",
            "args": [
                "${file}",
                "-g",
                "-o",
                "${fileDirname}/${fileBasenameNoExtension}"
            ],
            "group": "build",
            "problemMatcher": {
                "fileLocation": [
                    "relative",
                    "${workspaceRoot}"
                ],
                "pattern": {
                    "regexp": "^(.*):(\\d+):(\\d+):\\s+(warning error):\\s+(.*)$",
                    "file": 1,
                    "line": 2,
                    "column": 3,
                    "severity": 4,
                    "message": 5
                }
            }
        },
        {
            "label": "execute",
            "command": "cmd",
            "group": "test",
            "args": [
                "/C",
                "${fileDirname}\\${fileBasenameNoExtension}"
            ]
        }
    ]
}

C/C++ 컴파일 및 실행

테스트를 위해, 간단한 C언어 코드를 작성한다.

#include <stdio.h>

int main() {
    printf("Hello, world!\n");
    return 0;
}

설정에서 바로 가기 키로 들어가, ‘작업: 빌드 작업 실행’과 ‘작업: 테스트 작업 실행’의 단축키를 각각 Ctrl + Alt + C와 Ctrl + Alt + R로 변경한다.

이후

• Ctrl + Alt + C를 눌러 save and compile for C 작업으로 컴파일을 진행하고,
• Ctrl + Alt + R을 누르면 생성된 실행 파일(.exe)이 실행된다.
  

5. VSCode Debugging 도구 사용

프로그램이 내가 의도한대로 잘 동작하고 있는지 확인하는 방법은 무엇일까? 혹은 내가 작성한 프로그램에서 의도치 않은 오류가 발생하고 있는 경우에는 어떻게 오류의 발생 원인을 발견할 수 있을까?

1. 프로그램의 실행 값이 올바른지 확인한다. → 모든 경우에 대해 실행 값이 올바를 것이라고 확신할 수 있을까?
2. 프로그램의 중간마다 printf를 활용해 변수들의 값을 확인한다. → 변수가 너무 많으면 어떡하지? 그리고 매번 printf를 작성하는 것이 귀찮지 않을까?
3. 프로그램의 끝에서부터 주석 처리를 진행하며, 어느 부분에서 오류를 발생시키는지 확인한다. → 이것만으로는 오류의 발생 원인을 찾기에 부족할 수 있지 않을까?

따라서 프로그램의 실행을 한 줄씩 따라가며, 동시에 코드 실행에 따라 변화하는 변수의 값을 확인할 수 있도록(약간의 제약이 있긴 하지만…) 도와주는 Debugging 도구를 VSCode에서 사용해보자.

.vscode 폴더 내부에 launch.json 파일을 생성한다.

launch.json 파일 내용

{
    "version": "0.2.0",
    "configurations": [
        {
            "name":"build and debug for C++",
            "type": "cppdbg",
            "request": "launch",
            "program": "${fileDirname}\\${fileBasenameNoExtension}.exe",
            "args": [],
            "stopAtEntry": false,
            "cwd": "C:/mingw64/bin",
            "environment": [],
            "externalConsole": false,
            "MIMode": "gdb",
            "miDebuggerPath": "C:\\mingw64\\bin\\gdb.exe",
            "setupCommands": [
                {
                    "description": "Enable pretty-printing for gdb",
                    "text": "-enable-pretty-printing",
                    "ignoreFailures": true
                }
            ],
            "preLaunchTask": "save and compile for C++"
        },
        {
            "name":"build and debug for C",
            "type": "cppdbg",
            "request": "launch",
            "program": "${fileDirname}\\${fileBasenameNoExtension}.exe",
            "args": [],
            "stopAtEntry": false,
            "cwd": "C:/mingw64/bin",
            "environment": [],
            "externalConsole": false,
            "MIMode": "gdb",
            "miDebuggerPath": "C:\\mingw64\\bin\\gdb.exe",
            "setupCommands": [
                {
                    "description": "Enable pretty-printing for gdb",
                    "text": "-enable-pretty-printing",
                    "ignoreFailures": true
                }
            ],
            "preLaunchTask": "save and compile for C"
        }
    ]
}

C/C++ 디버깅

테스트를 위해, 간단하지 않은 C언어 코드를 작성한다.

🔗아래 코드와 관련된 문제(1541번: 잃어버린 괄호)

#include <stdio.h>
#include <string.h>

int main()
{
    char exp[51];
    scanf("%s", exp);

    int result = 0, flag = 0, num = 0;
    char op = 0;
    for (int i = 0; i < strlen(exp); i++)
    {
        if ('0' <= exp[i] && exp[i] <= '9')
        {
            num *= 10;
            num += exp[i] - '0';
            continue;
        }

        if (op == 0)
            result = num;
        else if (op == '+')
        {
            if (flag)
                result -= num;
            else
                result += num;
        }
        else
        {
            flag = 1;
            result -= num;
        }
        op = exp[i];
        num = 0;
    }

    // 마지막 숫자 처리
    if (op == 0)
        result = num;
    else if (op == '+')
    {
        if (flag)
            result -= num;
        else
            result += num;
    }
    else
    {
        flag = 1;
        result -= num;
    }

    printf("%d\n", result);

    return 0;
}

1. 코드 옆 빨간점을 클릭하여 중단점(프로그램 실행이 멈추는 부분)을 추가하고, build and debug for C을 선택해 디버깅을 시작한다.

1. 디버깅 시작 후, 등장한 터미널에 55-50+40을 입력하여 넣는다.

1. F10이나 좌상단 버튼을 눌러 코드를 한 줄씩 실행할 수 있다. 만약, 함수 내부에 들어가지 않도록 한 줄씩 실행하고 싶다면 F11이나 좌상단 두번째 버튼을, 다음 중단점으로 이동하고 싶다면 F5이나 좌상단 첫번째 버튼을 이용한다.

1. 결과값으로 55-(50+40), 즉 -35가 나오는 것을 확인할 수 있다.
   

6. (선택) VSCode에서 Formatter 사용

변수/함수/클래스명을 작성하는데 있어서 여러 코드 스타일들이 존재하고 있다. 대표적으로,

가 있다.

다른 사람들과 협업할 때는 주로 이러한 세세한 부분들을 통일하여 코드의 가독성을 높힌다. 또한, Github를 통한 버전 관리 시, 코드 스타일 차이로 인한 불필요한 변경사항을 줄일 수 있다.

그러나 띄어쓰기(공백)와 같은 세부적인 스타일은 사람마다 편차가 크고, 개발자가 매번 일관되게 관리하기 어려운 부분이다.

// 1번 예시
if(x==5){console.log("hi");}

// 2번 예시
if (x == 5) {
    console.log("hi");
}

// 3번 예시
if (x == 5) 
{
    console.log("hi");
}

따라서 자동 코드 Fomatter를 활용해, 스타일을 통일하는 것이 협업과 유지보수 측면에서 효과적이다.

아래와 같이 설정에 들어가, Formatter 사용을 설정한다.

*Python에서는 Black Formatter로 설정한다.

이후 작성한 코드를 저장하면, 자동으로 1, 2번 예시를 3번 예시로 포맷팅을 진행하는 것을 볼 수 있다.

(사실 과제 서버에서는 필요한 패키지들이 이미 설치되어 있기 때문에 크게 문제가 될 것이 없다. 하지만 과제 서버에서는 VSCode 사용이 불가하다는 치명적인 문제가 있기에, 로컬 환경에서 xv6를 설치해보려고 한다.)

xv6 설치 환경으로는 Ubuntu 20.04 버전이 추천되지만, 본인은 Ubuntu 22.04 버전에서 설치를 진행해보겠다.

xv6 repository clone

🔗xv6 repository

git clone https://github.com/mit-pdos/xv6-riscv.git

cd xv6-riscv
make qemu

제대로 설치 및 실행이 완료되었다면 아래와 같은 터미널 메세지를 확인할 수 있으며, ls를 입력해 ls 명령어 실행 결과를 확인할 수 있다.

Ctrl+a를 누른 후, x를 눌러 xv6를 종료할 수 있다.

xv6 실행에 필요한 패키지가 설치되어있지 않은 상황이라면, 당연히 제대로 실행이 이루어지지 않을 것이다. 아래에서 xv6 실행에 필요한 대표적인 두 패키지 설치를 진행해보겠다.

QEMU qemu-system-riscv 패키지 설치

sudo apt update
sudo apt install software-properties-common

sudo add-apt-repository ppa:canonical-server/server-backports
sudo apt update
sudo apt install qemu-system

설치 후 버전 확인

qemu-system-riscv64 --version

QEMU emulator version 9.0.2 버전이 설치된 것을 확인할 수 있었다.

RISC-V GNU Compiler Toolchain 설치

RISC-V GNU Compiler Toolchain은 xv6 레포지토리의 README 하단에서도 설치가 필요함을 명시하고 있다.

You will need a RISC-V "newlib" tool chain from https://github.com/riscv/riscv-gnu-toolchain, and qemu compiled for riscv64-softmmu.

0. Toolchain 설치에 앞서 필수 패키지들을 설치

   sudo apt update
   sudo apt-get install autoconf automake autotools-dev curl python3 python3-pip python3-tomli libmpc-dev libmpfr-dev libgmp-dev gawk build-essential bison flex texinfo gperf libtool patchutils bc zlib1g-dev libexpat-dev ninja-build git cmake libglib2.0-dev libslirp-dev

   
   

1. 레포지토리 클론 및 newlib 서브모듈 업데이트

   git clone https://github.com/riscv/riscv-gnu-toolchain
   cd riscv-gnu-toolchain
   

git submodule update --init --recursive newlib

<br>

2. 설치 경로 생성 후 쓰기 권한 부여
```bash
sudo mkdir -p /opt/riscv
sudo chown $USER:$USER /opt/riscv

3. 환경변수 설정

   echo 'export PATH=/opt/riscv/bin:$PATH' >> ~/.bashrc
   source ~/.bashrc

   
   

4. Toolchain 설치 진행 (대략 2시간 가까이 소요된다)

   ./configure --prefix=/opt/riscv
   make

   
   

설치 후 버전 확인

riscv64-unknown-elf-gcc --version

riscv64-unknown-elf-gcc (g04696df09) 14.2.0 버전이 설치된 것을 확인할 수 있었다. (설치 이후 레포지토리는 삭제해도 문제가 없다)

많은 전자상거래 추천 시스템(특히 소규모 소매업체)과 대부분의 뉴스 및 미디어 사이트는 사용자 ID를 장기적으로 추적하지 않는다. 따라서 실제 추천 시스템은 짧은 세션 기반 데이터만을 바탕으로 추천해야 하는 문제에 직면하며, 이 경우 행렬 분해 접근법(일반적인 추천 시스템에서 사용)은 정확도가 떨어질 수 있다.

1. INTRODUCTION

• 많은 사용자가 소규모 전자상거래 사이트에서 단 한두 번의 세션만을 가지며, 특정 도메인(예: 분류 광고 사이트)에서는 사용자 행동이 종종 세션 기반 특성을 보인다. 따라서 사용자의 후속 세션은 독립적으로 처리되어야 한다.

• 대부분의 세션 기반 추천 시스템은 사용자 프로필을 사용하지 않는 비교적 간단한 방법(예: item-item 유사도 등)으로 구성된다. 그러나 이러한 방법들은 종종 사용자의 마지막 클릭이나 선택만을 고려하며, 과거 클릭 정보를 무시한다.

• RNN 모델을 활용한 세션 기반 추천에서는 사용자가 웹사이트에서 처음 클릭한 항목을 초기 입력으로 간주할 수 있다. 그 다음 초기 입력을 바탕으로 모델에 출력(추천)을 요청하고, 사용자가 클릭할 때마다 이전 클릭 데이터를 기반으로 출력(추천)을 생성한다.

• 사용자가 관심을 가질 수 있는 상위 항목(Top items)에 모델링 파워를 집중시키기 위해, RNN 모델 학습에 순위 손실(Ranking loss)함수를 사용한다.

  
  

3. RECOMMENDATIONS WITH RNNS

3.1 CUSTOMIZING THE GRU MODEL

• GRU 기반 RNN 모델을 사용했으며, 네트워크의 입력은 세션의 현재 상태이고 출력은 각 항목이 세션에서 다음으로 선택될 확률(선호도)이다.

  • 세션의 현재 상태는 (1) 현재 이벤트의 항목이거나 (2) 세션 내의 모든 이벤트일 수 있다. (1)에서는 1-of-N 인코딩(입력 벡터의 길이가 항목 수와 동일하며, 활성 항목에 해당하는 좌표만 1이고 나머지는 0인 방식)이 사용되고, (2)에서는 이러한 표현의 가중합을 사용하며 이전에 발생한 이벤트는 가중치가 감소한다.
  • 추후 실험 결과에서 세션 내 모든 이벤트를 입력으로 넣는 것이 현재 이벤트 항목만을 입력으로 넣는 것에 비해 추가적인 정확도 향상을 가져오지 않는 것이 드러났다. (GRU가 LSTM의 특성을 가지기에 어찌 보면 당연한 것)

• 입력에서 이후에 임베딩 레이어를 추가할 수 있다.

  • 추후 실험 결과에서 항목의 임베딩을 사용하는 것이 약간 더 나쁜 결과를 보여주었기에, 1-of-N 인코딩을 유지했다고 한다.

• 여러 개의 GRU layers를 사용할 경우, 이전 레이어의 은닉 상태가 다음 레이어의 입력으로 사용된다. 또한, 입력은 선택적으로 네트워크의 더 깊은 GRU 레이어에 연결될 수 있으며, 이는 성능 향상에 기여하는 것으로 확인되었다.

  • 추후 실험 결과에서 단일 GRU 레이어가 가장 우수한 성능을 보였다. (일반적으로 세션의 수명이 짧아 다양한 해상도의 여러 시간 스케일이 적절히 표현될 필요가 없기 때문으로 추정된다)
  • GRU 레이어의 크기를 늘리는 것은 성능을 향상시켰음을 확인했다.

• Feedforward layers를 마지막 레이어와 출력 사이에 추가할 수 있다.

  • 추후 실험 결과에서 GRU 레이어 이후에 추가적인 Feedforward layers을 추가하는 것은 도움이 되지 않았다고 한다.
  • 출력 레이어의 활성화 함수로 tanh를 사용하는 것이 유익함을 발견했다.
    

3.1.1 SESSION-PARALLEL MINI-BATCHES

• 자연어 처리에서의 순차적 미니 배치는 본 연구에 적합하지 않다. 따라서 세션 병렬 미니배치(session-parallel mini-batches)를 사용한다.

1. 먼저, 세션의 순서를 생성한다.
2. 그 다음, 첫 번째 미니 배치의 입력을 활성 세션의 첫 번째 이벤트($𝑖{1,1}$)로 구성하고, 원하는 출력은 해당 세션의 두 번째 이벤트($𝑖{1,2}$)가 된다.
3. 두 번째 미니 배치는 두 번째 이벤트로 구성되며, 이러한 방식으로계속한다.
4. 만약 세션이 끝나면, 다음 사용 가능한 세션을 그 자리에 배치한다. 이때 세션은 독립적인 것으로 가정하므로, 전환이 발생할 때 적절히 은닉 상태를 초기화한다.
   

3.1.2 SAMPLING ON THE OUTPUT

• 모든 항목에 대해 점수를 계산하는 것은 알고리즘 복잡도 증가(→ 시간 증가)로 인해 실효성이 떨어진다.

• 따라서 출력에서 샘플링을 수행하여 항목의 작은 하위 집합에 대해서만 점수를 계산해야 한다.

• 이로 인해, 일부 가중치만 업데이트 되므로, 원하는 출력(positive examples) 외에도 몇몇 부정적인 예제(negative examples)에 대한 점수를 계산하고 원하는 출력이 높은 순위를 갖도록 가중치를 조정해야 한다.

  • 임의의 누락된 이벤트에 대한 자연스러운 해석은 ‘사용자가 해당 항목의 존재를 알지 못했기 때문에 상호작용이 없었다’이다.
  • 그러나 항목이 인기있을수록 사용자가 항목을 알고 있을 가능성이 높아지며, 누락된 이벤트가 싫어함(dislike)를 나타낼 가능성이 높다.

• 항목의 인기도에 비례하여 항목을 샘플링(popularity-based sampling)해야 한다.

  • 각 학습 데이터(세션)마다 별도의 샘플링을 생성하는 대신, 미니배치의 다른 학습 데이터에서 항목을 가져와 부정적인 예제로 사용한다.
  • 미니 배치의 다른 학습 데이터에 항목이 포함될 가능성이 그 항목의 인기도에 비례하기 때문이다.
  • 이 접근법으로 샘플링 단계를 생략함으로써 계산 시간을 단축할 수 있다.
    

3.1.3 RANKING LOSS

추천 시스템의 핵심은 항목의 관련성에 기반한 순위 매기기(relevance-based ranking)이다.

1. Pointwise Ranking: 항목의 점수 또는 순위를 서로 독립적으로 추정하며, 관련 항목의 순위가 낮아야 한다(1에 가까워야)는 방식으로 손실(loss)을 정의한다.

   • 추후 실험에서 Pointwise Ranking Loss(예: Cross-entropy, MRR 최적화)는 정규화를 적용했음에도 불구하고 일반적으로 불안정했다. 원하는 항목에 대해 높은 점수를 독립적으로 얻으려 하면서 부정적인 샘플에 대한 밀어내기가 작게 적용되기 때문으로 추정된다.

2. Pairwise Ranking: 긍정적 항목과 부정적 항목의 쌍을 비교하여 점수 또는 순위를 평가한다. 긍정적 항목의 순위가 부정적 항목보다 낮아야 한다는 제약을 손실로 강제한다.

3. Listwise Ranking: 모든 항목의 점수와 순위를 사용하여 이를 완벽한 순서(perfect ordering)와 비교한다. 하지만 정렬(sorting)을 포함하기 때문에 계산 비용이 크며, 일반적으로 자주 사용되지 않는다.

   • 관련 항목이 하나뿐인 경우, 리스트 방식 순위 매기기(listwise ranking)는 쌍 방식 순위 매기기(pairwise ranking)를 통해 해결될 수 있다.

따라서 두 가지 Pairwise Ranking을 사용했다.

• BPR(Bayesian Personalized Ranking): pairwise ranking loss를 사용하는 행렬 분해(matrix factorization) 방법이다. 긍정적인 항목의 점수를 샘플링된 여러 부정적인 항목들과 비교하고 그 평균을 손실로 사용하여, 두 항목의 예측값 사이의 차이를 최대화하는 방향으로 학습한다.

  $$ L_s = -\frac{1}{N_S} \cdot \sum_{j=1}^{N_S} \log (\sigma(\hat{r}{s,i} - \hat{r}{s,j}))

  $$

• $N_S$: 샘플의 크기.
• $\hat{r}_{s,i}$: 항목 $k$에 대한 점수.
• $i$: 해당 세션에서 긍정적인 항목(세션의 다음 항목).
• $j$: 부정적인 샘플들.

• TOP1:

• 관련 항목의 상대적인 순위*(relative rank)의 정규화된 근사값을 나타낸다.

  $$ \frac{1}{N_S} \cdot \sum_{j=1}^{N_S} I{\hat{r}{s,j} > \hat{r}{s,i}} = \frac{1}{N_S} \cdot \sum_{j=1}^{N_S} \sigma{\hat{r}{s,j} - \hat{r}{s,i}} $$

  하지만 $i$의 점수가 높아지도록 최적화하는 동안, 특정 긍정적인 항목이 부정적인 예제로 작용하면서 점수가 점점 더 높아지는 불안정성이 발생할 수 있다. 따라서 부정적인 항목의 점수를 0 근처로 유지하기 위해 손실에 정규화 항을 추가했다.

  $$ L_s = \frac{1}{N_S} \cdot \sum_{j=1}^{N_S} \sigma(\hat{r}{s,j} - \hat{r}{s,i}) + \sigma((\hat{r}_{s,j})^2) $$

  
  
  

4. EXPERIMENTS

DATASET

• RecSys Challenge 2015 (RSC15):

• 전자 상거래 사이트*의 클릭 스트림을 포함하며, 일부는 구매 이벤트로 끝나는 경우도 있다.

  • 학습 세트를 이용하며, 클릭 이벤트만 유지한다.
  • 길이가 1인 세션은 제거한다.
  • 테스트는 이후 하루 동안의 세션을 사용한다. 이때, 각 세션은 학습 또는 테스트 세트에 할당되며, 세션 중간에서 데이터를 분할하지 않는다.
  • 협업 필터링 특성 상, 테스트 세트에서 클릭된 항목이 학습 세트에 포함되지 않는 경우, 해당 클릭은 테스트 세트에서 제거한다.

• VIDEO: Youtube와 유사한 동영상 OTT 비디오 서비스 플랫폼에서 수집했다. 일정 시간 이상 비디오를 시청한 이벤트들을 수집했다.

  • Bot에 의해 생성되었을 가능성이 높은 매우 긴 세션을 필터링한다.
  • 학습 세트는 수집 기간(약 2개월)의 마지막 하루를 제외한 모든 세션으로 구성하고, 테스트 세트는 수집 기간의 마지막 하루 동안의 세션으로 구성한다.
    

EVALUATION

• 평가는 세션의 이벤트를 하나씩 제공하고, 다음 이벤트의 항목 순위를 확인하는 방식으로 이루어졌다.

• 항목들은 점수에 따라 내림차순으로 정렬되며, 이 목록에서의 위치가 항목의 순위이다.

  • RSC15 데이터셋에서는 학습 세트의 37,483개 모든 항목의 순위를 매겼다.
  • VIDEO 데이터셋에서는 항목 수가 너무 많아 비실용적이었기 때문에, 원하는 항목을 상위 30,000개의 가장 인기 있는 항목과 비교하여 순위를 매겼다.
    

평가 지표

• Recall@20: 테스트 사례에서 원하는 항목이 상위 20개 항목에 포함된 비율. (절대적인 순서가 중요하지 않은 경우)
• MRR@20: 원하는 항목의 역순위의 평균으로 순위가 20을 초과하면 역순위는 0으로 설정. (추천 순서가 중요한 경우)
  

Baseline 비교

• Item-KNN이 명백하게 우수한 성능을 보였다.

4.3 RESULTS

• GRU 기반 접근법은 두 데이터 셋에서 Item-KNN에 비해 두 평가 지표 모두에서 상당한 성능 향상을 보였다.

• 은닉 유닛 수를 늘리면 Pairwise Loss(TOP1, BPR)에 대한 결과가 더욱 개선되지만, Cross-entropy의 정확도는 감소한다. 그러나 Pairwise Loss의 개선이 기존 Cross-entropy의 정확도보다 뛰어나다.

  • 유닛 수를 늘리는 것이 학습 시간을 증가시키기는 하지만, GPU에서는 100 → 1000의 이동이 크게 비싸지않다. (추천 시스템에서는 새로운 사용자와 항목이 자주 추가되기 때문에, 잦은 재학습이 필요하다)
  • 따라서 Pairwise Ranking Loss를 사용하는 것을 권장한다.

• TOP1 Loss가 두 데이터셋에서 약간 더 나은 성능을 보이며, Item-KNN에 비해 20-30%정도 정확도가 향상되었다.

학습자의 과거 성과를 기반으로 특정 시점에서 추천이 필요한 학습자를 능동적으로 구별하는 기능

1. INTRODUCTION

동적 그래프 기반 지식 추적(dynamic graph-based knowledge tracing) 접근법에서 시계열 노드 분류(time-series node classification)를 제안한다.

• 동적 그래프 기반 지식 추적 접근법은 'Adaptive neural network for node classification in dynamic networks'에서 제안되었다.

• 학습자를 노드로 모델링하여, 특정 지식 개념을 기반으로 학습자를 그래프에서 그룹화한다. 이 과정에서 노드와 그래프의 토폴로지는 학습자의 지식 추적에 맞춰 시간에 따라 변화한다.

  • Gated Recurrent Unit(GRU) 네트워크와 Attention Neural Network(ANN)을 활용하여, 노드로 표현된 학습자와 그 이웃 노드의 정보를 집계해 특징 표현(feature representation)을 학습하고, 각 시간 단계에서 네트워크의 토폴로지 정보를 추출한다.
  • GRU(Gated Recurrent Unit)는 LSTM의 간소화된 버전이다.

2. PROPOSED APPROACH

Problem Definition

지도 학습 기반 노드 분류(supervised node classification)

• 강의 내용을 $G = (\zeta_1, \zeta_2, ..., \zeta_T)$로 구조화했으며, 여기서 $T$는 시간 단계(time steps)의 수를 나타낸다. $\zeta_t = (V, A_t, X_t, C)$는 시간 단계 $t$에서의 그래프이자, 노드 집합 $V$를 포함한 그래프를 의미한다. $N= ∣V∣$는 그래프 내 학습자/노드의 수를 나타낸다.

• 노드(학습자)들은 특정 지식 개념 $C$를 의존 관계로 공유하며, $C = {C_1, C_2, ..., C_m}$는 $m$개의 존재하는 지식 개념으로 구성된다.

• $A_t \in \mathbb{R}^{N \times N}$는 노드 간 연결을 설명하는 인접 행렬(adjacency matrix)로, $A_{ij} = 1$은 시간 $t$에 노드 $i$와 $j$가 공유하는 지식 개념 $C$가 있음을 나타내고, 연결이 없으면 $A_{ij} = 0$으로 표시된다.

• $X_t \in \mathbb{R}^{N \times f}$는 노드 속성 행렬(node attribute matrix)로, $f$는 학습자를 표현하는 속성(feature)의 차원 수입니다.

• 시간 단계에 따라 $A_t$​와 $X_t$는 변화하지만, $V$와 $C$는 모든 시간 단계에서 고정된다.

Dynamic Graph Based Knowledge Tracing

1. 먼저, 튜터는 사용할 지식 개념을 선택한다. 지식 추적 데이터셋은 시간 단계에 따라 변화하는 동적 그래프로 변환되며, 각 노드는 학습자를 나타내고 학습자의 이전 지식에서 추출 및 집계된 속성 특징(attribute features)을 포함한다. 생성된 그래프의 모든 학습자는 교사가 선택한 동일한 지식 개념을 공유한다.

2. 동적 그래프에서의 노드 분류(Node Classification) 아이디어는 네트워크 구조 정보와 노드 속성 정보를 통합하는데 있다. 이를 위해 두 개의 GRU(Gated Recurrent Unit) 네트워크(A-GRU와 T-GRU)를 사용한다.

   1. Attention Neural Network를 통해 관련 노드 정보를 캡처하고 중요한 이웃 노드들을 집계합니다. 이웃 표현(neighbour representation)과 이전 상태의 노드 특징 벡터를 결합하여 새로운 GRU 상태 벡터 $h^A_t \in \mathbb{R}^{d_h}$를 생성하며, 이는 A-GRU를 나타낸다.

   2. T-GRU의 경우, 서로 다른 시간 단계에서 노드/학습자의 토폴로지 컨텍스트 벡터를 고려하여 GRU 상태 벡터 $h^T_t \in \mathbb{R}^{d_h}$를 생성한다.

   3. 속성-토폴로지 Attention은 각 시간 단계에서 속성과 토폴로지의 중요도를 결정하며, 상태 벡터 $h^T_t$와 $h^A_t$를 받아 각각 Attention 값 $\beta^A_t$와 $\beta^T_t$를 계산한다. 따라서, 시간 단계 $t$에서의 최종 상태 벡터는 다음과 같이 정의된다:

      $$ h_t = [(\beta^T_t \times h^T_t) \oplus (\beta^A_t \times h^A_t)] \in \mathbb{R}^{2d_h} $$

   4. 그래프 구조의 시간적 변화를 감지하기 위해 Temporal Attention이 추가되었다. Attention 모델은 상태 $h_t$를 입력받아 각 상태에 대한 Attention 값 $\alpha_t$를 출력한다. 다중 헤드 셀프 Attention을 활용하여 노드의 최종 벡터 표현은 다음과 같이 정의된다:

      $$ \alpha \times H \in \mathbb{R}^{2d_h} $$

      • $H = [h_1, ..., h_t]$: 모든 $h_t$를 연결한 벡터.
      • $\alpha \in \mathbb{R}^T$는 서로 다른 시간 단계의 Attention 값.

3. 마지막으로, 교차 엔트로피 손실(cross-entropy loss)과 Softmax 함수를 사용해 노드 레이블을 추정한다. 시간 단계에 걸쳐 선택된 지식 개념에서 낮은 지식 획득을 나타내는 노드(학습자)만 추천 시스템에 입력되며, 해당 지식 개념에 맞는 학습 자료와 함께 제공된다.

3. EXPERIMENT

3.1 Dataset

ASSISTments 학습 플랫폼에서 제공된 데이터셋을 활용했으며, 관련 특징을 추출 및 집계하여 재구성하고 레이블링하였다. 학습자를 나타내기 위해 총 8가지 특징(소요 시간, 정답 수, 힌트 요청 수, 시도 횟수, 좌절 점수, 지루함 점수, 혼란 점수, 집중도 점수)을 선택했다. 각 학습자는 지식 획득이 낮아 추천이 필요한지 여부를 나타내는 이진 값으로 레이블링되었다.

레이블링된 데이터를 기반으로 "덧셈과 뺄셈 정수(Addition and Subtraction Integers)"라는 지식 개념을 예시로 선택했다. 해당 데이터에 따르면 학습자의 42%가 문제를 겪으며 추천이 필요하다고 나타났다. 이후, 선택된 지식 개념을 기반으로 동적 그래프를 생성하였으며, 특정 시간 단계(10)에 걸쳐 과제를 완료한 모든 학습자들을 연결한다.

3.2 Results and Discussion

• 여러 실험을 거친 후, 다음과 같은 매개변수에서 제안된 모델이 가장 높은 성능을 보였다: batch size = 2048, learning rate = 0.001, epochs = 30, 상태 벡터 크기(dhd_hdh​) = 12

• 이 모델은 그래프에서 각 학습자를 나타내는 선택된 특징의 중요성(A-GRU)과 동일한 지식 개념을 공유하는 학습자 간의 연결을 나타내는 그래프 토폴로지(T-GRU)를 결합한다. 시간 단계에 따른 그래프의 동적 표현을 활용하여, 정적 그래프 스냅샷에만 의존하는 정적 방법보다 학습자의 지식 획득을 더 효과적으로 모델링한다.

• 이 모델은 학습자별로 추천 필요성을 높은 정확도로 예측할 수 있으며, 이를 통해 학습자 탈락률을 크게 줄일 수 있다. 또한, 낮은 학습 성과를 보이는 학습자를 위한 적응형 시스템 구축에도 도움을 줄 것이다.

학생의 문제 해결 전략을 이해하는 것은 지능형 튜터링 시스템(Intelligent Tutoring Systems, ITS) 및 적응형 교육 시스템(Adaptive Instructional Systems, AIS)을 통한 효과적인 수학 학습에 큰 영향을 미칠 수 있다.

문제 해결에 사용된 전략은 학생의 숙련도를 나타낼 수 있다. 또한, 잘못된 전략에서 드러나는 특정 오개념을 바로잡기 위한 개인화 학습을 제공하고, 전략을 개선하기 위한 특정 문제를 설계하며, 학생의 사고 방식을 반영한 지도로 학생의 좌절감을 최소화할 수 있다.

PURPOSE

수학 학습에 있어서 확장 가능하고 공정한 학생의 문제 풀이 전략 예측 모델을 개발하는 것이 논문의 목표이다.

• 확장 가능성: 전체 데이터의 일부만을 샘플링하더라도 효율적인 학습 가능한 것.

• 공정성: (숙련도나 기술 수준에 차이가 존재하는) 학습자 유형에 따라 모델 정확도가 다르지 않은 것.

DATASET

미국 수학 교육 플랫폼인 MATHia를 활용한 실제 학생들의 학습 데이터를 사용했다.

• 학생과 컴퓨터 간의 상호작용 및 학생의 문제 해결 행동에 대한 로그를 포함한 것이다. (예: 사용된 지식 구성 요소(Knowledge Component), 해당 단계(KC)가 올바르게 완료되었는지 여부, 힌트가 필요한지 여부 등)

• PSLC datashop을 통해 공개적으로 이용 가능하다고 논문에 적혀 있었으나, 실제 데이터셋을 다운받아 확인해보기 어려웠다. Bridge to Algebra 2008-2009 (BA08), Carnegie Learning MATHia 2019-2020 (CL19).

• 연립방정식 문제를 해결하는 3가지 전략으로, 유사한 색상은 유사한 단계(KC)를 나타내며, 여러 전략들은 완전히 동일하지 않더라도 유사하거나 대칭적인 경우가 많다.

3. PROPOSED APPROACH

학생 $𝑆$와 문제 $𝑃$에 대해, $𝑆$가 $𝑃$를 해결하는데 사용할 전략(KC 시퀀스)을 예측하는 것이 논문에서 해결하고자하는 과제이다.

3.1 MVec Embeddings

Node2Vec와 유사한 접근법을 활용하되, KC $K$에 대한 학생 $S$의 숙련도(Mastery)를 이용해 그래프에서 경로를 샘플링하여 임베딩을 학습하는 것이다.

숙련도 값은 Attention 모델을 활용해 각 KC가 문제 해결에서 차지하는 역할(중요도)를 포함하여 계산한다.

관계 그래프 $G=(V,E)$의 구성

• 훈련 데이터의 각 학생과 문제, KC를 노드 $V∈V$로 표현한다.

• 학생 $S$가 문제 $P$를 해결하는 데 KC $K$를 사용하는 경우, 두 개의 간선 $E,E′∈E$가 생성된다.

  • $E$: 학생 노드와 KC 노드를 연결.
  • $E′$: KC 노드와 문제 노드를 연결.

• 좌측 그래프는 3명의 학생, 문제, 그리고 KC에 대한 예시 그래프이며, 우측은 임베딩을 학습하기 위해, 그래프에서 경로를 샘플링한 결과이다.

• 간단한 샘플링 전략 $Q$는 노드의 이웃을 무작위로 샘플링하는 것이지만, 학생이 KC를 문제에 성공적으로 적용했다면, 해당 간선은 더 큰 중요도를 부여받아야 한다. 따라서 Attention 모델을 훈련하여 그래프 $G$의 간선에 대한 샘플링 확률을 추정한다.

숙련도(CFA) 정량화

• 세 학생이 각 문제에 대해 KCs를 적용할 기회를 갖는 모습을 설명한다.

• CFA(Correct First Attempt)

  • 각 KC 시퀀스에 대해, 학생이 해당 KC를 적용할 기회를 가졌을 때 첫 번째 시도에서 올바르게 해결했는지(Correct, 1) 또는 잘못했는지(Wrong, 0)를 예측하는 값이다.
  • 1번 학생은 동일한 KC을 적용하는데 있어 일관성이 부족하다. (앞선 두번의 KC K는 올바르게 해결하지 못하였지만, 뒤에서는 올바르게 해결한 모습 등으로 CFA 값이 0과 1 사이의 값을 가짐) 반면, 2, 3번 학생은 동일한 KC를 일관되게 적용하므로, 숙련도가 높다고 볼 수 있다.

• 교육과정 구조(단원 → 차시)를 기반으로 Attention 모델을 학습시켰다.

• 각 차시에서 학생이 해결한 문제 $P$를 선택하고, $P$에서 사용된 각 KC에 대한 CFA 값을 예측하도록 모델을 훈련했다

• (CFA 값 예측을 위한) Attention 모델 구조

  • 인코더-디코더(encoder-decoder) 구조로, 입력은 KC 시퀀스로 구성되며, 인코더는 이 시퀀스를 잠재 표현으로 매핑하고 디코더는 CFA 값을 하나씩 디코딩한다.

  • Attention 가중치 계산:

    $$ \text{Attention}(\gamma, \kappa, \eta) = \text{softmax}\left(\frac{\gamma \kappa^T}{\sqrt{d_k}} \eta\right) $$

    • $γ, κ, η$: 각각 쿼리(query), 키(key), 값(value) 행렬.
    • $d_k$​: 잠재 표현의 차원.
    • 각 KC가 문제 해결에서 차지하는 역할(중요도)을 나타낸다고 볼 수 있다.

  • KC $K$에 대한 학생 $S$와 문제 $P$의 숙련도(CFA) 투영 계산:

    $$ \alpha(S, P, K) = \frac{\sum_{v \in \pi(a_i)} v}{\sum_{v \in \pi(a_i)} v + \sum_{v' \in \bar{\pi}(a_i)} v'} $$

    • $π(⋅)$: 입력 벡터에서 모델이 해당 단계를 올바르게 해결했다고 예측한 값만 추출.
    • $\bar{\pi}(\cdot)$: $π(⋅)$의 보완 집합으로, 학생이 해당 단계를 틀렸다고 예측한 값 추출.
    • $i$: $K$가 사용된 모든 인스턴스의 합산.

그래프 $G$에서 경로 샘플링

분리된 분포(아래의 식)를 사용해서 그래프 G에서 경로를 샘플링한다.

$$ Q(S)⋅Q(K∣S)⋅Q(P∣K,S) $$

• $Q(S)$: 학생 노드를 샘플링할 확률.

  • 균등 분포로 가정 (즉, 모든 학생이 동일한 확률로 선택됨).

• $Q(K∣S)$: 학생 $S$에게 주어진 $K$(Knowledge Component)를 샘플링할 확률. $$ Q(K|S) = \frac{1}{n} \sum_p \alpha(S, P, K) $$

  • $n$: 학생 $S$가 KC $K$를 적용할 기회.
  • $\alpha(S, P, K)$: 학생 $S$의 문제 $P$에 대한 KC $K$의 숙련도.

• $Q(P∣K,S)$: S와 K가 주어졌을 때 문제 P를 샘플링할 확률.

$$ Q(P∣K,S)=α(S,P,K) $$

MVec 임베딩 학습

1. $Q(S)$에서 무작위로 학생 $S$ 샘플링.
2. $Q(K∣S)$에서 $K$를 샘플링.
3. $Q(P∣K,S)$에서 $P$를 샘플링.
4. Word2Vec 모델을 통해 이웃 노드를 사용하여, 경로의 각 노드 예측.
5. Word2Vec 모델의 은닉 계층에서 임베딩 학습.

3.2 Non-Parametric Clustering

DP-Means HDP 클러스터링 기법을 활용한 비모수적 접근법을 이용하되, 전략 대칭성에 기반하여 학생과 문제의 MVec 임베딩을 공동으로 클러스터링하는 것이다.

이후 전체 데이터가 아닌 생성된 각 클러스터에서 샘플을 선택하여 모델을 훈련함으로써 정확도를 희생하지 않고 확장성을 확보할 수 있다.

• 대칭성(symmetry)에 기반한 비모수적 접근법을 통해 학생과 문제의 MVec 임베딩을 공동으로 클러스터링한다.

• 데이터셋 $D$에 대해, $S$는 학생 집합이고 $P$는 문제 집합이다.

Definition 1. 전략 불변 분할 (strategy-invariant partitioning)

• 분할 ${S_i}{i=1}^{k_1}$와 ${P_j}{j=1}^{k_2}$로 정의.

• 모든 $i$, $j$에 대해: 만약 $S,S′∈S_i​$이고 $P,P′∈P_j$​라면, $S$와 $S′$은 각각 $P$와 $P′$에 대해 동일한 전략을 따른다.

• $k_1$​: 학생 분할/클러스터의 수, $k_2$​: 문제 분할/클러스터의 수.

• 전략 불변 분할을 통해 전체 데이터가 아닌 각 클러스터에서 샘플을 선택하여 모델을 훈련함으로써 정확도를 희생하지 않고 확장성을 확보할 수 있다.

  • Introduction에서 DNN 모델이 전체 데이터 분포를 기반으로 학습할 때, 다수 그룹에게 편향될 수 있다는 점을 지적한 부분과 관련이 있다.

접근법 공식화

• 학생 집합: $S={x_{i1}}{i=1}^{N}$, 문제 집합: $P={x{j2}}_{j=1}^{M}$.

• 로컬 클러스터(Local Clusters): 학생 및 문제 각각의 클러스터.

• 글로벌 클러스터(Global Clusters): 학생 클러스터와 문제 클러스터를 결합한 클러스터.

• DP-Means HDP 클러스터링(2.3에서 다룸)

  $$ \sum_{p=1}^{g} \sum_{x_{ij} \in \ell_p} |x_{ij} - \mu_p|^2 + \lambda_\ell k + \lambda_g g $$

  • 전역 페널티 $λ_g$의 값이 클수록 적은 수의 거친(cloarse) 클러스터가 생성되고, 페널티 값이 작을수록 많은 수의 세밀한(fine-grained) 클러스터가 생성된다.

  1. 초기 클러스터링: $\ell_1, \ell_2, \ldots, \ell_g$는 현재의 글로벌 클러스터.

  2. 각 클러스터 내의 전략 대칭성을 기반으로 점수 $S(\ell_1, \ldots, \ell_g)$를 계산한다.

  3. 반복(iteration)마다 점수가 개선될 경우, $λ_g$를 점진적으로 감소시켜 더 세밀한 클러스터를 생성한다. (Coarse-to-fine refinement 접근법)

3.3 Refining Clusters using Symmetry

전략을 MVec 임베딩과 위치 인코딩의 조합으로 표현하며, Smith-Waterman(SW) 알고리즘을 이용하여 위치 임베딩 간의 정렬을 계산함으로써 전략 대칭성을 계산하는 것이다.

• 글로벌 클러스터: 각 글로벌 클러스터는 전략 집합을 암묵적으로 나타낸다.

  • 학생-문제 쌍 $(s,p)$이 클러스터에 속할 경우, 이는 $s$가 문제 $p$를 해결할 때 사용한 전략을 나타낸다.

• 클러스터 내 전략 간의 대칭성(symmetric similarity)을 정량화하는 것이 목표이다.

  
  

전략의 근사적 정렬 및 대칭성 계산

• 각 전략은 MVec임베딩과 위치 인코딩(positional encodings)의 조합으로 표현된다.

• 전략에서 특정 KC K를 다음 벡터로 표현:

  $$ \vec{K} = \vec{K}_e + \vec{K}_p $$

  • $\vec{K}_e$​: $K$의 MVec 임베딩.
  • $\vec{K}_p$​: $K$의 전략 내 위치 인코딩.

• 전략 간 대칭성을 계산하기 위해, 우리는 위치 임베딩 간의 정렬을 계산할 때, Smith-Waterman 알고리즘(SW)을 이용한다.

  • 두 시퀀스 간 가능한 최적의 정렬을 계산하기 위해 지역 탐색(local search) 수행한다.

  • 유사도 함수가 필요하며, 두 KC 간의 유사도로, $s(K,K′)=\vec{K}^\top \vec{K}'$으로 설정된다. 즉, $K$와 $K′$의 위치 임베딩 간의 코사인 유사도이다.

  • 정렬에 갭(gap, 비어있는 단계)을 남기는 비용을 나타내는 갭 페널티를 필요로 하며, 대칭성을 갭에 대해 불변으로 유지하기 위해 갭 페널티를 0으로 설정한다. 즉, 두 전략이 대칭적이라면 전략에 추가 단계를 포함하는 것이 허용하는 것이다.

  • 로컬 정렬에 기반한 스코어링 행렬(scoring matrix)을 반복적으로 계산한다. 최적의 정렬에 대한 스코어를 제공하는 스코어링 행렬을 계산하는 최악의 경우 복잡도는 $O(m \cdot n)$이며, 여기서 $m$과 $n$은 전략의 길이를 나타낸다.

전략 대칭성 정량화 및 클러스터링 대칭성 점수

• 두 전략 $K$와 $K′$ (길이 $n$과 $m$) 간의 대칭성을 SW 알고리즘을 기반으로 정렬 $L(K,K′)$을 통해 계산한다.

  • 정렬에는 $K$와 $K′$ 각각에서 매칭되거나 정렬된 KC 쌍 또는 갭(gap, 즉 $K$의 KC가 $K′$의 어떤 KC와도 정렬되지 못한 경우)이 포함된다.

• $K$와 $K′$ 간의 대칭 점수 계산:

  $$ r(K, K') = \frac{1}{\max(n, m)} \sum_{(K, K') \in L(K, K')} (\vec{K}^\top \vec{K}') $$

  • $(K,K′)∈L(K,K′)$: 정렬된 KC 쌍.
  • $\vec{K}^\top \vec{K}'$: 두 KC의 코사인 유사도. 따라서 $0≤r(K,K′)≤1$.

• 클러스터링 대칭성 추정:

  $$ S(\ell_1, \ldots, \ell_g) = \frac{1}{g} \sum_{p=1}^g \frac{1}{Z_p} \sum_{K, K' \in T(\ell_p)} r(K, K') $$

  • $T(ℓ_p​)$: 클러스터 $ℓ_p​$에 포함된 모든 전략의 집합.
  • $Z_p = \frac{2}{|T(\ell_p)|(|T(\ell_p)|-1)}$​: 정규화 항.
  • $S(ℓ_1​,\dots,ℓ_g​)$의 값이 클수록 $ℓ_1,…,ℓ_g$에 속하는 클러스터링이 높은 전략 대칭성을 가진다.
  • 반복(iteration) 중 대칭성 점수 $S$가 감소하지 않는 한, 또는 고정된 반복 횟수 내에서 $\lambda_g$를 $\epsilon$만큼 감소시키면서 $\lambda_g$를 조정한다.(Coarse-to-fine refinement 접근법)

3.4 Training the Model

학생과 문제 벡터를 입력으로 받아 KC 시퀀스를 출력으로 생성하는 One-to-Many LSTM 구조를 사용하여 전략을 예측한다.

4. EXPERIMENTS

4.3 Comparison to Baselines

1. Shakya et al. 의 접근법(CS): 동일한 데이터셋에서 중요도 샘플링(importance sampling)을 사용해 LSTM을 훈련하는 특화된 접근법. 다만, 숙련도(mastery)나 근사 대칭성(approximate symmetries)을 고려하지 않아 다양한 훈련 인스턴스를 효과적으로 찾지 못한다.

2. 계층적 샘플링(GS, Group Sampling): 학생이 해결한 문제의 수에 비례하여 샘플링하는 접근법.

3. 랜덤 샘플링(RS, Random Sampling): 학생과 문제를 균등하게 무작위로 샘플링하는 단순한 방법.

4. 어텐션 샘플링(AS, Attention Sampling): 논문에서의 접근법으로, 대칭성과 숙련도를 고려한 샘플링을 수행하는 접근법.

4.4 Results and Discussion

Accuracy & Scalability

• AS는 BA08 데이터셋(1.6M)의 1% 미만으로 80% 이상의 테스트 정확도를 달성했다.
• AS에서 추가적인 숙련도 임베딩 생성 및 비모수적 클러스터링 처리가 필요했음에도 가장 빠른 성능을 보였다.
• 전체 데이터셋을 사용한 모델 훈련 시도에서 모델 수렴에 실패했다.

Ablation Study

접근법에 각 구성 요소를 단계적으로 추가하면서, 훈련 데이터 샘플 크기 변화에 따른 테스트 정확도를 관찰했다.

• No Symmetries(NS): 대칭성을 사용하지 않으며, 클러스터링을 무작위로 수행했다.

• StrategySymmetries(SS): 대칭성을 사용하되, 숙련도를 이용하여 임베딩을 학습하지 않았다. Word2Vec 입력으로 학생($S$), 문제($P$), KC($K$)의 삼중 쌍 $(S,P,K)$만 사용하여 임베딩을 생성했다.

• SS + Mastery(SS + MS): 대칭성과 함께, 숙련도를 포함하여 MVec 임베딩을 학습했다.

Fairness

1. 성취 수준이 다른 학생그룹에 대해 정확도가 크게 다르지 않는지 확인했다.

2. 희귀 전략을 사용하는 하위 문제 그룹에서 차별적 오류가 발생하는지 확인했다. 문제 섹션을 $𝐸𝑑𝑖𝑡𝐷𝑖𝑠𝑡𝑎𝑛𝑐𝑒$를 이용해 계산한 전략 간 분산에 따라 5개의 하위 그룹으로 나누었다. ($𝐸𝑑𝑖𝑡𝐷𝑖𝑠𝑡𝑎𝑛𝑐𝑒 = \frac{변화된 단계 수}{총 단계 수}$)

학교 수업 과제를 학교 Linux 서버에서만 작성하라고 하시더라... (서버에서는 서버 용량 문제로 VSCode에서 ssh 원격 접속을 금지하는 중) Cheating 탐지를 위해, 사용한 shell 명령어를 확인한다나 뭐래나...

결국 방법은 Vim을 그나마 쓸만하게 만드는 것인가 싶어서 시작하는 Vim Plug-in 잔뜩 설치하기...!! (하지만 결론은 로컬에서 코드를 작성한 후, 서버로 옮겨적기만 했습니다)

1. vimrc 설치

https://github.com/amix/vimrc?tab=readme-ov-file

git clone --depth=1 https://github.com/amix/vimrc.git ~/.vim_runtime
sh ~/.vim_runtime/install_awesome_vimrc.sh

1.1. vimrc 단축키 요약

• :tabnew <파일 이름>: 새 탭 열기
• :tabnext,gt 키: 다음 탭으로 이동
• :tabprevious,gT 키: 이전 탭으로 이동
• _gt 키: _번째 탭으로 이동
• :tabclose: 탭 닫기
• Ctrl + w:탭 이동

2. NERDTree 설치

https://github.com/preservim/nerdtree

# vim-plug 설치 (이미 설치한 경우 건너뛰기)
curl -fLo ~/.vim/autoload/plug.vim --create-dirs \
    https://raw.githubusercontent.com/junegunn/vim-plug/master/plug.vim

~/.vim_runtime/my_configs.vim에 아래 내용 추가

call plug#begin('~/.vim/plugged')
" NERDTree 플러그인 추가
Plug 'preservim/nerdtree'   " NERDTree 플러그인 추가
call plug#end()

Vim을 연 후, 다음 명령어로 플러그인 설치

:PluginInstall

이후 다시~/.vim_runtime/my_configs.vim에 아래 내용 추가

" NERDTree를 자동으로 열고, 실행 결과 창 닫기
autocmd VimEnter * NERDTree
autocmd! User PlugClean,PlugInstall,PlugUpdate,PlugUpgrade quit     

2.1. NERDTree 단축키 요약

• o: 폴더 열기/닫기 또는 파일 열기
• t: 새 탭에서 파일 열기
• i: 수직 분할 창에서 파일 열기
• s: 수평 분할 창에서 파일 열기

3. VimColorScheme 설치

vimrc에도 colorscheme이 존재하지만 죄다 마음에 안드는 관계로...

https://github.com/rafi/awesome-vim-colorschemes

git clone https://github.com/rafi/awesome-vim-colorschemes.git \
    ~/awesome-vim-colorschemes
mv ~/awesome-vim-colorschemes/colors ~/.vim/colors
rm -rf ~/awesome-vim-colorschemes

~/.vim_runtime/my_configs.vim에 아래 내용 추가

"ColorScheme 적용
if has("syntax")
     syntax on
endif

set autoindent
set cindent
set nu

colo onehalfdark

set laststatus=2
set statusline=\ %<%l:%v\ [%P]%=%a\ %h%m%r\ %F\

🫠 FastAPI에서 진행 상황을 전송하려는 이유

1. 현재 프로젝트에서 사용하는 API가 여러 단계의 API를 연속적으로 호출하는 형태임.

   • 예를 들자면, '파스타 요리 API'를 만드는데, 그 API 내부에서 '재료 준비 API', '물 끓이기 API', '면 삶기 API', '소스 만들기 API', ...를 연속적으로 호출하는 상황.
     

2. 프론트엔드 측에서 현재 진행 상황을 공유받고 싶어함.

   • 즉, 내 파스타가 어느 단계까지 만들어 졌는지, 그 단계까지 진행한 결과는 어떻게 되는지를 표시하고자 함. (현재, 재료 준비를 완료했고, 무슨무슨 재료를 준비했다 등)

😵 문제 상황

우리는 파스타 네 개를 동시에 만들고 API로 각 파스타의 진행 상황을 공유받고 싶었다.

🤪 기존 처리 방식

기존 처리 방식은 '파스타 네 개를 동시에 만드는 것'을 프론트에게 떠넘기는 작전이었다. (아무래도 내가 프론트와 백 모두 하고 있었기에 가능한 작전이 아니었을까...)

장점

• FastAPI에서 StreamingResponse로 진행 상황을 전송하는 코드를 GPT에게서 얻을 수 있었다. (구현이 쉬웠음)

단점

• 프론트엔드에서 동시성 처리를 하는 것이 일반적이지 않다.
• 프론트엔드 작업을 Streamlit로 해서 Python을 사용했기에 동시성 처리가 가능했지, 아마 React에서 TS를 썼다면 불가능 했을지도...

기존 프론트엔드

1. Thread를 이용해 동시에 4개의 API에 요청
2. 각 API의 진행 상황을 Thread ID를 추가해 Queue에 Put
3. Queue에서 Get하면서 각 파스타의 진행 상황을 프론트엔드에 표시

• 이때 중요한 것은 각 파스타 요리의 성공/실패 여부를 확인해서, API 응답이 종료되었는지를 감지해야한다.

기존 백엔드 코드 일부

import os
from dotenv import load_dotenv
from fastapi import APIRouter
from fastapi.responses import StreamingResponse

import json
import httpx
from urllib.parse import urlencode

load_dotenv()
public_api_endpoint = os.getenv("PUBLIC_API_ENDPOINT") 
# 배포 시를 고려해 .env를 이용한 전역 변수 사용

router = APIRouter()

async def pasta_cooking(***):
    try:
        #### 재료 준비 ####
        query = {***}
        query_string = urlencode(query)

        url = f"{public_api_endpoint}/material/?{query_string}"

        async with httpx.AsyncClient() as client:
            response = await client.get(url) # 재료 준비 API 호출

        if response.status_code != 200: # 응답 오류
            raise Exception(response.json())

        result = response.json()["data"]

        yield json.dumps({
            "step": "재료 준비",
            "result": result
        })+ "\n" # 진행 상황 전송, '\n'으로 전송이 끝났음을 표시


        #### 물 끓이기 ####
        url = f"{public_api_endpoint}/water_boil/"

        async with httpx.AsyncClient() as client:
            response = await client.get(url) # 물 끓이기 API 호출

        if response.status_code != 200: # 응답 오류
            raise Exception(response.json())

        result = response.json()["data"]

        yield json.dumps({
            "step": "물 끓이기",
            "result": result
        })+ "\n" # 진행 상황 전송, '\n'으로 전송이 끝났음을 표시


        #### 이후 내용 중략... ####


    except Exception as e:
        yield json.dumps({
            "step": "파스타 요리 실패",
            "result": str(e),
        })+ "\n"


@router.get(
    "/pasta/",
    summary="***",
    description="***",
    tags=["Pasta"],
    responses={
        200: {
            "description": "***",
            "content": {
                "application/json": {
                    "example": {
                        "step": "",
                        "result": {
                            "": ""
                        },
                    }
                }
            },
        },
        422: { # 실제로 422 에러를 날리지는 않지만, 요리 실패 시를 명시하기 위해
            "description": "Fail to cooking a pasta",
            "content": {
                "application/json": {
                    "example": {
                        "step": "파스타 요리 실패",
                        "result": "A error message",
                    }
                }
            },
        },
    },
)
async def pasta(***):
    return StreamingResponse(
        pasta_cooking(***), 
        media_type="text/event-stream"
    )

🤯 새로운 처리 방식

새로운 처리 방식을 들여 온 이유는 단지 배포한 Streamlit 웹앱에서 문제가 생겼기 때문이다. (근데 문제 원인은 프론트에 작업을 떠넘긴 것이 아니라, '파스타 요리 실패' 응답을 보내는 로직이 모종의 이유로 작동하지 않았기 때문이었다...)

장점

• 백엔드에서 동시성 처리를 해서 프론트엔드로 보내는 것이 일반적인 방식이다.

단점

• FastAPI에서 StreamingResponse로 진행 상황을 전송하는 함수를 동시성 처리하는 코드의 예시를 찾을 수 없었다. (구현이 어려웠음)

새로운 프론트엔드 코드 일부

import os
import json
import requests
import sseclient
from dotenv import load_dotenv
from urllib.parse import urlencode

load_dotenv()
public_api_endpoint = os.getenv("PUBLIC_API_ENDPOINT")

query = {***}
query_string = urlencode(query)

url = (f"{public_api_endpoint}/pasta/?{query_string}&pasta_num=4"
with requests.get(url, headers={"Accept": "text/event-stream"}, stream=True) as response:
    client = sseclient.SSEClient(response)
    for event in client.events():
        if event.event == "end":
            break # API 응답 종료
        if event.data:
            client_data = json.loads(event.data)
            ## 내용 생략 ##

새로운 백엔드 코드 일부

방식 자체는 '기존 프론트엔드'처럼 동시에 함수를 실행하되, 각각의 진행 상황을 ID를 추가해 Queue에 저장하고 빼내는 방식으로 유사함

import os
from dotenv import load_dotenv
from fastapi import APIRouter
from fastapi.responses import StreamingResponse

import json
import httpx
import asyncio
from typing import AsyncGenerator
from urllib.parse import urlencode

load_dotenv()
public_api_endpoint = os.getenv("PUBLIC_API_ENDPOINT") 
# 배포 시를 고려해 .env를 이용한 전역 변수 사용

router = APIRouter()

async def pasta_cooking(pasta_id: int, queue: asyncio.Queue, ***):
    try:
        #### 재료 준비 ####
        query = {***}
        query_string = urlencode(query)

        url = f"{public_api_endpoint}/material/?{query_string}"

        async with httpx.AsyncClient() as client:
            response = await client.get(url) # 재료 준비 API 호출

        if response.status_code != 200: # 응답 오류
            raise Exception(response.json())

        result = response.json()["data"]

        await queue.put({
            "id": pasta_id,
            "step": "재료 준비",
            "result": result
        })


        #### 물 끓이기 ####
        url = f"{public_api_endpoint}/water_boil/"

        async with httpx.AsyncClient() as client:
            response = await client.get(url) # 물 끓이기 API 호출

        if response.status_code != 200: # 응답 오류
            raise Exception(response.json())

        result = response.json()["data"]

        await queue.put({
            "id": pasta_id,
            "step": "물 끓이기",
            "result": result
        })


        #### 이후 내용 중략... ####


    except Exception as e:
        await queue.put({
            "id": pasta_id,
            "step": "파스타 요리 실패",
            "result": str(e),
        })


async def n_pasta_cooking(
    queue: asyncio.Queue, pasta_num: int
) -> AsyncGenerator[str, None]:
    pasta_finish = 0 # 실패/완성된 파스타 수
    while pasta_finish < pasta_num:
        data = await queue.get()
        if data["step"] == "파스타 요리 실패" or data["step"] == "파스타 요리 완성":
            pasta_finish += 1
        yield f"data: {json.dumps(data)}\n\n"

    yield "event: end\ndata: Stream closed\n\n" # 파스타 요리 종료


@router.get(
    "/pasta/",
    summary="***",
    description="***",
    tags=["Pasta"],
    responses={
        200: {
            "description": "***",
            "content": {
                "application/json": {
                    "example": {
                        "id": 0,
                        "step": "",
                        "result": {
                            "": ""
                        },
                    }
                }
            },
        },
        422: { # 실제로 422 에러를 날리지는 않지만, 요리 실패 시를 명시하기 위해
            "description": "Fail to cooking a pasta",
            "content": {
                "application/json": {
                    "example": {
                        "id": 0,
                        "step": "파스타 요리 실패",
                        "result": "A error message",
                    }
                }
            },
        },
    },
)
async def pasta(***, pasta_num: int = 1):
    queue: asyncio.Queue = asyncio.Queue()

    pasta_set = []
    for i in range(pasta_num):
        pasta_id = i
        pasta = asyncio.create_task(pasta_cooking(pasta_id, queue, ***))
        pasta_set.append(pasta)

    return StreamingResponse(
        n_pasta_cooking(queue, pasta_num), media_type="text/event-stream"
    )

분명 공식 문서에서의 설명이나 이런 시도를 했던 누군가를 찾을 수 있지 않을까 싶었지만 (GPT 마저도...), 결국 찾지 못해서 구현에 시간이 오래 걸렸다. 구현 자체는 프론트엔드에서의 동시성처리가 백엔드로 넘어간 것뿐이라서 고생에 비해 크게 달라진 것이 없는게 아쉬울 뿐이다.

1. 첫 번째 이유는 단순히 가설이었다.

   • n 파리미터를 통해 받는 n개의 응답은 서로 unique하지 않을까?

   • 서로 다른 n개의 응답이 필요한데, 단지 temperature와 top_p를 올리는 것만으로는 해결이 안되었기 때문이다.

   • 결론은 대충 예상하긴 했지만 n번 호출과 비슷하게 작동하는 것으로 보였다. (동일한 응답이 존재했기 때문...)

     
     

2. 두 번째 이유는 input tokens에서의 이점이다.

   • 확인 결과, input tokens는 n 파라미터 사용 시가 1회 호출 시와 동일했기 때문
   • 하지만 당연하게도 completion tokens는 n회 만큼 증가했다.

😥 문제의 배경

1. LangChain 라이브러리의 JsonOutputParser 사용
   • 지금이야 OpenAI에서 Structured Output을 제공하지만, 몇달 전만해도 그렇지하지 않았기 때문에...
   • 아마 이것도 곧 OpenAI의 Structured Output을 이용하도록 변경할 듯

2. 공식 문서에서의 JsonOutputParser에 n 파라미터를 붙이는 것으로 n 파라미터가 작동하지 않음
   • 공식문서 링크: https://python.langchain.com/v0.2/docs/how_to/output_parser_json/
   • 기존 코드의 요약본은 아래와 같다. (민감한 부분은 ***로 블라인드 처리)

     from langchain_core.prompts import ChatPromptTemplate
     from langchain_core.prompts import PromptTemplate
     from langchain_core.output_parsers import JsonOutputParser
     from langchain_core.pydantic_v1 import BaseModel, Field
     

prompt = ChatPromptTemplate.from_messages( [ ("system", "***"), ("user", "{user_input}"), ] )

llm = ChatGooroomeeAI(model="***") model = prompt | llm.bind(temperature=1.0, maxTokens=1000, n=4)

async def gen(prompt_template, ): output_parser = JsonOutputParser(pydantic_object=OutputFormat) prompt = PromptTemplate( template=prompt_template, input_variables=[ "", "*", "*", ], partial_variables={ "format_instructions": output_parser.get_format_instructions() }, )

chain = prompt | model | output_parser
response = chain.invoke(
    {
        "***": ***,
        "***": ***,
        "***": ***,
    }
)
return response

class OutputFormat(BaseModel): : str = Field(description="") : str = Field(description="") process: dict[str, str] = Field( description="""응답 생성 과정으로, 'Step _'을 key로 하고 해당 Step의 과정을 진행한 내용을 value로 한다. 응답 예시) Step 1: 응답 생성 과정의 첫번째 과정 진행, Step 2: 응답 생성 과정의 두번째 과정 진행, ...""" )

<br>

### 😎 문제 해결 방법
1. 먼저 동일한 문제를 겪는 사람을 구글 검색을 통해 찾았다. ~~(경험 상 이런 문제는 GPT가 크게 도움이 되지 않기 때문에...)~~
    * 그리고 두 개를 찾을 수 있었다. 해당 링크는 아래 첨부한다.
    * 링크 1: https://github.com/langchain-ai/langchain/issues/6227
    * 링크 2: https://github.com/langchain-ai/langchain/issues/8789

<br>

2. 해결 코드 작성 과정은 아래와 같다.
    1. 먼저 위 코드처럼 
    ```python
    chain = prompt | model | output_parser
    ```
    이렇게 pipe로 연결된 경우에서 chain.\_generate()를 호출할 수가 없었다.

    <br>

    2. 따라서 링크 1의 내용처럼
    ```python
    response = llm._generate([[message]])
    ```
    위의 프롬프트 내용을 message로 변경해야했다.

    <br>

    3. 그 뒤로는 계속 변수 type 문제 때문에 헤맸었다. ~~(계속 호출이 불가능한 type이네 뭐네 오류 메세지가 떴음)~~ 사실 n개의 응답을 개별로 분리해 parsing하는 부분에서도 헤맸었다.

    <br>

    4. 결과적으로 해당 문제를 해결한 코드는 아래와 같다.
```python
from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import JsonOutputParser
from langchain_core.pydantic_v1 import BaseModel, Field

llm = ChatOpenAI(model="***", temperature=1.0, max_tokens=2000, n=4)
# max_tokens 값을 올려야 응답이 중간에 끊기는 것을 방지 가능

async def gen(prompt_template, ***):
    output_parser = JsonOutputParser(pydantic_object=OutputFormat)
    prompt = ChatPromptTemplate.from_messages(
        [
            ("system", "***"),
            ("user", prompt_template), # 바로 prompt_template 사용
        ]
    )

    response = llm._generate( # llm._generate 호출
        prompt.invoke( # prompt에 변수 삽입
            {
                "***": ***,
                "***": ***,
                "***": ***,
                "format_instructions": output_parser.get_format_instructions(),
            }
        ).to_messages() # message로 형식으로 변경
    )

    ## n개의 응답을 parsing하고 dict으로 분리 ##
    response_dict = {}
    for idx, res in enumerate(response.generations):
        response_dict[idx] = output_parser.parse(res.text) 
        # outputParser를 이용한 parsing

    return response_dict

나와 동일한 방식으로 ChatPromptTemplate을 사용하면서 n 파라미터를 사용하려고 시도한 경우를 찾지 못해서 해결에 난항을 겪었었다. 이 글을 보게 될 다른 이는 금방 해결할 수 있기를 바라며 글을 남긴다.

langchain n param langchain n param not work

1. 상단 검색바에 EC2 검색

2. 왼쪽 사이드 바에서 인스턴스 클릭

3. 우상단 인스턴스 시작 클릭

4. 인스턴스 이름 작성 후, Ubuntu 선택

5. 키 페어 생성 후, 저장 필수! 이후 인스턴스를 SSH로 접속하려면 필요하다.

6. Anaconda 설치를 해야하기에 16GiB로 설정

7. 인스턴스 시작 클릭

   
   

SSH로 인스턴스 접속

1. 생성한 인스턴스 체크 후, 우상단 인스턴스 시작 클릭

2. SSH 클라이언트 탭 선택 후, 아래 예를 복사한다.

3. Windows PowerShell을 열어서 복사한 내용을 붙여넣고, 키 페어의 위치에 맞게 경로를 수정한다.

Conda 설치

1. https://www.anaconda.com/download/success 에서 다운로드 링크를 우클릭해서 복사한다.

2. wget [복사한 링크]로 아나콘다를 다운로드한다.

3. 다운로드 받은 파일을 sh로 실행한다.

4. conda 명령어 설정을 한다. vi ~/.bashrc로 .bashrc 편집기를 열고

   파일의 맨 마지막에 아래 문구를 넣는다.

   export PATH=~/anaconda3/bin:~/anaconda3/condabin:$PATH

   source ~/.bashrc로 수정한 내용을 적용한다. conda -V를 실행해서 버전이 확인되면 끝!

   만약 버전 확인이 안되는 경우, 인스턴스를 중지했다가 다시 시작한다.

5. conda 가상 환경 접속 python --version으로 설치된 버전을 확인 후, conda create -n [이름] python=[버전]로 가상환경을 만든다.

   conda update -n base -c defaults conda로 conda를 업데이트하고 conda activate [이름]로 가상 환경에 접속한다.

Streamlit 실행

1. git clone [깃허브 주소]로 실행할 streamlit app 파일을 가져온다.

   아마도 private repository라면 로그인을 해야하는데 Password에 token을 넣는다.

   Settings -> Developer settings -> Personal acess tokens -> Tokens (classic)에서 새 token을 만든다. token을 만들 때는 repo, read:org, gist에 체크를 해준다.

   생성된 token은 한번만 보여지니 안전한 곳에 저장하자.

   
   

2. Streamlit 설치

   sudo apt update
   sudo apt upgrade
   sudo apt install python3-pip
   pip install streamlit

   을 순서대로 실행하고

   streamlit app 파일이 있는 디렉토리로 이동해서 streamlit run [실행파일].py를 실행한다.

   이때 필요한 라이브러리가 있다면 설치해준다. ex) langchain 등

   
   

3. 이때 그냥 실행하면 Windows Powershell을 종료했을 때 Streamlit 또한 같이 종료되기 때문에,

   nohup streamlit run [실행파일].py

   으로 실행할 수도 있다.

   나중에 streamlit app 실행을 종료하려면

   ps -ef | grep streamlt
   kill -9 [PID 값]

   을 입력하면 된다.

페이지 접속

1. 보안 규칙 수정 파란색 글씨로 표시된 (launch-wizard-4)를 클릭한다.

   이후 인바운드 규칙 편집으로 들어가서 아래 사진처럼 HTTPS, HTTP와 사용자 지정 TCP에서 8501 포트(Streamlit이 사용하는 포트)를 추가해준다.

2. 퍼블릭 IPv4 주소를 복사하고 뒤에 :8501 덧붙여 주소에 붙여넣으면 접속할 수 있다.

문제 해결 강의에서 leetcode의 Single Number와 비슷한 문제 해결 고민을 한 내용을 정리해 보았다. 이후에 Single Number 문제를 해결한 코드를 제시하겠다.

문제 내용 요약은 아래와 같다.

자연수가 여러 개 제시된다. 이때 하나의 수만 한 개만 제시되고, 나머지 수들은 두 개씩 제시된다. 한 개만 제시된 수를 구하라.

A안) 한 인덱스의 짝 존재 여부 확인

(정렬없이) 인덱스 0의 짝 존재 여부 확인 -> 인덱스 1의... -> 인덱스 2의... -> 인덱스 n-1의... 를 순서대로 확인하는 방법이다.

이때, 확인된 짝의 인덱스를 범위 밖의 값으로 변경하거나 linked list 자료형을 이용해 아예 값을 제공하는 방법으로 약간 시간을 줄일 수 있을 것 같다.

시간 복잡도는 O($n^2$)이다.

B안) check 배열 이용

check 배열을 따로 두고 해당 배열의 인덱스를 제공되는 수로 생각하여, 수가 확인되면 값을 1로 다시 확인되면 0으로 바꾸는 방법이다.

결론적으로 check 배열에서 홀로 값이 1인 인덱스 값이 답이 된다.

시간 복잡도는 O($n$)이다.

다만, 입력 범위가 작을 때 유효한 방법이고, 입력 값의 범위가 크다면 메모리 초과 위험이 발생한다.

C안) 정렬 이후 확인

O($n logn$) 시간 복잡도의 정렬 알고리즘을 사용해 정렬하고, 연속된 두 수가 짝을 이루는 지 확인하는 방법이다.

시간 복잡도는 O($nlogn$)이다.

D안) Hashing

Hashing을 이용하는 방법이다. Hash 함수를 잘 구현한다면 시간복잡도를 O($n$)으로 낮출 수 있으며, check 배열을 사용하는 B안에 비해서 메모리 사용을 줄일 수 있다.

다만, 구현 방법이 굉장히 까다로울 것이다.

E안) 비트 연산 이용

비트 연산 중에서 ^(Xor)를 이용하는 방법이다. 같은 두 수를 ^(Xor)하면 0이 되고, 결합 법칙(세 수 이상의 연산에서 순서를 바꿔도 결과가 동일)이 성립한다.

따라서 제시된 모든 수를 ^(Xor)하고 난 뒤 남은 수는 한 개만 제시된 수이다.

Single Number 문제 해결 코드

🔗https://leetcode.com/problems/single-number/

int singleNumber(int* nums, int numsSize) {
    /* using check array */
    char pos[300001] = {0};
    char neg[300001] = {0};

    for (int i = 0; i < numsSize; i++) {
        if (nums[i] >= 0)
            pos[nums[i]] = pos[nums[i]] == 0? 1 : 0; // toggle
        else
            neg[-nums[i]] = neg[-nums[i]] == 0? 1 : 0; // toggle
    }

    for (int i = 0; i < 300001; i++) {
        if (pos[i] == 1)
            return i;

        if (neg[i] == 1)
            return -i;
    }

    return 0;
}

위의 코드는 leetcode의 Single Number 문제의 경우, 입력 범위가 작기 때문에 간단한 B안을 이용해서 해결한 것이다.

반면, 아래 코드는 비트 연산자를 이용해 해결해 보았다.

int singleNumber(int* nums, int numsSize) {
    /* using bitwise operator */
    int target = nums[0];
    for (int i = 1; i < numsSize; i++)
        target ^= nums[i];

    return target;
}

실행 시간의 경우, check 배열을 이용하는 코드가 13ms, 비트 연산을 이용하는 코드가 11ms가 나온다.

🔗https://github.com/BanYeah/BanYeah?tab=readme-ov-file

시작

먼저 본인의 GitHub 아이디로 된 Public 레포지토리를 만든다. 이때, README.md 파일 추가 옵션에 체크한다.

그리고 해당 README.md 파일에 아래 내용들을 채우면 된다.

Header 꾸미기

🔻 예시 코드

![header](https://capsule-render.vercel.app/api?type=venom&color=2B2D3D&height=200&section=header&text=BanYeah.&fontColor=000000&fontSize=64&stroke=BE95E4)

아래 링크에서 🔗https://github.com/kyechan99/capsule-render 사용한 속성에 대한 설명을 확인할 수 있다. (아래는 type 속성 값마다 header의 형태)

GitHub Stats와 많이 사용한 언어

🔻 예시 코드

<a href="https://github.com/BanYeah"><img align="center" style="height:180px" src="https://github-readme-stats.vercel.app/api?username=BanYeah&show_icons=true&include_all_commits=true&theme=material-palenight&hide_border=true" alt="BanYeah's github stats" /></a>
<a href="https://github.com/BanYeah"><img align="center" style="height:180px" src="https://github-readme-stats.vercel.app/api/top-langs/?username=BanYeah&layout=compact&theme=material-palenight&hide_border=true" /></a>

(바로가기를 위해, a 태그를 추가)

아래 링크에서 🔗https://github.com/anuraghazra/github-readme-stats/blob/master/themes/README.md theme 종류를 확인할 수 있다.

프로그래밍 역량

🔻 예시 코드 일부

### Languages
<img src="https://img.shields.io/badge/c-A8B9CC?style=flat-square&logo=c&logoColor=white"> </t>
<img src="https://img.shields.io/badge/c++-00599C?style=flat-square&logo=cplusplus&logoColor=white"> 
<img src="https://img.shields.io/badge/Python-3776AB?style=flat-square&logo=Python&logoColor=white"/>  </br>
<img src="https://img.shields.io/badge/CSS3-1572B6?style=flat-square&logo=CSS3&logoColor=white"/>  </t>
<img src="https://img.shields.io/badge/HTML5-E34F26?style=flat-square&logo=HTML5&logoColor=white"/> 
<img src="https://img.shields.io/badge/JavaScript-F7DF1E?style=flat-square&logo=JavaScript&logoColor=white"/>
<img src="https://img.shields.io/badge/TypeScript-3178C6?style=flat-square&logo=TypeScript&logoColor=white"/>

아래 링크에서 브랜드별 로고와 색상을 확인하고 🔗https://simpleicons.org/?q=vel

<img src="https://img.shields.io/badge/{배지에 표시할 글자}-{색상}?style=flat-square&logo={브랜드 이름}&logoColor=white">

위 코드의 { } 내부를 채우면 된다.

배지 style의 종류는 아래와 같다. 🔗https://shields.io/badges/ansible-role

Solved.ac 프로필

🔻 예시 코드

[![Solved.ac프로필](http://mazassumnida.wtf/api/v2/generate_badge?boj=04smailing)](https://solved.ac/04smailing)

아래 링크에서 자세한 내용을 확인할 수 있다. 🔗https://github.com/mazassumnida/mazassumnida

자신만의 독창적인 GitHub 프로필을 꾸미는데 도움이 되었길 바랍니다.

GDB 사전 준비

먼저 gdb를 Ubuntu에 설치한다.

$ sudo apt update
$ sudo apt upgrade
$ sudo apt install gdb

그리고 어셈블리어를 편하게 보기 위해서, gdb plugin인 gef를 설치해주었다. 아래 링크를 참고해서 설치하면 된다. https://github.com/hugsy/gef

GDB 실행

Ubuntu에서 실행파일을 gdb로 실행한다.

$ gdb ./실행파일

본인은 AT&T 문법이 더 편해서 따로 설정했다.

$ set disassembly-flavor att

main 함수 확인

$ disas main

프로그램 시작

$ start

내가 실행하는 파일은 _start부터 실행되었다. 따라서 main 함수부터 확인하기 위해서, main 함수 맨 위에 breakpoint를 설정하고, breakpoint까지 이동했다.

$ b main
$ r

gdb 종료

$ quit

GDB 명령어

1. 프로그램 시작

   $ start

   
   

2. 프로그램 실행

   $ r
   OR
   $ run

   breakpoint가 있다면 그 위치에서 멈춘다.

   
   

3. 명령어 하나씩 실행

   $ si
   OR
   $ step

   이때, 함수를 호출한다면 함수 내부로 들어간다.

   
   

$ ni

반대로, ni는 함수를 호출하더라도 함수 내부로 들어가지 않는다.

$ si 5

이렇게 5줄을 실행할 수도 있다.

4. 현재 함수를 완료

   $ fin
   OR
   $ finish

   
   

5. breakpoint 설정

   $ b *0x12a3
   OR
   $ b *main+0

   
   

6. breakpoint 나열

   $ i b

   
   

7. breakpoint 제거

   $ del 1

   위에서 1은 6번에서 확인한 breakpoint Num이다.

   
   

8. breakpoint까지 실행

   $ continue 1

   
   

메모

lea  0xb51(%rip), %rsi
mov  %rbx, %rdi
call ... <strcspn@plt>

로 첫 번째 인자로 %rbx 값을, 두 번째 인자로 0xb51(%rip)를 준 상황일 때, 0xb51(%rip)의 값을 확인하는 방법은 다음과 같다.

$ x/s $rip + 0xb51