kongbuhaneunJiye

JPA(3) - 영속성 컨텍스트

ji._.ye — Wed, 24 Apr 2024 18:09:43 +0900

영속성 컨텍스트

영속성 컨텍스트: 엔티티를 영구 저장하는 환경
눈에 보이지 않는 논리적인 개념
엔티티 매니저를 통해서 영속성 컨텍스트에 접근 EntityManager.persist(entity); //엔티티를 DB에 저장하는 것이 아닌 엔티티 컨텍스트에 저장. 엔티티를 영속화한다는 뜻.

엔티티 매니저

엔티티 매니저를 통해 영속성 컨텍스트에 접근
엔티티 매니저와 영속성 컨텍스트는 1:1 또는 N:1 패밍
고객의 요청이 올때마다 EntityManager 생성

J2SE 환경

J2EE  환경

엔티티의 생명주기

비영속 (new/transient)
- 영속성 컨텍스트와 전혀 관계가 없는 새로운 상태
- JPA와 전혀 관련이 없는 상태

영속 (managed)
- 영속성 컨텍스트에 관리되는 상태
- 영속 상태라고해서 바로 DB에 저장되는 것이 아님. DB는 이후에 커밋해야 저장됨.

준영속 (detached)
- 영속성 컨텍스트에 저장되었다가 분리된 상태

삭제(removed)
- 영구저장된 DB에서 삭제된 상태

// 객체를 생성한 상태 (비영속)
Member member = new Member();
member.setId("member1");
member.setUsername("회원1");

EntityManager em = emf.createEntityManager();
em.getTransaction().begin();

//객체를 저장한 상태(영속)
em.persist(member)

//회원 엔티티를 영속성 컨텍스트에서 분리, 준영속 상태
em.detach(member);

//객체를 삭제한 상태(삭제)
em.remove(member);

영속성 컨텍스트의 이점

1. 엔티티 조회, 1차 캐시

엔티티 메니저는 DB트랜잭션 단위로 실행됨.
고객의 요청이 들어오고 이후 비즈니스가 종료되면, 영속성 컨텍스트도 종료되고 1차 캐시도 날라감.
고객이 10명이면 10개의 1차 캐시 생성.

ex) em.persist(entity)

엔티티를 영속화하면 1차 캐시에 저장됨

(바로 DB에 저장되는 것이 아님)

ex) em.find()

조회 요청을 받으면 먼저 DB가 아닌 1차 캐시에 접근.

1차 캐시에 해당 엔티티가 저장되어있는 경우 DB에 접근할 필요 없이 바로 1차 캐시에서 엔티티를 반환.

1차 캐시에 저장된 엔티티를 조회하는 경우

1차 캐시에 해당 엔티티가 없을 경우

→ DB에 접근

→ DB에서 엔티티를 반환하여 1차 캐시에 저장

→ 1차 캐시에 저장된 엔티티를 애플리케이션에 반환

memer2를 해당 트랜잭션 안에서 저장(영속), 조회한 적이 없으므로 1차 캐시에 저장되어있지 않음

DB에 접근하여 엔티티를 반환

2. 영속 엔티티의 동일성 보장

자바 컬렉션에서 주소가 같은 객체를 두 번 조회하면 동일한 객체로 인식하는 것처럼

영속성 컨텍스트에서 하나의 객체를 두 번 조회하면 동일힌 객체로 인식

Member a = em.find(Member.class, "member1");
Member b = em.find(Member.class, "member1");

System.out.println(a == b); // true

3. 엔티티 등록 - 쓰기 지연

엔티티를 등록하면 우선 1차 캐시에 저장했다가 이후 트랜잭션을 커밋하면 캐시에 저장된 엔티티가 한 번에 DB에 저장됨.

버퍼링 개념이라고 보면 됨.

EntityManager em = emf.createEntityManager();
EntityTransaction transaction = em.getTransaction();
//엔티티 매니저는 데이터 변경시 트랜잭션을 시작해야 한다.
transaction.begin(); // [트랜잭션] 시작

em.persist(memberA);
em.persist(memberB);
//여기까지 INSERT SQL을 데이터베이스에 보내지 않는다.

//커밋하는 순간 데이터베이스에 INSERT SQL을 보낸다.
transaction.commit(); // [트랜잭션] 커밋

em.persist(memberA); em.persist(memberB);

transaction.commit();

4. 엔티티 수정 - 변경 감지

JPA는 dirty checking 기능이 있음.

영속성 컨텍스트에서 자동으로 UPDATE쿼리문을 생성하기 때문에 애플리케이션에서 엔티티 수정 후 추가로 em.update(member); 코드를 작성할 필요가 없음

Dirty Checking

애플리케이션에서 엔티티 수정 후 transaction.commmit() 코드 실행

영속 컨텍스트에서 다음과 같이 동작

→ DB에 commit하기 전 flush가 자동으로 실행(영속성 컨텍스트의 변경 내용을 데이터베이스에 반영)

→ flush: 1차 캐시에서 엔티티와 스냅샷 비교

→ flush: 데이터가 바뀌었다면 (dirty == 1, 엔티티와 스냅샷이 다르다면)

UPDATE쿼리문을 '쓰기 지연 SQL 저장소' 에 저장

→ flush: '쓰기 지연 SQL 저장소' 의 쿼리문을 DB에 flush

→ DB에 커밋

EntityManager em = emf.createEntityManager();
EntityTransaction transaction = em.getTransaction();
transaction.begin(); // [트랜잭션] 시작

// 영속 엔티티 조회
//엔티티의 스냅샷이 1차 캐시에 저장됨
//스냅샷: 1차 캐시에 처음으로 저장된 시점의 엔티티
Member memberA = em.find(Member.class, "memberA");

// 영속 엔티티 데이터 수정
memberA.setUsername("hi");
memberA.setAge(10);

//em.update(member) 이런 코드가 있어야 하지 않을까? 필요없음 

transaction.commit(); // [트랜잭션] 커밋

5. 지연 로딩

플러시

플러시
- 영속성 컨텍스트를 비우는 것이 아님
- 영속성 컨테스트의 변경내용을 DB에 동기화 하는 것
- 트랜잭션이라는 작업 단위 안에서 커밋 직전에만 동기화 하면 됨

em.flush() 실행

→ 1차 캐시에서 엔티티와 스냅샷을 비교해 엔티티 변경 감지

→ 수정된 엔티티를 쓰기 지연 SQL저장소에 등록

→ 쓰기 지연 SQL저장소의 쿼리를 데이터베이스에 전송(등록, 수정, 삭제 쿼리)

플러시가 실행되는 경우
- em.flush() - 직접 호출
- 트랜잭션 커밋 - 플러시 자동 호출
- JPQL 쿼리 실행 - 플러시 자동 호출
  - 더보기
```
em.persist(memberA);
em.persist(memberB);
em.persist(memberC);
//중간에 JPQL 실행
query = em.createQuery("select m from Member m", Member.class);
List<Member> members= query.getResultList();
```
  - 더보기
    
    JPQL 쿼리문은 영속성 컨텍스트가 아닌 DB에 접근. 따라서 JPQL 실행 전 flush를 자동으로 호출하여 DB를 update 해야됨

플러시 모드 옵션
1. em.setFlushMode(FlushModeType.AUTO) : 커밋이나 쿼리를 실행할 때 플러시 (기본)
2. em.setFlushMode(FlushModeType.COMMIT) : 커밋할 때만 플러시

준영속 상태

영속 상태: em.persist(), em.find() 에 의해 엔티티가 영속성 컨텍스트의 1차 캐시에 올라온 상태

준영속 상태: 영속 상태의 엔티티가 영속성 컨텍스트에서 분리(detached) 된 상태 영속성 컨텍스트가 제공하는 기능을 사용 못함

준영속 상태로 만드는 방법
- em.detach(entity) 특정 엔티티만 준영속 상태로 전환
- em.clear() 영속성 컨텍스트를 완전히 초기화
- em.close() 영속성 컨텍스트를 종료

DFS / BFS

ji._.ye — Sun, 21 Apr 2024 16:09:22 +0900

DFS

특징

모든 정점을 방문하고자 할 때 사용됨.
재귀(Recursion) 혹은 스택(Stack)을 이용하여 구현.
무방향 그래프나 방향 그래프 모두에 적용.
모든 경로를 탐색하기 때문에 경로의 길이가 길어질 경우에는 BFS에 비해 시간이 오래 걸릴 수 있음.
어떤 경로가 있는지를 확인할 때 사용.

장점

현재 경로 상의 노드들만 기억하면 되므로 메모리 사용량이 적음.
목표 노드가 깊은 단계에 있을 경우 해를 빨리 찾을 수 있음.

단점

최단 경로를 보장하지 않음.
무한 루프에 빠질 수 있음.
그래프가 큰 경우에는 탐색 공간이 너무 커져서 메모리 문제가 발생할 수 있음.

import java.util.ArrayList;
import java.util.List;

public class Graph {
    private int V; // 그래프의 정점 개수
    private List<List<Integer>> adjList; // 인접 리스트

    public Graph(int vertices) {
        this.V = vertices;
        adjList = new ArrayList<>(V);
        for (int i = 0; i < V; i++) {
            adjList.add(new ArrayList<>());
        }
    }

    // 그래프에 간선 추가
    public void addEdge(int source, int destination) {
        adjList.get(source).add(destination);
    }

    // DFS 탐색 메서드
    public void dfs(int vertex, boolean[] visited) {
        visited[vertex] = true;
        System.out.print(vertex + " "); // 방문한 정점 출력

        // 현재 정점과 연결된 모든 정점을 탐색
        for (int neighbor : adjList.get(vertex)) {
            if (!visited[neighbor]) {
                dfs(neighbor, visited); // 재귀적으로 이웃 정점을 탐색
            }
        }
    }

    // DFS 탐색 시작
    public void dfsStart(int start) {
        boolean[] visited = new boolean[V]; // 방문 여부를 저장하는 배열
        dfs(start, visited); // 시작 정점부터 DFS 탐색 시작
    }

    public static void main(String[] args) {
        Graph graph = new Graph(5);
        graph.addEdge(0, 1);
        graph.addEdge(0, 2);
        graph.addEdge(1, 3);
        graph.addEdge(1, 4);

        System.out.println("DFS 탐색 결과:");
        graph.dfsStart(0); // 정점 0에서 시작하여 DFS 탐색 시작
    }
}

BFS

특징

1. 가까운 정점부터 탐색해나가는 알고리즘

2. 큐를 사용하여 구현

시작 정점을 큐에 넣음
큐에서 정점을 하나 꺼내어 방문
방문한 정점과 인접한 모든 정점들을 큐에 넣음
큐가 빌 때까지 위 과정을 반복

장점

시작 정점에서 목표 정점까지의 최단 경로를 찾을 수 있음
그래프의 모든 정점을 방문할 때 유용
깊이가 같은 노드를 모두 방문한 후에 깊이를 증가시키기 때문에, 어떤 경로가 있는지를 확인할 때 사용

단점

DFS보다 많은 메모리를 사용 (큐를 사용하기 때문에)
BFS는 재귀적으로 구현할 수 없음.

import java.util.*;

public class Graph {
    private int V; // 그래프의 정점 개수
    private List<List<Integer>> adjList; // 인접 리스트

    public Graph(int vertices) {
        this.V = vertices;
        adjList = new ArrayList<>(V);
        for (int i = 0; i < V; i++) {
            adjList.add(new ArrayList<>());
        }
    }

    // 그래프에 간선 추가
    public void addEdge(int source, int destination) {
        adjList.get(source).add(destination);
    }

    // BFS 탐색 메서드
    public void bfs(int start) {
        boolean[] visited = new boolean[V]; // 방문 여부를 저장하는 배열
        Queue<Integer> queue = new LinkedList<>(); // BFS를 위한 큐

        visited[start] = true; // 시작 정점 방문 표시
        queue.offer(start); // 시작 정점을 큐에 삽입

        while (!queue.isEmpty()) {
            int vertex = queue.poll(); // 큐에서 정점을 하나 꺼냄
            System.out.print(vertex + " "); // 방문한 정점 출력

            // 현재 정점과 연결된 모든 정점을 탐색
            for (int neighbor : adjList.get(vertex)) {
                if (!visited[neighbor]) {
                    visited[neighbor] = true; // 방문한 정점 표시
                    queue.offer(neighbor); // 방문하지 않은 정점을 큐에 삽입
                }
            }
        }
    }

    public static void main(String[] args) {
        Graph graph = new Graph(5);
        graph.addEdge(0, 1);
        graph.addEdge(0, 2);
        graph.addEdge(1, 3);
        graph.addEdge(1, 4);

        System.out.println("BFS 탐색 결과:");
        graph.bfs(0); // 정점 0에서 시작하여 BFS 탐색 시작
    }
}

Java 라이브러리

ji._.ye — Sun, 21 Apr 2024 12:33:36 +0900

1. String

1-1. 문자열 붙이기, 자르기

String N = "abcd"; 
Sring K = "efgh";
String s = N + K; //O(N+K)
s.substring(5); //"fgh" //O(N)
s.substring(0,3); //"abc"

1-2. 입력

BufferedReader - 입력 라이브러리, String 객체만 다룸

예1) 한 줄 입력, 한 줄에 한 단어

public Class main{
	public static void main(String[] args) throws IOException {
    
     		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            String s = br.readLine();
            
            .
            .
            .

예2) 한 줄 입력, 한 줄에 단어 여러개

public class Main {
    
	public static void main(String[] args) throws IOException {
 
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	    String[] input = br.readLine().split(" ");
        .
        .
        .

예3) Int 입력

BufferedReader는 String 객체만 취급하기 때문에 먼저 String 변수로 문자열을 저장하고 추후에 Integer 객체로 변환해야 한다.

        
public class Main {
	public static void main(String[] args) throws IOException {
 
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int N = Integer.parseInt(br.readLine());
        .
        .
        .

1-3. 출력

StringBuilder - 출력을 담당하는 class, 버퍼를 활용하여 문자열을 문자 시퀀스로 관리

String을 불변객체지만 StringBuilder는 가변객체.

예1) 문자열 하나 반환

import java.io.IOException;

public class Main {

	public static void main(String[] args) throws IOException{
		StringBuilder sb = new StringBuilder();
        
		//문자열 추가
		sb.append("ab"); //ab
	
		//다음 줄 이동
		sb.append("ef\n"); 
		/* 
		abef\n
        	------ 커서는 이 줄에 위치
		*/
		
       		sb.append("ij").append("\n");
		 /*
		 abef\n
        	ij\n
        	------ 커서는 이 줄에 위치
         	*/


		//문자열 삽입 
		sb.insert(2, "2");
		/*
		 ab2ef\n
        	 ij\n
		  ------ 커서는 이 줄에 위치
        	 */

		sb.insert(5, 5);
		/*
		 ab2ef5\n
        	 ij\n
		  ------ 커서는 이 줄에 위치
        	 */
	
		sb.insert(7, 7);
		/*
		 ab2ef5\n
        	 7ij\n
		  ------ 커서는 이 줄에 위치
       	  	*/

		sb.insert(6,6); 
		/*
		 ab2ef56\n
         	7ij\n
		  ------ 커서는 이 줄에 위치
        	 */
		

		//문자 삭제   
		sb.deleteCharAt(7); 
		/*
		 ab2ef567ij\n
	    	------ 커서는 이 줄에 위치
		*/
	
		//문자열 삭제
		sb.delete(8,11); //ab2f567------ 커서는 이 줄에 위치

		//문자열 뒤집기
		sb.reverse(); // 765f2ba

		//문자 교체
		sb.setCharAt(1, 'g'); //7g5f2ba
		
		//문자열 교체
		sb.replace(1,4,"change"); //7change2ba

		//문자열 길이 조정	
		sb.setLength(2); //7c

       
		//문자열 변환
		sb.toString(); //7c

	}  
}

ArrayList

동적 배열 자료구조

중복되는 값 포함 가능

import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        // ArrayList 생성
        ArrayList<String> arrayList = new ArrayList<>();

        // 요소 추가
        arrayList.add("Apple");
        arrayList.add("Banana");
        arrayList.add("Orange");

        // 요소 가져오기
        String firstElement = arrayList.get(0); //Apple 반환 
        
        // 요소 수정
        arrayList.set(1, "Grapes");

        // 요소 제거
        arrayList.remove(1); // 인덱스로 제거
        rrayList.remove("Orange"); // 값으로 제거
        
        // 요소가 포함되어 있는지 확인
        boolean containsBanana = arrayList.contains("Banana");
        
        // 특정 값의 인덱스 확인
        int indexOfGrapes = arrayList.indexOf("Grapes");

        // 사이즈 확인
        int size = arrayList.size();

        // 모든 요소 출력
        for (String element : arrayList) {
            System.out.println(element);
        }

        // ArrayList 비우기
        arrayList.clear();

        // ArrayList가 비어 있는지 확인
        boolean isEmpty = arrayList.isEmpty(); //true반환 
    }
}

LinkedList

dluble linked list 형태로 구현되어있음

요소들은 인덱스 순서를 유지

요소의 삽입, 삭제가 배열에 비해 효율적

인덱스 기반 접근은 ArayList보다 성능이 좋지 않음. 대신, 요소를 순차적으로 접근하는데 적합

메서드는 ArrayList와 동일

HashMap

키-값 쌍을 저장하는 자료구조

특정 키의 값을 검색하거나 저장하는데 사용됨

해시테이블을 기반으로 구현됨

해시 테이블: 키를 해시 함수를 사용해 해시 코드로 변환하고 이 해시 코드를 사용하여 값을 저장하거나 검색

import java.util.HashMap;

public class Main {
    public static void main(String[] args) {
        // HashMap 생성
        HashMap<String, Integer> hashMap = new HashMap<>();

        // 요소 추가
        hashMap.put("Apple", 10);
        hashMap.put("Banana", 20);
        hashMap.put("Orange", 30);

        // 요소 가져오기
        int appleQuantity = hashMap.get("Apple"); //O(1)

        // 요소 수정
        hashMap.put("Banana", 25); // O(1)

        // 요소 제거
        hashMap.remove("Orange"); 

        // 사이즈 확인
        int size = hashMap.size();

        // 모든 요소 출력
        System.out.println("HashMap의 모든 요소:");
        for (String key : hashMap.keySet()) {
            int value = hashMap.get(key);
            System.out.println(key + ": " + value);
        }

        // HashMap에 특정 키가 포함되어 있는지 확인
        boolean containsApple = hashMap.containsKey("Apple"); //O(1)
        
        // HashMap의 모든 키(key) 가져오기
        Set<String> keySet = hashMap.keySet();
   
    }
}

HashSet

Set 인터페이스를 구현

중복 X, 순서 X

해시 테이블을 기반으로 구현

import java.util.HashSet;

public class Main {
    public static void main(String[] args) {
        // HashSet 생성
        HashSet<String> hashSet = new HashSet<>();

        // 요소 추가
        hashSet.add("Apple");
        hashSet.add("Banana");
        hashSet.add("Orange");

        // 중복된 요소 추가
        hashSet.add("Apple"); //O(1)

        // 요소의 개수 확인
        int size = hashSet.size(); //3

        // 요소가 포함되어 있는지 확인 //O(1)
        boolean containsBanana = hashSet.contains("Banana"); // 출력: true

        // 요소 제거
        hashSet.remove("Orange"); //O(1)

        // HashSet이 비어 있는지 확인
        boolean isEmpty = hashSet.isEmpty(); //false

        // 모든 요소 출력
        System.out.println("HashSet의 모든 요소:");
        for (String element : hashSet) {
            System.out.println(element);
        }

        // HashSet 비우기
        hashSet.clear();
    }
}

Stack

LIFO - Lsat In first Out

Vector 클래스를 상속하여 구현

import java.util.Stack;

public class Main {
    public static void main(String[] args) {
        // 스택 생성
        Stack<Integer> stack = new Stack<>();

        // 요소 추가 (push) O(1)
        stack.push(10); //index 1
        stack.push(20); //index 2
        stack.push(30); //index 3

        // 요소 확인 (peek)  O(1)
        int topElement = stack.peek(); //30
        
        // 요소의 인덱스 검색 (search) O(n)
        int index = stack.search(20); //2
        
        // 요소 제거 (pop) O(1)
        int removedElement = stack.pop(); // 30 제거
        
        stack.contains(10); //true, O(n)
        
        // 스택이 비어 있는지 확인 (empty) O(1)
        boolean isEmpty = stack.empty(); // false


        // 스택의 모든 요소 출력
        System.out.println("스택의 모든 요소:");
        while (!stack.empty()) {
            System.out.println(stack.pop());
        }
    }
}

Queue

FIFO - First In First Out

전용 구조체가 존재하지 않음

일반적으로 LinkedList 클래스를 활용해 Queue 인터페이스를 구현

import java.util.Queue;
import java.util.LinkedList;

public class Main {
    public static void main(String[] args) {
        // Queue 생성 (LinkedList를 사용하여 구현)
        Queue<Integer> queue = new LinkedList<>();

        // 요소 추가 (offer) O(1)
        queue.offer(10);
        queue.offer(20);
        queue.offer(30);

        // 요소 확인 (peek) O(1)
        int frontElement = queue.peek(); // 10

        // 요소 제거 (poll) O(1)
        int removedElement = queue.poll(); // 10

        // Queue가 비어 있는지 확인 (isEmpty) O(1)
        boolean isEmpty = queue.isEmpty(); // false

        // Queue의 크기 확인 (size) O(1)
        int size = queue.size(); // 2

        // Queue의 모든 요소 출력
        System.out.println("Queue의 모든 요소:");
        for (int element : queue) {
            System.out.println(element);
        }
    }
}

PriorityQueue

요소를 우선순위에 따라 저장하고 제거

최소 힙을 사용하여 구현됨

중복값 허용

import java.util.PriorityQueue;

public class Main {
    public static void main(String[] args) {
        // PriorityQueue 생성
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();

        // 요소 추가 (offer) O(log n)
        priorityQueue.offer(30);
        priorityQueue.offer(10);
        priorityQueue.offer(20);

        // 요소 확인 (peek) O(1)
        int topElement = priorityQueue.peek(); // 10

        // 요소 제거 (poll) O(log n)
        int removedElement = priorityQueue.poll(); // 10

        // PriorityQueue가 비어 있는지 확인 (isEmpty) O(1)
        boolean isEmpty = priorityQueue.isEmpty(); // false

        // PriorityQueue의 크기 확인 (size) O(1)
        int size = priorityQueue.size(); // 2

        // PriorityQueue의 모든 요소 출력
        System.out.println("PriorityQueue의 모든 요소:");
        while (!priorityQueue.isEmpty()) {
            System.out.println(priorityQueue.poll());
        }
    }
}

Deque(Double-ended Queue)

양쪽 끝에서 삽입과 삭제를 모두 수행할 수 있는 큐(queue)의 확장된 형태

큐(Queue)와 스택(Stack)의 기능을 모두 제공

양쪽에서 요소를 추가하거나 제거

양방향으로 데이터를 처리해야 하는 상황에 매우 유용

ArrayDeque와 LinkedList를 이용하여 인터페이스 구현

addFirst(E e): Deque의 맨 앞에 요소를 추가합니다.
- 시간 복잡도: O(1)
addLast(E e): Deque의 맨 뒤에 요소를 추가합니다.
- 시간 복잡도: O(1)
offerFirst(E e): Deque의 맨 앞에 요소를 추가하고 성공 여부를 반환합니다.
- 시간 복잡도: O(1)
offerLast(E e): Deque의 맨 뒤에 요소를 추가하고 성공 여부를 반환합니다.
- 시간 복잡도: O(1)
removeFirst(): Deque의 맨 앞에 있는 요소를 제거하고 반환합니다.
- 시간 복잡도: O(1)
removeLast(): Deque의 맨 뒤에 있는 요소를 제거하고 반환합니다.
- 시간 복잡도: O(1)
pollFirst(): Deque의 맨 앞에 있는 요소를 제거하고 반환합니다. Deque가 비어 있는 경우 null을 반환합니다.
- 시간 복잡도: O(1)
pollLast(): Deque의 맨 뒤에 있는 요소를 제거하고 반환합니다. Deque가 비어 있는 경우 null을 반환합니다.
- 시간 복잡도: O(1)
getFirst(): Deque의 맨 앞에 있는 요소를 반환합니다. Deque가 비어 있는 경우 NoSuchElementException이 발생합니다.
- 시간 복잡도: O(1)
getLast(): Deque의 맨 뒤에 있는 요소를 반환합니다. Deque가 비어 있는 경우 NoSuchElementException이 발생합니다.
- 시간 복잡도: O(1)
peekFirst(): Deque의 맨 앞에 있는 요소를 반환합니다. Deque가 비어 있는 경우 null을 반환합니다.
- 시간 복잡도: O(1)
peekLast(): Deque의 맨 뒤에 있는 요소를 반환합니다. Deque가 비어 있는 경우 null을 반환합니다.
- 시간 복잡도: O(1)
isEmpty(): Deque가 비어 있는지 확인합니다.
- 시간 복잡도: O(1)
size(): Deque의 크기를 반환합니다.
- 시간 복잡도: O(1)

import java.util.Deque;
import java.util.ArrayDeque;

public class Main {
    public static void main(String[] args) {
        // Deque 생성 (ArrayDeque를 사용하여 구현)
        Deque<Integer> deque = new ArrayDeque<>();

        // 요소 추가 (addFirst / addLast) O(1)
        deque.addFirst(10);
        deque.addLast(20);
        deque.addFirst(5);
        deque.addLast(30);

        // Deque의 모든 요소 출력 O(1)
        System.out.println("Deque의 모든 요소:");
        for (int element : deque) {
            System.out.println(element);
        }

        // 요소 제거 (removeFirst / removeLast) O(1)
        int removedFirst = deque.removeFirst();
        int removedLast = deque.removeLast();

        // Deque의 크기 확인 (size) O(1)
        int size = deque.size();

        // Deque의 모든 요소 출력
        System.out.println("Deque의 모든 요소:");
        while (!deque.isEmpty()) {
            System.out.println(deque.removeFirst());
        }
    }
}

BinarySearch

정렬된 배열에서 원하는 값을 찾는 알고리즘

O(log n)

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] array = {1, 3, 5, 7, 9, 11, 13, 15, 17, 19};

        // 이진 탐색을 위해 배열을 먼저 정렬해야 함
        Arrays.sort(array);

        int key = 13;
        int index = Arrays.binarySearch(array, key);

        if (index >= 0) {
            System.out.println(key + "는 배열의 " + index + "번째 인덱스에 있습니다.");
        } else {
            System.out.println(key + "는 배열에 존재하지 않습니다.");
        }
    }
}

JPA - (1) JPA 소개

ji._.ye — Thu, 18 Apr 2024 20:08:45 +0900

JPA

- Java Pesistence API

- 자바 진영의 ORM 표준 기술

ORM

- 객체와 RDB를 연결하는 프레임워크

- Object-relational mapping(객체 관계 매핑)

- 객체는 객체대로 설계

- 관계형 데이터베이스는 관계형 데이터베이스대로 설계

- ORM 프레임워크가 중간에서 매핑

- 대중적인 언어에는 대부분 ORM 기술이 존재

JPA 동작 방식

애플리케이션 입장에선 자바 컬렉션에 저장하듯이 JPA를 이용하면 됨

JPA의 논리적 구조는 다음과 같음

- 애플리케이션과 JDBC 사이에서 동작

- 저장

- 조회

JPA의 물리적 구조

- JPA는 표준 명세서, 인터페이스의 모음

- JPA의 구현체 : 하이버네이트, EclipseLink, DataNucleus

JPA를 사용해야 하는 이유

1. SQL 중심적인 개발에서 객체 중심으로 개발

애플리케이션 입장에선 자바 컬렉션에 저장하듯이 JPA를 이용하면 됨

2. 생산성 -JPA와 CRUD

• 저장: jpa.persist(member)

• 조회: Member member = jpa.find(memberId)

• 수정: member.setName(“변경할 이름”)

• 삭제: jpa.remove(member)

3. 유지보수

필드 변경시 ...

- 기존: 애플리케이션에서 모든 sql 수정

- JPA: 애플리케이션에선 필드만 추가, sql은 JPA가 처리

4. 패러다임의 불일치 해결

참고:

2024.04.18 - [백엔드/스프링] - JPA - sql 중심적인 개발의 문제점

5. 성능

- 1차 캐시와 동일성(identity) 보장

- 트랜잭션을 지원하는 쓰기 지연(transactional write-behind)

- 지연 로딩(Lazy Loading)

JPA - (0) sql 중심적인 개발의 문제점

ji._.ye — Thu, 18 Apr 2024 19:26:50 +0900

객체의 인스턴스 저장소가 DB인 경우와 자바 컬렉션(list, set)인 경우 코드와 성능에서 크게 차이가 남

저장소가 DB인 경우

애플리케이션은 객체 지향 언어(Java...)를 사용하지만 데이터는 관계형DB에 보관.

애플리케이션과 데이터가 상호작용하기 위해선 객체를 SQL로 변환해 쿼리문을 DB에 전달 해야됨.

DB에 인스턴스를 보관하는 경우 애플리케이션 계층에서 객체답게 모델링 할수록 매핑 작업이 늘어남.

DB와 객체의 패러다임이 불일치!!

저장소가 자바 컬렉션인 경우

애플리케이션의 객체를 별도의 변환 없이 저장할 수 있음

객체의 인스턴스 저장소가 DB인 경우와 자바 컬렉션(list, set)인 경우 코드와 성능에서 크게 차이가 남

1. 상속

DB 테이블은 '상속 관계' 개념을 갖고있지 않음

관계형 DB에선 '슈퍼타입 서브타입'으로 이 개념을 대체함

대체할 만한 개념은 있지만 완전히 같은 것이 아니기에 유지보수와 구현이 복잡해짐

1) DB 사용

예1) Album 인스턴스를 저장할 때

인스턴스를 분해해 ITEM, ALBUM 테이블에 각각 INSERT 해야함

1. 인스턴스 분해

2.INSERT INTO ITEM....

3.INSERT INTO ALBUM

예2) Album 조회

1. 각각의 테이블에 따른 조인 sql 작성

2, 각각의 객체 생성

2) 자바 컬렉션에 인스턴스를 저장, 조회 한다면?

아래와 같이 간단한 코드를 작성하면 됨

list,add(album);

Album album = list.get(albumId);

2. 연관관계

두 객체가 연관관계를 맺을 때

객체는 참조를 사용: member.getTeam()

테이블은 외래키(join)를 사용: JOIN ON M.TEAM_ID = T.TEAM_ID

1) 객체다운 모델링 VS 테이블에 맞춘 객체 모델링

유지보수를 위해선 전자의 경우를 택해야 하지만 코드와 동작 방식이 더욱 복잡해짐

- 객체를 등록하고 DB에 저장하는 경우

예1) class 구현

객체다운 모델링 테이블에 맞춘 객체 모델링

예2) DB에 저장

객체다운 모델링 테이블에 맞춘 객체 모델링

- 객체 모델링 조회

예) 특정 member 조회

Member를 조회하기 위해선 Member와 Team 모두 조회해야됨.

연관관계에 있는 객체를 조회하기 위해 JOIN 작업을 추가적으로 해야됨.

2) 자바 컬렉션에 인스턴스를 저장, 조회 한다면?

list.add(member);

Member member = list.get(memberId);

Team team = member.getTeam();

3. 객체 그래프 탐색

객체는 자유롭게 그래프를 탐색할 수 있어야 함

하지만! DB에 객체를 저장한다면 처음 실행하는 sql에 따라 탐색 범위가 제한되면서 엔티티 신뢰 문제가 발생함

엔티티 신뢰 문제

계층형 아키텍쳐(MVC패턴)는 다음 계층을 믿고 사용할 수 있어야 하는데 쿼리에 따라 탐색할 수 있는 범위가 달라지기에 요청을 보낸 계층(상위 계층)이 요청을 받은 계층(하위 계층)을 신뢰하지 못함. 따라서 개발자는 상위 계층의 코드에 하위 계층에서의 탐색 범위를 벗어난 접근이 있는지 확인해야됨

예)

member.DAO.find 코드를 확인해야 Team, Order에 접근(탐색) 가능 여부를 알 수 있음.

service계층이(MemberService) repository 계층(memberDAO)을 신뢰하지 못함.

모든 객체를 미리 로딩하면 탐색 범위를 고려할 필요가 없지만 join으로 인해 성능이 낮아짐.

탐색 범위에 따라 메서드를 여러 개 구현하는 방법도 있지만 코드가 길어짐.

4. 비교하기

1) sql로 DB에 접근

memberDAO.getMember(): DB에서 인스턴스를 조회해 값이 세팅된 객체 인스턴스 생성 및 반환

즉, 같은 쿼리문을 날리면 data는 같지만 다른 객체 인스턴스가 생성됨

2) 자바 컬렉션으로 인스턴스에 접근

member1 == member2; // 두 인스턴스는 같음

결론

객체를 자바 컬렉션에 저장하듯이 DB에 저장할 순 없을까?

→ JPA(Java Persistence API) 등장

110501

ji._.ye — Tue, 26 Mar 2024 22:29:40 +0900

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main{
    public static void main(String[] args) throws Exception{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String [] input = br.readLine().split(" ");
        
        int N = Integer.parseInt(input[0]);
        int K = Integer.parseInt(input[1]);
        
        int D[][] = new int[N+1][N+1];
        for(int i = 0; i < N+1; i++){
            D[i][0] = 1; D[i][i] = 1;
            for(int j = 1; j < i; j++){
                D[i][j] = (D[i-1][j-1]+D[i-1][j])%10007;
            } 
        }
        
        System.out.println(D[N][K]);
    }
}

문제 포인트

1. 다이나믹 프로그래밍

이항계수는 다이나믹 프로그래밍의 대표적인 예시이다.

nCk = n! / {(n-k)! *k!} 공식을 사용하여 구할 수도 있지만 파스칼의 삼각형을 적용하여 다이나믹프로그래밍으로 계산하는 방법도 있다.

1.이차원 배열 D[n][k] 에 nCk의 값을 넣고

2. for문을 돌며 nCk = n-1Ck-1 + n-1Ck 공식 적용

와 같은 코드를 통해 쉽게 구할 수 있다.

이 문제에서 후자의 방법이 사용된 이유는 뒤에 설명하겠다.

출처: 위키백과

2. Mod(나머지) 연산

Mod연산은 대게 정답이 자료형의 범위를 넘어가는 경우 값의 크기를 줄이기 위해 사용된다. 여기서 주의해야 할 점은 답을 구하는 과정에서도 값이 범위를 넘어갈 수 있다는 것이다. 이를 해결하기 위한 방법은 간단하다. Mod연산을 답을 구하는 중간 단계에서도 실행하는 것이다.

(A + B) % C = {(A % C) + (A % B)} % C

(A x B) % C = {(A % C) x (A % B)} % C

(A - B) % C = {(A - C) + (A - B)} % C

Mod는 위와 같이 분배법칙(정확한 용어는 아니지만 편의상 이렇게 부르겠다) 이 성립하기 때문에 반복되는 연산일 경우 각 단계마다 Mod연산을 실행해도 올바른 답을 도출할 수 있음.

오답 노트

다이나믹프로그래밍이 아닌 nCk = n! / {(n-k)! *k!} 공식을 적용하여 문제를 풀었지만 오답이 나왔다.

nCk

= (n-0)x(n-1)x...x(n-k+1) / k!

= {(n-0)/(k-0)} x {(n-1)/k-1} x ...x {(n-k+1)/1}

for 문을 돌려 순차적으로 {(n-i)/(k-i)} % 10007 을 계산하였다.

오답의 이유는 for문의 각 단계에서 {(n-i)/(k-i)} 값이 소수가 나올 수도 있다는게 원인이었다.

다이나믹 프로그래밍을 적용한 경우 각 단계에선 무조건 정수가 나오기에 Mod연산을 해도 정수 값이 나온다.

//틀린 코드
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main{
    public static void main(String[] args) throws Exception{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String [] input = br.readLine().split(" ");
        
        int N = Integer.parseInt(input[0]);
        int K = Integer.parseInt(input[1]);
    
        int a = 1;
        for(; K>0 ;){
           a =  (N/K % 10007) * a; 
           --N; --K;
        }
        System.out.println(a % 10007);
    }
}

정리

다이나믹프로그래밍(파스칼의 삼각형) 기법을 사용해 for문의 각 단계에서 정수 값을 구하고 Mod를 적용해 값이 커지는걸 방지한다.

스프링부트 환경설정

ji._.ye — Tue, 26 Mar 2024 17:51:07 +0900

1. 프로젝트 생성

dependencies: Spring Web, Thymeleaf

https://start.spring.io/

Dependencies - 라이브러리 선택

Spring Web - 웹 개발에 필요한 라이브러리

Thymeleaf - HTML을 생성하는 템플릿 엔진

위와 같이 프로젝트 생성 후 Intellij에서 hello-spring 폴더에 위치한 build.gardle 오픈

Grale

라이브러리를 가져오고 빌드를 관리하는 툴
CI/CD를 위해 여러 작업들(Compile, Test, Packaging, Deploy&Run)을 자동화 시켜줌
Packaging - 스프링 코드를 패키징 해 .jar, .war 파일로 생성
jar 파일 - 컴파일된 여러 .class 파일이 포함된 단일 파일어플리케이션을 서버에 배포할땐 Gradle에서 jar파일을 생성해야 함.
빌드 도구 - 소스 코드를 샐행 가능한 어플리케이션으로 만들어주는 도구

plugins {
	id 'java'
	id 'org.springframework.boot' version '2.7.9'
	id 'io.spring.dependency-management' version '1.0.15.RELEASE'
}

group = 'hello'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '11'

repositories {
	mavenCentral()
}

dependencies {
	implementation 'org.springframework.boot:spring-boot-starter-thymeleaf:2.7.8'
	implementation 'org.springframework.boot:spring-boot-starter-web:2.7.8'
	testImplementation 'org.springframework.boot:spring-boot-starter-test:2.7.8'
	implementation 'org.springframework.boot:spring-boot-starter-jdbc'
	implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
	runtimeOnly 'com.h2database:h2'
	testImplementation('org.springframework.boot:spring-boot-starter-test:'){
		exclude group: 'org.junit.vintage',module: 'junit-vintage-engine'
	}
}

test{
	useJUnitPlatform()
}

2. 파일 설명

resources 폴더 - java를 제외한 나머지 코드, HTML 파일도 이 폴더에 들어감.

.gitignore - git에는 소스코드만 올라가야 됨. build된 결과물은 올라가면 안됨.

3.Run

HelloSpringApplication class의 main 메서드 실행

→ @SpringbootApplication 작동 : 톰캣 웹서버를 내장하고 있음

Tomcat initialized with port(s): 8080 (http)

브라우저 화면

localhost:8080에 연결이 안된다면?

Settings > Build, Execution > Deployment > Deburgger > Built-in Server

에서 port 가 8080으로 설정되어있는지 확인

스프링 활용 - 환경 설정

ji._.ye — Mon, 11 Sep 2023 09:24:29 +0900

@PersistenceContext

영속성 컨텍스트: 엔티티를 영구 저장하는 환경
스프링에는 영속성 관리를 위해 EntityManager존재
EntityManager를 빈으로 주입할 때 사용
EntityManager는 영속성 컨텍스트에 엔티티를 보관하고 관리

//MemberRepository

@Repository
public class MemberRepository {
    @PersistenceContext
    private EntityManager em;
    public  Long save(Member member){
        em.persist(member);
        return member.getId();
    }

    public Member find(Long id){
        return em.find(Member.class, id);
    }//같은 영속성 context 안에서는 ID가 동일하면 같은 Entity로 식별

}

@Transactional

오류가 발생했을 때 모든 작업을 원상태로 되돌릴 수 있음
데이터 추가, 갱신, 삭제 등으로 이루어진 작업에 오류가 발생했을 때 모든 작업들을 원상태로 되돌림
DB와 관련된 클래스, 메서드에 어노테이션 적용
테스트 메서드에 어노테이션을 적용하면 메서즈가 종료될 때 자동으로 롤백

@RollBack(false)

테스트 코드에서 데이터를 유지

//MemberRepositoryTest
...
 @Test
    @Transactional
    @Rollback(false)
    public void testMember() throws Exception{
        //given
        Member member = new Member();
        member.setUsername("memberA");

        //when
        Long saveId = memberRepository.save(member);
        Member findMember = memberRepository.find(saveId);
...

NCP 사용 후기

ji._.ye — Thu, 10 Aug 2023 16:45:22 +0900

네이버 Essential Hands-on 강의를 들으면서 VPC서비스 이용방법을 배워봤다.

하나의 IP주소를 할당 받고, 4개의 server를 생성하였다. 4개의 서버로 네트워크 트래픽을 분산시키기 위해 Load Balancer를 생성하였다.

VPC이름을 test, lab1으로 설정하요 가상 private cloud를 생성하였다. private이기 떄문에 CIDR은 같을 수 있다.

Load balancer는 애플리케이션 로드밸런서, 네트워크 로드밸런서, 네트워크 프록시 로드밸런서가 있는데 그 중에 가장 기본적인 애플리케이션 로드밸런서를 생성했다. load balance를 적용할 VPC로 lab1을 선택했다.

서버 수를 자동으로 변경해주는 Auto Scaling서비스도 이용했다. 최소 용량, 최대 용량, 기대 용량, 서버 수를 지정해주고 헬스 체크 유형을 선택하여 생성하면 된다. lab1-vpc를 서버로 설정하였고 로드밸런서를 통해 헬스 체크를 할 수 있도록 선택했다.

후기: Ncloud 서비스를 이용한 서버 생성에 대해 알아보았다. 버튼만 몇 번 클릭하면 서버가 생성돼서 매우 편리하고 대시보드에서 상황을 한 눈에 볼 수 있어서 서버 관리에 용이할 것 같다.

딥페이크 기술 보고서

ji._.ye — Thu, 23 Feb 2023 03:03:55 +0900

2학년 2학기, 데이터 사이언스 개론 수업에 제출했던 보고서다.

이론 보다는 사용 예시에 중점을 두어 작성했다. 100점 만점에 90점을 받았는데, 분량이 부족해서 점수가 깎인 것 같다.

논문을 읽어보며 기술적인 면을 더 공부해봐야겠다.

딥페이크 기술과 응용 사례

C111106 유지예

(초록)

고인이 되어 다시 볼 수 없을 거라 생각한 가수가 공연을 하고, 가상 인물이 실제 인물처럼 미디어에서 활동을 한다. 이는 모두 딥페이크로 구현한 것이다. 딥페이크란 딥러닝을 이용해 얼굴 이미지를 편집하는 기술이다. 본 글에서는 다양한 딥페이크 기술의 특징과 원리, 응용 사례에 대해 설명하고, 딥페이크 악용 사례와 이에 대응하는 딥페이크 탐지 기술에 대해 설명한다.

(서론)

영원히 못 볼 줄 알았던 사람을 다시 만나게 된다면 어떤 기분일까? 음악 채널 M-net은 AI음악 프로젝트 ‘다시 한번’을 통해 거북이의 터틀맨을 홀로그램 형태로 무대에 불러냈다. 거북이의 리더 ‘터틀맨’은 2008년 고인이 된 사람이다. 그런데 어떻게 무대에 설 수 있었을까? 그 방법은 바로 딥페이크 기술이다. 딥페이크는 AI를 이용해 사람의 이미지를 합성하는 기술이다. ‘딥페이크’란 용어는 2017년 미국의 온라인 커뮤니티 레딧에 할리우드 배우의 얼굴과 포르노를 합성한 편집물을 올린 네티즌의 아이디 ‘Deepfakes’에서 유래했다. 가상 인물, 얼굴 보정 등 다양한 분야에 딥페이크가 사용되고 있다. 딥페이크는 Face Synthesis, Facial attributes, facial expression, face swap 4종류가 있다. 각 기술의 특징에 대해 알아보자.

(본론1) Face Synthesis

Face Synthesis란 실제론 존재하지 않는 가상의 인물의 얼굴을 만들어내는 기술이다. 여기서 GAN(Generative Adversarial Networks)이 사용된다. GAN은 생성자와 구분자로 이루어진 두 네트워크를 경쟁시켜 학습시키는 비지도 학습 모델이다. 생성자는 기존 인물 사진으로 학습을 하며 실제 얼굴처럼 보이는 이미지를 생성한다. 판별자는 생성된 이미지 속 얼굴이 실제인지 가짜인지 구분하며 학습한다. 판별자가 가짜 이미지를 진짜 이미지라고 판단하면 생성자는 잘 학습된 것이므로 학습을 종료하고 생성모델을 사용해 이미지를 만드는 작업을 한다.

<그림 1> GAN의 아키텍처 (출처: Hamed Alqahtani. 2019. An Analysis Of Evaluation Metric Of GANs)

펄스나인은 가상인물 사업에 중점을 둔 기업이다. 이 기업은 가상 인물로 이뤄진 걸그룹 이너니티를 만들었다. 가상 걸그룹 이너니티는 실제 걸그룹처럼 음원을 내거나 미디어에 노출된다. 이 기업에서 만든 가상 인물들은 걸그룹뿐만 아니라 인플루언서, SNS 광고 모델, 유튜버 등 여러 분야에서 활동하고 있다.

(본론2) Facial attributes

Facial attributes란 얼굴의 특정한 속성을 바꾸는 기술이다. 속성을 추가하거나 삭제하는 등 임의로 조절할 수 있다. 예를 들어 피부 색이나 주름을 조절하고 앞머리를 생성할 수 있다. GAN에 기능을 추가한 다양한 알고리즘이 Facial attribute을 구현하는데 이용된다. cGAN(conditional-GAN)은 생성자와 판별자에 특정 속성을 나타내는 정보를 추가해준 것이다. 정보는 안경 유무, 빨강 머리 등 임의로 선택이 가능하다. StarGAN은 cGAN의 한 종류로, 단일 네트워크를 이용해 다중 도메인에서의 이미지 간의 변형을 효율적으로 수행할 수 있도록 하는 알고리즘이다. StarGAN을 이용하면 눈 크기, 피부색 등 여러 특징을 한 번에 바꿀 수 있다.

페이스북은 이미지 속 인물의 감은 눈을 뜨게 만드는 ExGAN(Exemplar GAN)기술을 개발했다. ExGAN은 cGAN의 한 종류로, 추가 정보를 생성자와 판별자 외에도 손실함수 등 다양한 곳에 적용한다. 이렇게 학습된 ExGAN은 단순히 눈을 붙이는 것에서 나아가 인물의 얼굴형이나 피부색에 어우러지도록 눈의 색과 모양을 구현한다.

“Toonify Yourself!”라는 홈페이지는 얼굴 사진을 업로드하면 카툰 캐릭터처럼 만들어준다. StyleGAN에 캐릭터 데이터를 학습시킨 알고리즘을 이용하였다. 사용자가 직접 나이, 미소, 남성, 안경 등 여러 도메인을 컨트롤 하여 원하는 모습의 캐릭터를 만들 수 있다.

<그림 2> Toonify의 emoji기술 (출처: bizsquare.info)

(본론3) Facial Expression

Facial Expression이란 얼굴의 표정이나 입모양 등을 변경하는 기법이다. 원본 영상에 해당하는 사람이 목표 영상에 해당하는 사람의 표정을 흉내 내도록 원본 영상을 변화시켜 새로운 이미지를 만들어낸다.

온라인 가계도 플랫폼인 마이헤리티지는 이 기술을 적용해 사진속 인물을 생동감 있게움직이는 영상으로 바꿔주는 ‘딥 노스텔지어’ 기능을 제공한다. 실제 사람이 촬영한 비디오를 바탕으로, 사진 속 인물이 어떻게 움직였는지 추정하는 원리로 기술을 구현했다. 사용자는 먼저 떠나버린 가족, 이전에 만난 적 없는 조상이나 역사 속 인물의 생생한 모습을 볼 수 있다. 표정, 입모양, 그리고 얼굴 움직임에 따른 각도 변화까지 자연스럽게 구현 가능하다.

<그림 3> 딥 노스텔지어 (출처: MyHeritage.com)

(본론4) Face Swap

Face Swap 이란 서로 다른 얼굴을 가진 두 이미지에서 얼굴 부분만 교체하는 기술이다. 사람들이 일반적으로 생각하는 딥페이크가 바로 이것이다. 원리는 다음과 같다. 원본 이미지의 얼굴부분을 목표 이미지의 얼굴로 교체하여 원본 이미지를 변환한다. 이 기술에는 심층 신경망의 한 유형인 오토인코더 방식이 사용되었다. 인코더는 이미지의 특징을 추출한다. 이때 원본 이미지와 목표 이미지의 인코더가 공유됨으로써 두 이미지의 공통된 특징, 예를 들어 눈, 코, 입의 위치가 학습된다. 디코더는 구별되어 있으므로 두 이미지 각각의 특성, 예를 들어 눈 모양, 입 크기 같은 정보가 학습된다. 이렇게 학습된 공유 인코더와 목표 이미지로 학습된 디코더를 이용해 얼굴을 바꿀 수 있다. 원본 이미지를 인코더를 거쳐 눈, 코, 입의 위치를 알아내고 디코더를 통해 그 위치에 목표 이미지의 이목구비를 삽입시킨다.

<그림 4> 오토인코더 (출처: Nguyen, Thanh Thi, et al.(2019), "Deep learning for deepfakes creation and detection.")

과거엔 Face Swap기술이 녹화를 마친 영상에 적용되었다. 하지만 기술이 발달함에 따라 얼굴 변환 속도가 빨라지면서 실시간으로 송출하는 영상에도 적용이 가능하게 됐다. 특히 이 기술에 가상인간을 접목시킨 산업이 활발히 이뤄지고 있다. 모니터속 가상인간이 사회를 보거나 뉴스 인터뷰이의 얼굴을 가상인물로 대체하는 등 생방송에서 이 기술이 적극적으로 활용되고 있다. 구체적인 사례를 보자.

콘텐츠 마케팅 전시회 ‘CMS 2022’에 가상인간 ‘재인’이 등장하였다. 재인은 앞서 소개한 기업 펄스나인이 만든 가상인물이다. 재인은 사회자 역할을 하며 위화감없이 매끄러운 진행을 이어나갔다. 행사장 맞은편 회의실에는 한 여성이 말을 하고 있고 face swap 기술을 통해 실시간으로 여성의 얼굴이 재인의 얼굴로 바뀐다. 화면으로 봤을 땐 가상인간인지 실제 인간인지 분간이 어려울 정도로 자연스럽다.

<그림 5> 가상인간 재인 (출처: 안하늘, 2022.09.08, m.hankookilbo.com)

(본론5) 딥페이크 악용 사례

앞서 소개한 사례들을 보면 딥페이크는 여러 분야에 활용되고 있다. 하지만 모든 기술이 그러하듯 항상 좋은 목적으로 사용되는 건 아니다. 여러 딥페이크 기술 중에서도 특히 Facial Expression과 Face Swap에서 악용사례가 빈번히 발생하고 있다. 실제 하지 않은 말이나 행동을 한 것처럼 영상을 조작해 유포하거나 그것을 악용하는 범죄가 증가하고 있다.

이제는 보이스 피싱이 아닌 딥페이크 피싱이 도래하고 있다. 딥페이크로 가족, 지인을 사칭하면 피해자는 완전히 속을 수밖에 없다. 2019년 유럽의 한 기업 CEO가 모 기업 회장을 딥페이크로 모방한 범죄자에게 속아 22만 유로를 송금하는 피해를 입었다. 2021년 A국에서는 범죄조직이 정부에서 운영하는 안면 인식 시스템을 딥페이크 기술로 속이는 방식으로 가짜 세금계산서를 발행해 세금을 탈루하려다 적발되었다.

딥페이크를 이용하여 대통령이나 유명 연예인 등 사회적 영향력이 큰 인물이 등장하는 가짜 뉴스 문제도 심각하다. 선거철에는 후보자들의 가짜 영상이 돌아다니며 대선판을 뒤흔들고 가짜 뉴스는 정치적, 사회적, 경제적으로 큰 혼란을 야기할 수 있다. 예시로 2022년 3월, 우크라이나 대통령이 항복을 선언하는 가짜 영상이 우크라이나 뉴스 사이트에 공개되어 국제적인 혼란을 일으켰다.

음란물에 연예인 또는 아동, 청소년 얼굴을 합성한 ‘딥페이크 성적 허위 영상물’ 유포 문제도 심각하다. 네덜란드의 사이버 보안회사 센시티의 조사에 따르면 2019년 기준 전 세계 딥페이크 영상 중 성인물이 96%에 이른다는 통계가 나왔다. 국내에선 2022년 딥페이크 음란물을 합성하고 텔레그램 채팅방을 통해 판매한 30 대 남성 A 씨가 검찰에 송치됐다.

(본론6) 딥페이크 탐지 기술

딥페이크 악용을 막기 위해 여러 기관에서 딥페이크를 탐지하는 AI에 대한 연구가 진행중이다. UCR의 연구팀은 변경된 이미지 내의 특정 영역을 감지하고 지역화할 수 있는 얼굴 표정 조작 감지(EMD) 프레임워크를 구축했다. 인텔은 심장이 혈액을 내보낼 때 정맥의 색이 변하는 점을 이용하여, 원본 영상에서 얼굴의 혈류 신호를 수집하고 시공간 지도로 변환시켜 딥러닝을 통해 영상의 진위를 판단하는 탐지기를 개발하였다.

(결론)

딥페이크 기술에는 Face Synthesis, Facial attributes, Facial Expression, Face Swap가 있고 이들의 원리와 사례에 대해 알아봤다. 딥페이크는 눈을 감을 사진을 뜨게 할 수 있고 역사속 인물 사진에 생동감을 주는 등 여러 분야에 사용되고 있다. 이렇게 딥페이크는 새로운 산업을 열었지만 가짜 뉴스나 금융 사기 등 악용 사례가 발생하고 있다. 이 문제점을 해결하기 위해 여러 기관에서 딥페이크 탐지 기술을 연구하고 있다. 따라서 딥페이크 기술을 무작정 수용하는 것 보단, 그것의 양면성에 유의하며 비판적으로 받아들일 필요가 있다.

(참고문헌)

-강진규(2021.11.29), 커지는 딥페이크 보이스피싱 우려...경고 잇따라, 디지털투데이(digitaltoday.co.kr, 2022.11.18.오전 2시 39분 접속)

-공감언론 뉴시스(2022.04.06), 친러 해커, '젤렌스키 항복' 가짜 영상 송출…"우크라 언론·기관 신뢰 저하 의도", 공감언론 뉴시스통신사(newsis.com,2022.11.18.오전 2시 41분 접속)

-김전은(2021.03.03), "오래된 스틸 사진에 생동감을"....AI 기술로 탄생, 인터넷신문위원회(thedailypost.kr, 2022.11.18.오전 2시 37분 접속)

-김정완(2022.11.17), ‘남의 얼굴에 음란물을…’ 딥페이크 피해 느는데, 아시아경제 (asiae.co.kr, 2022.11.18.오전 2시 43분 접속)

-김정호, 안재주, 양보성, 정주연, 우사이먼성일 (2020), 데이터 기반 딥페이크 탐지기법에 관한 최신 기술 동향 조사, 정보보호학회지

-박찬(2022.05.09), “다 걸렸어”...99% 딥페이크 탐지하는 AI 기술, AI타임스 (aitimes.com, 2022.11.18.오전 2시 47분 접속 )

-안하늘(2022.09.08), 얼굴 100만개·표정 1500장이 만든 가상인간..."Z세대 마음 얻어야 살아 남아", 한국일보(hankookilbo.com, 2022.11.18.오전 2시 31분 접속)

-윤희일(2022.05.09), 실제같은 가짜 '딥페이크'의 세계 완전해부...AI 세상의 새로운 게임체인저?, 경향신문 (khan.co.kr, 2022.11.18.오전 2시 45분 접속)

-이동재(2022.11.16), 인텔, 딥페이트 가짜 동영상 탐지 기술 공개...정확도 96% 기록, 헬로T (hellot.net, 2022.11.18.오전 2시 49분 접속)

-장기헌(2020), 머신러닝 기반의 얼굴 변환 시스템 구현 및 연구, p.6~9

-Brian Dolhansky, Cristian Canton Ferrer (2017), Eye In-Painting with Exemplar Generative Adversarial Networks, p.1~4

-Nguyen, Thanh Thi, et al (2019), Deep learning for deepfakes creation and detection, p. 3