numpy array를 사용할 때 for문을 피해야하는 이유

Avoid for loops with numpy array

• numpy는 배열을 효율적으로 다룰 수 있도록 만들어진 라이브러리입니다.
• 같은 배열을 저장하고 있더라도 list에 비해 효과적으로 메모리를 사용하고, tensor간 연산을 지원해 계산 속도에서도 큰 이점을 가집니다.¹
• 요소별로 연산을 필요로 할 때, for 문을 활용해 계산을 하면 numpy의 장점을 활용하지 못합니다.
• numpy는 범용 함수$ufunc$을 지원하기 때문에 for문을 사용할 때와 비교가 안될 만큼 효율적인 요소별 계산을 할 수 있습니다.
• 아래 예를 보게 된다면 numpy 배열에 요소별 연산을 할 때 for 문이 얼마나 비효율적인지 알게 됩니다.
  Loading

  Sorry, something went wrong. Reload?

  Sorry, we cannot display this file.

  Sorry, this file is invalid so it cannot be displayed.

  view raw np_ufunc.ipynb hosted with ❤ by GitHub
• 속도 뿐만 아니라 코드를 작성할 때도 for 문을 사용하지 않아도 되기 때문에 간결하게 코드를 작성할 수 있습니다.

Example

• 서울대학교 김성우 교수님의 "머신러닝을 위한 기초 수학 및 프로그래밍 실습" 강의의 과제로 작성했던 코드를 예로 들어보겠습니다.
• 코페르니쿠스가 화성의 위치를 계산하기위해 유도했던 식을 프로그램화 해보는 과제입니다. 두 시점에서 지구의 태양 중심의 경도(${\theta }_1,{\theta }_2$)와 화성의 지구 중심 경도(${\varphi }_1,{\varphi }_2$)로 아래와 같은 식으로 화성의 좌표를 계산할 수 있습니다.

$$x_{Mars}=\frac{(\sin {\theta }_2-\sin {\theta }_1)+(\tan {\varphi }_1\cos {\theta }_1-\tan {\varphi }_2\cos {\theta }_2)}{\tan {\varphi }_1-\tan {\varphi }_2}$$
$$y_{Mars}=\tan {\varphi }_1{x}_{Mars}+\sin {\theta }_1-\tan {\varphi }_1\cos {\theta }_1$$

• to_degree함수는 각도의 단위를 변환해주는 함수이고, calculate_coordinate는 화성의 좌표를 계산해주는 함수입니다.
• to_degree에서 단위를 변환해 주는 과정 중에 array간의 element-wise 계산을 수행합니다.
• calculate_coordinate에서는 line3 에서 데이터를 ${\theta }_1,{\varphi }_1,{\theta }_2,{\varphi }_2$ 벡터로 분리했고, line4와 line5에서 화성의 좌표를 계산합니다.

	def calculate_coordinate$angles$:
	angles = angles * np.pi/180
	t_1, p_1, t_2, p_2 = angles[:,0], angles[:,1], angles[:,2], angles[:,3]
	x = $np.sin(t_2$-np.sin$t_1$ + $np.tan(p_1$*np.cos$t_1$ -np.tan$p_2$*np.cos$t_2$))/$np.tan(p_1$ - np.tan$p_2$)
	y = np.tan$p_1$*x + np.sin$t_1$ - np.tan$p_1$*np.cos$t_1$
	return np.array$[x,y]$.T
	def to_degree$angle$:
	deg = angle.astype$dtype = np.int$
	minute = angle - deg
	angle = deg + minute/0.6
	return angle

view raw np_ufunc_efficient.py hosted with ❤ by GitHub

• 만약에 numpy 배열을 list처럼 생각하고 for 문을 사용한다면 다음과 같이 비효율적인 방식으로 장황하게 코드를 작성해야합니다.

	def inefficient_calculate_coordinate$angles$:
	[num_i, num_j] = angles.shape
	x = np.zeros$num_i$
	y = np.zeros$num_i$
	for i in range$num_i$:
	for j in range$num_j$:
	angles[i,j] = angles[i,j] * np.pi/180
	for i in range$num_i$:
	t_1, p_1, t_2, p_2 = angles[i,0], angles[i,1], angles[i,2], angles[i,3]
	x[i] = $np.sin(t_2$-np.sin$t_1$ + $np.tan(p_1$*np.cos$t_1$ -np.tan$p_2$*np.cos$t_2$))/$np.tan(p_1$ - np.tan$p_2$)
	y[i] = np.tan$p_1$*x[i] + np.sin$t_1$ - np.tan$p_1$*np.cos$t_1$
	return np.array$[x,y]$.T
	def inefficient_to_degree$angle$:
	[num_i, num_j] = angle.shape
	for i in range$num_i$:
	for j in range$num_j$:
	deg = int$angle[i,j]$
	minute = angle[i,j] - deg
	angle[i,j] = deg + minute/0.6
	return angle

view raw np_ufunc_inefficient.py hosted with ❤ by GitHub

• 실행 시간을 측정해보면 비효율 적인 방식이 3배의 시간이 걸리는 것을 볼 수 있습니다. 데이터가 많아지면 이 차이는 더 커집니다.

	import matplotlib.pyplot as plt
	import numpy as np
	import time
	def calculate_coordinate$angles$:
	angles = angles * np.pi/180
	t_1, p_1, t_2, p_2 = angles[:,0], angles[:,1], angles[:,2], angles[:,3]
	x = $np.sin(t_2$-np.sin$t_1$ + $np.tan(p_1$*np.cos$t_1$ -np.tan$p_2$*np.cos$t_2$))/$np.tan(p_1$ - np.tan$p_2$)
	y = np.tan$p_1$*x + np.sin$t_1$ - np.tan$p_1$*np.cos$t_1$
	return np.array$[x,y]$.T
	def to_degree$angle$:
	deg = angle.astype$dtype = np.int$
	minute = angle - deg
	angle = deg + minute/0.6
	return angle
	def inefficient_calculate_coordinate$angles$:
	[num_i, num_j] = angles.shape
	x = np.zeros$num_i$
	y = np.zeros$num_i$
	for i in range$num_i$:
	for j in range$num_j$:
	angles[i,j] = angles[i,j] * np.pi/180
	for i in range$num_i$:
	t_1, p_1, t_2, p_2 = angles[i,0], angles[i,1], angles[i,2], angles[i,3]
	x[i] = $np.sin(t_2$-np.sin$t_1$ + $np.tan(p_1$*np.cos$t_1$ -np.tan$p_2$*np.cos$t_2$))/$np.tan(p_1$ - np.tan$p_2$)
	y[i] = np.tan$p_1$*x[i] + np.sin$t_1$ - np.tan$p_1$*np.cos$t_1$
	return np.array$[x,y]$.T
	def inefficient_to_degree$angle$:
	[num_i, num_j] = angle.shape
	for i in range$num_i$:
	for j in range$num_j$:
	deg = int$angle[i,j]$
	minute = angle[i,j] - deg
	angle[i,j] = deg + minute/0.6
	return angle
	if __name__ == '__main__':
	observations = np.array([[159.23, 135.12, 115.21, 182.08],
	[5.47, 284.18, 323.26, 346.56],
	[85.53, 3.04, 41.42, 49.42],
	[196.50, 168.12, 153.42, 218.48],
	[179.41, 131.48, 136.06, 184.42],
	[180.0,118,136,168],
	[210, 151, 167, 204],
	[121, 66, 76, 123],
	[178, 108, 135, 153],
	])
	start = time.perf_counter
	brahe_processed = to_degree$observations$
	brahe_result = calculate_coordinate$brahe_processed$
	efficient_time = time.perf_counter - start
	print$'>>> Efficient Calculation : ', efficient_time$
	start = time.perf_counter
	brahe_processed_ineffi = inefficient_to_degree$observations$
	brahe_result_ineffi = inefficient_calculate_coordinate$brahe_processed_ineffi$
	inefficient_time = time.perf_counter - start
	print$'>>> Inefficient Calculation : ',inefficient_time$
	print$'>>> Inefficiency Ratio: ',inefficient_time/efficient_time$
	----------------
	>>> Efficient Calculation : 0.00013260000000003824
	>>> Inefficient Calculation : 0.0004408999999999663
	>>> Inefficiency Ratio : 3.3250377073894355

view raw np_ufunc_all.py hosted with ❤ by GitHub

np.vectorize로 ufunc 정의하기

• 라이브러리에서 제공하는 ufunc으로 대부분의 작업이 가능하지만 스칼라 연산에 대해 정의 된 함수를 ufunc으로 바꿀 수 있는 방법이 있습니다.
• 궂이 vectorize방법이 필요한 상황을 생각해보았지만 지금은 떠오르지 않지만 억지로 예시를 만들자면 다음과 같은 예시가 있을 수 있습니다.
• python 내장 라이브러리인 math의 sin함수는 numpy array 연산을 지원하지 않지만 vecotrize 함수를 사용해 다음과 같이 범용함수로 만들 수 있습니다.

	import math
	import numpy as np
	def function_for_scalr$x$:
	y = math.sin$x$ + 2
	return y
	vectorized_function = np.vectorize$function_for_scalar$
	test_array = np.random.rand$5$
	print$vectorized_function(test_array$)
	print$function_for_scalar(test_array$) # 에러 발생

view raw np_ufunc_vectorize.py hosted with ❤ by GitHub

마무리

• numpy array를 사용할 때 범용함수$universial function$의 유용함을 확인했습니다.
• numpy 연산의 특징을 잘 활용할 때, for 문을 사용해 코드가 길어질 때 발생할 수 있는 잠재적인 오류의 원인을 막을 수 있고 빠른 연산 속도를 보장할 수 있습니다.

Reference

[1] numpy ufunc docs
[2] Python Lists vs. Numpy Arrays - What is the difference? - UCF open course
[3] 코페르니쿠스 혁명 - wiki