간단한 선형대수의 수식들을 List Comprehesion을 사용하여 pythonic code 를 작성하려고 한다.

Linear Algebra codes - 1 은 처음 배웠을 때 작성한 것이라 부족한 부분이 있어 다시 작성하려고 한다.

2024.01.02 - [✍🏻Language/Python] - [Python for ML] Linear algebra codes

1. Vector Size Check

• vector 간 덧셈 또는 뺄셈 연산을 할 때, 연산이 가능한 사이즈인지를 확인하여 가능 여부를 True 또는 False로 반환

def vector_size_check(*vector_variables):
    return all(len(vector_variables[0]) == x 
                for x in [len(vector) for vector in vector_variables[1:]])

# 실행결과
print(vector_size_check([1,2,3], [2,3,4], [5,6,7])) 
print(vector_size_check([1, 3], [2,4], [6,7])) 
print(vector_size_check([1, 3, 4], [4], [6,7]))

True

Ture

Flase

2. Vector Addition

• vector간 덧셈을 실행하여 결과를 반환함, 단 입력되는 vector의 갯수와 크기는 일정하지 않음

def vector_addition(*vector_variables):
    if vector_size_check(*vector_variables) == False:
        raise ArithmeticError
    return [sum(element) for element in zip(*vector_variables)]

# 실행결과
print(vector_addition([1, 3], [2, 4], [6, 7])) 
print(vector_addition([1, 5], [10, 4], [4, 7]))
print(vector_addition([1, 3, 4], [4], [6,7]))

[9, 14]
[15, 16]

ArithmeticError

3. Vector Substraction

• vector간 뺄셈을 실행하여 결과를 반환함, 단 입력되는 vector의 갯수와 크기는 일정하지 않음

def vector_subtraction(*vector_variables):
    if vector_size_check(*vector_variables) == False:
        raise ArithmeticError
    return [2 * elements[0] - sum(elements) for element in zip(*vector_variables)]

# 실행결과
print(vector_subtraction([1, 3], [2, 4]))
print(vector_subtraction([1, 5], [10, 4], [4, 7]))

[-1, -1]
[-13, -6]

4. Scalar Vector Product

• 하나의 scalar 값을 vector에 곱함, 단 입력되는 vector의 크기는 일정하지 않음

def scalar_vector_product(alpha, *vector_variables):
    return [alpha * row for row in vector_variables]

# 실행결과
print (scalar_vector_product(5,[1,2,3])
print (scalar_vector_product(3,[2,2]))
print (scalar_vector_product(4,[1]))

[5, 10, 15]
[6, 6]
[4]

5. Matrix Size Check

• matrix 간 덧셈 또는 뺄셈 연산을 할 때, 연산이 가능한 사이즈인지를 확인하여 가능 여부를 True 또는 False로 반환함
• 열 판단 and 행 판단

def matrix_size_check(*martix_variables):
    all([len(set(len(matrix[0]) for matrix in matrix_variables)) == 1]) and 
        all([len(matrix_variables[0]) == len(matrix) for matrix in matrix_variables])

# 실행결과
matrix_x = [[2, 2], [2, 2], [2, 2]]
matrix_y = [[2, 5], [2, 1]]
matrix_z = [[2, 4], [5, 3]]
matrix_w = [[2, 5], [1, 1], [2, 2]]

print (matrix_size_check(matrix_x, matrix_y, matrix_z)) 
print (matrix_size_check(matrix_y, matrix_z))
print (matrix_size_check(matrix_x, matrix_w))

False

True

True

6. Is Matrix Equal

• 비교가 되는 n개의 matrix가 서로 동치인지 확인하여 True 또는 False를 반환함
• all( ) 이 두 번인 이유 : matrix 형태이므로 row의 값이 다 같은지 확인하고, column이 모두 같은지도 확인

def is_matrix_equal(*matrix_variables):
    all([all([len(set(row)) == 1 for row in zip(*matrix)]) for matrix in zip(*matrix_variables)])
    
# 실행결과
matrix_x = [[2, 2], [2, 2]]
matrix_y = [[2, 5], [2, 1]]

print (is_matrix_equal(matrix_x, matrix_y, matrix_y, matrix_y))
print (is_matrix_equal(matrix_x, matrix_x))

False

True

7. Matrix Addition

• matrix간 덧셈을 실행하여 결과를 반환함, 단 입력되는 matrix의 갯수와 크기는 일정하지 않음

def matrix_addition(*matrix_variables):
    if matrix_size_check(*matrix_variables) == False:
        raise ArithmeticError
    return [[sum(row) for row in zip(*matrix)] for matrix in zip(*matrix_variables)]
    
# 실행결과
matrix_x = [[2, 2], [2, 2]]
matrix_y = [[2, 5], [2, 1]]
matrix_z = [[2, 4], [5, 3]]

print (matrix_addition(matrix_x, matrix_y))
print (matrix_addition(matrix_x, matrix_y, matrix_z))

[[4, 7], [4, 3]]

[[6, 11], [9, 6]]

8. Matrix Subtraction

• matrix간 뺄셈을 실행하여 결과를 반환함, 단 입력되는 matrix의 갯수와 크기는 일정하지 않음

def matrix_subtraction(*matrix_variables):
    if matrix_size_check(*matrix_variables) == False:
        raise ArithmeticError
        
    return [[2 * row[0] - sum(row) for row in zip(*matrix)] for matrix in zip(*matrix_variables)]
    
# 실행결과
matrix_x = [[2, 2], [2, 2]]
matrix_y = [[2, 5], [2, 1]]
matrix_z = [[2, 4], [5, 3]]

print(matrix_subtraction(matrix_x, matrix_y))
print(matrix_subtraction(matrix_x, matrix_y, matrix_z))

[[0, -3], [0, 1]]

[[-2, -7], [-5, -2]]

9. Matrix Transpose

• matrix의 역행렬을 구하여 결과를 반환함, 단 입력되는 matrix의 크기는 일정하지 않음

def matrix_transpose(*matrix_variables):
    return [[element for element in row] for row in zip(*matrix_variables)]]
    
# 실행결과
matrix_w = [[2, 5], [1, 1], [2, 2]]
print(matrix_transpose(matrix_w))

[[2, 1, 2], [5, 1, 2]]

10. Scalar Matrix Product

• 하나의 scalar 값을 matrix에 곱함, 단 입력되는 matrix의 크기는 일정하지 않음

def scalar_matrix_product(alpha, matrix_variable):
    return [[alpha * element for element in row] for row in matrix_x]

# 실행결과
matrix_x = [[2, 2], [2, 2], [2, 2]]
matrix_y = [[2, 5], [2, 1]]
matrix_z = [[2, 4], [5, 3]]
matrix_w = [[2, 5], [1, 1], [2, 2]]

print(scalar_matrix_product(3, matrix_x))
print(scalar_matrix_product(2, matrix_y))
print(scalar_matrix_product(4, matrix_z))
print(scalar_matrix_product(3, matrix_w))

[[6, 6], [6, 6], [6, 6]]
[[4, 10], [4, 2]]
[[8, 16], [20, 12]]
[[6, 15], [3, 3], [6, 6]]

11. Is Product Availability Matrix

• 두 개의 matrix가 입력 되었을 경우, 두 matrix의 곱셈 연산의 가능 여부를 True 또는 False로 반환함

def is_product_availability_matrix(matrix_a, matrix_b):
     return len([colunm_vector for colunm_vector in zip(*matrix_a)]) == len(matrix_b)
     
# 실행 결과
matrix_x= [[2, 5], [1, 1]]
matrix_y = [[1, 1, 2], [2, 1, 1]]
matrix_z = [[2, 4], [5, 3], [1, 3]]

print(is_product_availability_matrix(matrix_y, matrix_x))
print(is_product_availability_matrix(matrix_y, matrix_z))
print(is_product_availability_matrix(matrix_z, matrix_x))
print(is_product_availability_matrix(matrix_z, matrix_w))
print(is_product_availability_matrix(matrix_x, matrix_x))

True

True

True

False

True

12. Matrix Product

• 곱셈 연산이 가능한 두 개의 matrix의 곱셈을 실행하여 반환함

def matrix_product(matrix_a, matrix_b):
    return [[sum(x * y for x, y in zip(row, col)) for col in zip(*matrix_b)] for row in matrix_a]]
    
# 실행결과
matrix_x= [[2, 5], [1, 1]]
matrix_y = [[1, 1, 2], [2, 1, 1]]
matrix_z = [[2, 4], [5, 3], [1, 3]]

print(matrix_product(matrix_y, matrix_z))
print(matrix_product(matrix_z, matrix_x))
print(matrix_product(matrix_x, matrix_x))

[[9, 13], [10, 14]]
[[8, 14], [13, 28], [5, 8]]
[[9, 15], [3, 6]]

Asterisk(*)

• 단순 곱셈, 제곱 연산, 가변 인자(여러 개 값들을 한 번에 받을 수 있음)등 다양하게 사용됨
• tuple, dict 등의 자료형에 들어가 있는 값을 unpacking 하기 편리함
• 함수의 입력값, zip 등에 유용하게 사용가능

Ex 1) 가변 인자 사용 예

• a = 1, *args = (2, 3, 4, 5, 6)
• 가변 인자는 Tuple 형태

def asterisk_test(a, *args):
    print(a, args)
    print(type(args))
    
asterisk_test(1, 2, 3, 4, 5, 6)

1 (2, 3, 4, 5, 6)

<class 'tuple'>

Ex 2) 키워드 인자 사용 예

• a = 1, **kargs = {'b':2, 'c':3, 'd':4, 'e':5, 'f':6}
• 키워드 인자는 Dict 형태

def asterisk_test(a, **kargs):
    print(a, kargs)
    print(type(kargs))
    
asterisk_test(1, b=2, c=3, d=4, e=5, f=6)

1 {'b':2, 'c':3, 'd':4, 'e':5, 'f':6}

<class 'dict'>

Ex 3) unpacking 예 

• 함수 선언의 args는 하나의 tuple을 받음
• 이것을 *args를 하여 unpacking 

def asterisk_test(a, args):
    print(a, *args)
    print(type(args))
    
asterisk_test(1, (2,3,4,5,6))

1 2 3 4 5 6     (unpacking 된 결과)

<class 'tuple'>

Ex 3-1) unpacking 예 2

a, b, c = ([1, 2], [3, 4], [5, 6])
print(a, b, c)

data = ([1, 2], [3, 4], [5, 6])
print(*data)

[1, 2], [3, 4], [5, 6]

[1, 2], [3, 4], [5, 6]

Ex 3-2) unpacking 예 3

def asterisk_test(a, b, c, d, e):
    print(a, b, c, d, e)
    
data = {"d":1, "c":2, "b":3, "e":56}
asterisk_test(10, **data)

10 3 2 1 56

Ex 3-3) unpacking 예 4

for data in zip(*([1, 2], [3, 4], [5, 6])):
    print(sum(data))

9    (1 + 3+ 5)

12    (2+ 4 + 6)

Reduce 함수

• map 함수와 달리 list에 똑같은 함수를 적용해서 통합(이전의 계산 결과를 하나의 입력으로 넣는다)
• 사용을 위해 from functools import reduce 호출
• Legacy library나 다양한 머신러닝 코드에서 여전히 사용중

Ex 1) 기본적인 사용 예

from functools import reduce

print(reduce(lambda x, y: x + y, [1, 2, 3, 4, 5]))

15 -> (처음 계산 1 + 2 = 3을 x에 넣고, 다음의 계산 3 + 3 = 6 을 x에 넣고. . . 반복)

Ex 2) 팩토리얼 계산

def factorial(n):
    return reduce(
            lambda x, y: x * y, range(1, n+1))
            
print(factorial(5))

120 -> (1 * 2 * 3 * 4* 5)

Map 함수

• Sequence 자료형(List, Tuple)의 각 원소(element)에 동일한 function을 적용함
• Python 3 부터는 사용하지 않는 것을 추천하지만, Legacy library 나 다양한 머신러닝 코드에서 여전히 사용중
• 모든 원소에 함수를 적용하고 싶을 때 자주 사용한다.
• map( ) 만을 적용한 결과는 값의 주소가 출력되고, list(map( )) 을 같이 사용해주어야 적용된 결과가 출력된다.

map(Function_name, List_data)

1. Function_name = 적용시킬 함수
2. List_data = Sequence 자료형

Ex 1) 기본적인 map 함수 사용 예

ex = [1, 2, 3, 4, 5]
f = lambda x: x ** 2
print(map(f, ex)) # 주소 출력
print(list(map(f, ex)))

<map at 0x10eb2db00>

[2, 4, 6, 8, 10]

Ex 1-1) map만 사용하여 값을 출력하는 방법

ex = [1, 2, 3, 4, 5]
f = lambda x: x ** 2
print(f, ex)    # map 함수만 적용하면 값의 주소가 출력

for i in map(f, ex):    # for loop을 사용하면 값이 출력
    print(i)

<map object at 0x10f16c9e8>

1

4

9

16

25

Ex 2) zip 함수와 동일한 결과 출력하기

• 2개 이상의 Sequence 자료형에 대해 사용할 경우, 같은 인덱스에 있는 원소와 연산한다.

ex = [1, 2, 3, 4, 5]
f = lambda x, y: x + y
print(list(map(f, ex, ex)))

[2, 4, 6, 8, 10]

Ex 3) lambda 함수 + Filter(if문)

• lambda 와 Filter를 함께 사용할 때는 List comprehension과는 달리 Filter는 조건을 만족하지 않을 때의 else 값을 반드시 넣어주어야함

# 만족할 때는 제곱, 만족하지 않으면 원래의 값 그대로
ex = [1, 2, 3, 4, 5]
list(map(
    lambda x: x ** 2 if x % 2 == 0 else x,
    ex))

[1, 4, 3, 16, 5]

Ex 3-1) List comprehension으로 Ex 3) 표현해보기

ex = [1, 2, 3, 4, 5]
result = [i for i in ex if i % 2 == 0 else i]
print(result)

[1, 4, 3, 16, 5]