개발일기장

OpenAI LLM API: Responses, Chat Completions, Batch

NickTop — Sat, 25 Apr 2026 23:47:47 +0900

LLM API에는 아직 하나의 공식 표준이 없다. 하지만 OpenAI의 Chat Completions 형식은 너무 널리 쓰이게 되면서 사실상 표준처럼 자리 잡았다. 그래서 대부분의 LLM 서비스는 Chat Completions와 호환되게 LLM Endpoint를 제공한다

Chat Completions API

오랫동안 OpenAI 기반 챗봇 개발의 표준처럼 사용되던 방식.

messages 배열의 입력을 받고 각 message는 system, user, assistant 같은 role을 가진다

대화를 구성하는 메시지 목록을 주면 모델이 응답을 반환한다

SDK 함수는 실제로 /v1/chat/completions를 호출한다

from openai import OpenAI

client = OpenAI()

completion = client.chat.completions.create(
    model="gpt-5",
    messages=[
        {"role": "system", "content": "너는 친절한 고객 응대 챗봇이야"},
        {"role": "user", "content": "OpenAI와 Anthropic 모델의 차이가 뭐야?"}
    ]
)

print(completion.choices[0].message.content)

Responses API

기존에 채팅을 위한 API(chat completions)와 복잡한 기능 수행을 위한 Assistant API가 분리되어있었지만, 에이전트 구축에 용이하도록 Responses API로 병합했다

https://openai.com/ko-KR/index/new-tools-for-building-agents/

새로운 프로젝트를 구축중이라면 Responses API를 쓰도록 권장한다.

단, 오디오는 아직 지원하지 않기 때문에 chat completions를 써야한다

가장 큰 특징은 아래와 같다

- Built-in tool : 예) web_search

- Seamless multi-turn

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-5",
    instructions="너는 친절한 고객 응대 챗봇이야",
    input="OpenAI와 Anthropic 모델의 차이가 뭐야?"
)

print(response.output_text)

그러면, 대화이력은 어떻게 보낼수있을까?

기존 chat completions처럼 배열로 보내도 되지만, previous_response_id를 쓰면 어플리케이션 입장에서 대화이력을 저장소에 담지 않아도 된다

from openai import OpenAI

client = OpenAI()

response1 = client.responses.create(
    model="gpt-5",
    instructions="너는 친절한 고객 응대 챗봇이야",
    input="OpenAI와 Anthropic 모델의 차이가 뭐야?",
    store=True
)

response2 = client.responses.create(
    model="gpt-5",
    instructions="너는 친절한 고객 응대 챗봇이야",
    input="조금 더 자세히 설명해줘",
    previous_response_id=response1.id,
    store=True    
)

tool 사용시 tools 파라미터에 넣어주면 된다. web_search는 기본제공한다

answer = client.responses.create(
    model="gpt-5.5",
    input="Who is the current president of France?",
    tools=[{"type": "web_search"}]
)

print(answer.output_text)

https://developers.openai.com/api/docs/guides/migrate-to-responses

Batch API

즉각적인 응답이 필요없을때 쓸수있다

여러개의 요청을 동시에 보낸다

https://developers.openai.com/api/docs/guides/batch

OAuth란

NickTop — Sat, 21 Mar 2026 16:15:15 +0900

OAuth란?

OAuth 2.0는 제3자 애플리케이션이 HTTP 서비스에 대해 제한된 접근 권한을 얻을 수 있게 한다.

(출처 : https://datatracker.ietf.org/doc/html/rfc6749)

유의할 점은, OAuth는 인증이 아니라 권한부여를 토큰으로 표준화한 방식이다

LinkedIn OAuth

OAuth를 처음 접하면 "구글로 로그인 = OAuth"처럼 보이지만, 정확히 말하면 비밀번호를 공유하지 않고도, 필요한 권한만 위임해서 API를 안전하게 호출하는 것이다.

OAuth가 해결하려는 문제

Linkedin을 구글을 통해 로그인 할때 다음과 같이 할 수 있다

OAuth 이전 사용자 정보 조회

이 방식은 다음 문제가 크다.

- 제3자(Linkedin)가 비밀번호를 보관하게 됨
- 최소권한(조회만 허용 등) 통제 어려움
- 사고 시 피해 범위가 큼

OAuth는 이를 토큰(access token)으로 바꿔 해결합니다

OAuth Role

괄호안의 내용은 위 예시와 매핑한것이다

resource owner(User) : 자원(사용자 정보)의 주인

resource server(Google) : 자원을 제공하는 서버

client(Linkedin) : 자원을 가져오려는 애플리케이션

authorization server(Google) : 클라이언트에게 액세스 토큰을 발급하는 서버. authorization server와 resource server가 다를 수도 있고 같을 수도 있다.

OAuth 흐름

OAuth 기본흐름

기본적인 흐름은 위와 같다.

"인증"을 어떻게 하는지는 서비스마다 다르게 구현되어있다

여기서 Access Token마다 어떤 resource까지 제공할 수 있는지 제한되어있다.

예를들어, 어떤 Access Token로는 이름까지만 제공가능하고 어떤 Access Token은 이름과 이메일이 제공가능하다

OAuth + OIDC

OAuth + OIDC 플로우

OIDC : OAuth2.0에서 확장된 ID 인증 프로토콜

1) 사용자가 Linkedin에서 “Google로 로그인”을 누른다

이때 Linkedin은 구글 로그인 페이지로 브라우저를 리다이렉트
중요한 점: 사용자가 구글 ID/PW를 입력하는 곳은 구글 화면이고, Linkedin은 비밀번호를 절대 받지 않음

2) Linkedin → Google /authorize 요청(브라우저 프론트 채널)

client_id: "이 요청은 LinkedIn 앱에서 왔다"
redirect_uri: "로그인 결과를 LinkedIn의 이 주소로 돌려줘"
scope=openid email profile: "로그인(OIDC) + 기본 프로필/이메일을 원해"

4) Google → LinkedIn으로 code 전달(브라우저 리다이렉트)

구글은 아래정보와 함께 Linkedin의 redirect_uri로 돌려보냄

code=... (짧은 수명의 1회용 코드)
state=... (요청 때 보낸 state와 동일해야 함)

Linkedin은 여기서 state가 일치하는지 확인해서 "중간에 누가 끼어든 요청"을 막음

5) LinkedIn → Google /token 교환(서버-서버 백채널)

이제 Linkedin 서버가 구글에 code를 토큰으로 교환

구글은 보통 다음을 반환:

id_token (JWT): "이 사용자는 누구다"를 서명된 형태로 증명
access_token: 사용자 정보 같은 구글 리소스 API 호출용

6) LinkedIn이 id_token을 검증하고 사용자 계정을 연결한다

Linkedin은 id_token을 검증

서명 검증(구글이 진짜 발급했는지)
iss(발급자), aud(수신자=Linkedin), exp(만료) 확인

그리고 구글 계정의 고유 식별자를 통한 계정 매핑

8) 최종: LinkedIn이 자체 세션을 만들어 로그인 완료

LinkedIn은 “구글 토큰”을 그대로 쓰는 게 아니라,
최종적으로 LinkedIn 서비스용 세션(쿠키/세션 토큰) 을 발급해서 로그인 상태를 유지해.

3-legged(사용자 대행) vs 2-legged(서비스 대 서비스)

OAuth에 꼭 end user가 껴있지는 않다

3-legged OAuth: 사용자 대행(사용자 동의가 존재)
Access token의 의미: 사용자가 A어플리케이션에게 이 scope로 B어플리케이션의 자원 접근을 허락했다.

2-legged OAuth: A 시스템이 "자기 자신 자격"으로 토큰을 발급받아 B API를 호출, 이때 사용자가 관여하지 않는다

Access Token의 의미 : A 서비스는 이 scope로 B API를 호출할 권한이 있다

LLM이 Temperature=0으로 고정했는데도 결과가 바뀌는 이유

NickTop — Sat, 31 Jan 2026 22:41:44 +0900

https://github.com/jhong92-pro/llm-batch-invariance/blob/main/llm-batch-invariance.ipynb

결합법칙

LLM의 대부분 연산은 matmul / reduction인데, GPU에서는 병렬 합산이 일어나며 합치는 순서가 바뀌면 반올림 오차가 달라질 수 있다

import torch
a = torch.Tensor([1e16])
b = torch.Tensor([-1e16])
c = torch.Tensor([1])

print("(a + b) + c :" , (a + b) + c)
print("a + (b + c) :" , a + (b + c))

(a + b) + c : tensor([1.])
a + (b + c) : tensor([0.])

수학적으로는 둘 다 1이어야 할 것 같지만, floating-point에서는 반올림 때문에 결과가 달라질 수 있음

Batch invariance

M, K, N = 512, 512, 512

A0 = torch.randn(M, K, device=device, dtype=dtype)
B0 = torch.randn(K, N, device=device, dtype=dtype)
C_single = A0 @ B0

def make_batched_inputs(batch_size: int):
    A = torch.randn(batch_size, M, K, device=device, dtype=dtype)
    B = torch.randn(batch_size, K, N, device=device, dtype=dtype)
    A[0].copy_(A0)
    B[0].copy_(B0)
    return A, B

batch_sizes = [1,2,3,4,5,6,7,8,9,10,100,1000]

for B in batch_sizes:
    A, Bmat = make_batched_inputs(B)
    C_batch = torch.bmm(A, Bmat)
    diff = C_batch[0] - C_single
    max_abs = diff.abs().max().item()
    l2 = torch.norm(diff).item()
    same = torch.allclose(C_batch[0], C_single, atol=1e-5, rtol=1e-5)
    print(f"Batch {B}: max_abs_diff={max_abs}, l2_diff={l2}, allclose={same}")

Batch 1: max_abs_diff=0.0, l2_diff=0.0, allclose=True
Batch 2: max_abs_diff=0.0001068115234375, l2_diff=0.005174573510885239, allclose=False
Batch 3: max_abs_diff=0.0001068115234375, l2_diff=0.005174573510885239, allclose=False
...
Batch 1000: max_abs_diff=0.0001068115234375, l2_diff=0.005174573510885239, allclose=False

Batch=1 이후로는 결과가 약간 다르다

커널/연산 전략 차이로 인한 FP 오차차이가 생기기 때문이다

torch.profiler로 operation을 확인하면 아래와 같다

[single (bmm)] GEMM-related ops: ['aten::bmm', 'ampere_sgemm_32x32_sliced1x4_nn']
[batched (bmm, B=2)] GEMM-related ops: ['aten::bmm', 'ampere_sgemm_128x128_nn']
[batched (bmm, B=200)] GEMM-related ops: ['aten::bmm', 'ampere_sgemm_128x128_nn']

간단한 transformer를 만들어서 실험해봐도 layer output이 달라진다(깃허브 코드 참고)

B=1: max_abs=4.882812e-03, l2=1.297607e-01 (worst layer_3)
B=4: max_abs=5.859375e-03, l2=1.132202e-01 (worst layer_3)
B=8, 16: exact match (all zeros)
B=32: max_abs=3.906250e-03, l2=7.080078e-02 (worst layer_1)

꼭, 배치가 커질수록 크게 달라지지는 않는다

GPT-2 테스트

모델: gpt2-medium
decoding: greedy(argmax)
baseline: batch=2
비교: batch=3,4,7,8,16,32
배치 구성: 0번은 동일 prompt, 나머지는 distractor(다른 질문들)

def build_batch(batch_size: int, prompt: str):
    """index0 : prompt / rest : DISTRACTORS"""
    if batch_size == 1:
        return [prompt]
    need = batch_size - 1
    return [prompt] + DISTRACTORS[:need]

"Tell me about yourself.\nanswer : " input에서 바로 flip이 관측된다

=== prompt 1/103, Flip checks (vs baseline) ===
Baseline(B=2) : I'm a professional artist. I'm a professional ...
batch=3: FLIPS at steps: [ 4  5  6  7  8  9 10 11 12 13 14 15 16 17 18]...
batch=4: FLIPS at steps: [ 4  5  6  7  8  9 10 11 12 13 14 15 16 17 18]...
batch=7: FLIPS at steps: [ 4  5  6  7  8  9 10 11 12 13 14 15 16 17 18]...
...

[Baseline B=2 top-k]
  '\xa0': -90.499222
  ' young': -90.501602
  ' writer': -90.504623
  ' woman': -90.577217
  ' student': -90.678535
  ' man': -90.699829
  ' guy': -90.841461
  ' professional': -90.907951
  ' twenty': -91.086029
  ' 22': -91.121254
[Batch B=3 top-k]
  ' young': -90.602028
  ' writer': -90.617401
  '\xa0': -90.664429
  ' woman': -90.695312
  ' student': -90.778191
  ' man': -90.795197
  ' guy': -90.942856
  ' professional': -91.005234
  ' twenty': -91.189301
  ' 22': -91.211235
  ...

분류 모델도 애매한 샘플에서는 top-1과 top-2의 차이가 작아질 수 있지만, 보통 결정은 한 번만 내리고 그 결과가 다음 입력으로 피드백되지 않는다. 반면 LLM은 토큰을 여러 번 연속으로 선택해야 하고, next-token 분포에서 top-1/top-2 마진이 작은 순간이 자주 나타난다. 그래서 아주 작은 수치 차이(배치/커널/반올림)가 특정 스텝에서 top-1을 바꾸면 토큰 flip이 발생하고, 그 flip이 이후 생성 과정 전체로 누적 및 증폭되기 쉽다.

실무적으로 왜 중요할까?

요청 단위로 caching할 때, 항상 같은 답을 기대하면 깨질 수 있음
golden set 평가를 배치로 돌릴 때, 배치 크기나 배치 구성(정렬/섞임)에 따라 결과가 미세하게 달라짐
실제로는 수치 오차/커널 선택 문제지만, 관측되는 현상은 '남이 뭐 넣었냐에 따라 내 답이 바뀐다'로 보임

사내 교육용 자연어처리 ppt

NickTop — Tue, 21 Oct 2025 23:50:18 +0900

자연어처리기초발표자료.pptx

0.64MB

수학적인 내용은 없애고 개념 및 용어들에 친숙해질수있도록 내용구성했습니다

Spring Boot: WebClient vs RestTemplate

NickTop — Tue, 30 Sep 2025 21:55:28 +0900

Spring Boot에서 외부 API를 호출할 때 가장 많이 쓰이는 두 가지가 있습니다.
RestTemplate과 WebClient입니다.

RestTemplate : 오래된 방식 (동기/블로킹)
WebClient : 새로운 방식 (Spring 5에서 새로 추가, 비동기/논블로킹, Spring WebFlux 기반)

RestTemplate

Spring 3부터 제공된 오래된 HTTP 클라이언트
동기(Blocking) 방식 : 요청이 끝날 때까지 스레드가 대기
요청을 보낼 때마다 스레드를 점유 (1000개의 요청을 한번에 받으려면 1000개의 스레드 필요)
트래픽이 많으면 스레드 풀을 크게 잡아야함

	public static void main(String[] args) {
		RestTemplate restTemplate = new RestTemplate();
		String url = "https://www.naver.com";

		ResponseEntity<String> response =
				restTemplate.getForEntity(url, String.class);

		System.out.println(response.getBody());
	}

WebClient

특징

Spring 5 (WebFlux)에서 새로 추가된 HTTP 클라이언트
비동기(Non-blocking) 방식 지원
Reactor 기반 - Mono/Flux 리액티브 타입으로 결과 반환 (아직 도착하지 않은 값 표현, 코드 작성이 상대적으로 어려움)
동기/비동기 둘 다 가능
이벤트루프 기반 : 하나의 스레드가 여러 작업 상태 변화를 감시하고 처리가능한 작업을 전달, 즉 하나의 스레드로 여러 작업 처리 가능

    public static void main(String[] args) {
        WebClient webClient = WebClient.create("https://www.naver.com");

        Mono<String> response = webClient.get()
                .retrieve()
                .bodyToMono(String.class);

        // 비동기 실행 → subscribe
        response.subscribe(System.out::println);

        // 동기로 결과 받기
        String result = response.block();
        System.out.println("동기 결과: " + result);
    }

요약

RestTemplate은 아직도 사용중이지만, 성능은 webclient가 더 좋기 때문에 spring에서는 Webclient를 쓰는것을 권유하고 있습니다

RestTemplate is in maintenance mode, with only requests for minor changes and bugs to be accepted. Please, consider using the WebClient instead.

https://docs.spring.io/spring-framework/reference/6.0/integration/rest-clients.html

LoadRunner로 WebSocket(STOMP) 부하 테스트하기

NickTop — Fri, 29 Aug 2025 21:57:11 +0900

로드러너

LoadRunner는 기업에서 가장 널리 쓰이는 성능·부하 테스트 도구 중 하나입니다.

VuGen (Virtual User Generator)
- 가상의 사용자 스크립트 작성·녹화 도구
- 웹, 모바일, DB, 메시징, WebSocket 등 다양한 프로토콜 지원
Controller
- 시나리오 설계 및 실행
- 동시 사용자 수, 부하 패턴(증가·감소), 런타임 설정 제어
Load Generators
- 실제로 Vuser 부하를 발생시키는 엔진
- 분산 환경에서 여러 대를 동시에 동작시켜 대규모 트래픽 발생 가능
Analysis
- 실행 결과를 그래프·리포트로 시각화
- 응답 시간, TPS, 자원 사용량 비교·분석

테스트 대상 어플리케이션

아래와 같은 환경에서 테스트를 진행합시다

[브라우저]<--SockJS-->[서버(WsEndpoint)]→STOMP 프로토콜→[메시지 핸들러]

아래 github 예시가 있어서 가져왔습니다

https://github.com/zacscoding/spring-websocket-random-chat/tree/master

아래와 같은 흐름입니다

1. Join버튼으로 접속

2. 다른 사용자가 Join을 할때까지 기다림

3. 2명의 사용자가 Join버튼을 눌렸다면 서버가 두 사용자에게 chatRoomId 발급

4. chatRoomId로 웹소켓 연결

5. 채팅시작

user를 변수로 설정할 수 없어서 코드를 약간 수정했습니다

https://github.com/jhong92-pro/spring-websocket-random-chat

VuGen

글은 OpenText_Performance_Engineering_25.3_Community_Edition로 작성했습니다 (회사에서 쓰는 버전이랑은 다름)

처음켜면 New Script and Solution으로 스크립트를 생성합니다

첫 생성

화면 상단 Record > Record를 클릭합니다

브라우저가 실행되는데, 여기서 실행되는 모든 이벤트가 코드로 생성됩니다

Record

recording 화면

저는 Action.h에 스크립트를 생성하겠습니다

vuser_init은 vuser가 처음 생성될때 실행되는 스크립트이고

action은 부하테스트할 transaction을 명시하는 부분입니다

vuser가 없어질때 vuser_end가 실행됩니다

회사에서는 URL address에 localhost:8080/#user4를 입력하면 해당 페이지로 넘어갔던것같은데 안되네요

채팅 연결을 해주어야하기때문에 다른 브라우저 localhost:8080/#user3 열어서 join까지 눌려줬습니다

그리고 record되는 브라우저에서는 join눌리고 Hello까지 send합니다

그리고 녹화를 종료합니다

vugen 화면 녹화

여기까지 완료하면 Action.h에 스크립트가 생깁니다

(브라우저에 따라 스크립트가 다르게 생성될 수 있습니다)

Action()
{

	web_set_sockets_option("SSL_VERSION", "AUTO");

	web_url("seed", 
		"URL=https://clientservices.googleapis.com/chrome-variations/seed?osname=win&channel=stable&milestone=139", 
		"Resource=0", 
		"Referer=", 
		"Snapshot=t17.inf", 
		"Mode=HTML", 
		LAST);

	lr_think_time(5);

	web_url("localhost:8080", 
		"URL=http://localhost:8080/", 
		"Resource=0", 
		"RecContentType=text/html", 
		"Referer=", 
		"Snapshot=t18.inf", 
		"Mode=HTML", 
		EXTRARES, 
		"Url=/favicon.ico", ENDITEM, 
		"Url=https://content-autofill.googleapis.com/v1/pages/ChVDaHJvbWUvMTM5LjAuNzI1OC4xMzkSGQm5Nc-FPgmrixIFDbXFZk8hIWaXE1v3UzI=?alt=proto", "Referer=", ENDITEM, 
		LAST);

	web_custom_request("user1", 
		"URL=http://localhost:8080/join/user4", 
		"Method=GET", 
		"Resource=0", 
		"RecContentType=application/json", 
		"Referer=http://localhost:8080/", 
		"Snapshot=t19.inf", 
		"Mode=HTML", 
		LAST);

	web_url("info", 
		"URL=http://localhost:8080/chat-websocket/info?t=1756466220884", 
		"Resource=0", 
		"RecContentType=application/json", 
		"Referer=http://localhost:8080/", 
		"Snapshot=t20.inf", 
		"Mode=HTML", 
		EXTRARES, 
		"Url=https://content-autofill.googleapis.com/v1/pages/ChVDaHJvbWUvMTM5LjAuNzI1OC4xMzkSIAkf41AQ3bHCORIFDbXFZk8SBQ0ZM-ltIQAtAEQDk8TN?alt=proto", "Referer=", ENDITEM, 
		LAST);

	web_custom_request("xhr_streaming", 
		"URL=http://localhost:8080/chat-websocket/264/3aheysmp/xhr_streaming?t=1756466221550", 
		"Method=POST", 
		"Resource=0", 
		"RecContentType=application/javascript", 
		"Referer=http://localhost:8080/", 
		"Snapshot=t21.inf", 
		"Mode=HTML", 
		"EncType=", 
		LAST);

	web_websocket_connect("ID=0", 
		"URI=ws://localhost:8080/chat-websocket/264/20xkw5rr/websocket", 
		"Origin=http://localhost:8080", 
		"SecWebSocketExtensions=permessage-deflate; client_max_window_bits", 
		"OnOpenCB=OnOpenCB0", 
		"OnMessageCB=OnMessageCB0", 
		"OnErrorCB=OnErrorCB0", 
		"OnCloseCB=OnCloseCB0", 
		LAST);

	
	/*Connection ID 0 received buffer WebSocketReceive0*/

	web_websocket_send("ID=0", 
       "Buffer=[\"CONNECT\\nuserId:user4\\nchatRoomId:4ba9f87a-c749-436d-90e0-899091e6a432\\naccept-version:1.1,1.0\\nheart-beat:10000,10000\\n\\n\\u0000\"]",
		"IsBinary=0", 
		LAST);

	/*Connection ID 0 received buffer WebSocketReceive1*/

	web_websocket_send("ID=0", 
       "Buffer=[\"SUBSCRIBE\\nid:sub-0\\ndestination:/topic/chat/4ba9f87a-c749-436d-90e0-899091e6a432\\n\\n\\u0000\"]",
		"IsBinary=0", 
		LAST);
	
	lr_think_time(5);

	web_websocket_send("ID=0", 
       "Buffer=[\"SEND\\ndestination:/app/chat.message/4ba9f87a-c749-436d-90e0-899091e6a432\\ncontent-length:66\\n\\n{\\\"messageType\\\":\\\"CHAT\\\",\\\"senderSessionId\\\":\\\"user4\\\",\\\"message\\\":\\\"Hello\\\"}\\u0000\"]",
		"IsBinary=0", 
		LAST);

	/*Connection ID 0 received buffer WebSocketReceive2*/

	return 0;
}

회사에 있는 버전은 web_websocket_send를 자동으로 만들지 못했었는데 이러한 경우, 브라우저 네트워크 탭을 복사하여 코드를 넣으면 됩니다.

브라우저 탭에 있는 웹소켓 자체가 Array에 감싸진 String이라 그대로 복사 붙여넣기 하면 오류가 나고 []를 넣고 "와 \는 escape하여 넣어야합니다.

스크립트 수정

몇까지 수정 포인트가 있습니다

첫번째로 chatRoomId가 상수가 아닌 API respone를 통해 변수로 받아야합니다

web_reg_save_param 를 통해서 변수를 받을 수 있습니다

left와 right boundary를 지정하고, 이후 response중에서 left와 right boundary가 있으면 감지하여 변수로 저장합니다

	web_reg_save_param("chatRoomId",
	    "LB=\"chatRoomId\":\"",    // Left boundary
	    "RB=\"",                  // Right boundary
	    LAST);

	web_custom_request("user8", 
		"URL=http://localhost:8080/join/user8", 
		"Method=GET", 
		"Resource=0", 
		"RecContentType=application/json", 
		"Referer=http://localhost:8080/", 
		"Snapshot=t12.inf", 
		"Mode=HTML", 
		LAST);

이렇게 하면 "chatRootId": 와 "사이에 있는 값을 chatRoomId라는 변수로 저장합니다

그리고 저장한 변수는 lr_eval_string으로 값을 가져올 수 있습니다

	web_websocket_send("ID=0", 
       lr_eval_string("Buffer=[\"CONNECT\\nuserId:user8\\nchatRoomId:{chatRoomId}\\naccept-version:1.1,1.0\\nheart-beat:10000,10000\\n\\n\\u0000\"]"),
		"IsBinary=0", 
		LAST);

	/*Connection ID 0 received buffer WebSocketReceive1*/

	web_websocket_send("ID=0", 
       lr_eval_string("Buffer=[\"SUBSCRIBE\\nid:sub-0\\ndestination:/topic/chat/{chatRoomId}\\n\\n\\u0000\"]"),
		"IsBinary=0", 
		LAST);


	web_websocket_send("ID=0", 
       lr_eval_string("Buffer=[\"SEND\\ndestination:/app/chat.message/{chatRoomId}\\ncontent-length:66\\n\\n{\\\"messageType\\\":\\\"CHAT\\\",\\\"senderSessionId\\\":\\\"user8\\\",\\\"message\\\":\\\"Hello\\\"}\\u0000\"]"),
		"IsBinary=0", 
		LAST);

두번째는 여러명의 유저로 부하테스트를 하려면 user도 파라미터 처리해야합니다 (나중에 Controller에서 써야함)

화면 좌측 Parameters를 더블클릭합니다

위와 같이 파라미터를 지정합니다

저는 Vuser마다 서로 다른 user 하나만 지정되게 하고 싶어서 select next row와 update value on을 위와 같이 지정했습니다

user 파라미터를 불러옵니다 (web_custom_request에는 lr_eval_string 없어도 {}안에 값 넣으면 알아서 세팅됩니다)

	web_custom_request("user8", 
		"URL=http://localhost:8080/join/{user}", 
		"Method=GET", 
		"Resource=0", 
		"RecContentType=application/json", 
		"Referer=http://localhost:8080/", 
		"Snapshot=t12.inf", 
		"Mode=HTML", 
		LAST);
        
        
        ...
        
        
   	web_websocket_send("ID=0", 
       lr_eval_string("Buffer=[\"CONNECT\\nuserId:{user}\\nchatRoomId:{chatRoomId}\\naccept-version:1.1,1.0\\nheart-beat:10000,10000\\n\\n\\u0000\"]"),
		"IsBinary=0", 
		LAST);

	/*Connection ID 0 received buffer WebSocketReceive1*/

	web_websocket_send("ID=0", 
       lr_eval_string("Buffer=[\"SUBSCRIBE\\nid:sub-0\\ndestination:/topic/chat/{chatRoomId}\\n\\n\\u0000\"]"),
		"IsBinary=0", 
		LAST);


	web_websocket_send("ID=0", 
       lr_eval_string("Buffer=[\"SEND\\ndestination:/app/chat.message/{chatRoomId}\\ncontent-length:66\\n\\n{\\\"messageType\\\":\\\"CHAT\\\",\\\"senderSessionId\\\":\\\"{user}\\\",\\\"message\\\":\\\"Hello\\\"}\\u0000\"]"),
		"IsBinary=0", 
		LAST);

세번째로는 sockJS가 첫 연결할때 (serverId)/(sessionId)형태로 지정하므로 sessionId만 난수로 바꿔줍니다

ws://localhost:8080/chat-websocket/264/20xkw5rr/websocket

#include "time.h"

Action()
{
    char buf[8];
    int i;
    const char charset[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

    srand(time(NULL) + lr_eval_string("{user}"));

    for (i = 0; i < 8; i++) {
        int key = rand() % (int)(sizeof(charset) - 1);
        buf[i] = charset[key];
    }

    lr_output_message("Random string = %s", buf);

    lr_save_string(buf, "randStr");

...


	web_websocket_connect("ID=0", 
      lr_eval_string("URI=ws://localhost:8080/chat-websocket/264/{randStr}/websocket"),
		"Origin=http://localhost:8080", 
		"SecWebSocketExtensions=permessage-deflate; client_max_window_bits", 
		"OnOpenCB=OnOpenCB0", 
		"OnMessageCB=OnMessageCB0", 
		"OnErrorCB=OnErrorCB0", 
		"OnCloseCB=OnCloseCB0", 
		LAST);

char나 int 같은 변수선언은 함수 최상단에 선언해야하며, 중간에 선언할 경우 오류가 발생합니다

마지막으로 content-length는 STOMP 프로토콜에서 바디-길이와 실제 메시지 길이 불일치가 발생할 수 있으므로 없앱니다

	web_websocket_send("ID=0", 
       lr_eval_string("Buffer=[\"SEND\\ndestination:/app/chat.message/{chatRoomId}\\n\\n{\\\"messageType\\\":\\\"CHAT\\\",\\\"senderSessionId\\\":\\\"{user}\\\",\\\"message\\\":\\\"Hello\\\"}\\u0000\"]"),
		"IsBinary=0", 
		LAST);

메시지를 보내는 부분만 부하 테스트 대상으로 한정하기 위해 맨마지막 웹소켓 통신 부분만 Action.h에 두고 나머지는 vuser_init으로 옮긴 최종 코드입니다

vuser_init.c

/* -------------------------------------------------------------------------------
	Script Title       : 
	Script Description : 
                        
                        
	Recorder Version   : 0
   ------------------------------------------------------------------------------- */
#include "time.h"

vuser_init()
{
    char buf[8];
    int i;
    const char charset[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

    srand(time(NULL) + lr_eval_string("{user}"));

    for (i = 0; i < 8; i++) {
        int key = rand() % (int)(sizeof(charset) - 1);
        buf[i] = charset[key];
    }

    lr_output_message("Random string = %s", buf);

    lr_save_string(buf, "randStr");

	web_url("localhost:8080", 
		"URL=http://localhost:8080/", 
		"Resource=0", 
		"RecContentType=text/html", 
		"Referer=", 
		"Snapshot=t11.inf", 
		"Mode=HTML", 
		EXTRARES, 
		"Url=/favicon.ico", ENDITEM, 
		"Url=https://content-autofill.googleapis.com/v1/pages/ChVDaHJvbWUvMTM5LjAuNzI1OC4xMzkSGQm5Nc-FPgmrixIFDbXFZk8hIWaXE1v3UzI=?alt=proto", "Referer=", ENDITEM, 
		LAST);
	
	web_reg_save_param("chatRoomId",
	    "LB=\"chatRoomId\":\"",    // Left boundary
	    "RB=\"",                  // Right boundary
	    LAST);

	web_custom_request("user8", 
		"URL=http://localhost:8080/join/{user}", 
		"Method=GET", 
		"Resource=0", 
		"RecContentType=application/json", 
		"Referer=http://localhost:8080/", 
		"Snapshot=t12.inf", 
		"Mode=HTML", 
		LAST);
	
	lr_output_message(lr_eval_string("{chatRoomId}"));

	web_url("info", 
		"URL=http://localhost:8080/chat-websocket/info?t=1756299447468", 
		"Resource=0", 
		"RecContentType=application/json", 
		"Referer=http://localhost:8080/", 
		"Snapshot=t13.inf", 
		"Mode=HTML", 
		EXTRARES, 
		"Url=https://content-autofill.googleapis.com/v1/pages/ChVDaHJvbWUvMTM5LjAuNzI1OC4xMzkSIAkf41AQ3bHCORIFDbXFZk8SBQ0ZM-ltIQAtAEQDk8TN?alt=proto", "Referer=", ENDITEM, 
		LAST);

	web_websocket_connect("ID=0", 
      lr_eval_string("URI=ws://localhost:8080/chat-websocket/264/{randStr}/websocket"),
		"Origin=http://localhost:8080", 
		"SecWebSocketExtensions=permessage-deflate; client_max_window_bits", 
		"OnOpenCB=OnOpenCB0", 
		"OnMessageCB=OnMessageCB0", 
		"OnErrorCB=OnErrorCB0", 
		"OnCloseCB=OnCloseCB0", 
		LAST);

	/*Connection ID 0 received buffer WebSocketReceive0*/

	web_websocket_send("ID=0", 
       lr_eval_string("Buffer=[\"CONNECT\\nuserId:{user}\\nchatRoomId:{chatRoomId}\\naccept-version:1.1,1.0\\nheart-beat:10000,10000\\n\\n\\u0000\"]"),
		"IsBinary=0", 
		LAST);

	/*Connection ID 0 received buffer WebSocketReceive1*/

	web_websocket_send("ID=0", 
       lr_eval_string("Buffer=[\"SUBSCRIBE\\nid:sub-0\\ndestination:/topic/chat/{chatRoomId}\\n\\n\\u0000\"]"),
		"IsBinary=0", 
		LAST);



	return 0;
}

Action.h

Action()
{
	web_websocket_send("ID=0", 
       lr_eval_string("Buffer=[\"SEND\\ndestination:/app/chat.message/{chatRoomId}\\n\\n{\\\"messageType\\\":\\\"CHAT\\\",\\\"senderSessionId\\\":\\\"{user}\\\",\\\"message\\\":\\\"Hello\\\"}\\u0000\"]"),
		"IsBinary=0", 
		LAST);

	return 0;
}

또한, vuser_init에서 연결한 websocket은 action.h에서 연결이 끊기기 때문에 Runtime Settings > Browser Emulation > Simulate a new user on each iteration 체크해제합니다

Browser Emulation

마지막으로 Run Logic에서 iteration을 5로 하여 실제로 5번 호출되는지 테스트 해봅시다

스크립트를 실행하고 브라우저에서 localhost:8080으로 접속하여 join을 눌립니다

스크립트 테스트

Controller

이제 Vugen 스크립트 설정이 끝났으므로 Controller를 들어갑시다

간단하게 Manual Scenario를 씁시다

Controller Schedule 설정

Scenario Groups : VuGen의 스크립트를 불러옵니다. 여러 스크립트를 사용할 수 있습니다

Scenario Schedule : Vuser를 설정합니다. 스크립트마다 다르게 설정할 수도 있고 똑같이 설정할 수도 있습니다.

Start Vusers를 아래와 같이 설정했다면, 총 10명의 Vuser가 생성되고, 1부터시작하여 10까지 1초간격으로 추가로 생성된다는 뜻입니다

Start Vusers 화면

아래처럼 설정하고 돌려보겠습니다

(추가적으로 webhttphtml1 오른쪽 마우스 > runtime setting > pacing > 1초로 지정하며 각 action을 1초 간격으로 실행하게 했습니다)

Vuser 설정

Vuser를 홀수개만 설정하고 하나는 브라우저에서 localhost:8080/#user10으로 띄워서 실제로 잘 돌아가는지 봅시다

websocket 응답여부 확인

websocket statistics

이후 Loadrunner Analysis로 결과를 볼 수 있습니다 (생략)

웹소켓은 Response time이나 오류를 감지하기 힘들기 때문에 다른 방법으로 SLA 측정을 해야 합니다.
따라서 메시지가 정상적으로 DB에 적재되는지, 로그에 누락이나 지연이 없는지를 별도로 확인하는 방식으로 성능을 검증해야 합니다.

PEFT : Parameter Efficient Fine-Tuning

NickTop — Sat, 14 Jun 2025 19:13:59 +0900

거대모델은 pretrained 모델을 파인튜닝하는데 리소스가 많이 소요됩니다

따라서 일부 파라미터만 파인튜닝합니다

또한 N개의 task별로 N개의 모델이 존재한다면 효율적이지 못합니다

대부분의 파라미터는 유지한채로, 변경되는 부분만 바꾼다면 리소스를 효율적으로 사용할 수 있습니다

Adapter

Parameter-Efficient Transfer Learning for NLP : 2019

https://arxiv.org/pdf/1902.00751

adapter architecture

Task별로 adapter부분만 fine tuning합니다

아래와 같이 단순히 맨 마지막 layer만 fine tuning 할때보다 더 성능이 좋습니다

fine tuning top layers vs adapter

하지만 inference에서 추가적인 adapter에 따른 latency가 있습니다

BitFit

https://arxiv.org/pdf/2106.10199

BitFit: Simple Parameter-efficient Fine-tuning for Transformer-based Masked Language-models (2021)

BitFit 실험 결과

BitFit : BIas-Term FIne-Tuning

말 그대로 각 task별로 bias만 업데이트 시킵니다

bias는 전체파라미터중 0.08%의 비중입니다. 하지만 뛰어난 성능을 보입니다

Base model은 Bert입니다

Prefix Tuning

Prefix-Tuning: Optimizing Continuous Prompts for Generation : 2021

https://arxiv.org/pdf/2101.00190

prefix tuning methodology

모든 레이어의 앞 쪽 N개의 토큰만 파인튜닝합니다

base모델은 BART와 GPT입니다

Prompt Tuning

The Power of Scale for Parameter-Efficient Prompt Tuning: 2021

https://arxiv.org/pdf/2104.08691

prompt tuning architecture

Pretrained Model은 건드리지 않습니다

각 task마다 추가적인 k개의 토큰을 입력 앞에 넣습니다

추가적인 k개의 토큰만 파인튜닝합니다. 논문에서는 5개의 토큰만 써도 충분하다고 합니다 (20,480 추가 parameter)

논문상에서 직접적으로 prefix tuning에 비해 parameter efficient라고 하는 반면 정확도에 대한 언급은 없습니다

base모델은 T5입니다

LoRA

https://arxiv.org/pdf/2106.09685

LORA: LOW-RANK ADAPTATION OF LARGE LANGUAGE MODELS (2021)

LoRA architecture

pretrained weight는 고정시키고 A와 B만 학습합니다 (W_new = W + AB)

설계에 따라 r을 변경하면서 tunable parameter수를 조절할 수 있습니다

장점은 다른 방법들과 달리 inference에서 latency가 아예 없습니다

왜냐하면 W_new = W + AB를 미리 계산할 수 있기 때문입니다

대부분의 task에서 full fine tuning과 비교했을떄 퍼포펀스 drop이 거의 없거나 LoRA가 조금 더 앞섭니다

PEQA

Memory-Efficient Fine-Tuning of Compressed Large Language Models via sub-4-bit Integer Quantization : 2023

https://arxiv.org/pdf/2305.14152

Quantization을 고려합시다

LoRA는 learnable parameter수를 줄였지만 어쨌든 학습을 위해서 전체 W는 메모리에 올라가있어야 합니다

QAT : 전체 파라미터를 학습해야 함

PEFT → PTQ : PEFT 중에는(학습중에는) quantization으로 인한 memory 감소 효과를 볼순 없음 (물론 inference단계에선 경량화 효과 있음)

PTQ → PEFT : 학습중에는 quantization으로 인한 memory 감소 효과를 볼 수 있지만, inference 단계에서 메모리 절감 효과를 볼 수 없음(?)

PEQA architecture

quantization 후 scale만 학습함

DynamicViT: Efficient Vision Transformers with Dynamic Token Sparsification

NickTop — Sun, 18 May 2025 16:33:21 +0900

Overview

https://arxiv.org/pdf/2106.02034

DynamicViT는 토큰 사이즈를 줄여 네트워크를 효율화하는 방식입니다

각 이미지패치가 결과에 어느정도의 영향을 주는지 파악하는 MLP를 만들어 영향이 적은 패치를 사용하지 않도록 합니다

overview of Dynamic ViT

Methodology

Prediction Module

$\hat{D} \in (0,1)^N$

N : number of Token

C : size of token

D는 현재 이미지 패치가 마스킹된 결과값입니다

$\textbf{z}^{local} = MLP(\textbf{x}) \in \mathbb{R}^{N \times C'}$

C' = C/2

$\textbf{z}^{global} = Agg(\textbf{z}^{local},\hat{D}) \in \mathbb{R}^{C'}$

Agg는 단순히 평균을 낸것입니다

local은 각 패치의 정보이고 global은 전체 이미지에 대한 정보입니다

두 값을 다시 MLP에 넣어 값이 낮은 토큰을 drop합니다

$\textbf{z}_i = [\textbf{z}_i^{local},\textbf{z}_i^{global}]$

$\textbf{\pi} = Softmax(MLP(\textbf(z)) \in mathbb{R}^{N \times 2}$

각 토큰에 대한 결과는 [P(keep), P(prune)] i.e.) [0.88, 0.12] 로 나옵니다

local을 얻는데 쓰인 MLP

LayerNorm → Linear(C, C/2) → GELU

keep, prune확률을 구하는데 쓰인 MLP

Linear(C, C/2) → GELU → Linear(C/2, C/4) → GELU → Linear(C/4, 2) → Softmax

참고로, 모든 stage별로 MLP는 동일합니다

pruning은 모든 layer에 적용되진 않았고 3개의 stage로 했을때 성능이 좋았다고 합니다

[ρ, ρ^2, ρ^3]로 점진적으로 pruning을 적용했으며 4개이상의 stage에서 gain은 없었다고 합니다

stage별 실험결과

Attention Masking

D를 0과 1로만 정의하면 미분불가능합니다

Gumbel-Softmax를 적용했습니다

D = Gumbel-Softmax(π)

또다른 문제가 있는데 각 이미지 토큰에 마스킹을 적용하더라도 self-attention을 구할때 softmax를 통과하면 마스킹한 효과를 주지 못합니다

i.e)

softmax([-2,-4,1,-1,1] ⊙ [1,1,0,0,1] ) = [0.0278, 0.00376, 0.2053, 0.2053, 0.5580]

즉 masking을 했지만 softmax를 통과하면 0이 아님

따라서 기존의 Attention ($A=softmax(\frac{QK^T}{\sqrt{C}})$)을 다음과 같이 변경합니다

${\begin{aligned}
\mathbf{P} &= \mathbf{QK}^T / \sqrt{C} \in \mathbb{R}^{N\times N}, \\
\mathbf{G}_{ij} &=
\begin{cases}
1, & i = j, \\[6pt]
\hat{\mathbf{D}}_{j}, & i \neq j.
\end{cases} \\[10pt]
\tilde{\mathbf{A}}_{ij} &= \frac{\exp(\mathbf{P}_{ij}) \mathbf{G}_{ij}}{\sum_{k=1}^{N}\exp(\mathbf{P}_{ik}) \mathbf{G}_{ik}},
\end{aligned}
}$

$A_{i,j}$의 의미가 i토큰을 참조할때 j가 얼마나 중요한지를 나타냅니다

j번째 토큰을 프루닝했다면 중요도가 0이 되는 것을 위 식에서 알 수 있습니다

pruning 학습할때는 연산을 위해 각 layer에서 전체 number of token을 유지하고, inference할때는 실제로 입력 토큰을 없앱니다

Loss

총 4개의 loss를 씁니다

기본 prediction 계산

$\mathcal{L}_{\text{cls}} = \text{CrossEntropy}(y, \hat{y})$

각 토큰을 teacher의 token과 똑같이 만듬 (왜 하는건진 잘 모르겠음)

$\mathcal{L}_{\text{distill}} = \frac{1}{\sum_{b=1}^{B} \sum_{i=1}^{N} \hat{\mathbf{D}}^{b,S}_i}\sum_{b=1}^{B} \sum_{i=1}^{N} \hat{\mathbf{D}}^{b,S}_i \left( t_i - t'_i \right)^2$

teacher model과 loss를 일치시키기 위한 KL divergence

$\mathcal{L}_{\text{KL}} = \text{KL}(\mathbf{y} \parallel \mathbf{y}')$

프루닝 될 토큰 개수를 구하기 위한 ρ_ratio Loss

$\mathcal{L}_{\text{ratio}} = \frac{1}{BS} \sum_{b=1}^{B} \sum_{s=1}^{S} \left( \rho^{(s)} - \frac{1}{N} \sum_{i=1}^{N} \hat{\mathbf{D}}^{b,s}_i \right)^2$

Visualization

실험결과에 대한 visualization

이미지를 구별하기 위한 배경 부분은 프루닝되고 이미지만 남음

Kernel Ridge Regression

NickTop — Tue, 6 May 2025 16:21:13 +0900

Ridge Regression

$\underset{\beta}{min} ||Y-\beta X|| +\lambda ||\beta||^2$

기존의 regression식에 정규화를 더한다

정규화 수식은 베타가 작은 값을 유지하게 만든다

베타가 작아지면 작은 x의 변화로 y가 크게 변하지 않는다

이를 통해 오버피팅을 방지한다

Kernel Ridge Regression

Primal Form

linear한 수식이 아닌 일반적인 식에 대해 생각해보자 $y = \phi(x)$

$\underset {\omega}{min} ||Y - \Phi \omega|| + \lambda ||\omega||^2$

(Y는 1*n 벡터입니다)

$\Phi \in \mathbb{R}^{n \times D}$

$\omega \in \mathbb{R}^{D}$

n은 데이터셋 개수, D는 특성 개수 (y = [w1,w2,w3,w4] (내적) [x1,x2,x3*x1,x1*x2]으로 풀 수 있고 이때 D=4)

미분가능한 함수가 최대 또는 최소를 가지는 지점은 미분이 0이 될때임 (2차함수를 생각하면 쉬움)

$L = ||Y - \Phi \omega|| + \lambda ||\omega||^2$

$\frac {\partial L}{\partial w} = -2\Phi^T(Y-\Phi w) + 2\lambda \omega =0$

위를 풀면

$\omega = (\Phi^T\Phi + \lambda I)^{-1}\Phi^TY$

Dual Form

일반적으로 kernel ridge regression은 dual form을 가리키는 말이다

https://en.wikipedia.org/wiki/Woodbury_matrix_identity

woodbury 행렬 항등식을 쓰면 $\omega$를 다음과 같이 정의할 수 있다

$\omega = \Phi^T(\Phi \Phi^T + \lambda I)^{-1}Y$

이를 예측식에 대입하면

$y = \phi(x)^T \omega =( \Phi \phi(x))^T(\Phi \Phi^T + \lambda I)^{-1}Y$

여기서 kernel을 다음과 같이 정의할 수 있습니다

$K = \Phi \Phi^T$

$K_{ij} = k(x_i,x_j)$

kernel은 위와같이 두 입력값을 통한 수식입니다

최종 예측값은

$\hat y(x) = [k(x_1,x),k(x_2,x),...,k(x_n,x)]^T(K+\lambda I)^{-1}Y$

그럼 이걸 왜 쓸까 -> 고차원 특징을 명시적으로 설계하지 않아도 됨

D가 너무 커지면 연산량이 너무 많아집니다

K의 차원은 n*n이기 때문에 feature에 weight를 곱한 모델을 만들지 않아도 됩니다

즉, feature를 설계하는 것이 아닌 kernel을 설계하는 것입니다

대표적으로는 RBF가 있습니다

https://en.wikipedia.org/wiki/Radial_basis_function_kernel

Radial basis function kernel - Wikipedia

From Wikipedia, the free encyclopedia Machine learning kernel function In machine learning, the radial basis function kernel, or RBF kernel, is a popular kernel function used in various kernelized learning algorithms. In particular, it is commonly used in

en.wikipedia.org

Dataset Distillation

NickTop — Thu, 1 May 2025 15:01:31 +0900

https://arxiv.org/pdf/1811.10959

Introduction

MNIST와 cifar10 distillation 결과

dataset으로부터 가짜이미지를 만들어 적은 이미지로도 모델을 학습합니다

model poisioning

특정 label(plane)을 attack하는 이미지를 만들어 gradient step하나만 돌려 모델의 정확도를 낮출 수도 있습니다

Approach

$\theta_1 = \theta_0 - \tilde{\eta} \nabla_{\theta_0} \ell(\tilde{\mathbf{x}}, \theta_0) $ : weight는 가짜 데이터 (synthetic data)로만 학습됩니다

$\tilde{\mathbf{x}}^*, \tilde{\eta}^* = \arg\min_{\tilde{\mathbf{x}}, \tilde{\eta}} \mathcal{L}(\tilde{\mathbf{x}}, \tilde{\eta}; \theta_0) = \arg\min_{\tilde{\mathbf{x}}, \tilde{\eta}} \ell (\mathbf{x}, \theta_1) = \arg\min_{\tilde{\mathbf{x}}, \tilde{\eta}} \ell(\mathbf{x}, \theta_0 - \tilde{\eta} \nabla_{\theta_0} \ell(\tilde{\mathbf{x}}, \theta_0)) $

$\arg\min_{\tilde{\mathbf{x}}, \tilde{\eta}} \ell (\mathbf{x}, \theta_1)$ : 실제 데이터 x의 loss가 줄어드는 방향으로 synthetic data와 learning rate를 선택합니다

계산

gradient를 계산하는 방법을 살펴봅시다

${\begin{align}
\frac {\partial L}{\partial \tilde{x}} &= \frac{\partial L}{\partial \theta_1} \frac{\partial \theta_1}{\partial \tilde{x}} \\
&= \frac{\partial L}{\partial \theta_1} (\frac {\partial}{\partial \tilde x}(\theta_0 - \tilde \eta \nabla \ell (\tilde x, \theta_0))) \\
&= \frac{\partial L}{\partial \theta_1} (\frac{\partial \theta_0}{\partial \tilde x} - \tilde \eta \frac{\partial^2 \ell (\tilde x, \theta_0))}{\partial \tilde x \partial \theta_0}) \\
&=-\tilde \eta \frac{\partial L}{\partial \theta_1} \frac{\partial^2 \ell (\tilde x, \theta_0))}{\partial \tilde x \partial \theta_0}
\end{align} }$

approach에서 weight가 한번만 업데이트 되었지만, 실제로는 여러번 업데이트 됩니다

$\theta_t$ 상태에서 $\theta_T$가 되었다고 합시다 (T-t번 업데이트됨)

그리고 한번 업데이트할때 s만큼의 데이터를 쓴다고 합시다

${\theta_{s+1} = \theta_s - \tilde{\eta}_s \nabla_{\theta_s} \ell(\tilde{\mathbf{x}}, \theta_s)}$

미분하면

${\frac {\partial \theta_{s+1}}{\partial \theta_s} = I - \tilde \eta_s H_s}$

이를 반영하면

${\begin{align}
\frac {\partial L}{\partial \tilde x} &= \frac {\partial L}{\partial \theta_T}\frac {\partial \theta_T}{\partial \theta_{T-1}}\frac {\partial \theta_{T-1}}{\partial \theta_{T-2}}...\frac {\partial \theta_{t+2}}{\partial \theta_{t+1}} \frac {\partial \theta_{t+1}}{\partial \tilde x} \\
&=\frac {\partial L}{\partial \theta_T} \prod_{s=t+1}^{T}(I-\tilde\eta_sH_s) (-\tilde\eta_t \frac{\partial^2 \ell (\tilde x, \theta_t))}{\partial \tilde x \partial \theta_t})
\end{align}}$

하지만 실험과정에서 위와 같이 얻은 synthetic data를 다른 weight initialization에 사용했을때 문제가 있었다고 합니다.

그래서 여러개의 weight initialization에 대해서 synthetic data를 업데이트 했다고 합니다

N개의 weight initialization에 대해 synthetic data를 업데이트 했다고 합시다

논문에서 최종 loss는 아래와 같이 계산됩니다

${\begin{align}
\frac {\partial L}{\partial \tilde x}
&=\sum^N_{i=1} \frac {\partial L}{\partial \theta_T^{(i)}} \prod_{s=t+1}^{T}(I-\tilde\eta_s^{(i)}H_s^{(i)}) (-\tilde\eta_t^{(i)} \frac{\partial^2 \ell (\tilde x, \theta_t^{(i)}))}{\partial \tilde x \partial \theta_t^{(i)}}) \\
\end{align}}$

$\tilde \eta$도 학습되는 파라미터입니다

비슷한 방법으로 계산하면

${\frac {\partial L}{\partial \tilde \eta_t^*}=\frac {\partial L}{\partial \theta_T} \prod_{s=t+1}^{T}(I-\tilde\eta_sH_s) (- \frac{\partial \ell (\tilde x, \theta_t))}{ \partial \theta_t})}$