출처 : (https://light-tree.tistory.com/196) pretrained된 Teacher network(큰 모델)의 학습된 정보를 추출해서 student network(작은 모델) 학습시키는데 이용하는 것. 그냥 작은 모델로 학습하는 것 보다 더 높은 정확도를 얻을 수 있음

Soft label : [0, 0, 0, 1] 처럼 원핫 인코딩된 결과가 아니라 [0.1, 0.2, 0.1, 0.6] 처럼 확률로 나타낸 라벨값 soft predictions : softmax한 값에 T를 나눠주어 극단적인 값의 분포를 완화해줌 hard prediction : 그냥 softmax한 값

결과적으로 distillation loss + student loss 값을 이용해 student모델을 학습시킴으로써 teacher model의 정보를 이용할 수 있다

Knowledge Distillation 코드 구현

코드 출처 : (https://keras.io/examples/keras_recipes/better_knowledge_distillation/) 사용할 데이터셋 : oxford_flowers102 Teacher model : Pretrained된 BiT ResNet152x2 모델 (https://www.kaggle.com/datasets/spsayakpaul/bitresnet101x3flowers102) Student model: ResNet50V2

1. Distillation Loss 구현 Teacher model과 student model의 softmax값에 T를 나누어줘 값을 평탄화 해주었고, distillation_loss_fn(KL divergence)를 이용해 두 값의 분포 차이값을 계산함. 그리고 나서 student_loss와 distillation_loss값을 alpha로 비율을 조정해서 값을 더해 최종 loss값을 계산함.

** 2. 계산한 loss값을 이용해 가중치 업데이트**

** 3. Knowledge distillation을 이용핸 student model의 결과 **

한시간(20 epoch)만큼 모델을 돌린 결과

매우 안 좋은 결과가 나왔다.

https://git.io/JBO3Y에서 해당 Distillation을 100000 epoch만큼 훈련시킨 모델을 얻을 수 있는데 여기에서는 95.54%가 나왔다.

결론 : Knowledge distillation을 이용해 모델 크기를 줄일수는 있지만 학습 시키는 시간은 더 크게 해야 좋은 결과를 내는 작은 모델을 얻을 수 있을 것 같다.

SR에서의 Knowledge Distillation

Image Super-Resolution Using Knowledge Distillation(10.1007/978-3-030-20890-5_34) 참고

Teacher model에서 각각 T1, T2, T3의 statistical map을, Student model에서 s1, s2, s3의 statistical map을 추출해서 loss(Teacher output, Student output) + loss(t1, s1) + loss(t2, s2) + loss(t3, s3)를 loss로 계산해서 knowledge distillation을 구현

Vision Transformer를 이해하기 위해 Transformer를 직접 코드로 구현해보면서 모델을 이해해 봄(출처 : 딥러닝을 이용한 자연어처리 입문, https://wikidocs.net/31379)

포지셔널 인코딩

입력 데이터의 위치정보를 입력데이터에 추가함 위 수식을 인덱스에 따른 위치정보로 표현해서 임베딩된 데이터에 추가해줌

Scaled dot-product Attention

입력데이터에서 구한 Q, K, V를 입력하면 값(셀프 어텐션 값)을 계산해줌

Multi-head Attention

위에서 한 코드는 한번의 attention인데 여러 번의 attention을 병렬로 사용, 병렬로 attention한 결과들을 합쳐 새로운 가중치 행렬 W를 곱해줌 먼저 input에 Q, K, V를 각각 만드는 dense layer를 곱함 -> Q, K, V 생성됨 Q, K, V를 각각 num_heads만큼 나누어서 (input_dim / num_heads)의 차원을 가지는 num_heads만큼의 attention을 만듬. 각각의 attention을 Scaled dot-product후 합친 후 W 곱해줌

인코더 구현

위 이미지처럼 인코더 블록 하나를 구현하고 num_layers만큼 쌓아주엇음

Vision Transformer 구현 및 코드 분석

(출처 : https://keras.io/examples/vision/image_classification_with_vision_transformer/) Transformer 모델을 이미지에 적용시킨 모델 이미지를 여러 개의 patch로 나누고, 시퀸스 데이터처럼 만듬 그 후 Position Embedding을 더한 다음 Transformer Encoder를 통과시킨다

이미지를 여러 Patch 나누기 + Position Embedding

tf.image.extract_patches 함수를 사용해 이미지를 여러 Patch로 나눔, 나눈 patch들을 projection + position embedding으로 값을 바꿔줌

transformer에서는 position embedding을 sin, cos함수로 표현했는데, ViT에서는 embedding함수로 위치 정보 파라미터를 업데이트 할 수 있도록 구현한 것 같음.

ViT 모델 구현

Transformer에서는 Multi Head Attention을 직접 구현해 봤는데 ViT에서는 tensorflow에서 구현된 함수를 사용하였다.

최종 구현

1, 2에서 만든 코드를 합치고, 마지막에 일반 분류문제처럼 Layer를 추가 해 주어서 최종 ViT 모델을 구현하였다

https://leetcode.com/problems/reverse-linked-list-ii/ 인덱스 m에서 n까지를 역순으로 만들어라. 인덱스 m은 1부터 시작한다

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

Input: head = [1,2,3,4,5], left = 2, right = 4
Output: [1,4,3,2,5]

Input: head = [5], left = 1, right = 1
Output: [5]

풀이

내풀이

한번에 맞게 풀었지만 깔끔하지 못하고 그냥 주먹구구식으로 풀어서 너무 아쉽다... 그냥 count 변수를 추가해서 n, m일때 연결리스트를 뒤집어 주었는데 뒤집어 줄때 n==m인경우, n=1경우를 하드코딩해서 깔끔하지 않은것 같다.

class Solution:
    def reverseBetween(self, head: Optional[ListNode], left: int, right: int) -> Optional[ListNode]:
        prev_head, trav = None, head
        count = 1

        while count != left:
            count += 1
            prev_head, trav = trav, trav.next

        reverse_end = prev = trav

        # reverse
        if trav.next:
            prev, trav = trav, trav.next
            count += 1

        while count != right+1:
            count += 1
            next, trav.next = trav.next, prev
            prev, trav = trav, next

        if prev_head:
            prev_head.next = prev
        reverse_end.next = trav

        if left == 1:
            return prev
        else:
            return head

책 풀이

https://leetcode.com/problems/odd-even-linked-list/

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

The first node is considered odd, and the second node is even, and so on. 연결 리스트를 홀수 노드 다음에 짝수 노드가 오도록 재구성하라. 공간 복잡도 O(1), 시간복잡도 O(n)에 풀이하라

풀이

내 풀이

책 풀이랑 거의 똑같이 푼 것 같다. 공간복잡도가 O(n)이라 새로운 연결리스트로 홀수, 짝수 나눈게 아니라 원래 있던 연결리스트에 값을 계속 업데이트 해주었다. ->98 ms

class Solution:
    def oddEvenList(self, head: Optional[ListNode]) -> Optional[ListNode]:

        if not head:
            return head

        odd = odd_head = head
        even = even_head = head.next

        while even and even.next:
            odd.next, even.next = odd.next.next, even.next.next
            odd, even = odd.next, even.next

        odd.next = even_head

        return odd_head

https://leetcode.com/problems/swap-nodes-in-pairs/

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

연결 리스트를 입력받아 페어 단위로 스왑하라

Input: head = [1,2,3,4]
Output: [2,1,4,3]

Input: head = [1]
Output: [1]

풀이

재귀를 이용해서 리스트 노드 2개씩 보면서 두 개를 바꾸어주었다.

class Solution:

    def swap(self, head: Optional[ListNode]) -> Optional[ListNode]:
        if not head or not head.next:
            return head

        first, second = head, head.next
        first.next, second.next = second.next, first

        first.next = self.swap(first.next)

        return second



    def swapPairs(self, head: Optional[ListNode]) -> Optional[ListNode]:
        return self.swap(head)

이번에는 책 풀이랑 비슷하게 풀어 깔끔하게 잘 푼것 같다.

clone 후 코드를 실행해보면 정상 실행이 되지 않아 오류 발생 및 해결방법 정리

오류 1 - tecogan의 구현코드는 tensorflow 1.x버전이라 2.x에서 실행 불가 해결 1 - 해당 깃허브의 pull requests를 찾아보던 중 누가 2.x에 호환되도록 request한 코드가 있었음(https://github.com/RAFALAMAO/TecoGAN), 해당 코드로 교체함

오류 2 - python3 runGan.py 1 실행시 라이브러리 설치했음에도 불구하고 cannot import 오류발생 해결 2 - python3 대신 python으로 실행, runGan.py에서 python3으로 적힌 실행코드들을 모두 python으로 바꾸어줌

오류 3 - python runGan.py 2 실행 중 cannot import name 'compare_ssim' from 'skimage.measure' 해결 3 - TecoGAN/LPIPSmodels/util.py와 TecoGAN/metrics.py에서 from skimage.measure import compare_ssim의 코드를 from skimage.metrics import structural_similarity로 바꿈

예제 LR 이미지들을 Pretrained된 모델에 돌려보기

예제 이미지 다운로드

python runGan.py 0 실행 -> wget 오류 발생(코드 실행환경은 리눅스, 현재환경은 윈도우) runGan.py코드를 보고 pretrained model과 예제 이미지를 직접 다운로드

1. TecoGAN/model에 파일 넣기 https://ge.in.tum.de/download/data/TecoGAN/model.zip
2. TecoGAN/LR에 파일 넣기 https://ge.in.tum.de/download/data/TecoGAN/vid3_LR.zip

                       https://ge.in.tum.de/download/data/TecoGAN/tos_LR.zip

3. TecoGAN/HR에 파일 넣기 https://ge.in.tum.de/download/data/TecoGAN/vid4_HR.zip

                       https://ge.in.tum.de/download/data/TecoGAN/tos_HR.zip

LR이미지들을 pretrained 모델에 입력으로 넣어 HR영상으로 출력

python runGan.py 1 실행 현재는 TecoGAN/LR/calendar 영상이 입력으로 들어감 runGan.py 파일에서 testpre에 학습시키고 싶은 LR데이터셋의 경로를 넣을 수 있음 결과(Calendar dataset)

원본 이미지 SR된 이미지 LR 이미지

SR된 이미지와 원본 이미지를 비교해 평가지표 출력

python runGan.py 2 실행 위와 마찬가지로 testpre에서 평가할 이미지 변경가능 평가지표 결과는 TecoGAN/metric_log에 저장됨

결과

모델 학습 시켜보기

학습용 데이터셋 다운로드

python dataPrepare.py –help로 살펴보기 -> cannot import name ‘clock’ from ‘time’ 에러 (dataPrepare.py 코드를 보니 from time import clock 코드 안 쓰여서 주석처리 함) python dataPrepare.py –start_id 2000 –duration 120 –disk_path datasets로 데이터셋 다운 전체 데이터를 다운받는데 시간이 너무 오래 걸려서 50/290개만 받음(1시간 소요)

데이터셋 학습

python runGan.py 2 실행 (Train the TecoGAN Model) wget 오류 발생(윈도우 환경) -> 직접 파일 다운로드 사전 훈련된 VGG19, FRVSR model 직접 다운로드 후 TecoGAN/model에 압축 풀기 http://download.tensorflow.org/models/vgg_19_2016_08_28.tar.gz http://ge.in.tum.de/download/2019-TecoGAN/FRVSR_Ours.zip

runGan.py에서 TrainingDataPath 경로를 -disk_path에서 설정한 경로(datasets)로 수정

데이터도 50/290개만 받았으므로 다음과 같이 str_dir, end_dir, end_dir_val값 수정 (주석 값이 원래 값)

오류 1 - module 'tensorflow.compat.v1' has no attribute 'contrib' 해결 1 – TecoGAN/lib/Teco.py의 tf.contrib.image.dense_image_warp를 모두 tfa.image.dense_image_warp로 바꾸어줌

오류 2 - module 'tensorflow.python.ops.summary_op_util' has no attribute 'skip_summary' 해결 2 – TecoGAN/lib/ops.py에서 from tensorflow.python.ops import summary_op_util를 from tensorflow.python.ops import summary_op_util from tensorflow.python.distribute.summary_op_util import skip_summary로 바꾸어주고, 아래에 있는 코드 중 summary_op_util.skip_summary를 skip_summary로 바꾸어줌

오류 3 – 노트북 GPU(MX250)으로 모델 학습 시 batch_size를 1로 해도 OOM에러 발생 해결 3 – runGan.py에서 batch_size가 4(default)로 되어있는데 2로 수정 및 본체 GPU(RTX 3060ti 사용)

학습 종료조건이 되지 않았지만 너무 오래 걸릴 것 같아 8시간만 학습

학습결과 확인

Tensorboard –logdir ‘log 경로’ 실행

학습을 오래 시키지 않았음에도 불구하고 SR이 잘 된 모습을 확인할 수 있었다.

https://leetcode.com/problems/add-two-numbers/

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

역순으로 저장된 연결 리스트의 숫자를 더하라

Input: l1 = [2,4,3], l2 = [5,6,4]
Output: [7,0,8]
Explanation: 342 + 465 = 807.

Input: l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
Output: [8,9,9,9,0,0,0,1]

풀이

내 풀이

두 연결 리스트의 길이를 맞추기 위해서 값이 0인 연결리스트를 추가 해줘서 길이를 맞추어 두 수를 덧셈 해줌 -> 150 ms

class Solution:
    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:

        l1_trav, l2_trav = l1, l2
        l1_prev = None
        next_val = 0
        while l1_trav.next or l2_trav.next:

            if not l1_trav.next:
                l1_trav.next = ListNode(0)
            if not l2_trav.next:
                l2_trav.next = ListNode(0)

            l1_trav.val, next_val = (l1_trav.val + l2_trav.val+ next_val) % 10 , (l1_trav.val + l2_trav.val + next_val) // 10


            l1_trav, l2_trav = l1_trav.next, l2_trav.next

        l1_trav.val, next_val = (l1_trav.val + l2_trav.val+ next_val) % 10 , (l1_trav.val + l2_trav.val + next_val) // 10

        if next_val:
            l1_trav.next = ListNode(next_val)

        return l1

책 풀이

자료형 변환

연결 리스트를 문자열로 이어 붙인다음 숫자로 변환하고, 이를 모두 계산한 후 다시 연결리스트로 바꾼다. -> 비효율적 풀이 : 160 ms

class Solution:
    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
        # 연결 리스트 뒤집기
        a = self.toList(self.reverseList(l1))
        b = self.toList(self.reverseList(l2))

        resultStr = int(''.join(str(e) for e in a)) + int(''.join(str(e) for e in b))

        return self.toReversedLinkedList(str(resultStr))


    def reverseList(self, head: ListNode) -> ListNode:
        node, prev = head, None

        while node:
            next, node.next = node.next, prev
            prev, node = node, next

        return prev


    def toList(self, node: ListNode) -> List:
        list: List = []
        while node:
            list.append(node.val)
            node = node.next

        return list

    def toReversedLinkedList(self, result: str) -> ListNode:
        prev: ListNode = None
        for r in result:
            node = ListNode(r)
            node.next = prev
            prev = node

        return node

전가산기 구현

내가 한 방법이랑 비슷함 더 나은 부분은

1. 몫과 나머지 계산을 divmod()로 계산
2. l1에 값을 더한게 아니라 새로운 리스트 노드를 만들어서 값을 반환

->129 ms

    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
        root = head = ListNode(0)

        carry = 0

        while l1 or l2 or carry:
            sum = 0

            if l1:
                sum += l1.val
                l1 = l1.next
            if l2:
                sum += l2.val
                l2 = l2.next


            # 몫과 나머지 계산
            carry, val = divmod(sum+carry, 10)
            head.next = ListNode(val)
            head = head.next

        return root.next

https://leetcode.com/problems/reverse-linked-list/

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

연결 리스트를 뒤집어라

Input: head = [1,2,3,4,5]
Output: [5,4,3,2,1]

풀이

내 풀이

이전 노드, 현재 노드, 다음 노드 변수를 선언해서 연결 리스트를 뒤집었다. -> 81 ms...

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:

        before_head = None
        trav_head = head
        after_head = head.next

        while not trav_head:
            trav_head.next = before_head
            before_head = trav_head
            trav_head, after_head = after_head, after_head.next


        return before_head

책 풀이

재귀 구조로 뒤집기

->81 ms

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        def reverse(node: ListNode, prev: ListNode = None):
            if not node:
                return prev
            next, node.next = node.next, prev
            return reverse(next, node)

        return reverse(head)

반복 구조로 뒤집기

->80 ms

class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        node, prev = head, None

        while node:
            next, node.next = node.next, prev
            prev, node = node, next

        return prev

내가 햇던 코드랑 비슷한데 훨씬 간결하게 잘 표현했다...

https://leetcode.com/problems/merge-two-sorted-lists/

# Definition for singly-linked list.
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

정렬되어 있는 두 연결 리스트를 합쳐라

Input: list1 = [1,2,4], list2 = [1,3,4]
Output: [1,1,2,3,4,4]

Input: list1 = [], list2 = []
Output: []

풀이

내 풀이

연결리스트를 돌아다니는 두 개의 trav 변수를 이용해 값을 비교하며 새로운 연결 리스트를 만듬 -> 78 ms

class Solution:
    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:

        head, trav = None, None
        list1_trav, list2_trav = list1, list2

        if not list1:
            return list2

        if not list2:
            return list1

        if list1_trav.val > list2_trav.val:
            head, trav = list2, list2
            list2_trav= list2_trav.next
        else:
            head, trav = list1, list1
            list1_trav = list1_trav.next

        while list1_trav and list2_trav:
            if list1_trav.val > list2_trav.val:
                trav.next, list2_trav = list2_trav, list2_trav.next
            else:
                trav.next, list1_trav = list1_trav, list1_trav.next  
            trav = trav.next

        while list1_trav:
            trav.next, list1_trav = list1_trav, list1_trav.next
            trav = trav.next
        while list2_trav:
            trav.next, list2_trav = list2_trav, list2_trav.next
            trav = trav.next

        return head

책 풀이

재귀 함수로 구현 -> 38 ms

class Solution:
    def mergeTwoLists(self, list1: Optional[ListNode], list2: Optional[ListNode]) -> Optional[ListNode]:
        if (not list1) or (list2 and list1.val > list2.val):
            list1, list2 = list2, list1

        if list1:
            list1.next = self.mergeTwoLists(list1.next, list2)

        return list1

https://leetcode.com/problems/palindrome-linked-list/

# Definition for singly-linked list.
class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

연결 리스트가 팰린드롬 구조인지 판별하라

Input: head = [1,2,2,1]
Output: true

Input: head = [1,2]
Output: false

풀이

내 풀이

연결 리스트들을 배열에 옮겨닮은 후, 원래 배열과 뒤집은 배열이 같은지 반환 -> O(n), 1868 ms

class Solution:
    def isPalindrome(self, head: Optional[ListNode]) -> bool:

        a = []

        while(1):
            a.append(head.val)

            if head.next == None:
                break

            head = head.next

        return a[::] == a[::-1]

책 풀이

리스트 변환

-> O(n), 2705 ms pop(0) 하는 부분에서 값을 꺼내온 다음에 모든 값을 앞으로 시프팅 하기 때문에 시간이 많이 걸렸다 -> Deque를 사용 : 이중 연결 리스트 구조로 양쪽 방향 모두 추출하는데 O(1) 시간만큼 걸림

class Solution:
    def isPalindrome(self, head: Optional[ListNode]) -> bool:
        q: List = []

        if not head:
            return True

        node = head

        while node is not None:
            q.append(node.val)
            node = node.next

        while len(q) > 1:
            if q.pop(0) != q.pop():
                return False

        return True

데크를 이용한 최적화

-> O(n), 2705 ms -> 1643 ms로 감소 Deque를 사용 : 이중 연결 리스트 구조로 양쪽 방향 모두 추출하는데 O(1) 시간만큼 걸림

class Solution:
    def isPalindrome(self, head: Optional[ListNode]) -> bool:
        q: Deque = collections.deque()

        if not head:
            return True

        node = head
        while node is not None:
            q.append(node.val)
            node = node.next

        while len(q) > 1:
            if q.popleft() != q.pop():
                return False

        return True

런너를 이용한 풀이

-> O(n), 1643 ms -> 1541 ms로 감소 링크드 리스트에서 2개의 러너를 사용 하나는 2칸씩 이동하는 러너, 하나는 하나씩 이동하는 러너 2칸씩 이동하는 러너가 끝에 도착하면 하나씩 이동하는 러너는 링크드 리스트에서 중간 위치가됨. 이 점을 이용해 중간 위치를 알 수 있으므로 중간 이전과 중간 이후의 값 비교 가능

class Solution:
    def isPalindrome(self, head: Optional[ListNode]) -> bool:
        rev = None
        slow = fast = head

        #런너를 이용해 역순 연결 리스트 구성
        while fast and fast.next:
            fast = fast.next.next
            rev, rev.next, slow = slow, rev, slow.next

        if fast:
            slow = slow.next

        # 팰린드롬 여부 확인
        while rev and rev.val == slow.val:
            slow, rev = slow.next, rev.next

        return not rev

파이썬 다중 할당

rev = 1, slow = 2->3이라 가정

rev, rev.next, slow = slow, rev, slow.next

rev=2->3, rev.next=1, slow=3이 되고, rev.next=1이므로 최종적으로 rev=2->1, slow=3이 된다. 다중 할당을 하게 되면 이 같은 작업이 동시에 일어나기 떄문에, 이 모든 작업은 중간과정없이 한 번의 트랜잭션으로 끝나게 된다. V.S

rev, rev.next = slow, rev
slow = slow.next

rev=2->3, rev.next=1, 따라서 rev=2->1이 되는데 rev=slow, 동일한 참조가 되었으며 rev=2->1이 되었기 떄문에 slow=2->1로 바뀐다. 그래소 slow=1이 된다.

https://leetcode.com/problems/best-time-to-buy-and-sell-stock/

한 번의 거래로 낼 수 있는 최대 이익을 산출하라 입력 : [7, 1, 5, 3, 6, 4] 출력 : 5 설명 : 1일 때 사서 6일 때 팔면 5의 이익을 얻는다

풀이

BruteForce로 계산

모든 경우의 수를 계산해 본다 -> O(N^2), timeout

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        max_price = 0

        for i, price in enumerate(prices):
            for j in range(i, len(prices)):
                max_price = max(prices[j] - price, max_price)

        return max_price

저점과 현재 값과의 차이 계산

배열을 쭉 지나가면서 최저값을 저장하면서 현재 값과의 차이를 계산해준다 -> O(n)

class Solution:
    def maxProfit(self, prices: List[int]) -> int:

        min_price = prices[0]
        max_price = 0

        for price in prices:
            min_price = min(min_price, price)
            max_price = max(price - min_price, max_price)

        return max_price

개선점 : min_price = price[0]을 sys.maxsize로 대체 가능하다