chaelog

ㅇ

cheonniii — Fri, 20 Sep 2024 20:56:44 +0900

photo

cheonniii — Fri, 20 Sep 2024 16:53:01 +0900

DBSCAN / 3DGS / VAE

cheonniii — Mon, 3 Jun 2024 23:23:43 +0900

DBSCAN 개념 정리 → 3DGS에 어떻게 적용할지 → 예상되는 문제점, 해결 방안 + 궁금증 정리 → VAE

Density Based Clustering

Clusters: regions of high density that are separated from one another by regions on low density

DBSCAN

: Density-based algorithm

- Density: # of points within a specified radius (Eps)

Point

- core point: if it has at least a specified # of points (MinPts) within Eps

- border point: X core point, core point의 neighborhood

- noise point: X core point, X border point

Process

1. Label all points as core, border, noise points

2. noise points 제거

3. Put an edge between all core points within a distance Eps of each other

4. Make each group of connected core points into a separate cluster

5. Assign each borer point to one of the clusters of its associated core points

K-means clustering vs. DBSCAN

- K-means는 간단하고 강력한 clustering 방법이지만, cluster가 non-circular 모양일 때 문제가 되고, cluster의 개수를 먼저 구체화해야한다는 단점이 있다.

- DBSCAN은 사전에 cluster의 개수를 요구하지 않는다.

+ 다양한 cluster의 모양이나 크기 handle 가능. (density based로 클러스터링하기 때문에)

- Distance metric

- Epsilon (ε)

- The radius of the neighborhood around a point

- It determines the distance within which points are considered neighbors

- Minimum points (MinPts)

- The minimum # of neighbors a point must have within its epsilon radius to be considered a core point, defining a dense area.

주제에 대한 고민

Mini splatting & Clustering으로 3DGS memory 최적화

DBSCAN → 미분 가능해야하는데 어떻게 하면 미분 가능하게 할지 고민

DBSCAN은 backpropagation 안함 !

DBSCAN은 밀도 기반 unsupervised learning의 클러스터링 방법으로, supervised learning과 달리 backpropagation이나 gradient descent 같은 학습 과정을 사용하지 않는다. 학습 시킨다는 개념 자체가 존재하지 않고, 파라미터 최적화도 ML 모델처럼 자동으로 이루어지지 않아서 실험 통해 직접 찾아야 함. (eps, min_samples 같은)

어떻게 미분 가능하게 연결하지?

→ Variational Autoencoder (VAE)와 같은 미분 가능한 알고리즘 사용

VAE: 입력 데이터를 저차원 잠재 공간으로 인코딩한 다음, 이를 다시 원래의 데이터로 디코딩하는 과정을 거침. (이 과정은 전체적으로 미분 가능해서 gradient descent와 같은 최적화 알고리즘을 사용할 수 있음)

DBSCAN의 클러스터링 결과를 VAE에 통합하는 방법 ? 내 생각..

1. 클러스터 소속 정보를 추가적인 입력 또는 조건부 정보로 활용

: VAE의 입력에 클러스터 소속 정보를 추가하여, 네트워크가 이 정보를 고려하여 재구성하도록 (?)

VAE 모델에 입력 데이터 외에 추가적인 정보를 제공.

DBSCAN을 사용하여 데이터를 클러스터링한 후, 각 데이터 포인트가 속한 클러스터의 레이블을 추가적인 입력 정보로 VAE 모델에 제공.

이렇게 하면, VAE의 인코더는 원본 데이터와 클러스터 레이블을 함께 고려하여 잠재 공간에 매핑하게 됨.

디코더는 이 잠재 공간의 벡터를 받아 원래의 데이터를 재구성하려 할 때, 클러스터 레이블 정보를 이용함

2. 클러스터 결과를 잠재 공간의 규제로 사용

: 잠재 공간에서 비슷한 데이터 포인트들이 DBSCAN 결과와 유사한 클러스터를 형성하도록 규제를 적용 (?)

DBSCAN 결과로 얻어진 클러스터들이 비슷한 특성을 가진 데이터 포인트들로 구성되어 있음을 고려하여, VAE의 잠재 공간에서도 같은 클러스터에 속하는 데이터 포인트들이 서로 가깝게 위치하도록 함.

이를 위해 손실 함수에 클러스터 기반의 규제 항을 추가.

예를 들어, 같은 클러스터에 속하는 데이터 포인트들의 잠재 벡터 사이의 거리가 작도록 하고, 다른 클러스터에 속하는 데이터 포인트들의 잠재 벡터 사이의 거리는 크도록 손실 함수 설계.

VAE (Auto-Encoding Variational Bayes)

https://arxiv.org/pdf/1312.6114

Ch 4. Recursion_Assignment 1

cheonniii — Mon, 25 Mar 2024 01:28:36 +0900

https://colab.research.google.com/drive/1tcVU6aP4jGObq_m6HePgPvtJK3bq29I8#scrollTo=UFvIxDpNhlKm

Approach 1

Using For loop

x^n 계산하기 위해 x를 n번 곱한다.

def power_with_for_loop(x, n):
    result = 1
    for _ in range(n):
        result *= x
    return result

실행한 결과

Time Complexity Analysis:

In this approach, we iterate 'n' times, performing a constant-time operation within each iteration.
Therefore, the time complexity is O(n).

Practical Time Complexity Comparison:

For n = 100, the algorithm will iterate 100 times, resulting in linear time complexity.

Theoretical Time Complexity Analysis:

The time complexity is theoretically O(n), as the algorithm iterates 'n' times linearly.

Approach 2

Using Recursive Algorithm

def power_recursive(x, n):
    if n == 0:
        return 1
    return x * power_recursive(x, n - 1)

실행한 결과

Time Complexity Analysis:

In this approach, the function calls itself recursively 'n' times.
Each function call involves a constant-time operation.
Therefore, the time complexity is O(n).

Practical Time Complexity Comparison:

For n = 100, the recursive algorithm will make 100 function calls, resulting in linear time complexity.

Theoretical Time Complexity Analysis:

The time complexity is theoretically O(n), as the function is recursively called 'n' times.

conclusion

Both approaches have a time complexity of O(n) theoretically and practically for the given value of n = 100. However, in practice, the recursive approach might suffer from issues such as stack overflow for larger values of n due to the repeated function calls, making the iterative approach more suitable for large inputs. Nonetheless, both algorithms provide linear time complexity for calculating the power of x raised to the nth power.

Complexity Analysis of Algorithms / Recursion_OP

cheonniii — Thu, 14 Mar 2024 12:04:00 +0900

Complexity Analysis of Algorithms

Open Problem 1

Compare the efficiency of the below two algorithms, visually or theoretically or in your way!

알고리즘 1에서는 n^(7/5) 항이 n의 증가에 따라 가장 빠르게 증가한다.

알고리즘 2에서는 n^(11/6) 항이 n이 지배적이다.

각 최고차항의 지수를 비교했을 때 2의 n^(11/6)이 1보다 크다.

➡️ n이 커질수록 알고리즘 2의 실행시간이 알고리즘 1보다 더 빠르게 증가하므로, 알고리즘 1이 알고리즘 2보다 효율적이다.

시각적으로 비교한 결과

Open Problem 2

Find the time complexity of the following Python code and explain:

i=1 
while(i<n): 
    i*=2 
    print("data")

i가 1에서 시작해서 i가 n보다 작은 동안 i의 값을 2배씩 증가시키는 반복문

매 반복마다 data 출력함.

- 반복문은 i의 값이 매 반복마다 2배로 증가하기 때문에, n에 도달하기 위해 필요한 반복 횟수는 n의 크기에 따라 로그 스케일로 증가함.

- i는 1, 2, 4, 8, ... 과 같이 증가하고 n에 도달하거나 넘기 위해서는 log작은2n 번의 반복이 필요함.

➡️ 시간 복잡도는 O(logn)

n이 커질수록 실행시간이 로그 함수의 증가율로 증가함을 의미한다. while 반복문은 i가 n을 초과할 때까지 반복됨.

Open Problem 3

Find the time complexity of the following Python code and explain:

i = n
while(i>0):
    print("complexity")
    i /= 2

i가 0보다 큰 동안 i의 값을 2로 나누는 반복문을 포함한다. 매 반복마다 complexity 출력됨.

- 반복문은 i의 값이 매 반복마다 절반으로 감소하기 때문에 i가 0보다 작아지기까지 필요한 반복 횟수는 n의 크기에 따라 로그 스케일로 증가한다.

- i는 n, n/2, n/4, ... 과 같이 감소하며 0에 도달하거나 그보다 작아지기 위해서는 log작은2n번의 반복이 필요하다.

➡️ 시간 복잡도는 O(logn)

Open Problem 4

Find the time complexity of the following Python code and explain:

for i in range(1,n):
    j = i 
    while(j<n):
        j*=2

for 루프는 1부터 n-1까지 반복하고, while 루프는 j가 n 미만일 때까지 j의 값을 2배로 증가시킨다. 여기서 j는 for 루프이ㅡ 각 반복마다 i로 초기화된다.

- for 루프는 n-1번 반복해서 O(n)의 시간복잡도를 가진다.

- while 루프에서는 j가 매번 2배씩 증가하기 때문에, i부터 n에 도달하기까지의 반복횟수는 log작은2n에 비례한다. 따라서 while 루프의 시간 복잡도는 O(logn)이다.

- 총 시간 복잡도는 for와 while의 결합이다.

➡️ 시간복잡도는 O(nlogn)

Open Problem 5

Find the time complexity of the following Python code and explain:

i=1
while(i<n): 
    print("python")
    i = i**2

i가 1에서 시작해서 i가 n보다 작은 동안 i의 값을 i제곱하는 반복문

- while 루프는 i의 값이 매 반복마다 제곱되기 때문에 i가 n에 도달하기까지 필요한 반복 횟수는 n의 크기에 따라 로그 로그 스케일로 증가한다.

엥?

계속 1이면..무한..?

Recursion

Open Problem 1

In the lecture slide, we showed the time complexity of the below algorithm for Fibonacci series is O(2^n). In similar way, find Big Omega $Ω (\cdot)$ of this algorithm.

# Recursion
def fib_recursive(n):
  if n < 0:
    print("Incorrect input")
  elif n == 0: 
    return 0
  elif n == 1 or n == 2:
    return 1
  else:
    return fib_recursive(n-1)+fib_recursive(n-2)

Ω는 알고리즘의 최소 실행 시간이나 하한을 나타내는 데 사용됨.

Big O을 통해 최악의 시간 복잡도가 O(2^n)이라는 것을 알 수 있음. 그러나 피보나치 수열을 계산하는 알고리즘 특성상 각 단계에서 재귀 호출이 이루어지고, 이 호출이 연속적으로 이루어지므로 성능 하한도 지수임.

➡️ Ω(2^n)

Open Problem 2

Can you write an algorithm for the Fibonacci series with a time complexity of $O (n)$ $O (n)$

def fib_dynamic(n):
    # n이 0이거나 음수인 경우의 처리
    if n < 0:
        print("Incorrect input")
        return None
    # n이 0 또는 1인 경우의 처리
    elif n == 0:
        return 0
    elif n == 1:
        return 1
    
    # 첫 번째 항과 두 번째 항의 초기 값 설정
    fib_0, fib_1 = 0, 1
    # n번째 항까지 계산
    for i in range(2, n + 1):
        fib_n = fib_0 + fib_1
        fib_0, fib_1 = fib_1, fib_n
    return fib_n

print(fib_dynamic(10))  # 10번째 피보나치 수를 출력

Open Problem 3

Write functions that calculates the factorial of n (i.e., n!)
- Approach 1: Using For loop
- Approach 2: Using Recursive algorithm

Time complexity analysis
- Provide comparison of both practical (e.g. for n=100) and theoretical time complexity analysis for each approach

1. Approach 1: Using For loop

def factorial_for_loop(n):
    if n < 1:  # 0! = 1
        return 1
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

- 1부터 n까지 의 수에 대해 1번씩 곱셈 수행함.

- 시간 복잡도는 O(n)

(n에 대해 선형적으로 증가하는 연산 횟수를 가짐.)

2. Approach 2: Using recursive algorithm

def factorial_recursive(n):
    if n < 1:  # 0! = 1
        return 1
    else:
        return n * factorial_recursive(n - 1)

- 각 단계에서 n에 대한 곱셈을 한 번 수행하고 n-1에 대해 자신을 호출함.

n에서 1까지 감소하면서 각 단계마다 한 번의 호출이 발생하므로 시간 복잡도는 O(n).

n = 100과 같은 상대적으로 큰 값에 대해서는 for 루프 방식이 재귀 방식보다 선호될 수 있음. 재귀 방식은 호출 스택의 크기에 제한이 있기 때문에, 매우 깊은 재귀 호출이 필요한 경우 스택 오버플로우 오류가 발생할 수 있음.

Open Problem 4

Write an recursive algorithm that prints out multiplication table (i.e., gugu-dan). For example, “Table of 3” should print out the below.

## 3 x 1 = 3
## 3 x 2 = 6
## 3 x 3 = 9
## 3 x 4 = 12
## 3 x 5 = 15
## 3 x 6 = 18
## 3 x 7 = 21
## 3 x 8 = 24
## 3 x 9 = 27

def print_multiplication_table(number, i=1):
    if i > 9:  # 기저 조건: i가 9보다 크면 종료
        return
    print(f"{number} x {i} = {number * i}")
    print_multiplication_table(number, i + 1)  # 재귀 호출: 다음 곱셈을 출력

# 예제: 3의 구구단 출력
print_multiplication_table(3)

Open Problem 5

Write an algorithm that convert the given decimal number into an equivalent binary number. For example, The decimal number $10$ can be represented as the binary number $1010$ .

## Decimal number =  10  can be represented as the Binary number 1010

10진수를 2진수로 변환하는 알고리즘 작성

1. 주어진 10진수 n을 2로 나눈다.

2. 나머지를 결과 문자열에 추가한다.

3. n을 2로 나눈 몫으로 업데이트하고 1단계로 돌아간다.

4. n이 0이 될 때까지 이 과정 반복한다.

5. 마지막으로 결과 문자열을 뒤집는다. (나머지 구하는 과정에서 2진수의 가장 낮은 자리수부터 계산하기 때문)

코드 예시

def decimal_to_binary(n):
    # 기저 조건: n이 0이면, 빈 문자열을 반환
    if n == 0:
        return "0"
    # 재귀적으로 나머지를 문자열로 변환하여 결합
    else:
        return decimal_to_binary(n // 2) + str(n % 2) if n > 1 else str(n % 2)

# 예제: 10을 이진수로 변환
binary_number = decimal_to_binary(10)
# 앞에 "0"이 올 경우를 대비하여 int로 변환 후 다시 str로 변환하여 불필요한 "0" 제거
binary_number = str(int(binary_number))
print(f"Decimal number = 10 can be represented as the Binary number {binary_number}")

10진수를 2진수로 변환하는 재귀함수 decimal_to_binary를 정의한다. 함수는 10진수 n을 인수로 받아, 이를 2진수 문자열로 변환하여 반환한다. n이 0이면 0을 반환하고, 1 이상이면 n을 2로 나눈 몫을 함수에 다시 넘기고 현재의 n을 2로 나눈 나머지를 문자열에 추가한다. 이 과정을 n이 0이 될 때까지 반복하고 최종적으로 생성된 문자열을 반환한다.

Open Problem 6

Suppose there is a given number, $n$ (i.e. 12).
- If that given number is even, you half that number. You continue to half the resulting number if it is even.
- If not (i.e., if the number is odd), then you take the odd number and multiply it by 3 and add 1.
- You continue to apply these two operations (either $n * 2$ or $3 n + 1$ ) until n = 1.
For example,
- Say $n = 20$ . Then $20 - > 10 - > 5 - > 16 - > 8 - > 4 - > 2 - > 1$
- Say $n = 32$ . Then $32 - > 16 - > 8 - > 4 - > 2 - > 1$
Write algorithms that using For loop or recursive algorithm.
What is this conjecture and any interesting story?

콜라츠 추측. 어떤 자연수 n에 대해서도 다음 규칙을 반복하면 최종적으로 1에 도달한다.

이 짝수라면, 을 2로 나눈다.
이 홀수라면, 에 3을 곱하고 1을 더한다.
이 과정을 이 1이 될 때까지 반복한다.

For loop 사용한 알고리즘

def collatz_for_loop(n):
    sequence = [n]  # 초기 수 n을 시퀀스에 포함
    while n != 1:
        if n % 2 == 0:
            n = n // 2
        else:
            n = 3 * n + 1
        sequence.append(n)
    return sequence

Recursive Algorithm

def collatz_recursive(n, sequence=None):
    if sequence is None:
        sequence = [n]
    if n == 1:
        return sequence
    elif n % 2 == 0:
        sequence.append(n // 2)
        return collatz_recursive(n // 2, sequence)
    else:
        sequence.append(3 * n + 1)
        return collatz_recursive(3 * n + 1, sequence)

Data Structures_week2 review

cheonniii — Tue, 12 Mar 2024 09:56:33 +0900

1. Complexity Analysis of Algorithms

- Spatial complexity analysis

- Time complexity analysis

2. Asymptotic Notations in Complexity Analysis

- Big O notation

- Big Ω notation

- Big ⊝ notation

3. Recursive Algortihm

Examples

- Summation: Recursion vs. Iteration

- Fibonacci: Recursion vs. Iteration

- Tower of Hanoi

- Fractal

Complexity Analysis of Algorithms

1. Spatial complexity analysis

- Mempory space required for execution

2. Time complexity analysis

a) Practical Speed

- Measuring the actual execution time of algorithms

b) Theoretical Speed

- Measure the number of operations performed by the algorithm as a function of data input size n

➡️ Theoretical speed이 합리적 (Free of implementation, Independent of hardware, Independent of software)

1. Time Complexity Analysis: Practical

- Measuring the actual execution time of algorithms

import time # importing time module
start_time = time.time() # record start time
sum = 0
for i in range(2000):
sum = sum + i
end_time = time.time() # record end time
elapsed_time = end_time-start_time # the difference is execution time
print('Execution time:', round(elapsed_time,5), 'seconds')

## Execution time: 0.01051 seconds

- difference of end time & start time = execution time

- time: module that measures current time in the processor

2. Time Complexity Analysis: Theoretical

- Measure the number of operations performed by the algorithm as a function of data input size . We call the number of operations as a function of n as f(n)

- e.g. Compare 3 algorithms to compute n^2

1) Algorithm 1

- n * n

- number of multiplicaton = 1

- number of assignment = 1

- In total: 2

def nn_1(n):
out = n*n	# 1 multiple
return out	# 1 assignment: 결과 output에 저장

2) Algortithm 2

- number of summation = n

- number of assignment = n + 1

- In total: 2n + 1

def nn_2(n):
out = 0		# initialize out=0: 1회
for i in range(n):	# iterate n times
	out += n	# summation happens 1 time인데 for loop로 n번 반복되니까 assignment n*1회
return out

3) Algorithm 3

- number of summation = n^2

- number of assignment = n^2 + 1

- In total = 2n^2 + 1

def nn_3(n):
out = 0
for i in range(n):
for j in range(n):
out += 1
return out

알고리즘 1이 가장 좋은 결과 보였다

Big O, Ω, ⊝ Notation

- Big O: the upper bound of the function (worst-case complexity of an algorithm)

알고리즘의 시간 복잡도 나타내는 표기

- Big Ω: the lower bound of the function (best-case complexity of an algorithm)

- Big ⊝: the lower and upper bound of the function (average-case complexity of an algorithm)

Properities of Big O

- 데이터 입력값 n이 충분히 크다고 가정하고 있기 때문에 상수항 무시

- O(N^2 + 2N + 1) → O(N^2)와 같이 영향력이 지배적인 N^2 이외의 항 무시

Recursion

def sum_recursive(n):
 return n + sum_recursive(n-1)
sum_recursive(3)

stopping criteria 없음

⬇️ Base condition is needed to stop the recursion otherwise will run infinitely.

def sum_recursive(n):
 if n < 1:
 return 0
 else:
 return n + sum_recursive(n-1)
sum_recursive(3)

Fibonacci Series

1. Recursion

def fib_recursive(n):
 if n < 0:
 print("Incorrect input")
 elif n == 0:
 return 0
 elif n == 1 or n == 2:
 return 1
 else:
 return fib_recursive(n-1)+fib_recursive(n-2)
fib_recursive(8)

T(n) = T(n-1) + T(n-2) + 1

O(2^n)

2. Iteration

def fib_for(n):
 fib = [0,1] + [0]*(n-1)
 for i in range(2, n+1): # run (n-1) times: O(n)
 fib[i] = fib[i-1] + fib[i-2]
 return fib[n]
fib_for(8)

O(n)

recursion is inefficient for Fibonacci Series

→ it becomes worse when n becomes larger

Data Structures 1주차 수업 정리

cheonniii — Tue, 5 Mar 2024 17:44:10 +0900

1, 2강 정리

1_Intro to Data Structure

2_Introduction to Python

1_ Intro to Data Structure

Data Structure

- ways of organizing and storing data in a computer

Programs = Algorithms + Data Structures

- Program: search a specific number

- Algorithm: sequential search

- Data Structure: array

Types of Data Structure (요약)

1. Linear: data elements are arranged sequentially or linearly

e.g. array, list, stack, queue

2. Non-linear: data elements are on non-sequentially or in multiple levels

e.g. tree, graph

Types of Algorithms

- sorting, searching

- creating minimum spanning tree

➡️ Array, Linked List, Stack, Queue, Tree, Graph

1. Array (or Simple List)

- A collection of items of same data type stored at contiguous memory locations

- A static data structure with a fixed memory size, i.e., once the size is given to it, it cannot be changed

2. Linked List

- A collection of items of same data type not stored at a contiguous location, but rather consists of series of connected nodes

- A dynamic data structure does not have any fixed memory size, i.e., its size can be changed.

3. Stack

- A pile of arranged objects

- The insertion of a new element and removal of an existing element takes place at the same end at the top of the stack

- LIFO(Last In First Out) or FILO(First In Last Out)

4. Queue

- A line of things

- The insertion of a new element and removal of an existing element takes place at the opposite end

- LILO(Last In Last Out) or First In First Out (FIFO)

5. Tree

- A tree data structure has a root, branches, and leaves

- The difference between a tree in nature and a tree in computer science is that a tree data structure has its root at the top and its leaves on the bottom

- A hierarchical structure that is used to represent and organize data in a way that is easy to navigate and search

- Tree consists of nodes of parent-child relationship

6. Graph

- A diagram showing the relation between variable quantities

- A Graph consists of vertices/nodes and edges

1. Sorting

- Puts elements of a list into an order

2. Searching

- Trying to find something by seeking carefully and thoroughly

3. Creating Minimum Spanning Tree

- Minimum Spanning Tree: a subset of the edges of a connected, edge-weighted graph that connects all the vertices together without any cycles and with the minimum possible total edge weight

- Prim’s algorithm, Kruskal’s algorithm, etc

2_Introduction to Python

보충 필요한 부분만 정리함

Attributes

- class creates a user-defined data structure

- Attributes: the variables that belong to a class

- Attributes can be accessed using the dot (.) operator

class MyClass: # a class in its simplest form
 name = "Ewha" # attribute: a variable that belong to a class
 age = 25
myobject = MyClass() # an object in its simplest form
print("My name is", myobject.name)
print("I'm", myobject.age, "years old")

## My name is Ewha

## I'm 25 years old

self Parameter

- A reference to the current instance of the class, and is used to access variables that belongs to the class

class MyClass:
 name = "Ewha"
 age = 25
 def myname(self): # a function that belongs to the class
 print("My name is", self.name)
 print("I'm", self.age, "years old")
myobject = MyClass()
myobject.myname()
print("Access name variable inside object:", myobject.name)
print("Access age variable inside object:", myobject.age)

## My name is Ewha

## I'm 25 years old

## Access name variable inside object: Ewha

## Access age variable inside object: 25

__init__() Function

- A function which is always executed when the class is being initiated

- __init__: used to initialize objects of a newly created object of a class

class MyClass:
 def __init__(self,name,age):
 self.name = name
 self.age = age
 def myname(self):
 print("My name is", self.name)
 print("I'm", self.age, "years old")

myobject = MyClass(name="Amy", age=55)
myobject.myname()
print(myobject)

## My name is Amy

## I'm 55 years old

## <__main__.MyClass object at 0x0000000052F37CD0>

내적 (2)

cheonniii — Tue, 27 Feb 2024 23:08:50 +0900

하우스홀더 방법을 이용한 QR 분해

A = [[1, -1, 4], [1, 4, -2], [1, 4, 2], [1, -1, 0]]

QR 분해할 행렬 A 선언

A1 = deepcopy(A)

a1 = transpose(A)[0]
print(a1)

>>> [1, 1, 1, 1]

deepcopy 함수를 이용해 행렬 A의 내용을 복사한 행렬 A1을 구함

첫번째 열 추출하여 a1이라 함

nm1 = norm(a1)
print(nm1)

>>> 2.0

벡터 a1의 norm 구하기

e1 = [1]
for i in range (0, len(a1)-1):
	e1.append(0)
    
tmp_e1 = []
for i in range (0, len(e1)):
	val = sign(a1[0])*nm1*e1[i]
    tmp_e1.append(val)
    
v1 = v_add(a1, tmp_e1)
print(v1)

>>> [3.0, 1.0, 1.0, 1.0]

e1 벡터 리스트 생성하고 벡터 v1 생성

v1 생성 공식

v1 = a1 + sign(a1)||a1||e1

# H1 생성
H1 = householder(v1)
print(H1)

행렬 H1

H1 = I -2(v1v1^T)/(v1^Tv1)

tmp_res1 = matmul(H1, A1)

H1과 A1의 행렬 곱을 구하고 tmp_res1에 저장

matmul 함수 이용

A2 = []
for i in range(1, len(A1)):
	tmp_row = []
    for j in range(1, len(A1[0])):
    	tmp_row.append(tmp_res1[i][j]))
    A2.append(tmp_row)
print(A2)

tmp_res1 행렬의 1행과 1열을 제거한 행렬 A2를 구하는 과정

A2의 원소를 담을 비어있는 리스트를 생성하고 A2에 추가할 행에 대한 반복문 수행.

인덱스는 0이 아닌 1부터 시작해야함. 행렬 tmp_res1의 1행을 제외해야하기 때문

행렬 A2에 추가할 행이 될 비어 있는 리스트 tmp_row 정의하고

A2의 열에 대한 반복문 수행

a2 = transpose(A2)[0]
print(a2)

행렬 A2의 1열을 추출해 벡터 a2 생성

같은 과정 거쳐서 v2랑 v3 생성하고 H2와 H3 생성

tmp_H2 = identity(len(A))
for i in range(1, len(A)):
	for j in range(1, len(A)):
    	tmp_H2[i][j] = H2[i-1][j-1]
H2 = tmp_H2
print(H2)

3행 3열 크기의 행렬 H2를 4행 4열 크기의 행렬로 바꾸는 과정

기본 뼈대가 될 단위 행렬 tmp_H2를 identity 함수를 이용해 만듦

비슷한 과정 거쳐서 2행 2열이었던 H3 행렬을 4행 4열 형태로 변환하기

여기까지 하면 H1, H2, H3를 모두 구할 수 있음

Q = H1*H2*H3
Q = matmul(matmul(H1, H2), H3)
print(Q)

Q = H1H2H3

행렬 곱 이용해 행렬 Q 구할 수 있음

R = H3 * H2 * H1 * A
R = matmul(matmul(matmul(H3, H2), H1), A)
print(R)

R = H3H2H1A

행렬 R 구하는 식

> 함수 생성

여태까지의 과정 일반화하는 함수 생성하여 하우스홀더 방법 이용한 QR 분해 수행

def qr_householder(A):
'''
입력값: 행렬 A
출력값: 행렬 Q, R
'''

n = len(A)
p = len(A[0])

H_list = []

for i in range(0, p):

	if i==0:
    	A1 = deepcopy(A)
        exA = A1
    elif i < p-1:
    	Ai = []
        for j in range(1, len(exA):
        	row = []
            for k in range(1, len(exA[0])):
            Ai.append(row)
        exA = Ai
    elif i==p-1:
    	Ap = []
        for j in range(1, len(HA)):
        	Ap.append(HA[j][i])
        exA = Ap
   
    # 열 추출
    if i<p-1:
    	a = transpose(exA)[0]
    else:
    	a = exA
    nm = norm(a)
    
    # e 생성
    e = [1]
    for j in range(0, len(a)-1):
    	e.append(0)
    
    # v 생성
    tmp_e = []
    for j in range(0, len(e)):
    	val = sign(a[0])*nm*e[j]
        tmp_e.append(val)
    v = v_add(a, tmp_e)
    
    # H 생성
    H = householder(v)
    
    # H*A
    if i==p-1:
    	HA = []
        for j in range(0, len(H[0]):
        	val += H[j][k]*exA[k]
        HA.append(val)
    else: 
    	HA = matmul(H, exA)
    
    H_list.append(H)
    
    if i > 0:
    	tmp_H = identity(len(A))
        for j in range (i, len(A)):
        	for k in range(i, len(A)):
            	tmp_H[j][k] = H_list[-1][j-i][k-i]
        H_list[01] = tmp_H
        
    Q = deepcopy(H_list[0])
    for j in range(0, len(H_list)-1):
    	Q = matmul(Q, H_list[j+1])
    
    R = deepcopy(H_list[-1])
    for j in rnage(1, len(H_list)):
    	R = matmul(R, H_list[-(j+1)])
    R = matmul(R, A)
    
    return Q, R

qr_householder 함수

qr_householder 함수의 입력값은 행렬 A

Deep Learning for Audio Signal Processing 리뷰

cheonniii — Tue, 13 Feb 2024 10:10:34 +0900

Abstract

오디오 신호 처리를 위한 딥러닝 기술 다루는 논문

1. Introduction

neural network가 주목받은 이유

perceptron algorithm
backpropagation algorithm
딥러닝에서의 음성 인식의 성공

image processing ➡️ audio로 많은 딥러닝 method가 채택됨

	Image	Raw Audio (1D)	2D Audio
D	2D	1D (t)	2D (t-f)
time	instantaneous	-	sequentially
order	little constraints	-	chronological

2. Methods

A. 오디오 분석, 합성 개념

B. input representations

C. 모델

D. 데이터

E. 평가 방법

A. Problem Categorization

대상 예측 종류에 따른 카테고리 분류

1️⃣ 전역 레이블, 지역 레이블, 자유 길이 시퀀스

전역 레이블 single global label

단일 전역 클래스 레이블을 예측하는 경우
1. 시퀀스 분류 (Sequence Classification)
  - 정의: 단일 전역 클래스 레이블을 예측하는 것
  - ex. 사전에 정의된 가능한 클래스 집합에서 언어, 화자, 음악 키 또는 음향 장면을 예측하는 것
2. 다중 레이블 시퀀스 분류 (Multi-label Sequence Classification)
  - 정의: 가능한 클래스 집합 중에서 여러 레이블을 선택할 수 있는 경우
  - ex. 여러 음향 이벤트 또는 음악 음계를 예측하는 것으로, 클래스들이 서로 의존할 때 특히 효과적임
3. 시퀀스 회귀 (Sequence Regression)
  - 정의: 연속 범위에서 대상 값을 예측
  - ex. 음악의 템포를 추정하거나 다음 오디오 샘플을 예측
4. 회귀 문제에 대한 주의사항:
  - 회귀 문제는 분류 문제로 변환될 수 있
  - ex. 오디오 샘플을 양자화하여 (예: 8비트로) 예측하면 256개의 클래스로 이루어진 분류 문제로 전환

지역 레이블 local label per time step

각 시간 단계별로 지역 레이블을 예측하는 경우
1. 시간 단계별 레이블 예측 (Label per Time Step Prediction):
  - 각 시간 단계마다 일정 수의 오디오 샘플을 포함할 수 있으며, 따라서 대상 시퀀스의 길이는 입력 시퀀스 길이의 일부분이 됨.
  - 시퀀스 레이블링 (Sequence Labeling): 각 시간 단계별로 분류를 수행하는 것을 의미함.
  - ex. 코드 어노테이션 및 보컬 활동 감지. 이벤트 감지는 스피커 변경이나 음표 시작과 같은 이벤트가 발생하는 시간을 예측하려고 하는데, 이는 이진 시퀀스 레이블링 작업으로 정의될 수 있습니다.
2. 시간 단계별 회귀 (Regression per Time Step):
  - 각 시간 단계에서 연속적인 예측을 생성하며, 예측은 이동하는 소리 원본까지의 거리나 목소리의 음높이 또는 소스 분리일 수 있음.
3. 시퀀스 변환 (Sequence Transduction):
  - 대상 시퀀스의 길이가 입력 길이의 함수가 아닌 경우
  - ex. 음성 인식, 음악 전사, 또는 언어 번역

자유 길이 시퀀스 free-length sequence of labels

입력 길이에 관계없이 레이블 시퀀스의 길이가 정해져 있지 않음

2️⃣ 단일 클래스, 클래스 집합, 숫자 값

단일 클래스
클래스 집합
숫자 값

B. Audio Features

음성 처리: 적절한 특징 표현 구축하고, 이 특징에 대한 적절한 classifier 설계하는 것이 별개

prob: 신경망이 자동으로 특징을 추출하고 최적화를 수행하더라도, 그 결과로 생성된 특징이 분류 목표에 대해 최상의 성능을 보장하지 않을 수 있음

sol: DNNs

특징 추출 2) 목표 최적화 (ex. 분류) ➡️ 동시 수행

전통적인 오디오 특징으로는 MFCCs가 주로 사용되며, 최근에는 딥러닝 모델에서 자동으로 학습되는 특징 추출이 주목받고 있음. 멜 필터 뱅크와 상수-Q 스펙트럼은 주파수 투영에 사용되는 중요한 개념이며, 스펙트로그램의 공간적 특성을 고려하기 위해 다양한 접근이 시도되고 있음

MFCCs
- 오디오 분석 작업에 사용
- 로그 크기로 변환되며 DCT로 근사적으로 흰색화 및 압축됨.
- 딥러닝 모델에서는 이 과정이 불필요해서, 이를 생략하면 로그-멜 스펙트럼이 생성됨.
멜 필터 뱅크와 Constant-Q Spectrum:
- 멜 필터 뱅크는 인간 청각 시스템에서 영감을 받음.
- 어떤 작업에서는 변조를 번역으로 캡처하는 데 적합한 상수-Q 스펙트럼을 사용하는 것이 선호됨.
로그-멜 및 Constant-Q 스펙트로그램:
- 스펙트로그램은 시간적인 스펙트럼의 연속이며, 인접한 시간 및 주파수의 스펙트로그램은 상관관계가 있음.
- 음향에서는 주파수의 고조의 추가 상관관계가 있으며, 이를 모델링하기 위해 제 3 차원이 추가될 수 있음.
윈도우 크기 및 스펙트럼 계산:
- 윈도우 크기는 시간 및 주파수 해상도 간의 교환을 나타냄.
- 다양한 윈도우 길이를 사용하거나 빈도 대역에서 투영된 스펙트라를 따로 처리하여 공간적으로 로컬한 모델에 유용함.
필터 뱅크에 의존하지 않는 방법:
- 설계된 필터 뱅크에 의존하지 않기 위해 데이터 기반 통계 모델 학습을 위한 다양한 방법이 제안됨.
- 멜-간격 삼각형 필터 대신 데이터 기반 필터를 학습하여 사용하는 방법 등이 있음.
- 이러한 방법은 목표 작업에 대해 직접 최적화된 학습된 필터를 사용함.

C. Models

오디오 신호는 다양한 형태로 나타낼 수 있고, 이를 딥러닝 모델로 분석하기 위해 다양한 네트워크 레이어가 쌓일 수 있음. 딥 뉴럴 네트워크는 이러한 층이 많이 쌓인 신경 네트워크를 가리킴.

a) Convolutional Neural Networks (CNNs)

Convolutional Operation:
- 학습 가능한 커널과의 입력과의 합성을 기반으로 함.
- 스펙트럼 입력 특징의 경우 1차원 시간 합성 또는 2차원 시간-주파수 합성이 일반적.
- 원시 파형 입력에 대해 시간 영역 1차원 합성 적용.
Pooling Layers:
- 합성곱층 위에 추가되어 학습된 특징 맵을 다운샘플링하는 데 사용됨.
Layer Structure:
- 일련의 합성층과 풀링층으로 구성되며, 그 뒤에 하나 이상의 밀집층이 따라올 수 있음.
- 시퀀스 레이블링을 위해 밀집층을 생략하여 완전 합성 네트워크 (FCN)를 얻을 수 있음.
Receptive Field:
- CNN의 구조에 의해 정해진 예측 계산에 참여하는 샘플 또는 스펙트럼의 수.
- 큰 커널 또는 더 많은 층을 쌓음으로써 늘릴 수 있으며, 필요한 경우 확장된 합성 (dilated convolution)을 사용할 수 있음.
Dilated Convolution:
- 합성층의 필터 길이보다 큰 영역에 적용되며, 필터 계수 사이에 0을 삽입하여 확장됨.
- 다른 층들을 쌓아도 큰 수용 영역을 얻을 수 있음.
Optimal Architecture Determination:
- 현재 최적의 CNN 아키텍처를 결정하는 데 관한 이론은 부족함.
- 아키텍처는 주로 실험적으로 검증 오차를 기반으로 선택되며, 경험적인 지침에 의존함.

b) Recurrent Neural Networks (RNNs)

CNNs로는 제한된 크기만 모델링할 수 있지만, RNNs는 현재 단계의 입력과 이전 단계의 숨겨진 상태로 출력을 계산하여 다른 방법으로 모델링함.

Temporal Dependency Modeling:
- RNNs 모델은 각 시간 단계에서 현재 입력 및 이전 단계의 숨겨진 상태를 사용하여 출력을 계산함.
- 이는 입력의 시간적 종속성을 내재적으로 모델링하며, 수용 영역을 무한대로 확장할 수 있음.
Bidirectional RNNs:
- 오프라인 응용에서는 미래로의 수용 영역을 확장하기 위해 두 번째 재현을 역순으로 하는 양방향 RNNs 사용.
Exponential Growth of Representable States:
- RNNs에서는 모든-모든 커널을 사용하는 재귀적 숨겨진 유닛 수의 선형 성장에 대조적으로, 표현 가능한 상태의 수가 기하급수적으로 증가.
- 훈련 또는 추론 시간은 최대로 제곱 증가.
Gradient Issues:
- 훈련 중에 사라지거나 폭발하는 기울기 문제가 발생할 수 있음.
- Long Short-Term Memory (LSTM)은 게이팅 메커니즘 및 메모리 셀을 활용하여 이를 완화.
Variations to Address Gradient Issues:
- 여러 변형이 개발되어 이 문제에 대응함. LSTM, 스파스 재귀 네트워크, 반복 레이어 쌓기 등.
Extended Models:
- LSTMs은 시간 및 주파수 영역을 모델링하는 데 확장됨.
- Frequency LSTMs (F-LSTM) 및 Time-Frequency LSTMs (TF-LSTM)이 CNN 대안으로 도입됨.
CRNN (Convolutional Recurrent Neural Network):
- CNN의 출력을 처리하여 로컬 정보를 추출하고 재귀적 레이어가 더 긴 시간적 컨텍스트를 결합하는 모델.

c) Sequence-to-Sequence Models

입력 시퀀스를 직접 출력 시퀀스로 변환
Traditional Systems vs. End-to-End Models:
- 전통적인 시스템은 작업을 여러 하위 작업으로 분할하고 각 작업을 독립적으로 해결.
- 최근 딥러닝 모델의 큰 모델링 용량 때문에 입력 오디오 신호를 대상 시퀀스로 직접 매핑하는 E2E 훈련된 시스템에 대한 관심이 증가함.
Jointly Trained Components
- 전통적인 ASR 시스템에서는 음향, 발음, 언어 모델링 구성 요소가 일반적으로 독립적으로 훈련됨.
- E2E Sequence-to-Sequence model에서는 음향, 발음, 언어 모델링이 단일 시스템에서 같이 훈련됨.
Connectionist Temporal Classification (CTC):
- 출력 시퀀스의 길이를 입력 시퀀스와 일치시키기 위해 블랭크 기호를 도입하여 모든 블랭크 삽입 방법에 대해 최적화함.
- 별도의 반복 언어 모델 구성 요소를 포함한 CTC 모델이 제안됨.
Recurrent Neural Network Transducer (RNNT):
- Graves에 의해 기본 CTC 모델이 확장되어 별도의 반복 언어 모델 구성 요소를 도입한 모델.
Attention-Based Models:
- 입력 및 출력 시퀀스 간의 정렬을 학습하며 목표 최적화와 함께 작동하는 모델.
- 'Listen, Attend and Spell (LAS)' 모델은 다른 모델들에 비해 개선되었음.
Simplified Training and Decoding:
- 전통적인 시스템과 비교하여 훈련이 간단하며, 결정 트리나 별도 시스템에서 생성된 시간 정렬을 부트스트랩할 필요가 없음.
- 모델은 직접 대상 시퀀스를 예측하도록 훈련되므로 디코딩도 단순화됨.

d) Generative Adversarial Networks (GANs)

Unsupervised Generative Models:
- GANs는 지정된 데이터셋의 현실적인 샘플을 낮은 차원의 임의의 잠재 벡터에서 생성하는 비지도 생성 모델.
Two Networks - Generator and Discriminator:
- Generator는 잘 알려진 사전에서 추출한 잠재 벡터를 샘플로 매핑.
- Discriminator는 주어진 샘플이 실제인지 가짜인지를 판별하는 역할.
Adversarial Framework:
- Generator와 Discriminator는 적대적인 프레임워크에서 서로 경쟁하여 학습.
Limited Use in Audio Domain:
- GANs는 이미지 합성에서 성공을 거두었지만, 오디오 도메인에서의 활용은 제한적.
Applications in Audio:
- Source separation, music instrument transformation, speech enhancement과 같은 오디오 처리 작업에 활용.

e) Loss Function

Differentiability Requirement for Training:
- 훈련에 그래디언트 디센트를 사용할 때 시스템의 훈련 가능한 매개변수에 대해 미분 가능한 손실 함수의 선택이 중요.
Mean Squared Error (MSE):
- 오디오의 스펙트럼 엔벨롭에 대한 두 오디오 프레임 간의 차이를 측정하기 위해 사용될 수 있음.
- 시간 구조를 고려하기 위해 log-mel spectrograms를 비교.
Challenges in Time Domain Comparison:
- 두 오디오 신호를 시간 도메인 샘플 간의 MSE로 비교하는 것은 강건한 측정 방법이 아님.
- 예를 들어, 동일한 주파수의 두 사인파 신호의 경우 손실은 주파수의 차이에 완전히 의존함.
Dynamic Time Warping and Earth Mover's Distance:
- 신호의 약간 비선형적인 왜곡을 고려하기 위해 다항이동 거리 또는 Wasserstein GANs에서의 동적 시간 왜곡 거리와 같은 다른 유형의 거리 측정이 더 적합할 수 있음.
Tailoring Loss Functions for Applications:
- 특정 응용 분야에 맞게 손실 함수를 설계할 수 있음.
- 예를 들어, 소스 분리에서는 심리음성 음성 간략화 실험에 기반한 객관적이고 미분 가능한 손실 함수를 설계할 수 있음.
Combining Different Loss Functions:
- 다양한 손실 함수를 조합하여 사용할 수 있음.
- 제어된 오디오 합성에서는 VAE의 잠재 변수가 정의된 범위 내에 남아 있도록 하기 위한 하나의 손실 함수와 제어 공간의 변경이 생성된 오디오에 반영되도록 하는 다른 손실 함수가 조합됨.

f) Phase modeling

Magnitude Spectrum in Log-Mel Spectrum:
- 로그-멜 스펙트럼 계산에서 크기 스펙트럼은 사용되지만 위상 스펙트럼은 손실됨.
- 분석을 위해 위상이 손실되는 것이 원하는 결과일 수 있음.
Requirement for Plausible Phases in Synthesis:
- 합성에는 현실적인 위상이 필요.
- Griffin-Lim 알고리즘을 사용하여 크기 스펙트럼에서 위상을 추정할 수 있음.
Neural Network Approaches:
- WaveNet과 같은 신경망은 로그-멜 스펙트럼에서 시간 도메인 신호를 생성하는 데 훈련될 수 있음.
Direct Handling of Complex Spectrum:
- 신경망 구조는 복소 스펙트럼을 직접 처리할 수 있음.
- 입력 특성으로 크기 및 위상 스펙트럼을 모두 포함하거나 복소 목표를 사용하여 깊은 학습 아키텍처를 훈련시킬 수 있음.
Invariance to Small Phase Shifts:
- 원시 파형을 입력 표현으로 사용할 때, 시간적으로 동일한 소리가 다른 위상 변화에서 나타날 수 있는 어려움이 있음.
- 작은 위상 변화에 대한 불변성을 갖는 표현을 사용하는 것이 중요.
Methods for Achieving Phase Invariance:
- 일반적으로 작은 위상 변화에 불변한 표현을 위해 합성곱 레이어와 시간에 따라 풀링하는 DNN 레이어 등이 사용됨.
Raw Audio as Input Representation:
- 원시 오디오를 입력 표현으로 사용하는 경우, 자동 회귀 모델과 같은 합성 작업에서 자주 사용됨.

A. ID convolution

이전 레이어의 활성화를 1-D 필터로 합성하여 현재 레이어의 표현(h 및 y)을 생성함.
주황색 점선은 (t-1) 시간의 출력을 계산하는 데 사용되는 처리를 나타내고, 빨간 실선은 (t) 시간의 출력을 생성하는 처리를 나타냄.

B. Dilated ID convolution

확장 요인 (k)을 사용하여 매 k번째 활성화만 고려함.
확장은 분석된 시간적 맥락의 범위를 증가시키기 위해 연속적으로 증가하는 요인 (1, 2, 4, ...)으로 쌓일 수 있음.

C. Recurrent layer

ht의 활성화는 현재 입력 xt와 이전 활성화 ht−1에서 계산됨.

D. Bi-directional recurrent layer

활성화는 시작부터 끝까지 양방향에서 계산됨

E. Attention

시퀀스 변환에 사용되며, 재귀 레이어를 포함한 인코더와 디코더가 관여함.
문맥 (ct)은 디코더 임베딩 (hd)과 인코더 임베딩 간의 관계에 따라 가중 평D. 균임.

D. Data

컴퓨터 비전에서 ImageNet(레이블링 이미지로 이루어짐)으로 딥러닝이 발전함

↕

But 음성, 음악, 환경 소리 등 여러 도메인 포함하는 공유 가능한 품질의 데이터셋 없음

음성 인식을 위한 영어로 된 큰 데이터셋 있음. 음악 시퀀스 분류 또는 음악 유사성에는 Million Song Dataset, Note-by-Note Sequence Labeling에는 MusicNet이 있음.

↕

But 화음, 비트, 또는 구조 분석과 같은 고수준 음악적 시퀀스 레이블링을 위한 데이터셋은 종종 훨씬 작음.

데이터 생성 및 데이터 증강은 제한된 훈련 데이터 문제를 해결하는 다른 방법임. 어떤 작업에서는 실제 데이터와 유사한 데이터를 알려진 합성 매개변수 및 레이블과 함께 생성할 수 있음.
생성된 데이터만으로 알고리즘의 성능이 현실 데이터에서 낮을 수 있음. 데이터 증강은 기존 예제를 조작하여 가능한 입력 범위를 확장함으로써 추가 훈련 데이터를 생성함.
ASR은 음성 조각을 피치 시프팅(음성 트랙 변조) 및 타임 스트레칭으로 변환하는 것 제안함.
화음 인식에는 음성의 피치 시프팅이 유용하며, 시간 스트레칭 및 스펙트럼 필터링과 결합하여 노래 목소리 감지 및 악기 인식에 사용될 수 있음.

E. Evaluation

평가 기준은 작업마다 다름

1. 음성 인식

- 일반적으로 WER로 평가됨

- WER: 참조 및 가설 단어 문자열을 정렬한 후 단어 오류의 분수를 계산하며, 삽입, 삭제 및 대체 비율로 이루어져 있음. (삽입, 삭제, 대체 수 / 참조단어수)

2. 음악 및 음향 장면 분류

- 고정된 분류 임계값 없이 이진 분류하기 위해 AUROC가 사용됨

- 클래스 간의 의미적 관계 고려할 수 있음

- ex. 화음 탐지 작업의 손실은 감지된 화음과 실제 화음이 조화롭게 관련될 경우 더 작게 설계될 수 있음

3. 이벤트 감지

- 등가 오류율 또는 F-점수로 성능 측정

- 참 양성, 거짓 양성, 거짓 음성은 일정한 길이의 세그먼트 또는 이벤트 당으로 계산됨

4. 목소리 분리 품질

- 신호 대 왜곡 비율, 신호 대 간섭 비율, 신호 대 아티팩트 비율로 측정됨

- MOS

3. Applications

A. 분석

음성 분석 (A1): 음성 분석을 위한 방법들의 구체적인 응용사례를 살펴봄.
음악 분석 (A2): 음악에 대한 분석에 대한 응용사례를 다룸.
환경 소리 분석 (A3): 환경 소리에 대한 분석에 대한 구체적인 응용을 살펴봄.

B. 합성 및 변형

음원 분리 (B1): 오디오의 소스 분리에 대한 메소드 및 적용사례를 다룸.
음성 개선 (B2): 음성 개선에 관한 방법과 응용사례를 살펴봄.
오디오 생성 (B3): 오디오 생성에 대한 방법과 응용사례를 다룸. </aside>

A. Analysis

1) Speech

모델 변화

파라미터와 데이터로 훈련된 DNNs가 2012년에 WER 감소시킴
기존의 triphone-state GMM/HMM 모델이 음성 모델링에서 주류였으나, discriminative 훈련과 하이브리드 모델의 도입으로 변화함
CLDNN 모델은 Convolutional, LSTM 및 피드포워드 레이어의 캐스케이드로 LSTM 단독 모델보다 우수성을 보임.

최근 발전과 적용

RNN의 도입으로 전통적인 HMM 기반 폰 상태 모델링에서의 조건부 독립 가정이 불필요해짐
Sequence-to-Sequence 모델인 CTC 및 LAS에 대한 관심 O
음성 기반 응용 프로그램이 증가함에 따라 음성 지원을 다양한 환경과 언어로 확장하는 것이 중요해짐.
전이 학습을 사용하여 저자원 언어에 대한 ASR 시스템의 성능을 향상시킴.
ASR 모델의 성공으로 음성 관련 작업에서도 딥러닝 기술이 채택되고 있음

2) Music

특징 및 다양성

음악은 시간 및 주파수 측면에서 공통 제약 조건을 따르며, 이는 소스 간 및 내부 종속성을 생성하여 음악 녹음의 자동 설명에 다양한 가능성을 제공함.

사용되는 곳
- 저수준 분석 (온셋 및 오프셋 감지, 기본 주파수 추정), 리듬 분석 (비트 추적, 미터 식별, 다운비트 추적, 템포 추정), 고음수 분석 (키 감지, 멜로디 추출, 코드 추정) 및 고수준 분석 (악기 감지, 악기 분리, 전사, 구조 분할, 아티스트 인식, 장르 분류) 작업이 딥러닝을 통해 해결됨.
- 예시: 온셋 감지에 대한 MLP 훈련, CNN 및 RNN을 사용한 비트 및 다운비트 추적, 코드 인식을 위한 CRNN 모델 등.
음악 처리 과제
- 코드 인식, 음향 이벤트 감지, 전역 템포 추정, 태그 예측 등 다양한 음악 처리 과제에 딥러닝이 성공적으로 적용됨.
- CNN, RNN, CRNN과 같은 다양한 아키텍처가 사용되며, 입력 표현과 아키텍처 선택에 대한 공통된 합의가 없어 더 많은 연구가 필요함

3) Environmental Sounds

개요 및 응용 분야
- 환경 소리는 말과 음악 신호 외에도 우리 환경에 대한 다양한 정보를 운반하고 있음.
- 환경 소리의 계산적 분석은 context-aware 장치, 음향 감시, 멀티미디어 색인 및 검색과 같은 여러 응용 분야에서 활용됨.
기본 접근법
- 오디오 녹음 전체에 하나의 장면 레이블을 할당하는 것을 목표로 함.
- 사전에 정의된 장면 레이블로 "집", "거리", "차 안", "레스토랑" 등이 포함됨.
- 다항 분류 문제로 간주되며 각 장면 클래스에 대한 훈련 자료가 필요함.
b) 음향 이벤트 감지 (Acoustic Event Detection):
- 개별 소리 이벤트의 시작 및 종료 시간을 추정하고 해당 이벤트에 이벤트 레이블을 할당하는 것을 목표로 함.
- 가능한 이벤트 클래스 집합은 사전에 정의되어야 함.
- 지도 학습을 적용하여 각 이벤트 클래스의 활동을 짧은 시간 세그먼트에서 예측하는 것이 효율적임.
- 보통, 이벤트 감지를 수행하는 데 사용되는 지도 분류기는 분류 대상 세그먼트 외부에서 계산된 신호의 음향 특성을 사용함.
c) 태깅 (Tagging)
- 다중 (동시에 발생할 수 있는) 소리 클래스의 활동을 예측하는 것이 목표.
- 태깅 및 이벤트 감지에서는 동시에 활동할 수 있는 여러 이벤트 클래스를 대상으로 할 수 있음.
- 겹치는 클래스가 허용된 경우, 다중 레이블 분류 문제로 간주되며 이진 벡터로 활동 클래스를 표현함.
a) 음향 장면 분류 (Acoustic Scene Classification):
특징
- 환경 소리의 분석은 연구 분야가 덜 확립되어 있어 음성 및 음악과 비교하여 개발 시스템용 제한된 크기와 다양성의 데이터셋이 더 제한적임.
- 환경 데이터셋이 제한된 크기이기 때문에 데이터 증강이 흔히 사용되며 매우 효과적임.

4) Localization and Tracking

다채널 오디오 및 음향 소스 위치
- 다채널 오디오는 음향 소스의 위치를 파악하고 추적하는 데 사용될 수 있음.
- 음향 소스의 공간 위치를 결정하고 시간에 따라 이를 추적하는 것이 목표.
단일 마이크로폰 어레이와 방향 추정
- 여러 마이크로폰으로 구성된 단일 마이크로폰 어레이를 사용하여 소리 소스의 방향을 추정할 수 있음.
- 다채널 마이크로폰 어레이에서의 신호를 사용하여 방향 추정은 두 가지 방식으로 정의될 수 있음:
  - 가능한 방향의 고정 그리드를 형성하고 특정 방향에 활성 소스가 있는지 여부를 다중 레이블 분류를 사용하여 예측.
  - 회귀를 사용하여 대상 소스의 방향 또는 공간 좌표를 예측.
딥러닝 방법의 차이
- 소스 위치 추적을 위한 다양한 딥러닝 방법의 차이점은 사용된 입력 특징, 네트워크 토폴로지, 그리고 하나 이상의 소스가 어떻게 지역화되는지에 있음.
- 사용된 딥 러닝을 기반으로 한 위치 추적에는 위상 스펙트럼, 크기 스펙트럼, 채널 간 일반화 교차 상관등이 포함됨.

B. Synthesis and Transformation

1) Source Separation

정의: 여러 소스의 혼합에서 각각의 소스에 해당하는 신호를 추출하는 과정으로, 오디오 신호 처리에서 중요한 역할을 함.

응용 분야: 음악 편집 및 리믹싱, 음성 및 기타 소리의 강력한 분류를 위한 전처리, 음성 명료도 향상을 위한 전처리 등과 관련된 응용 분야가 있음.

<수학적 정의>

i는 소스 인덱스, I는 소스의 수, n은 샘플 인덱스

시간-주파수 도메인의 마스킹 연산:

최신 음원 분리 방법은 주로 시간-주파수 도메인에서 마스킹 작업을 추정하는 경향이 있음.
시간- 주파수 처리의 이유
1. 자연 소리 소스의 구조가 시간-주파수 도메인에서 잘 보임
➡️ 더 쉽게 모델링할 수 있음.
1. 합성 과정에서의 컨볼루션 믹싱
- 음원 분리는 소스에서 마이크로폰으로의 음향 전달 함수를 포함하는 컨볼루션 믹싱을 수반함
- 전달 함수는 주파수 도메인에서 순간적인 믹싱으로 근사될 수 있음
➡️ 처리를 단순화함
1. 자연 소리 소스는 희소성 가짐
➡️ 해당 도메인에서의 분리가 용이함

<마스킹 수식>

마스킹은 주파수 f 및 시간 t에서 혼합 신호 스펙트럼 Xm(f,t)을 분리된 소스 신호 스펙트럼의 추정치인 S^m(f,t)로 얻기 위해 혼합 신호 스펙트럼에 분리 마스크 Mm,i(f,t) 곱하는 과정으로 정의됨

딥러닝을 활용한 음원 분리

단일 마이크로폰에서 동작하는 딥 러닝 방법은 주로 소스의 스펙트럼 구조를 모델링하는 데 의존함.
두 가지 범주로 나뉨:
1. 입력 혼합 X(f,t)을 기반으로 분리 마스크 Mi(f, t)를 예측하는 방법.
2. 입력 혼합에서 소스 신호 스펙트럼 Si(f, t)를 예측하는 방법.
딥 러닝은 입력 혼합 스펙트럼 X(f, t)와 오라클 마스크 또는 깨끗한 신호 스펙트럼 사이의 관계에 기반한 지도 학습을 기반으로 함.
딥 뉴럴 네트워크의 아키텍처로는 컨볼루션, 순환 레이어를 포함한 다양한 방법이 사용됨.
표준 평균 제곱 오차 손실은 주관적 분리 품질에 대해 최적이 아니므로 명료도를 향상시키기 위해 사용자 정의 손실 함수가 개발됨

최근 접근 방식

최근에는 딥 클러스터링을 기반으로 한 접근 방식이 사용됨. 이 방법은 각 시간-주파수 지점에 대한 임베딩 벡터를 추정하고 이를 비지도 학습 방식으로 클러스터링하는 것임.
이러한 접근 방식은 훈련 세트에 존재하지 않는 소스를 분리할 수 있음.

2) Audio Enhancement

음성 개선 기술
- 소음을 감소하여 음성 품질을 향상시키는 목적으로 사용됨.
- ASR 시스템에서 소음 강건성을 위해 중요한 구성 요소로 작용.
- Wiener와 같은 기존 소음 제거 방법은 정지된 소음을 가정하나, 딥러닝은 시간에 따라 변하는 소음을 모델링할 수 있음.
GAN을 활용한 음성 개선:
- 특히 SEGAN은 부가적인 소음이 있는 환경에서 음성을 향상하는 데 효과적.
- SEGAN은 기존의 개선 방법에 비해 감각적인 음성 품질 지표에서 향상을 보임.
- GAN을 사용하여 logmel 스펙트라로 표현된 음성을 향상시키지만, ASR에 사용될 때 간단한 회귀 방법보다 개선이 없음.

3) Generative Models

생성 모델
- 실제 소리 데이터베이스에서 학습한 특성을 기반으로 소리를 합성하여 현실적인 샘플 생성.
- 학습된 소리와 유사하면서도 학습 집합의 소리를 단순히 복사하는 것이 아니라 독창적이어야 함.
- 조건부 합성: 음성 합성의 경우 화자, 음악의 고조 경로, 환경 소리 생성 시 물리적 매개변수 등을 조건으로 설정하는 것이 바람직.
- 시간 및 효율성: 훈련 및 생성 시간이 짧아야 하며 이상적으로는 실시간 생성이 가능해야 함.
- 모델 유형: 스펙트럼 표현 또는 원시 오디오에서 생성 가능. 스펙트럼 표현은 합성 시에 상호 정보를 잃어버리기 때문에 이를 복원하는 등의 추가 단계가 필요함.
음성 생성 모델
- 블록별 접근: VAE 또는 GANs의 경우 저차원 잠재 표현에서 합성되며, 업샘플링이 필요. 다층 RNN 및 dilated convolutions을 사용하여 해결.
- 자기 회귀적 접근: RNN을 사용하여 각 샘플을 반복적으로 생성. 단, 훈련이 비용이 많이 들 수 있음.
- WaveNet: 분류 문제로 캐스팅하여 각 샘플을 예측. WaveNet 모델은 다른 음성 합성 방법을 크게 능가하지만 훈련이 계산적으로 소모적임.
- 병렬 WaveNet: 훈련 속도 문제를 해결하기 위한 솔루션으로 개발되었으며 응용 프로그램에서 효과적으로 사용됨.
평가 방법:
- 객관적 평가: 생성된 소리의 인식 가능성을 분류자(e.g., 인셉션 스코어)를 사용하여 테스트.
- 주관적 평가: 인간의 강제 선택 테스트를 통해 생성된 소리의 인식 가능성을 확인.
- 다양성 및 원본성 평가: 정규화된 로그멜 스펙트라로 나타낸 소리의 다양성 및 원본성을 평가.
- 튜링 테스트: 생성된 오디오와 실제 오디오 간의 구별이 거의 불가능한 경우에 대한 어려운 테스트. WaveNet은 이를 능가하는 결과를 보임.

4. Discussion and Conclusion

IV-A. 특성

IV-B. 모델

IV-C. 데이터 요구 사항

IV-D. 계산 복잡성

IV-E. 해석 가능성 및 적응성

A. Features

전통적 특성과 딥러닝 특성 비교
- 전통적으로는 MFCCs가 주로 사용되었으나, 딥 러닝에서는 주로 로그 멜 스펙트로그램이 사용됨.
- 원시 파형은 수작업 특성을 피하고 딥 러닝 모델의 모델링 능력을 더 잘 활용하는데 중점.
특성 선택과 성능 비교
- 분석 작업에서는 로그멜 스펙트로그램이 더 간결한 표현 제공.
- 원시 파형의 사용은 더 높은 계산 비용과 데이터 요구 사항을 동반하지만 특별한 경우에는 이점이 있을 수 있음.

B. Models

모델
- ASR, MIR, 환경 소리 분석에서 딥 모델은 시퀀스 분류를 위한 서포트 벡터 머신 및 시퀀스 전송을 위한 GMM-HMM을 대체함.
- 오디오 개선/소음 제거 및 소스 분리에서는 딥 러닝이 이전에는 NNMF 및 와이너 방법으로 처리된 작업을 해결함.
- 오디오 합성에서는 Wavenet, SampleRNN, WaveRNN 등이 연결적 합성을 대체함.
모델 유형의 활용
- CNNs, RNNs 및 CRNNs이 모든 도메인에서 성공적으로 활용됨.
- CNNs는 고정된 수용 영역을 가지며 예측에 고려되는 시간적 맥락을 제한하지만, 컨텍스트 크기를 조절하기가 매우 쉬움.
- RNNs는 이론적으로 무제한의 시간적 맥락을 기반으로 예측할 수 있지만, 이를 학습하려면 모델에 적응이 필요하며 컨텍스트 크기에 대한 직접적인 제어를 방해함.
- CRNNs는 양쪽의 이점과 단점을 상속하여 그 사이에서 타협점을 제공함.
우수한 모델에 대한 열린 질문
- 어떤 상황에서 어떤 모델이 우수한지에 대한 연구 질문.
- 다양한 모델을 사용하여 다른 연구 그룹이 최첨단 결과를 얻고 있어 특정 아키텍처 유형을 효과적으로 설계하고 조정하는 각 연구 그룹의 전문 지식에 기인할 수 있음.

C. Data Requirements

한정된 데이터셋 문제
- 대부분의 오디오 도메인에서는 소규모 데이터셋이 딥러닝 모델의 크기와 복잡성을 제한함.
컴퓨터 비전과의 대조
- 오디오에는 ImageNet과 같은 광범위한 사전 훈련 모델이 없어 컴퓨터 비전과 비교됨.
동등한 작업 부재
- 오디오 도메인에서 전이 학습을 위한 동등한 작업을 찾는 연구가 필요함.
사전 훈련된 모델 적응 문제
- 최소한의 데이터로 사전 훈련된 오디오 모델을 새로운 작업에 유연하게 적응하는 방법을 찾는 것이 중요함.
도메인별 도전과제
- 음악과 같은 도메인 내에서도 고유의 도전 과제가 있어 별도의 접근법이 필요함.
대체 패러다임 탐구
- 전이 학습이 적절하지 않을 경우, 반지도 학습, 액티브 학습 또는 소수 데이터 학습과 같은 대체 패러다임을 탐구함.

D. Computational Complexity

딥러닝의 성공은 빠르고 대규모의 계산의 발전을 기반으로 함.
최첨단 딥 뉴럴 네트워크는 일반적으로 더 많은 계산 능력과 더 많은 훈련 데이터를 필요로 하며, 일반적인 방법에 비해 더 많은 계산이 필요함.
대형 딥 모델을 훈련하고 평가하는 데 최적이 아닌 CPU 대신 주로 일반적인 그래픽 처리 장치(GPGPUs) 및 Tensor Processing Units(TPUs)와 같은 특수 애플리케이션 집적 회로가 최적화된 프로세서를 사용함.

E. Interpretability and Adaptability

딥러닝에서 연구자들은 주로 원시적인 레이어 블록과 목표 작업에 대한 손실 함수를 사용하여 네트워크 구조를 설계함.
모델의 매개변수는 입력과 대상 또는 비지도 훈련을 위해 입력만에 대한 손실에 대한 기울기 하강을 통해 학습됨.
레이어 매개변수와 실제 작업 간의 연결은 해석하기 어려움. 네트워크 뉴런의 활동을 목표 작업과 연관시키거나 예측이 어떤 입력 부분에 기반을 두는지 조사하는 연구들이 진행 중.
네트워크나 하위 네트워크의 동작 방식을 이해하기 위한 추가 연구는 모델 구조를 개선하여 실패 사례에 대응하는 데 도움이 될 수 있음.

[8주차] 위변조 탐지

cheonniii — Fri, 29 Dec 2023 11:54:11 +0900

Audio Tampering Detection

1. Audio authentication in forensic examination (절차 정의, 하는 이유)

- 오디오 위변조 탐지는 증거로 제출된 오디오에 수행되는 표준 절차

- 오디오 인증은 편집되거나 다시 녹음된 오디오의 흔적을 정확하게 감지하기 위한 절차로, 오디오가 원본인지 변경된 것인지 결정하는 과정

2. Forensic anallyst's task

- 녹음이 조작되었는지 확인하고, 조작 유형(복사 이동, 스플라이싱, 삽입) 및 원본 오디오에서의 조작 위치 식별

- 오디오가 녹음된 환경 또는 녹음 장치 식별

3. Tampering attacks on audio

- 원본 오디오 파일에 스플라이싱, 복사-이동, 삽입 및 삭제 등의 조작이 가해질 수 있음

- 스플라이싱: 하나의 오디오의 짧은 클립이 동일한 오디오의 다른 위치에 복붙되는 것. 다른 환경의 오디오를 교체

4. Focus

- 스플라이싱 위조 탐지에 중점을 두고 있음

- MFCC 및 DRD 특성 추출

- DRD 특성은 시간 및 주파수 대역에서의 에너지 decay 속도에 따라 오디오 신호를 나누어 추출되고, 속도 분포에 대한 기본 통계가 적용됨

5. Machine learning models

- MFCC 및 DRD 특성을 추출하여 KNN, SVM, Decision Tree 및 Random Forest 사용하여 위조 오디오 분류

- 정확도 높이기 위해 ANN, CNN, LSTM과 같은 딥러닝 모델로 train

ANN

# 데이터 전처리 및 모델 구축
from keras import Sequential
from keras.layers import Dense, Dropout

model = Sequential()

# ANN Model
model.add(Dense(units=256, activation='relu', input_dim=1025))
model.add(Dropout(0.4))
model.add(Dense(units=256, activation='relu'))
model.add(Dropout(0.4))
model.add(Dense(units=256, activation='relu'))
model.add(Dropout(0.4))
model.add(Dense(units=2, activation='softmax'))

# 모델 컴파일
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# 모델 학습
model.fit(x_train, y_train, epochs=50, validation_data=(x_test, y_test), batch_size=500)

# 모델 평가
train_loss_score = model.evaluate(x_train, y_train)
test_loss_score = model.evaluate(x_test, y_test)
print(train_loss_score)
print(test_loss_score)

# 모델 예측
y_predicted = model.predict(x_test)

# 혼동 행렬 생성
import tensorflow as tf
y_predicted_labels = [np.argmax(i) for i in y_predicted]
cm = tf.math.confusion_matrix(labels=y_test, predictions=y_predicted_labels)
cm

# 혼동 행렬 시각화
import seaborn as sn
plt.figure(figsize=(10, 7))
sn.heatmap(cm, annot=True, fmt='d')
plt.xlabel('Predicted')
plt.ylabel('Truth')

CNN

# 데이터 전처리
from keras.utils.np_utils import to_categorical
y_train = to_categorical(y_train, num_classes=2)
y_test = to_categorical(y_test, num_classes=2)

# 모델 구축
from keras import Sequential
from keras.layers import Conv2D, MaxPooling2D, Dropout, Flatten, Dense

model = Sequential()

# CNN Model
model.add(Conv2D(64, kernel_size=5, strides=1, padding="Same", activation="relu", input_shape=(200, 1, 1)))
model.add(MaxPooling2D(padding="same"))

model.add(Conv2D(128, kernel_size=5, strides=1, padding="same", activation="relu"))
model.add(MaxPooling2D(padding="same"))
model.add(Dropout(0.3))

model.add(Flatten())

model.add(Dense(256, activation="relu"))
model.add(Dropout(0.3))

model.add(Dense(512, activation="relu"))
model.add(Dropout(0.3))

model.add(Dense(2, activation="softmax"))

# 모델 컴파일
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# 모델 학습
model.fit(x_train, y_train, epochs=50, validation_data=(x_test, y_test), batch_size=500)

# 모델 평가
train_loss_score = model.evaluate(x_train, y_train)
test_loss_score = model.evaluate(x_test, y_test)
print(train_loss_score)
print(test_loss_score)

# 모델 예측
y_predicted = model.predict(x_test)

# 혼동 행렬 생성
import tensorflow as tf
y_predicted_labels = [np.argmax(i) for i in y_predicted]
cm = tf.math.confusion_matrix(labels=y_test, predictions=y_predicted_labels)
cm

# 혼동 행렬 시각화
import seaborn as sn
plt.figure(figsize=(10, 7))
sn.heatmap(cm, annot=True, fmt='d')
plt.xlabel('Predicted')
plt.ylabel('Truth')

LSTM

# Data reshaping for LSTM(3D)
x_train = np.reshape(x_train, (x_train.shape[0], 1, 200, 1))
x_test = np.reshape(x_test, (x_test.shape[0], 1, 200, 1))
x_train.shape, x_test.shape, y_train.shape, y_test.shape

# test data size same for all models
from keras.utils import to_categorical
y_train = to_categorical(y_train, num_classes=2)
y_test = to_categorical(y_test, num_classes=2)
y_train.shape, y_test.shape

# model building
from keras import Sequential
from keras.layers import LSTM, Dense
model = Sequential()

# LSTM Model
model.add(LSTM(200, activation='relu', return_sequences=True, input_shape=(200,1)))
model.add(LSTM(100, activation='relu', return_sequences=True))
model.add(LSTM(50, activation='relu', return_sequences=True))
model.add(LSTM(25, activation='relu'))
model.add(Dense(20, activation='relu'))
model.add(Dense(10, activation='relu'))
model.add(Dense(2))

model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

model.fit(x_train, y_train, epochs=50, validation_data=(x_test, y_test), batch_size=500)

train_loss_score = model.evaluate(x_train, y_train)
test_loss_score = model.evaluate(x_test, y_test)
print(train_loss_score)
print(test_loss_score)

# predict first 50 audios in the test set
y_predicted = model.predict(x_test[50])

import tensorflow as tf
y_predicted_labels = [np.argmax(i) for i in y_predicted]
cm = tf.math.confusion_matrix(labels=y_test, predictions=y_predicted_labels)
cm

import seaborn as sn
plt.figure(figsize=(10, 7))
sn.heatmap(cm, annot=True, fmt='d')
plt.xlabel('Predicted')
plt.ylabel('Truth')

<feature_tatble_DRD>

WAV 파일에서 추출한 특징들을 변수에 저장하고, 나중에 분석 및 시각화를 위해 사용할 수 있도록 테이블 형태로 정리

import os
import numpy as np
from scipy.stats import skew, kurtosis
from scipy.io import wavfile

def feature_table_DRD(directory):
    files = [f for f in os.listdir(directory) if f.endswith('.wav')]
    num_files = len(files)

    xdata_m_t = np.zeros((num_files, 32))
    xdata_me_an = np.zeros((num_files, 1))
    xdata_st_d = np.zeros((num_files, 1))
    xdata_var_an = np.zeros((num_files, 1))
    xdata_skew_ness = np.zeros((num_files, 1))
    xdata_ku_r = np.zeros((num_files, 1))

    for k, file_name in enumerate(files):
        full_file_path = os.path.join(directory, file_name)
        print(f'Now reading {full_file_path}')

        Fs, rec = wavfile.read(full_file_path)
        M_t, mb, sd, variance, sb, kur = featurefun_DRD(rec, Fs)

        xdata_m_t[k, :] = M_t
        xdata_me_an[k, :] = mb
        xdata_st_d[k, :] = sd
        xdata_var_an[k, :] = variance
        xdata_skew_ness[k, :] = sb
        xdata_ku_r[k, :] = kur

    return xdata_m_t, xdata_me_an, xdata_st_d, xdata_var_an, xdata_skew_ness, xdata_ku_r

def featurefun_DRD(rec, Fs):
    # 이 함수는 실제로 정의되어 있지 않아서 주어진 내용만으로는 세부 내용을 알 수 없습니다.
    # featurefun_DRD 함수가 정의되어 있다면, 해당 부분을 적절히 채워넣어야 합니다.
    # 아래는 임시적으로 구현한 것으로 실제 함수 내용과는 무관합니다.
    M_t = np.mean(rec)
    mb = np.mean(rec)
    sd = np.std(rec)
    variance = np.var(rec)
    sb = skew(rec)
    kur = kurtosis(rec)

    return M_t, mb, sd, variance, sb, kur

# 사용 예시
directory_path = '/path/to/your/directory'
xdata_m_t, xdata_me_an, xdata_st_d, xdata_var_an, xdata_skew_ness, xdata_ku_r = feature_table_DRD(directory_path)

<feature_table_MFCC>

MFCC 특성 추출하여 특성 테이블 생성하는 코드(원래 MATLAB 코드였는데 파이썬으로 변환함)

import os
import numpy as np
from python_speech_features import mfcc
from scipy.io import wavfile

def feature_table_mfcc(directory):
    files = [f for f in os.listdir(directory) if f.endswith('.wav')]
    num_files = len(files)

    xdata_mfcc_mb = np.zeros((num_files, 13))
    xdata_mfcc_sd = np.zeros((num_files, 13))
    xdata_mfcc_kur = np.zeros((num_files, 13))
    xdata_mfcc_sb = np.zeros((num_files, 13))

    for k, file_name in enumerate(files):
        full_file_path = os.path.join(directory, file_name)
        print(f'Now reading {full_file_path}')

        Fs, rec = wavfile.read(full_file_path)
        rec = rec[:, 0]

        mfcc_mb, mfcc_sd, mfcc_kur, mfcc_sb = featurefun_MFCC(rec, Fs)

        xdata_mfcc_mb[k, :] = mfcc_mb
        xdata_mfcc_sd[k, :] = mfcc_sd
        xdata_mfcc_kur[k, :] = mfcc_kur
        xdata_mfcc_sb[k, :] = mfcc_sb

    return xdata_mfcc_mb, xdata_mfcc_sd, xdata_mfcc_kur, xdata_mfcc_sb

def featurefun_MFCC(rec, Fs):
    # 이 함수는 실제로 정의되어 있지 않아서 주어진 내용만으로는 세부 내용을 알 수 없습니다.
    # featurefun_MFCC 함수가 정의되어 있다면, 해당 부분을 적절히 채워넣어야 합니다.
    # 아래는 임시적으로 구현한 것으로 실제 함수 내용과는 무관합니다.
    mfcc_feat = mfcc(rec, Fs)
    mfcc_mb = np.mean(mfcc_feat, axis=0)
    mfcc_sd = np.std(mfcc_feat, axis=0)
    mfcc_kur = np.kurtosis(mfcc_feat, axis=0)
    mfcc_sb = np.mean(np.abs(mfcc_feat - np.mean(mfcc_feat, axis=0))**3, axis=0) / np.std(mfcc_feat, axis=0)**3

    return mfcc_mb, mfcc_sd, mfcc_kur, mfcc_sb

# 사용 예시
directory_path = '/path/to/your/directory'
xdata_mfcc_mb, xdata_mfcc_sd, xdata_mfcc_kur, xdata_mfcc_sb = feature_table_mfcc(directory_path)

DRD 특성 추출하는 MATLAB 함수 ➡️ 파이썬으로 바꿈

STFT 계산
Magnitude Spectrum 계산
magnitude spectrum ➡️ perceptual scale로 변환
Energy Envelope 추정
로컬 피크 검출
로컬 피크 중 유효한 decay 시작 및 종료지점 선택
최소 제곱법으로 선형 피팅(→DRD 특성 얻음)
DRD Feature Vector 계산 (DRD 특성 계산하고, 함수 이용하여 평균, 표준편차, 분산, 왜도, 첨도 계산함)
최종적으로 features_test1에 DRD 특성 담은 벡터 반환

목적: 입력 오디오 신호에서 DRD 특성 추출하고, 이거 통해서 오디오의 decay 속도와 관련된 특성 파악

▸DRD: Decay Rate Distribution

음향 신호의 decay 속도 분포를 나타내는 특징. 주파수별로 음향 신호가 얼마나 빨리 감되는지 분석.

DRD 특징 추출하는 과정에서 음향 신호를 주파수 영역으로 변환한 후, 각 주파수 대역에서의 decay 속도를 계산하여 분포를 나타냄.

import numpy as np
from scipy.signal import spectrogram
from scipy.stats import skew, kurtosis

def featurefun_DRD(rec, Fs):
    siglen = len(rec)
    wlen = 1024
    hop = wlen // 4
    fftpt = 1024
    win = np.hamming(wlen)

    r = int(np.ceil((1 + fftpt) / 2) - 1)
    c = int(1 + np.floor((siglen - wlen) / hop))
    stft = np.zeros((r, c))

    indx = 0

    for i in range(c):
        rec_win = rec[indx:indx + wlen] * win
        R = np.fft.fft(rec_win, fftpt)
        stft[:, i] = R[:r]
        indx += hop

    timevec = np.arange(wlen / 2, wlen / 2 + (c - 1) * hop, hop) / Fs
    freqvec = np.arange(0, r) * Fs / fftpt

    magSpec = np.abs(stft)
    logMagSpec = 10 * np.log10(np.maximum(magSpec, 0.00001))

    # ... (이어지는 부분은 그대로 사용)

    # 최소 제곱법으로 선형 피팅
    p = np.zeros((r4, 2))
    f = np.zeros((r4, len(x1[i])))

    for i in range(r4):
        p[i, :] = np.polyfit(x1[i], y1[i], 1)
        f[i, :] = np.polyval(p[i, :], x1[i])

    # DRD Feature Vector 계산
    Nb = r1
    D = np.zeros((Nb, r4))
    count2 = 0

    for k in range(r4):
        for j in range(Nb):
            if loc_final[k, 0] == j + 1:
                count2 += 1
                D[j, count2] = p[k, 0]

    # Mean vector m_t
    m_t = np.zeros(Nb)

    for i in range(Nb):
        Np_i = np.count_nonzero(D[i, :])
        if Np_i > 0:
            m_t[i] = np.sum(D[i, :]) / Np_i

    M_t = m_t

    # Statistical functions on M_t
    mb = np.mean(M_t)
    sd = np.std(M_t)
    variance = np.var(M_t)
    sb = skew(M_t)
    kur = kurtosis(M_t)

    # DRD feature vector
    features_test1 = np.concatenate((M_t, [mb, sd, variance, sb, kur]))

    return features_test1

음향 신호(rec) 기반으로 MFCC 특징 추출하는 함수

STFT: 음향 신호를 STFT 사용하여 주파수 영역으로 변환함. 윈도우 함수(hamming) 사용함. 윈도우 겹치는 방식으로 STFT 계산함
MelSpectrogram 계산: 주파수 영역에서 Mel 스케일로 변환된 스펙트로그램 계산함. Mel 필터 및 로그 변환 사용함
MFCC 계산: DCT 사용하여 MFCC 계산함. 13개의 계수 추출함
MFCC 계수에 대해 평균(md), 표준편차(sd), 점도(kur), 비대칭도(sb) 계산하여 통계적 특징 벡터 얻음

MFCC 활용하여 음향 신호의 주파수 특성을 추출하고, 각 계수에 대한 통계적 특징 계산하는 코

코드텍스트

import numpy as np
from scipy.fftpack import fft
from scipy.signal import spectrogram
from scipy.stats import skew, kurtosis

def featurefun_mfcc(rec, Fs):
    wlen = 1024
    hop = wlen // 4
    fftpt = 4096
    win = np.hamming(wlen)

    # Short Time Fourier Transform
    _, _, stft = spectrogram(rec, fs=Fs, window=win, nperseg=wlen, noverlap=hop)

    # Log of magnitude of spectrum
    mag_spec = np.abs(stft)
    mag_spec[mag_spec == 0] = 0.00001
    log_mag_spec = 10 * np.log10(mag_spec)

    # Conversion to perceptual scale
    filter_bank = melbank(Fs, fftpt)
    mel_spec = np.dot(filter_bank, log_mag_spec)

    # MFCC Calculation
    log_mel = np.log10(mel_spec)
    mel_ceps = dct(log_mel, axis=0)
    mfccs = np.abs(mel_ceps[1:14, :])

    # Statistical functions on MFCCs
    mb = np.mean(mfccs, axis=1)
    sd = np.std(mfccs, axis=1)
    kur = kurtosis(mfccs, axis=1)
    sb = skew(mfccs, axis=1)

    return mb, sd, kur, sb

# 임의로 Mel 필터를 생성하는 함수
def melbank(fs, nfft, num_channels=20):
    fmin = 0
    fmax = fs / 2
    mel_points = np.linspace(freq_to_mel(fmin), freq_to_mel(fmax), num_channels + 2)
    hz_points = mel_to_freq(mel_points)
    bin_points = np.floor((nfft + 1) * hz_points / fs).astype(int)

    filter_bank = np.zeros((num_channels, nfft))
    for m in range(1, num_channels + 1):
        filter_bank[m - 1, bin_points[m - 1]:bin_points[m]] = (bin_points[m] - mel_points[m - 1]) / (bin_points[m] - bin_points[m - 1])
        filter_bank[m - 1, bin_points[m]:bin_points[m + 1]] = (mel_points[m + 1] - bin_points[m]) / (bin_points[m + 1] - bin_points[m])

    return filter_bank

def freq_to_mel(freq):
    return 2595 * np.log10(1 + freq / 700)

def mel_to_freq(mel):
    return 700 * (10 ** (mel / 2595) - 1)

# 예시 음향 신호와 샘플링 주파수
example_rec = np.random.rand(44100)  # 임의의 음향 신호 (44100Hz 샘플링)
example_fs = 44100

# 특징 추출
example_mb, example_sd, example_kur, example_sb = featurefun_mfcc(example_rec, example_fs)

print("Mean of MFCCs:", example_mb)
print("Standard Deviation of MFCCs:", example_sd)
print("Kurtosis of MFCCs:", example_kur)
print("Skewness of MFCCs:", example_sb)

여기까지는 음성 파일 자체가 조작된거 탐지하는 방법

⬇️화자가 연기를 하고 있는지 알아내는 방법

1. 목표: 음향 정보만을 활용하여 거짓말을 감지하는 머신 러닝 모델 훈련.

2. 특징 추출: MFCC, 에너지 엔벨롭, 및 피치 컨투어를 사용하여 음성 특징을 추출.

3. 모델 훈련

Gradient Boosting Classifier (GBC)
Support Vector Machine (SVM)
Stochastic Gradient Descent (SGD)

4. 학습 분류기: GBC, SVM, SGD로 구성된 다수결 앙상블 학습 분류기 생성

# LieDetection
# GOAL : True/Lie Detection Using Sequences from Video
Create Lie Detection Model using Deep Learning RNN (Final Yr USJP Research Project)

Steps:

01. Extract Keypoints from video using mediapipe fashmesh
02. Train an RNN LSTM DL Model
03. Make real time predictions using sequences



# How it Works
  01. Extract Keypoints from mediapipe fashmesh 
  2. Train a deep neural network with LSTM layers for sequences
  3. Perform real time True/ Lie Detection using OpenCV


# Contents of our notebook:

    01. Import and Install Dependencies
    02. Using Mediapipe (Google's open-source framework)
        - Given the original image and obtaining the values through the model.
        - Storing the keypoints values in the mediapipe into a variable.
        - Calculating blink rate (Euclidean distance).
    03. Extract Position Landmarks (Keypoints Values)
    04. Setup Folder for Collection
    05. Collect Keypoints Values for Training and Testing
    06. Preprocess Data and Create Labels and Features
    07. Build and Train LSTM Neural Network
    08. Make Predictions
    09. Save Weights
    10. Evaluation using Confusion Matrix and Accuracy
    11. Test in Real Time

# Full code details of the video:
[![Watch Here]()](https://www.youtube.com/watch?v=PSu1qiPmiRw)