R, Python 분석과 프로그래밍의 친구 (by R Friend)

영화 "그린 북 (Green Book)"

감독: 피터 패럴리
출연: 비고 모텐슨 (토니 발레롱가 역), 마허샬라 알리(돈 셜리 역)

영화의 제목인 “그린 북(Green Book)”은 1950~60년대 아직도 흑인 인종차별이 심했던 미국 남부 지방에 흑인이 여행할 때 안심하고 묵을 수 있는 숙박시설을 안내해주는 책을 말합니다. 제목에서 알 수 있는 것처럼 “인종차별”에 대한 심각한 이야기를 흑인 천재 피아니스트와 백인 운전사의 로드 무비 형식을 빌려 때론 유머러스하게, 때론 인종차별의 민낯을 직시하며 생각할 거리를 주는 영화입니다.  

이 영화는 1962년 뉴욕을 배경으로 하고 있으며, 실화에 바탕을 둔 영화입니다. 영화 마지막에 영화의 모티브가 되었던 두 명의 실존 인물 사진이 나와요. 유족은 이 영화에 허구가 많이 가미되었다면서 반발했다고는 하네요. 
 
제91회 아카데미 시상식에서 작품상, 각본상, 남우조연상을 수상했으며, 극장 총 수익이 3억 416억 달러로 영화 흥행도 큰 성공을 거둔 영화예요.  

영화는 교양과 품위를 갖춘 “흑인” 천재 피아니스트 돈 셜리(마허샬라 알리) 박사와, 말과 행동이 거칠고 서민적이며 허풍과 임기응변 선수인 “백인” 운전사 토니 발레롱가(비고 모텐슨)의 8주 간의 미국 남부 트리오 공연 (피아노, 첼로, 베이스) 동안 둘 사이에 벌어지는 일을 다룹니다. 일반적으로 “흑인”과 “백인” 하면 떠오르는 선입관과는 정반대의 설정인데요, 이런 선입관에 반하는 관계 속에서 인종 차별에 대한 얘기를 풀어나가는 감독의 줄타기가 대단합니다. 아래의 영화 장면처럼 돈 셜리 박사는 마치 왕족처럼 차려입고 상아 의자에 앉아 내려다보고 있고, 토니 발레롱가는 직업을 얻기 위해 인터뷰를 보는 입장에서 아래쪽 허름한 의자에 앉아 올려다보고 있어요. 처음엔 좀 어색하지 않으세요? (우리가 이리 세뇌되어있어요. -,-;)

저는 이 영화에 나오는 자잘한 유머가 무척 재미있었어요. 돈 셜리 ‘박사(Doctor)’ 라고 해서 병원에서 일하는 의사인줄 알았는데 카네기홀에 사는 피아니스트라고 해서 놀랐다는 토니 부부의 얘기, 핏츠버그에는 가슴 큰 여자가 많아서 찌찌버그라고 불린다는 얘기를 들었다면서 핏츠버그에 가면 직접 두 눈으로 확인을 해보겠다는 토니, “죠팽”은 아무나 칠 수 있지만 이런 음악은 당신만 연주할 수 있다는 토니의 응원성 멘트에 돈 셜리가 “쇼팽”을 나처럼 치는건 아무나 못하죠 하면서 정중하게 바로잡아 주는 장면이라든지… 방긋 미소지게 하는 소소한 장면들이 여럿 있어요. :-)

영화 마지막 즈음에 첼리스트가 말해주는 장면 중에 돈 셜리가 북부에서 공연하면 남부에서보다 3배나 더 많은 공연료를 받고 또 인간적으로 대접을 받을 수 있음에도 불구하고 왜 남부지역에서 인종차별을 당하면서 낮은 공연료에도 순회공연을 하게 되었는지에 대한 이야기가 나와요. 돈 셜리가 남부 지역 공연을 자원했는데요, 흑인에 대한 인종차별에 대해 자신이 할 수 있는 한에서 사람들 마음을 움직이고자 용기를 냈다는 말이 큰 감동이 있었어요. 

“왜냐면 천재성만으론 부족하거든요. 사람의 마음을 움직이려면 용기가 필요해요.”
(Because genius is not enough. It takes courage to change people's hearts.)


토니와 돈 셜리가 여행을 하면서 처음에는 서로의 다름으로 인해 갈등하지만 점차 서로를 존중하고, 이해하고 또 서로 약한 부분을 도와주면서 일면 닮아가는 과정이 기분좋게 그려졌어요. 가령, 토니가 부인에게 편지를 쓸 때 돈 셜리가 세익스피어처럼 아름다운 문장으로 편지를 쓸 수 있도록 도와준다든지, 후라이드 치킨을 손으로 잡고 먹어본 적이 없는 돈 셜리에게 토니가 강권하면서 기어이 손으로 먹는 후라이드 치킨의 맛을 볼 수 있게 해준다던지… 편지 코치를 받던 토니가 동생과 연락을 끊고 지내는 돈 셜리 박사에게 먼저 편지를 써보라고 권하는 장면… 마지막 공연을 깽판치고 크리스마스 전에 뉴욕 집으로 돌아오는 길에 잠을 못자고 운전하다가 지친 토니가 도저히 안되겠다며 숙박시설에서 잠을 자고 가자고 하자 돈 셜리는 운전대를 잡고 교대로 운전을 해주는 장면… 참 훈훈하고 따뜻한 장면들이예요. 
(돈 셜리 유족은 영화가 너무 미화되었다고 반발했다고 하네요. -,-;)


돈 셜리와 토니 발레롱가가 항상 사이좋게 공연을 다녔던 건 아니고, 싸우기도 했는데요, 돈 셜리가 비가 내리는 와중에 차를 박차고 나가서 울부짖는 장면이 인상적이었어요. 

돈 셜리는 “나는 충분히 흑인도 아니고, 난 충분히 백인도 아니고, 난 충분히 남자도 아니고… 그럼 난 뭐지?” 라고 소리쳐요. 

흑인이면서 최고의 교육을 받은 앵글로색슨 백인처럼 교양있고 품위있게 말하고 행동하는 돈 셜리. 남부지방에서 흑인 여러명이 농장에서 일하고 있고, 백인 토니가 고장난 차를 수리하고, 돈 셜리 박사는 차 옆에서 기다리고, 농장의 흑인들과 돈 셜리가 눈이 마주치는 장면은 느리게 지나가면서 긴 여운을 남겨요. 돈 셜리는 수영장에서 남자랑 둘이 같이 있었다는 이유로 경찰에게 잡히기도 해요. 돈 셜리는 어디에도 속하지 못하면서 사회에서 비주류로서 당할 수 있는 차별을 당하고 있는지라 얼마나 외롭고 힘들까 싶어요. 그럼에도 돈 셜리는 남 탓, 사회 탓만 하고 주저앉는게 아니라 사람들의 마음을 움직이기 위해 자신이 할 수 있는 일, 남부지방 순회공연을 해요. 그래서 더 감동이예요. 

돈 셜리는 인종차별에 뚜껑이 열려서 주먹이 먼저 나가는 토니에게 "폭력으로는 못 이겨요. 품위(dignity)가 이겨요." 라고 말해요. 마하트마 간디가 연상되는 장면이었어요. 

저는 이 영화 그린북을 인종 차별을 너무 심각하지 않으면서도 사람들에게 생각할 거리를 준 미덕을 갖춘 영화라고 생각해요. 그런데 language exchange 를 하고 있는 미국 변호사분과 이 영화 얘기를 나누었는데요, 미국 내 흑인들 중에는 이 영화에 대해서 비판적인 시선을 가진 이들이 꽤 있다고 해요. 이 영화가 백인이 각본을 쓰고, 백인이 제작을 하고, 백인이 감독을 했고, 백인 역할의 토니가 더 주목을 받은 영화이고, 백인 토니는 문제해결사로, 흑인 돈 셜리는 문제를 일이키고 도움을 받는 인물로 묘사가 되었다면서 흑인 사회에서는 이 영화에 화가 난 이들이 많다고 하더라구요. 제가 한국인이다보니 영화를 이렇게 못 봤구나, 흑인들은 기분 안좋게 이 영화를 볼 수도 있구나 싶어서 좀 놀랬어요. 자라온 배경과 정체성이 누구의 시선이냐에 따라서 영화가 달리 보일 수도 있겠구나 싶어서요. 


그럼에도 불구하고 저는 이 영화의 미덕, 인종차별에 대해서 문제제기하고, 흑인과 백인이라는 두 세계의 굉장히 다른 두 사람이 서로를 인정하고, 존중하고, 또 가르쳐주고 배우면서 같이 성장하고 변화해가는 모습을 때론 미소짓게, 때론 뭉클하게 이야기로 풀어낸 이 영화의 미덕은 높여사줘야 한다고 생각해요. 


이번 주말에 뭘 하면 좋을지 고민이세요? 맥주 한잔 곁들이면서 그린북(Green Book)’ 영화 한편 때리세요! ^_-*

지난 포스팅에서는 두 개의 PyTorch 텐서를 합치기 (concatenating two PyTorch tensors) 에 대해서 다루었습니다.
(바로가기 ==> https://rfriend.tistory.com/781 )

이번 포스팅에서는 반대로 한 개의 PyTorch 텐서를 복수 개로 나누기 (splitting a tensor into multiple tensors) 하는 방법을 소개하겠습니다. 

(1) 하나의 PyTorch 텐서를 위-아래의 복수 개의 텐서로 나누기
      (splitting a tensor into multiple tensors vertically)

      : torch.vsplit(tensor, indices_or_sections), torch.split(tensor, split_size_or_sections, dim=0)

(2) 하나의 PyTorch 텐서를 좌-우의 복수 개의 텐서로 나누기
     (splitting a tensor into multiple tensors horizontally) 

     : torch.hsplit(tensor, indices_or_sections), torch.split(tensor, split_size_or_sections, dim=1)

먼저 PyTorch 텐서를 위-아래의 수직으로 복수 개의 텐서로 나누기를 해보겠습니다. 

(1) 하나의 PyTorch 텐서를 위-아래의 복수 개의 텐서로 나누기
      (splitting a tensor into multiple tensors vertically)
      : torch.vsplit(tensor, indices_or_sections), torch.split(tensor, split_size_or_sections, dim=0)

torch.vsplit() 과 torch.split(dim=0) 의 경우 매개변수의 사용법에 차이가 있습니다. 

torch.vsplit(tensor, indices_or_sections) 은 indices_or_sections 매개변수로 input tensor 의 행(row) 을 몇으로 나눌지(indices)를, 그래서 결국 몇 개의 텐서로 나누고 싶은지를 지정해주는 것입니다. 가령, 아래 예의 경우 텐서 z 는 Size[6, 6] 인데요, indices_or_sections=2 로 입력할 경우, 6/2 = 3 으로서 각 3개의 균등한 행을 가지는 2개의 텐서로 나누어줍니다. 

반면에, torch.split(tensor, split_size_or_sections, dim=0) 은 (a) "dim=0" 으로 행에 대해서 수직으로 텐서 분리를 수행하라고 지정을 해주어야 하고, (b) split_size_or_sections 에서 지정한 숫자만큼의 크기(split_size)로 행을 가지도록 텐서를 분리해줍니다. 가령, 아래 예의 Size[6, 6] 의 텐서 z에 대해서 torch.split(z, 3, dim=0) 으로서 split_size_or_sections = 3 을 입력해주면 각 행을 3개씩의 크기(split size)로 가지는 텐서로 분리를 해줍니다. (원래 텐서에 행이 6개 있는데, 분리할 텐서는 각 3개씩 행을 가지라고 했으므로 결과적으로 총 2개의 텐서로 분리가 됨). 

예제로 사용할 Size[6, 6]의 PyTorch 텐서 z 를 만들어보겠습니다. 

z = torch.arange(36).reshape(6,6)

print(z)
# tensor([[ 0,  1,  2,  3,  4,  5],
#         [ 6,  7,  8,  9, 10, 11],
#         [12, 13, 14, 15, 16, 17],
#         [18, 19, 20, 21, 22, 23],
#         [24, 25, 26, 27, 28, 29],
#         [30, 31, 32, 33, 34, 35]])

텐서 z 를 torch.vsplit(z, 2) 를 사용해서 2개의 텐서로 분리를 해보겠습니다. (indices_or_sections = 2 로 입력하면 6을 2로 나누어서 3개씩의 행을 가지는 2개의 텐서로 분리해줌)

## vsplit(): Splits input, a tensor with two or more dimensions, 
## into multiple tensors vertically according to indices_or_sections.
torch.vsplit(z, 2)

# (tensor([[ 0,  1,  2,  3,  4,  5],
#          [ 6,  7,  8,  9, 10, 11],
#          [12, 13, 14, 15, 16, 17]]),
#  tensor([[18, 19, 20, 21, 22, 23],
#          [24, 25, 26, 27, 28, 29],
#          [30, 31, 32, 33, 34, 35]]))

이때 반환되는 아웃풋은 두 개의 텐서를 묶어놓은 튜플(tuple)입니다. 

type(torch.vsplit(z, 2))
# tuple

위에서 2개로 분리한 텐서들의 묶음인 튜플에 원하는 부분의 텐서에 접근하기 위해서는 인덱싱(indexing)을 사용하면 됩니다. 아래 예에서는 2개로 분리한 텐서의 각 첫번째와 두번째 튜플에 접근해서 가져와봤습니다.  

## accessing a tensor after splitting
torch.vsplit(z, 2)[0]

# tensor([[ 0,  1,  2,  3,  4,  5],
#         [ 6,  7,  8,  9, 10, 11],
#         [12, 13, 14, 15, 16, 17]])


torch.vsplit(z, 2)[1]

# tensor([[18, 19, 20, 21, 22, 23],
#         [24, 25, 26, 27, 28, 29],
#         [30, 31, 32, 33, 34, 35]])

torch.split(z, 3, dim=0) 은 dim=0 으로 지정을 해주면 됩니다. 

## Splits the tensor into chunks. 
## Each chunk is a view of the original tensor.
torch.split(z, 3, dim=0)

# (tensor([[ 0,  1,  2,  3,  4,  5],
#          [ 6,  7,  8,  9, 10, 11],
#          [12, 13, 14, 15, 16, 17]]),
#  tensor([[18, 19, 20, 21, 22, 23],
#          [24, 25, 26, 27, 28, 29],
#          [30, 31, 32, 33, 34, 35]]))

## split_size_or_sections : list of sizes for each chunk
torch.split(z, [1,2,3], dim=0)

# (tensor([[0, 1, 2, 3, 4, 5]]),
#  tensor([[ 6,  7,  8,  9, 10, 11],
#          [12, 13, 14, 15, 16, 17]]),
#  tensor([[18, 19, 20, 21, 22, 23],
#          [24, 25, 26, 27, 28, 29],
#          [30, 31, 32, 33, 34, 35]]))

(2) 하나의 PyTorch 텐서를 좌-우의 복수 개의 텐서로 나누기
     (splitting a tensor into multiple tensors horizontally) 

     : torch.hsplit(tensor, indices_or_sections), torch.split(tensor, split_size_or_sections, dim=1)

이번에는 하나의 PyTorch 텐서를 좌-우 수평으로해서 복수 개의 텐서로 나누어볼텐데요, 역시 torch.hsplit() 과 torch.split(dim=1) 의 경우 매개변수의 사용법에 차이가 있습니다.

torch.hsplit(tensor, indices_or_sections) 은 indices_or_sections 매개변수로 input tensor 의 열(column) 을 몇으로 나눌지(indices)를, 그래서 결국 몇 개의 텐서로 나누고 싶은지를 지정해주는 것입니다. 가령, 아래 예의 경우 텐서 z 는 Size[6, 6] 인데요, indices_or_sections=2 로 입력할 경우, 6/2 = 3 으로서 각 3개의 균등한 열을 가지는 2개의 텐서로 좌-우로 나누어줍니다. 

반면에, torch.split(tensor, split_size_or_sections, dim=1) 은 (a) "dim=1" 으로 행에 대해서 수평으로 텐서 분리를 수행하라고 지정을 해주어야 하고, (b) split_size_or_sections 에서 지정한 숫자만큼의 크기(split_size)로 행을 가지도록 텐서를 분리해줍니다. 가령, 아래 예의 Size[6, 6] 의 텐서 z에 대해서 torch.split(z, 3, dim=0) 으로서 split_size_or_sections = 3 을 입력해주면 각 열(column)을 3개씩의 크기(split size)로 가지는 텐서로 분리를 해줍니다. (원래 텐서에 열이 6개 있는데, 분리할 텐서는 각 3개씩 열을 가지라고 했으므로 결과적으로 총 2개의 텐서로 분리가 됨). 

## hsplit(): Splits input, a tensor with two or more dimensions, 
## into multiple tensors horizontally according to indices_or_sections.

torch.hsplit(z, 2)

# (tensor([[ 0,  1,  2],
#          [ 6,  7,  8],
#          [12, 13, 14],
#          [18, 19, 20],
#          [24, 25, 26],
#          [30, 31, 32]]),
#  tensor([[ 3,  4,  5],
#          [ 9, 10, 11],
#          [15, 16, 17],
#          [21, 22, 23],
#          [27, 28, 29],
#          [33, 34, 35]]))

torch.hsplit(tensor, indices_or_sections) 에서 indices_or_sections 매개변수로 indices 넣어줄 때는 정수로 나누어지는 값을 넣어주어야 합니다. 가령, 아래 예에서는 Size[6, 6] 의 텐서에서 dimension 1 의 방향으로 4개 나누라고 지정해었더닌 6을 4로 나눌 수 없다면서 RunTimeError: torch.hsplit attempted to split along dimension 1, but size of the dimension 6 is not divisible by the split_size 4! 라는 에러가 발생했습니다. 

## RuntimeError
torch.hsplit(z, 4)

# RuntimeError: torch.hsplit attempted to split along dimension 1, 
# but the size of the dimension 6 is not divisible by the split_size 4!

torch.split(z, 3, dim=1) 에서는 dim=1 로 차원을 지정해주면 됩니다. 

torch.split(z, 3, dim=1)

# (tensor([[ 0,  1,  2],
#          [ 6,  7,  8],
#          [12, 13, 14],
#          [18, 19, 20],
#          [24, 25, 26],
#          [30, 31, 32]]),
#  tensor([[ 3,  4,  5],
#          [ 9, 10, 11],
#          [15, 16, 17],
#          [21, 22, 23],
#          [27, 28, 29],
#          [33, 34, 35]]))

torch.split() 함수에서 split_size_or_sections 매개변수에 리스트로 해서 나누고 싶은 텐서의 크기 (split_size_sections) 를 복수개로 지정해줄 수도 있습니다. 아래의 예에서는 Size[6, 6]의 텐서를 열의 개수를 1개, 2개, 3개를 가지는 총 3개의 텐서로 분리(split_size_or_sections = [1, 2, 3])해 본 것입니다. 매우 편리한 기능입니다! 

## split_size_or_sections : list of sizes for each chunk
torch.split(z, [1,2,3], dim=1)

# (tensor([[ 0],
#          [ 6],
#          [12],
#          [18],
#          [24],
#          [30]]),
#  tensor([[ 1,  2],
#          [ 7,  8],
#          [13, 14],
#          [19, 20],
#          [25, 26],
#          [31, 32]]),
#  tensor([[ 3,  4,  5],
#          [ 9, 10, 11],
#          [15, 16, 17],
#          [21, 22, 23],
#          [27, 28, 29],
#          [33, 34, 35]]))

이번 포스팅이 많은 도움이 되었기를 바랍니다. 

행복한 데이터 과학자 되세요!  :-)

이번 포스팅에서는 두 개의 PyTorch 텐서를 하나로 합치는 방법을 소개하겠습니다. 

(1) torch.cat((x, y), dim=0), torch.concat(dim=0): 두 개의 텐서를 위-아래로 합치기 (vertically, row wise)

(2) torch.cat((x, y), dim=1), torch.concat(dim=1): 두 개의 텐서를 좌-우로 합치기 (horizontally, column wise)

(3) torch.vstack((x, y)), torch.row_stack(): 두 개의 텐서를 위-아래로 합치기 (vertically, row wise)

(4) torch.hstack((x, y)), torch.column_stack(): 두 개의 텐서를 좌-우로 합치기 (horizontally, column wise)

(5) torch.stack((x, y), dim=0): 두 개의 텐서를 새 차원(new dimension)으로 위-아래로 합치기

(6) torch.stack((x, y)dim=1): 두 개의 텐서를 새 차원(new dimension)으로 좌-우로 합치기

두 개의 텐서를 위-아래로 합치기 (vertically, row wise concatenation) 는 torch.cat(dim=0), torch.concat(dim=0), torch.vstack(), torch.row_stack() 로 수행 가능합니다. 

두 개의 텐서를 좌-우로 합치기 (horizontally, column wise concatenation) 는 torch.cat(dim=1), torch.concat(dim=1), torch.hstack(), torch.column_stack() 로 수행 가능합니다. 

torch.stack((x, y), dim=0) 은 새로운 차원(new dimension)을 추가해서 두 개의 텐서를 위-아래로 합쳐주며, 

torch.stack((x, y), dim=1) 은 새로운 차원을 추가해서 두 개의 텐서를 좌-우로 합쳐주는 차이점이 있습니다. 

예제로 사용할 두 개의 PyTorch 텐서를 만들어보겠습니다. 

import torch

x = torch.arange(12).reshape(3, 4)
y = torch.arange(12, 24).reshape(3, 4)

print(x)
# tensor([[ 0,  1,  2,  3],
#         [ 4,  5,  6,  7],
#         [ 8,  9, 10, 11]])

print(y)
# tensor([[12, 13, 14, 15],
#         [16, 17, 18, 19],
#         [20, 21, 22, 23]])

(1) torch.cat(dim=0), torch.concat(dim=0)
        : 두 개의 텐서를 위-아래로 합치기 (vertically, row wise)

## torch.cat(): concatenating in the axis 0
torch.cat((x, y), dim=0) # or torch.concat((x, y), 0)

# tensor([[ 0,  1,  2,  3],
#         [ 4,  5,  6,  7],
#         [ 8,  9, 10, 11],
#         [12, 13, 14, 15],
#         [16, 17, 18, 19],
#         [20, 21, 22, 23]])


torch.cat((x, y), dim=0).shape
# torch.Size([6, 4])

(2) torch.cat((x, y), dim=1), torch.concat(dim=1)
        : 두 개의 텐서를 좌-우로 합치기 (horizontally, column wise)

## concatenating in the axis 1
torch.cat((x, y), dim=1) # or torch.concat((x, y), 1)

# tensor([[ 0,  1,  2,  3, 12, 13, 14, 15],
#         [ 4,  5,  6,  7, 16, 17, 18, 19],
#         [ 8,  9, 10, 11, 20, 21, 22, 23]])


torch.cat((x, y), dim=1).shape
# torch.Size([3, 8])

(3) torch.vstack((x, y)), torch.row_stack()
        : 두 개의 텐서를 위-아래로 합치기 (vertically, row wise)

## Stack tensors in sequence vertically (row wise).
torch.vstack((x, y))

# tensor([[ 0,  1,  2,  3],
#         [ 4,  5,  6,  7],
#         [ 8,  9, 10, 11],
#         [12, 13, 14, 15],
#         [16, 17, 18, 19],
#         [20, 21, 22, 23]])


## or equivalently
torch.row_stack((x, y))


torch.row_stack((x, y)).shape
# torch.Size([6, 4])

(4) torch.hstack((x, y)), torch.column_stack()
        : 두 개의 텐서를 좌-우로 합치기 (horizontally, column wise)

## Stack tensors in sequence horizontally (column wise).
torch.hstack((x, y))

# tensor([[ 0,  1,  2,  3, 12, 13, 14, 15],
#         [ 4,  5,  6,  7, 16, 17, 18, 19],
#         [ 8,  9, 10, 11, 20, 21, 22, 23]])


## or equivalently
torch.column_stack((x, y))


torch.column_stack((x, y)).shape
# torch.Size([3, 8])

(5) torch.stack((x, y), dim=0)
        : 두 개의 텐서를 새 차원(new dimension)으로 위-아래로 합치기

위의 (1)~(4)번의 메소드 대비해서 torch.stack((x, y), dim=0) 은 새로운 차원(new dimension)을 추가해서 두 개의 텐서를 위-아래로 합쳐주며, torch.stack((x, y), dim=1) 은 새로운 차원을 추가해서 두 개의 텐서를 좌-우로 합쳐주는 차이점이 있습니다. (1)~(4)번의 텐서 합치기를 했을 때의 shape 과 (5)~(6)번의 텐서 합치기 후의 shape 을 유심히 비교해보시기 바랍니다.  

## Concatenates a sequence of tensors along a new dimension.
## stack with axis=0 (vertically, row-wise)
torch.stack((x, y), dim=0) # axis=0

# tensor([[[ 0,  1,  2,  3],
#          [ 4,  5,  6,  7],
#          [ 8,  9, 10, 11]],

#         [[12, 13, 14, 15],
#          [16, 17, 18, 19],
#          [20, 21, 22, 23]]])

## new dimension
torch.stack((x, y), dim=0).shape
# torch.Size([2, 3, 4])

(6) torch.stack((x, y)dim=1)
        : 두 개의 텐서를 새 차원(new dimension)으로 좌-우로 합치기

## stack with axis=1 (horizontally, column-wise)
torch.stack((x, y), dim=1) # axis=1

# tensor([[[ 0,  1,  2,  3],
#          [12, 13, 14, 15]],

#         [[ 4,  5,  6,  7],
#          [16, 17, 18, 19]],

#         [[ 8,  9, 10, 11],
#          [20, 21, 22, 23]]])


## new dimension
torch.stack((x, y), dim=1).shape
# torch.Size([3, 2, 4])

다음 포스팅에서는 이어서 '하나의 PyTorch 텐서를 복수개의 텐서로 나누기 (splitting a PyTorch tensor into multiple tensors)' 에 대해서 소개하겠습니다.  

이번 포스팅이 많은 도움이 되었기를 바랍니다. 

행복한 데이터 과학자 되세요!  :-)

이번 포스팅에서는 PyTorch 에서 인덱싱(indexing)과 슬라이싱(slicing)을 이용해서 텐서 내 원하는 위치의 원소 부분집합을 가져오는 방법을 소개하겠습니다. PyTorch 로 딥러닝을 할 때 인풋으로 사용하는 데이테셋이 다차원의 행렬인 텐서인데요, 인덱싱과 슬라이싱을 자주 사용하기도 하고, 또 차원이 많아질 수록 헷갈리기도 하므로 정확하게 익혀놓을 필요가 있습니다. NumPy의 인덱싱, 슬라이싱을 이미 알고 있으면 그리 어렵지 않습니다. 

(1) 파이토치 텐서 인덱싱 (indexing of PyTorch tensor) 

(2) 파이토치 텐서 슬라이싱 (slicing of PyTorch tensor)

(3) 1개 값만 가지는 파이토치 텐서에서 숫자 가져오기 : tensor.item() 

(4) 파이토치 텐서 재구조화 (reshape)

(1) 파이토치 텐서 인덱싱 (indexing of PyTorch tensor)

먼저, 예제로 사용할 PyTorch tensor를 NumPy ndarray를 변환해서 만들어보겠습니다.

torch.Size([3, 5]) 의 형태를 가진 텐서를 만들었습니다. 

import torch
import numpy as np

## -- creating a tensor object
x = torch.tensor(
    np.arange(15).reshape(3, 5))

print(x)
# tensor([[ 0,  1,  2,  3,  4],
#         [ 5,  6,  7,  8,  9],
#         [10, 11, 12, 13, 14]])


## -- shape, size of a tensor

x.shape
# torch.Size([3, 5])

x.size(0)
# 3

x.size(1)
# 5

다양한 인덱싱 시나리오별로 예를 들어서 설명을 해보겠습니다. 

(1-1) 1번 행 전체를 인덱싱 해오기 

## indexing using position number
x[1]  # or equivalently x[1, :]
# tensor([5, 6, 7, 8, 9])

(1-2) 1번 행, 2번 열 원소 인덱싱 해오기

x[1, 2]
# tensor(7)

(1-3) 1번 열 전체를 인덱싱 해오기

x[:, 1]
# tensor([ 1,  6, 11])

(1-4) 1번 열, 블리언(Boolean) True 인 행만 인덱싱 해오기

## indexing using Boolean
x[1][[True, False, False, False, True]]
# tensor([5, 9])

(1-5) 1번 열, 텐서(tensor)의 값의 행만 인덱싱 해오기

## indexing using a tensor
x[1][torch.tensor([1, 3])]
# tensor([6,8])

(1-6) 1번 열을 가져오되, 행은 리스트의 위치 값 순서대로 바꾸어서 가져오기

## changing the position using indexing
x[1, [4,3,0,1,2]]
# tensor([9, 8, 5, 6, 7])

(1-7) 행 별로 열의 위치를 달리해서 값 가져오기

(예) 0번 행의 4번 열, 1번 행은 3번 열, 2번 행은 2번 열의 값 가져오기

## 행별로 인덱싱할 위치를 바뀌가면서 인덱싱하기
x[torch.arange(x.size(0)), [4,3,2]]
# tensor([ 4,  8, 12])

(1-8) 전체 행의 마지막 열(-1) 값 가져오기

## -1 : last elements
x[:, -1]
# tensor([ 4,  9, 14])

(1-9) 인덱싱한 위치에 특정 값을 재할당 하기

(예) 1번 행에 값 '0'을 재할당하기

## asinging new value using indexing
x[1] = 0


print(x)
# tensor([[ 0,  1,  2,  3,  4],
#         [ 0,  0,  0,  0,  0],   <----- '0' 으로 재할당 됨
#         [10, 11, 12, 13, 14]])

(2) 파이토치 텐서 슬라이싱 (slicing of PyTorch tensor)

(2-1) 1번 행 이후의 행의 모든 값 가져오기

x = torch.tensor(
    np.arange(15).reshape(3, 5))

print(x)
# tensor([[ 0,  1,  2,  3,  4],
#         [ 5,  6,  7,  8,  9],
#         [10, 11, 12, 13, 14]])


## -- slicing
x[1:]
# tensor([[ 5,  6,  7,  8,  9],
#         [10, 11, 12, 13, 14]])

(2-2) 1번 행 이후의 행 & 3번 열 이후의 열의 모든 값 가져오기

x[1:, 3:]
# tensor([[ 8,  9],
#         [13, 14]])

(2-3) 전체 행, 1번 열의 값 가져오기

x[:, 1]
# tensor([ 1,  6, 11])

(2-4) 1번 행, 전체 열의 값 가져오기

x[1, :]  # or equivalently x[1]
# tensor([5, 6, 7, 8, 9])

(2-5) 1번 행의, 1번과 4번 행의 값 가져오기

(생소한 코드예요. ^^;)

## tensor[1::3] ==> (1, None, None, 4)
x[1][1::3]
# tensor([6, 9])

(3) 1개 값만 가지는 파이토치 텐서에서 숫자 가져오기 : tensor.item()

## torch.tensor.item()
## : get a Python number from a tensor containing a single vlaue
y = torch.tensor([[5]])
print(y)
# tensor([[5]])

y.item()
# 5

만약 PyTorch tensor가 1개의 값(즉, 스칼라) 만을 가지는 것이 아니라 여러개의 값을 가지는 경우, tensor.item() 메소드를 사용하면 ValueError: only one element tensors can be converted to Python scalars 가 발생합니다. 

## ValueError
x.item()

# ValueError Traceback (most recent call last)
# <ipython-input-74-3396a1b2b617> in <module>
# ----> 1 x.item()

# ValueError: only one element tensors can be converted to Python scalars

(4) 파이토치 텐서 재구조화 (reshape)

NumPy의 reshape() 메소드와 동일하게 PyTorch tensor 도 reshape() 메소드를 이용해서 형태(shape)를 재구조화할 수 있습니다. 

torch.tensor([[0, 1, 2, 3, 4, 5]])
# tensor([[0, 1, 2, 3, 4, 5]])


## -- reshape
torch.tensor([[0, 1, 2, 3, 4, 5]]).reshape(2, 3)
# tensor([[0, 1, 2],
#         [3, 4, 5]])

이번 포스팅이 많은 도움이 되었기를 바랍니다. 

행복한 데이터 과학자 되세요!  :-)

이번 포스팅에서는 PyTorch tensor 와 NumPy ndarrays 의 행렬 곱셈(matrix multiplication) 성능을 비교해보겠습니다. GPU 는 Google Colab 을 사용해서 성능을 테스트했습니다. 

(1) PyTorch tensor & GPU 로 행렬 곱셈 (matrix multiplication) 

(2) PyTorch tensor & CPU 로 행렬 곱셈

(3) NumPy ndarrays & CPU 로 행렬 곱셈

m * n 행렬 A 와 n * p 행렬 B 가 있다고 했을 때, 행렬 곱셈(matrix multiplication) C = AB 는 아래와 같이 정의할 수 있습니다.  행렬 곱셈 연산은 A 의 i번째 행과 B의 j번째 열의 성분들을 각각 곱한 후 더한 것이며, 서로 독립적으로 병렬 연산 (calculation in parallel) 이 가능합니다. GPU 는 수 천 개의 cores 를 가지고 있으므로 단지 수 개의 cores를 가지는 CPU 보다 병렬로 행렬 곱셈을 매우 빠르게 수행할 수 있습니다. 

(1) PyTorch tensor & GPU 로 행렬 곱셈 (matrix multiplication)

PyTorch를 불러오고, torch.manual_seed() 로 초기값을 설정해서 매번 동일한 난수가 발생하게 설정을 해준 다음, torch.rand() 함수로 난수를 생성해서 torch 객체를 만들어보겠습니다. 

import torch
print(torch.__version__)
#1.13.1+cu116

## generate the torch objects with random numbers
torch.manual_seed(1004)
x = torch.rand(1, 25600)
y = torch.rand(25600, 100)

다음으로, torch tensor 객체를 저장할 디바이스를 정의하겠습니다. 아래 코드는 GPU 를 사용할 수 있으면 (torch.cuda.is_available() == True) 'cuda' 로 디바이스를 정의하고, 그렇지 않으면 'cpu'로 디바이스를 정의합니다. 

## define the device
device = 'cuda' if torch.cuda.is_available() else 'cpu'

이제 x, y의 두 개 tensor 객체를 위에서 정의한 디바이스에 등록(register)해서 정보를 저장하겠습니다. 

## register and save the tensor objects with the device
x, y = x.to(device), y.to(device)

마지막으로, PyTorch tensor 객체인 행렬 x와 y 의 행렬 곱셉(matrix multiplication, z = (x@y))을 GPU 를 사용해서 해보겠습니다. 이때 실행 성능을 확인하기 위해 %timeit 으로 실행 시간을 측정해보겠습니다. 

행렬 곱셉에 25.4 µs ± 26.9 µs per loop 의 시간이 걸렸네요.  

## (1) run matrix multiplication of the Torch objects on GPU
%timeit z = (x@y)

# The slowest run took 6.94 times longer than the fastest. 
# This could mean that an intermediate result is being cached.
# 25.4 µs ± 26.9 µs per loop (mean ± std. dev. of 7 runs, 1 loop each)

(2) PyTorch tensor & CPU 로 행렬 곱셈 (matrix multiplication)

이번에는 PyTorch tensor 에 대해 CPU 를 사용(x.cpu(), y.cpu())해서 행렬 곱셉을 해보겠습니다. 

PyTorch tensor에 대해 CPU 로는 932 µs ± 292 µs per loop 의 시간이 소요되었으며, 이는 위의 PyTorch tensor & GPU 대비 약 37배 더 시간이 소요되었습니다. 

## (2) run matrix multiplication of the same tensors on CPU
x, y = x.cpu(), y.cpu()

%timeit z = (x@y)

# 932 µs ± 292 µs per loop 
# (mean ± std. dev. of 7 runs, 1000 loops each)

(3) NumPy ndarrays & CPU 로 행렬 곱셈

마지막으로 NumPy의 ndarrays 로 위의 PyTorch로 했던 행렬 곱셉을 똑같이 실행해서, 소요시간을 측정(%timeit)해 보겠습니다.

NumPy의 ndarrays 로 행렬 곱셉은 1.17 ms ± 46.4 µs per loop 이 걸려서, 위의 PyTorch tensor & GPU 는 NumPy ndarrays 보다 46배 빠르고, 위의 PyTorch tensor & CPU 는 NumPy ndarrays 보다 1.25 배 빠르걸로 나왔습니다. 

역시 GPU 가 행렬 곱셉 성능에 지대한 영향을 끼치고 있음을 확인할 수 있습니다! 

## (3) run matrix multiplication on NumPy arrays
import numpy as np

x = np.random.random((1, 25600))
y = np.random.random((25600, 100))

%timeit z = np.matmul(x, y)

# 1.17 ms ± 46.4 µs per loop 
# (mean ± std. dev. of 7 runs, 1000 loops each)

PyTorch tensor & GPU 의 강력한 성능을 이용해서 멋진 딥러닝 모델 학습하세요. 

이번 포스팅이 많은 도움이 되었기를 바랍니다. 

행복한 데이터 과학자 되세요!  :-)

이번 포스팅에서는 PyTorch 모듈을 사용해서 난수를 생성하여 텐서 객체를 만드는 여러가지 방법을 소개하겠습니다. (numpy 유사하네요)

1. 난수를 생성해서 PyTorch tensor를 만들기

  (1-1) torch.rand(size) : 0과 1 사이의 실수[0, 1) 로 난수를 생성해서 텐서 만들기

  (1-2) torch.randn(size) : 표준정규분포 X~N(0, 1)로 부터 난수를 생성해서 텐서 만들기

  (1-3) torch.randint(low, high, size) : low~high 사이의 정수로 난수를 생성해서 텐서 만들기

  (1-4) torch.randperm(the upper bound, n) : 0~n 사이의 정수를 무작위로 섞어서 텐서 만들기 

2. 인풋과 동일한 형태(same shape as input tensor)로 난수를 생성해서 PyTorch tensor 만들기

  (2-1) torch.rand_like(input) : 인풋과 동일한 형태(shape)로 0~1 사이의 실수로 난수를 생성해서 텐서 만들기

  (2-2) torch.randn_like(input) : 인풋과 동일한 형태로 표준정규분포 X~N(0,1)에서 난수를 생성해서 텐서 만들기

  (2-3) torch.randint_like(input, low, high) : 인풋과 동일한 형태로 low~high 사이의 정수로 난수를 생성해서 텐서 만들기

1. 난수를 생성해서 PyTorch tensor를 만들기

  (1-1) torch.rand(size) : 0과 1 사이의 실수[0, 1) 로 난수를 생성해서 텐서 만들기

이때 0은 포함되고 1은 포함되지 않습니다. 난수를 생성하는 것이기 때문에 실행할 때마다 매번 텐서 안의 원소 값이 달라집니다. 

import torch

## generating a tensor object with random numbers b/w 0 and 1
torch.rand(2, 4)

# tensor([[0.6653, 0.6714, 0.4876, 0.2055],
#         [0.9733, 0.5680, 0.9754, 0.1981]])

만약, 난수 생성 값을 매번 동일하게 나오게 하고 싶다면 torch.manual_seed() 메소드로 난수 초기값을 설정해주면 됩니다. (아래 코드를 실행하면 저와 동일한 난수 값으로 구성된 텐서를 반환할 것입니다.)

## setting a seed number for reproducibility
torch.manual_seed(1004) 
torch.rand(2, 4)

# tensor([[0.9716, 0.3893, 0.2629, 0.9071],
#         [0.1041, 0.0360, 0.1655, 0.7124]])

(1-2) torch.randn(size) : 표준정규분포 X~N(0, 1)로 부터 난수를 생성해서 텐서 만들기

평균이 0, 표준편차가 1인 표준정규분포 X~N(0, 1) 로 부터 실수 난수를 생성해서 텐서를 만들어줍니다. 

# generating a tensor from a standard normal distribution, X~N(0, 1)
torch.randn(2, 4)

# tensor([[ 1.0868, -1.5346, -0.4525,  0.3689],
#         [-0.9079, -0.2578, -0.3581,  0.4072]])

(1-3) torch.randint(low, high, size) : low~high 사이의 정수로 난수를 생성해서 텐서 만들기

이때 low 값은 포함되고, high 값은 포함되지 않습니다. 

## generating a tensor with random integers
## (including the low value, but not including the high value)
torch.randint(low=0, high=10, size=(2, 4))

# tensor([[9, 2, 7, 8],
#         [5, 3, 0, 8]])

(1-4) torch.randperm(the upper bound, n) : 0~n 사이의 정수를 무작위로 섞어서 텐서 만들기

아래의 예처럼 upper bound 'n' 이 '10' 이면 0~9 까지의 정수 (10은 미포함) 를 모두 사용해서 무작위로 섞어서 텐서를 만들어줍니다. 

## returns a random permutation of integers from 0 to n
torch.randperm(10)

# tensor([5, 3, 2, 7, 6, 9, 4, 1, 8, 0])

2. 인풋과 동일한 형태(same shape as input tensor)로 난수를 생성해서 PyTorch tensor 만들기

(2-1) torch.rand_like(input)

           : 인풋과 동일한 형태(shape)로 0~1 사이의 실수로 난수를 생성해서 텐서 만들기

예제로 numpy ndarray 로 (2, 3) 형태의 PyTorch tensor 를 만들어보았습니다. 

## creating a tensor object with numpy array
import numpy as np

y = np.array([[1., 2., 3.], [4., 5., 6.]])
z = torch.tensor(y)

print(z)
# tensor([[1., 2., 3.],
#         [4., 5., 6.]], dtype=torch.float64)


z.shape
# torch.Size([2, 3])

torch.rand() 가 0~1 사이의 실수에서 난수를 생성해서 텐서를 만들었는데요, torch.rand_like(input) 은 인풋과 같은 형태(shape)로 0~1 사이의 실수에서 난수를 생성해서 텐서를 만들어줍니다. 

## Returns a tensor with the same size as input 
## that is filled with random numbers 
## from a uniform distribution on the interval [0,1)
torch.rand_like(z)

# tensor([[0.6764, 0.6955, 0.1822],
#         [0.4265, 0.8873, 0.2876]], dtype=torch.float64)

(2-2) torch.randn_like(input)
           : 인풋과 동일한 형태로 표준정규분포 X~N(0,1)에서 난수를 생성해서 텐서 만들기

## Returns a tensor with the same size as input 
## that is filled with random numbers from 
## a normal distribution with mean 0 and variance 1.
torch.randn_like(z)

# tensor([[-1.2964, -0.0624,  1.2123],
#         [ 2.2158,  0.2930, -0.2537]], dtype=torch.float64)

(2-3) torch.randint_like(input, low, high)

           : 인풋과 동일한 형태로 low~high 사이의 정수로 난수를 생성해서 텐서 만들기

## Returns a tensor with the same shape as Tensor input 
## filled with random integers generated uniformly 
## between low (inclusive) and high (exclusive)
torch.randint_like(input=z, low=0, high=10)

# tensor([[7., 6., 8.],
#         [2., 9., 1.]], dtype=torch.float64)

이번 포스팅이 많은 도움이 되었기를 바랍니다. 

행복한 데이터 과학자 되세요! :-)

이번 포스팅에서는 PyTorch 의 자료구조인 tensor가 무엇이고, tensor 객체를 만드는 방법(how to create a PyTorch tensor objects)을 소개하겠습니다. 

(1) 텐서(tensor)는 무엇인가? 

(2) PyTorch 텐서 만들고 속성정보 조회하기

(3) 0(zeros), 1(ones)로 채워진 텐서, 빈 텐서(empty tensor) 만들기

(1) 텐서(tensor)는 무엇인가? 

텐서(tensor) 는 PyTorch의 가장 기본적인 데이터 유형으로서, NumPy의 다차원 배열인 ndarray 와 유사합니다. 

스칼라(Scalar)는 0 차원의 텐서, 벡터(Vector)는 1 차원의 텐서, 행렬(Matrix)은 2 차원의 텐서, 그리고 3차원 이상의 다차원 행렬은 다차원 텐서입니다. PyTorch의 텐서는 스칼라, 벡터, 행렬 및 다차원 텐서를 모두 아우르는 일반화된 데이터 구조를 말합니다. 

PyTorch 로 GPU를 사용해서 다차원 행렬을 가지고 병렬처리를 하려면 텐서 객체로 데이터를 변환해야 합니다. 

텐서 내의 데이터 원소는 모두 같은 데이터 유형이어야 합니다. (가령, 모두 float 이거나, int 이거나 동일해야 함.)

(2) PyTorch 텐서 만들고 속성정보 조회하기

(2-1) 리스트(List)에 대해 torch.tensor(a list) 로 텐서 만들기

import torch

## creating a tensor object with a list of lists
x = torch.tensor([[1., 2., 3.]])

print(x)
# tensor([[1., 2., 3.]])

(2-2) NumPy의 다차원 array 를 torch.tensor(np.array) 로 텐서로 변환하기

## creating a tensor object with numpy array
import numpy as np

y = np.array([[1., 2., 3.], [4., 5., 6.]])
z = torch.tensor(y)

print(z)
# tensor([[1., 2., 3.],
#         [4., 5., 6.]], dtype=torch.float64)

(2-3) 텐서의 형태(shape)와 데이터 유형(dtype) 속성정보 조회하기

## accessing the Shape and DataType of a tensor

print(x.shape)
# torch.Size([1, 3])

print(x.dtype)
# torch.float32

(3) 0(zeros), 1(ones)로 채워진 텐서, 빈 텐서(empty tensor) 만들기

(3-1) 0 으로 채워진 텐서 만들기 : torch.zeros(size)

## generating a tensor object with zeros
torch.zeros((2, 4))

# tensor([[0., 0., 0., 0.],
#         [0., 0., 0., 0.]])

(3-2) 1 로 채워진 텐서 만들기 : torch.ones(size)

## generating a tensor object with ones
torch.ones((2, 4))

# tensor([[1., 1., 1., 1.],
#         [1., 1., 1., 1.]])

(3-3) 빈 텐서 만들기 : torch.empty(size)

## generating a tensor filled with uninitialized data.
torch.empty((2, 4))

# tensor([[0., 0., 0., 0.],
#         [0., 0., 0., 0.]])

이번 포스팅이 많은 도움이 되었기를 바랍니다. 

행복한 데이터 과학자 되세요! :-)

지난번 포스팅에서는 불균형 데이터(imbalanced data)가 무엇이고, 분류 모델링 시 무엇이 문제인지에 대해서 알아보았습니다. --> https://rfriend.tistory.com/773

이번 포스팅부터는 불균형 데이터를 가지고 분류 모델링 시 대처방법에 대해서 몇 번에 나누어서 이론과 Python을 활용한 코드를 소개하겠습니다.  먼저 (3-1) 소수 클래스의 데이터 추가 수집과 (3-2) 불균형 데이터 분류 모델에 적합한 성능평가 지표 선정 부터 시작해볼까요? 

[ 불균형 데이터로 분류 모델링하는 방법 ]
  1. 소수 클래스의 데이터 추가 수집 (Get more minority data) 
  2. 불균형 데이터 분류 모델에 적합한 성능평가 지표 선정 
       (evaluation metrics for imbalanced classification)  

  3. 샘플링 방법 (Sampling methods)
    3-1. Undersampling
      : Random Sampling, Tomek Links
    3-2. Oversampling
      : Resampling, SMOTE, Borderline SMOTE, ADASYN
  4. 비용 또는 가중치 조정 방법 (Cost, Weight)
  5. Outlier detection 방법
      : One-class SVM, Isolation Forest, DBSCAN clustering
  6. 확률 튜닝 알고리즘 (Probability Tuning Algorithms)

1. 소수 클래스의 데이터 추가 수집 (Get more minority data)

만약 소수 집단의 데이터를 추가로 수집하거나 또는 생성할 수 있다면 두 집단의 구성비가 균형을 잡히도록 소수 집단의 개수를 늘리면 되겠습니다. 

하지만, 데이터를 수집하는데는 시간과 비용 (time and cost) 이 소요된다는 점, 상황에 따라서는 소수 데이터의 추가 수집이 불가능하다는 점도 고려를 해야겠습니다. 이런 제약사항 때문에 알고리즘적으로 불균형 데이터 문제를 해결하는 방법을 알아둘 필요가 있습니다. 
(다음번 포스팅부터 소개해요)

2. 불균형 데이터 분류 모델에 적합한 성능평가 지표 선정 
     (evaluation metrics for imbalanced classification)

균형 데이터 (balanced data)에 대한 
 - 분류 모델의 성능 평가 지표에 대한 이론은 https://rfriend.tistory.com/771 를 참고하구요, 
 - Python 을 이용한 분류 모델의 성능 평가 코드는 https://rfriend.tistory.com/772 를 참고하세요. 

불균형 데이터 (imbalanced data)에 대한 분류 모델 평가 지표를 선정하는 데는 
 (a) 범주와 확률 중에서 무엇을 예측하는가? 
 (b) 두 범주가 동등하게 중요한가? 아니면 양성(Positive) 범주가 더 중요한가?
 (c) False Negative, False Positive 가 동등하게 중요한가? 아니면 둘 중 하나가 더 중요한가?
의 질문에 대한 답변 별로 평가 지표가 달라집니다. 
(아래의 ‘불균형 데이터에 대한 이진 분류 모델 평가 지표’ 참조) 

(1) 범주(class labels)를 예측하고, 두 범주가 동등하게 중요하며, 다수 범주가 80~90% 이상으로서 불균형 데이터(imbalanced data)인 경우 

       --> Geometirc-Mean (or G-Mean) 

G-Mean = sqrt(Sensitivity x Specificity)

기하평균 G-Mean 은 다수 집단 (Majority class)과 소수 집단 (Minority class) 간 모두의 분류 성능을 측정하는 지표입니다. 낮은 G-Mean 점수는 비록 음성 사례(negative cases)가 정확하게 분류가 되더라도 양성 사례(positive cases)의 분류는 저조한 성능을 보인다는 뜻입니다. G-Mean 지표는 음성 범주(negative class)의 과적합(over-fitting)을 피하고, 양성 범주(positive class)의 과소 적합(under-fitting)을 피하는데 중요하게 사용됩니다. 

(2) 범주를 예측하고, 두 범주가 동등하게 중요하며, 다수 범주가 80~90% 미만인 균형 데이터(balanced data)는

      --> 정확도(Accuracy) 평가지표를 사용하면 됩니다.

하지만, 불균형 데이터에 대해서 정확도 지표를 사용할 경우 다수 집단 만을 잘 분류하고 소수 집단에 대해서는 제대로 분류를 못해도 높은 정확도 점수가 나오는 문제가 있습니다. 

(3) 범주 (class labels) 를 예측하고, 양성 범주 (Positive class)가 더 중요하며, 

      - False Negative, False Positve 가 동등하게 중요하면 (Sensitivity, Precision이 균형있으면 좋은 모델)   
         --> F1 Score

      - False Negative 가 더 비용이 크면 (Sensitivity가 높으면 좋은 모델)   --> F2 Score

      - False Positive 가 더 비용이 크면  (Precision이 높으면 좋은 모델)       --> F0.5 Score

를 사용합니다. 

F1 Score, F0.5 Score, F2 Score 는 높으면 높을수록 더 좋은 모델로 해석합니다.  

참고로, 두 개의 범주가 바뀌어서 양성(Positive)이 음성(Negative)으로, 음성은 양성으로 바뀐 상태에서 혼돈 매트릭스를 만들어서 F2 Score를 계산하면 Inv F0.5 Score 가 됩니다. [2]

아래는 불균형 데이터에 대한 분류 모델의 혼돈 매트릭스를 3가지 시나리오 별로 가상으로 구성하여, 민감도(Sensitivity), 정밀도(Precision), F1 Score, F0.5 Score, F2 Score 를 계산해본 것입니다. 위 설명을 이해하는데 도움이 되기를 바랍니다. 

(a) F1 Score는 정밀도(Precision)와 민감도(Sensitivity) 의 역수의 산술평균의 역수인 조화평균(Harmonic Mean)으로서, 정밀도와 민감도 간의 균형을 측정합니다. 만약 정밀도나 민감도가 0 이라면 F-Measure 는 0 이됩니다. F1 Score는 False Negative 와 False Positive가 동등하게 중요할 때의 모델 성능지표로 적합합니다. 민감도(Sensitivity)와 정밀도(Precision)이 균형있을 때 F1 Score가 높게 나옵니다. 

(b) 불균형 데이터 (imbalanced data)인 경우에는 F0.5 Score 또는 F2 Score 를 사용하는데요, 비즈니스적으로 중요한 소수 범주(minority class)의 False Negative 가 더 비용(cost)이 크면(즉, Sensitivity가 높은 모델이 더 좋은 모델로서, Sensitiviey에 가중치를 더 줌) F2 Score 를 사용합니다. 예측된 양성이 비록 틀리는 비용을 감수하고서라도, 실제 양성(Positive)을 하나라도 더 분류해내고 싶을 때 F2 Score 지표를 사용합니다. 

(c) 반대로, False Positive 가 비용이 더 크면(즉, (Precision이 높은 모델이 더 좋은 모델로서, Precision에 가중치를 더 줌) F0.5 Score를 모델 성능지표를 선택합니다. 실제 양성을 놓치는 비용을 감수하고서라도, 일단 모델이 양성으로 분류를 했으면 실제로도 양성이기를 바라는 경우에 F0.5 Score 지표를 사용합니다. 

(4) 확률(Probability)을 예측하고, 확률 예측치의 정확도를 평가하고 싶을 때

      --> Brier Score

Brier Score 는 확률 예측치의 정확도(accuracy of probability forecast)를 평가할 때 사용합니다. Brier Score 는 두개의 범주(bianry categories)를 가진 이진 분류(binary classification)의 예측 확률에만 사용할 수 모델 평가지표 입니다. [3]

Brier Score의 수식은 아래와 같이 모든 관측치에 대해서 예측확률과 실제 결과(발생하면 1, 아니면 0)와의 차이의 제곱합(Squared Summation)을 관측치의 개수로 나누어서 구한 ‘평균 제곱합 확률 오차(MSE, Mean Squared Error)’ 입니다. 

Brier Score 는 작으면 작을 수록 이진 분류 모델의 확률 예측치가 정확하다는 뜻이며, 반대로 크면 클 수록 이진 분류 모델의 확률 예측치가 부정확하다고 해석합니다. 

- 모든 확률 예측치에 대해서 완벽하게 모두 다 맞추면 Brier Score 는 0 이 됩니다. (최소값) 
- 반대로, 모든 확률 예측치가 완벽하게 다 틀리면 Brier Score 는 1 이 됩니다. (최대값) 

(5) 확률을 예측하고, 범주가 필요하며, 양성(Positive) 범주가 더 중요한 불균형 데이터의 경우 
   —> Precision-Recall Curve Plot, Precision-Recall AUC (Area Under the Curve)

Precision-Recall Curve 그림은 X축이 Recall, Y축이 Precision으로 해서, 두 범주를 분류하는 확률의 의사결정 기준점(Decision Treshold)을 0에서 1로 조금씩 변경해가면서 혼돈 매트릭스를 계산하고, 이어서 Precision과 Recall을 계산한 후에, 이 값들을 선으로 연결한 그래프입니다. 

아래의 그래프처럼 Precision-Recall Curve 가 우측 상단으로 붙을 수록 불균형 데이터의 양성(Positive)을 더 잘 분류하는 모델이라고 평가할 수 있습니다. (Precision 과 Recall 은 Trade-off 관계에 있음). 

ROC AUC 처럼, Precision-Recall Curve 의 아래 부분의 면적을 적분한 값이 PR AUC (Precision-Recall Area Under the Curve) 값이 됩니다. 하나의 score 로 계산이 되므로, 여러 모델을 수치적으로 비교할 수 있습니다. PR AUC가 크면 클 수록 소수의 양성 범주(minority Positive class) 를 잘 분류하는 모델이라고 평가할 수 있습니다. 

[ Reference ] 

(1) Tour of Evaluation Metrics for Imbalanced Classification
: https://machinelearningmastery.com/tour-of-evaluation-metrics-for-imbalanced-classification/

(2) "F-score" from Wikipedia: https://en.wikipedia.org/wiki/F-score

(3) Brier Score: https://www.statisticshowto.com/brier-score/

앞으로 몇 번의 포스팅으로 나누어서 불균형 데이터 (imbalanced data)에 대해서 다루어보도록 하겠습니다. 

1. 불균형 데이터 (Imbalanced Data) 란 무엇인가? 
2. 불균형 데이터는 분류 모델링 시 무엇이 문제인가? 
3. 불균형 데이터로 분류 모델링하는 방법에는 무엇이 있나? 

1. 불균형 데이터 (Imbalanced Data) 란 무엇인가? 

불균형 데이터 (Imbalanced Data) 는 목표 변수(target/output variable) 가 범주형 데이터 일 때, 범주 별로 관측치의 개수, 비율의 차이가 많이 나는 데이터를 말합니다. 


아래의 각 산업별 예처럼, 정상 대 비정상의 비율이 90%:10% 처럼 불균형하거나, 더 심하면 99%:1% 처럼 극심하게 불균형한 데이터 (extremely imbalanced data) 도 있습니다. 우리가 관심있어하고 예측하고 싶어하는 비정상 관측치가 정상보다 매우 적은 불균형 데이터를 실무에서는 어렵지 않게 볼 수 있습니다. 

  - 제조회사에서 양품 대 불량품
  - 신용카드회사에서 정상 거래 대 사기 거래 (Fraud) 
  - 은행의 정상 거래 대 돈세탁 거래
  - 의료검진센터에서 정상 대 암(cancer) 진단
  - 사이버보안 회사에서 정상 IP 대 비정상 IP 
  - 통신회사에서 유지 고객 대 이탈(Churn) 고객 
  - 설비/장비의 정상 대 이상 운영
  - 유통회사 대리점의 정상 대 비정상 거래

불균형 데이터에서 다수를 차지하는 범주를 ‘다수 범주(majority class)’라고 하고, 적은 수를 차지하는 범주는 ‘소수 범주 (minority class)’ 라고 합니다. 

2. 불균형 데이터는 분류 모델링 (Classification Modeling) 시 무엇이 문제인가? 

불균형 데이터를 가지고 분류 모델을 훈련시키면 우리가 관심있어하는 minority class 를 제대로 분류할 수 없는 쓸모없는 모델이 만들어질 위험이 있습니다. 가령, 정상(majority class) : 비정상(minority class) 의 비율이 99% : 1% 라고 해보겠습니다. 이런 불균형 데이터에 대해 분류 모델을 훈련시킨 후 예측을 하면 모든 데이터를 ‘정상(majority class)’ 이라고 분류한다고 했을 때 정확도(accuracy)는 99%가 됩니다. 얼필 보면 잘 만들어진 모델 같습니다만, 우리가 관심있어하는 ‘비정상(minority class)’ 범주는 하나도 제대로 분류를 해내지 못했으므로 쓸모없는 모델이라고 하는 것입니다. 

또한, 소수 집단(minority class) 의 관측치 개수가 적으면 소수 집단의 모집단 분포를 샘플링한 소수의 관측치가 대표하기에는 부족하므로 분류 모델이 과적합 (overfitting)에 빠질 위험이 있습니다. 그래서 훈련 데이터셋에는 소수 집단을 분류했다고 하더라도, 새로운 데이터에 대해서는 소수 집단을 제대로 분류를 못할 위험이 있습니다. 

3. 불균형 데이터로 분류 모델링하는 방법에는 무엇이 있나? 

아래의 6가지 방법이 있는데요, 3-2번 부터 해서 하나씩 차근차근 이어서 포스팅을 해보겠습니다. 

  3-1. 소수 클래스의 데이터 추가 수집 (Get more minority data) 
  3-2. 불균형 데이터 분류 모델에 적합한 성능평가 지표 선정 
       (evaluation metrics for imbalanced classification)
  3-3. 샘플링 방법 (Sampling methods)
    3-3-1. Undersampling
      : Random Sampling, Tomek Links
    3-3-2. Oversampling
      : Resampling, SMOTE, Borderline SMOTE, ADASYN
  3-4. 비용 또는 가중치 조정 방법 (Cost, Weight)
  3-5. Outlier detection 방법
      : One-class SVM, Isolation Forest, DBSCAN clustering
  3-6. 확률 튜닝 알고리즘 (Probability Tuning Algorithms)

이번 포스팅이 많은 도움이 되었기를 바랍니다. 

행복한 데이터 과학자 되세요!   :-)

지난번 포스팅에서는 분류 모델(classification model)의 성능을 평가할 수 있는 지표 (evaluation metrics)에 대해서 소개하였습니다. (https://rfriend.tistory.com/771)

이번 포스팅에서는 Python을 사용하여 예제 데이터에 대해 분류 모델의 성능 평가를 해보겠습니다. 

(1) 예제로 사용할 Breast Cancer 데이터셋을 로딩하고, Data와 Target으로 구분

(2) Training set, Test set 분할

(3) Logistic Regression 모델 적합 (Training)

(4) 예측 (Prediction)

(5) 혼돈 매트릭스 (Confusion Matrix)

(6) 분류 모델 성능 지표: Accuracy, Precision, Recall rate, Specificity, F-1 score

(7) ROC 곡선, AUC 점수

(1) 예제로 사용할 Breast Cancer 데이터셋을 로딩하고, Data와 Target으로 구분 

target의 '0' 이 'malignant (악성 종양)' 이고, '1'은 'benign' 으로서 정상을 의미합니다. 우리는 'malignant (악성 종양)' 을 분류하는 모델에 관심이 있으므로 target '0' 이 'Positive Label' 이 되겠습니다. 

import numpy as np

## load a Iris dataset
from sklearn.datasets import load_breast_cancer

bc = load_breast_cancer()

## target names
bc.target_names
#array(['malignant', 'benign'], dtype='<U9')

## [0: 'malignant'(악성), 1: 'benign']
np.unique(bc['target'], return_counts=True) 
#(array([0, 1]), array([212, 357]))


## getting data, target
bc_data = bc['data']
bc_target = bc['target']

bc_data.shape
#(569, 30)

bc_target[:20]
#array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])

(2) Training set, Test set 분할

Training set 0.5, Test set 0.5 의 비율로 무작위 추출하여 분할하였습니다. 

## splits training and test set
from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(
    bc_data, 
    bc_target, 
    test_size=0.5,  
    random_state=1004
)

(3) Logistic Regression 모델 적합 (Training)

Traning set을 사용해서 로지스틱 회귀모형을 적합하였습니다.

## training a Logistic Regression model with training set
from sklearn.linear_model import LogisticRegression

clf = LogisticRegression(
    solver='liblinear', 
    random_state=1004).fit(X_train, y_train)

(4) 예측 (Prediction)

Test set에 대해서 예측을 하고 모델 성능 평가를 해보겠습니다. 

predict() 메소드는 범주를 예측하여 반환하고, predict_praba() 메소드는 확률(probability)을 반환합니다. 

## prediction for test set
y_pred = clf.predict(X_test) # class
y_pred_proba = clf.predict_proba(X_test) # probability

실제 범주의 값과 예측한 범주의 값, 그리고 target '0'(malignant, 악성 종양) 일 확률을 DataFrame으로 묶어보았습니다. 

# All in a DataFrame
pred_df = pd.DataFrame({
    'actual_class': y_test, 
    'predicted_class': y_pred, 
    'probabilty_class_0': y_pred_proba[:,0] # malignant (악성)
})

pred_df.head(10)
#    actual_class  predicted_class  probabilty_class_0
# 0             1                1            0.002951
# 1             0                0            0.993887
# 2             0                1            0.108006
# 3             1                1            0.041777
# 4             0                0            1.000000
# 5             0                0            1.000000
# 6             0                0            0.999633
# 7             1                1            0.026465
# 8             0                0            0.997405
# 9             1                1            0.002372

이제 여기서부터 분류 모델의 성능 평가를 시작합니다. 

(5) 혼돈 매트릭스 (Confusion Matrix)

혼돈 매트릭스의 Y축은 Actual 의 malignant (0), benign(1) 이며, X 축은 Predicted 의 malignant (0), benign(1) 입니다. 

## model evaluation
# Confusion matrix
from sklearn.metrics import confusion_matrix

confusion_matrix(y_test, y_pred, 
                 labels=[0, 1]) # 'malignant'(0), 'benign'(1)

#                   predicted
#                   malignant  benign
# actual malignant [[102,       16],
#        benign    [  3,       164]])

(6) 분류 모델 성능 지표: Accuracy, Precision, Recall rate, Specificity, F-1 score

from sklearn.metrics import accuracy_score
from sklearn.metrics import precision_recall_fscore_support

## performance metrics
accuracy = accuracy_score(y_test, y_pred)

precision, recall, fscore, support = \
    precision_recall_fscore_support(y_test, y_pred)

print('Accuracy   : %.3f' %accuracy) # (102+164)/(102+16+3+164)
print('Precision  : %.3f' %precision[0]) # 102/(102+3)
print('Recall     : %.3f' %recall[0]) # 102/(102+16)
print('Specificyty: %.3f' %recall[1]) # 164/(3+164)
print('F1-Score   : %.3f' %fscore[0]) # 2/(1/precision + 1/recall) = 2/(1/0.971+1/0.864)

# Accuracy   : 0.933
# Precision  : 0.971
# Recall     : 0.864
# Specificyty: 0.982
# F1-Score   : 0.915

sklearn의 classification_report() 메소드를 활용해서 한꺼번에 쉽게 위의 분류 모델 성능평가 지표를 계산하고 출력할 수 있습니다. 참고로, 'macro avg' 는 가중치가 없는 평균이며, 'weighted avg'는 support (관측치 개수) 로 가중치를 부여한 평균입니다. 

from sklearn.metrics import classification_report

target_names = ['malignant(0)', 'benign(1)']
print(classification_report(y_test, y_pred, 
                            target_names=target_names))

#               precision    recall  f1-score   support

# malignant(0)       0.97      0.86      0.91       118
#    benign(1)       0.91      0.98      0.95       167

#     accuracy                           0.93       285
#    macro avg       0.94      0.92      0.93       285
# weighted avg       0.94      0.93      0.93       285

(7) ROC 곡선, AUC 점수

ROC 곡선과 AUC 점수는 예측 확률을 이용합니다.

ROC 곡선은 모든 의사결정 기준선 (decision threshold)에 대하여 혼돈 매트릭스를 만들고, X축에는 False Positive Rate(=1-specificity), Y축에는 True Positive Rate (=recall, sensitivity) 의 값을 선그래프로 그린 것이며, 좌측 상단으로 그래프가 붙을 수록 더 잘 적합된 모델이라고 평가합니다. AUC 점수는 ROC 곡선의 아랫부분의 면적을 적분한 값입니다. 

## ROC Curve, AUC
import sklearn.metrics as metrics

fpr, tpr, threshold = metrics.roc_curve(
    y_test, 
    y_pred_proba[:, 0], 
    pos_label=0) # positive label

AUC = metrics.auc(fpr, tpr)

# plotting ROC Curve
import matplotlib.pyplot as plt

plt.figure(figsize = (8, 8))
plt.plot(fpr, tpr, 'b', label = 'AUC = %0.3f' % AUC)
plt.title(('ROC Curve of Logistic Regression'), fontsize=18)
plt.legend(loc = 'lower right')

plt.plot([0, 1], [0, 1],'r--') # random guess
plt.xlim([0, 1])
plt.ylim([0, 1])
plt.ylabel('True Positive Rate', 
                fontsize=14)
plt.xlabel('False Positive Rate', 
                fontsize=14)

plt.show()

[ Reference ] 

1) Breast Cancer Dataset
: https://scikit-learn.org/stable/modules/generated/sklearn.datasets.load_breast_cancer.html

2) Scikit-Learn Logistic Regression
: https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html

3) 분류 모델의 성과 평가 지표 : https://rfriend.tistory.com/771

이번 포스팅이 많은 도움이 되었기를 바랍니다. 

행복한 데이터 과학자 되세요!  :-)