블러링(bluring)이란 초점이 맞지 않은 사진처럼 영상을 부드럽게 만드는 필터링 기법이다. 스무딩(smoothing)이라고 표현하기도 한다. 대표적인 블러링 기법에는 박스 블러, 가우시안 블러가 있다.

커널이란?

커널(필터라고도 표현함)이란 주로 이미지를 변환하는데 사용되는 작은 행렬을 의미한다.

일반적으로 이미지에 커널을 적용할 때는 컨볼루션 연산을 수행한다.(아래의 사진 참고)

Separable filter란?

2차원 필터는 두 개의 1차원 필터의 외적(outer product)으로 표현할 수 있다. 이렇게 나누어 진 1차원 필터를 Separable filter라고 한다. 모든 2차원 필터가 두 개의 일차원 필터로 표현 될 수 있는 것은 아님에 주의해야한다. 외적으로 표현하지 못하는 2차원 필터는 2개의 1차원 필터로 나눌 수 없다. 아래의 사진은 Separable filter의 예이다.

이렇게 나누어진 1차원 필터를 이미지 픽셀 값에 각각 컨볼루션하면 2차원 필터를 이미지 픽셀 값에 컨볼루션 연산한 것과 동일한 결과가 나온다.

Separable filter를 쓰는 이유

일반 2D filter를 컨볼루션해서 사용하는 것보다 연산량이 적기 때문에 속도면에서 우위를 가져갈 수 있다.

예를 들어 N X N 크기의 2D 필터가 있다고 하자.

이미지 픽셀 수가 M인 경우 2D필터를 그대로 적용하려면 총 $N^2 \times M$번 연산을 수행해야한다.

하지만 Separable filter를 사용하는 경우 $2 \times N \times M$이 된다.

필터의 크기가 커질수록 연산량의 차이는 점점 더 벌어진다는 것을 알 수 있다.

박스 블러

개념

박스 블러(Box blur)는 이미지 내 특정한 픽셀을 포함한 주변 픽셀 값들을 모두 더해서 평균을 내는 방식으로 블러를 구현한다. 아래의 사진은 Box blur 커널의 예시이다.

구현방법

1. 박스 블러 필터를 1차원 필터 2개로 나눈다.(Separable filter)
2. 원본 이미지 픽셀 값에 가로 방향 필터를 적용해 컨볼루션 연산을 시행한다.
3. 가로 방향 필터를 적용한 픽셀 값들에 세로 방향 필터를 적용해 컨볼루션 연산을 시행한다.

결과

이미지 원본	박스 블러 적용 후
# 가우시안 블러

개념

가우시안 블러(Gaussian Blur)는 이미지의 각 픽셀의 값을 해당 픽셀 주변의 다른 픽셀의 색상 값의 가중 평균으로 대체하여 블러를 구현하는 방법이다. 이 때 중심에 가까운 픽셀일수록 더 큰 가중치를 가진다.

구현방법

1. 가우시안 블러 필터를 1차원 필터 2개로 나눈다.(Separable filter)
2. 원본 이미지 픽셀 값에 가로 방향 필터를 적용해 컨볼루션 연산을 시행한다.
3. 가로 방향 필터를 적용한 픽셀 값들에 세로 방향 필터를 적용해 컨볼루션 연산을 시행한다.

결과

이미지 원본	가우시안 블러 적용 후

박스 블러 VS 가우시안 블러

박스 블러 적용 후	가우시안 블러 적용 후

박스 블러

• 주변 픽셀들의 값을 평균화하기 때문에 경계가 흐려지는 효과가 강하게 나타남
• 세부적인 텍스처 정보 손실 값이 큼
• 계산이 간단하기 때문에 실시간 이미지 처리에 유리함.

가우시안 블러

• 가우시안 분포를 따르는 블러링 방식이기 때문에 세부적인 텍스터 정보를 적절히 살리면서 블러 구현 가능
• 박스블러와 달리 필터 요소값마다 적용해야 할 값이 다르기 때문에 계산이 복잡하고 시간이 박스블러에 비해 좀 더 소요됨

게리 안토나치가 제안한 전략으로 오리지널 듀얼 모멘텀에서 채권, 부동산, 불경기 자산 등을 추가해서 크게 4가지 자산으로 나누고 모멘텀을 적용한 전략이다.

전략 설명

포함 자산

• 포트폴리오를 4개 파트로 나눔(각 파트에 자산의 25% 배분)
• 파트 1: 주식 - 미국 주식 SPY 또는 해외 주식 EFA
• 파트 2: 채권 - 미국 회사채 LQD 또는 미국 하이일드 채권 HYG
• 파트 3: 부동산 - 부동산 리츠 VNQ 또는 모기지 리츠 REM
• 파트 4: 불경기 - 미국 장기채 TLT 또는 금 GLD

매수 전략

• 매월 말 각 파트 별 2개 자산의 최근 12개월 모멘텀을 계산
• 둘 중 수익이 더 높은 ETF에 투자 (상대 모멘텀)
• 두 ETF 수익 모두가 BIL(미국 초단기채)수익보다 낮으면 달러 현금에 투자 (절대 모멘텀)

매도 전략

• 월 1회 리밸러싱

구현 코드

필요한 패키지 임포트

import yfinance as yf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from datetime import datetime

데이터 다운로드

# 데이터 다운로드
tickers = ['SPY', 'EFA', 'LQD','HYG',  'VNQ', 'REM', 'TLT', 'GLD', 'BIL']
start = '2007-05-01' # BIL은 2007년 5월 이전의 정보는 없음
end = '2023-06-01'
data = yf.download(tickers, start=start, end=end)['Adj Close']

월별 데이터셋으로 변환

# 월별 데이터셋 변환
monthly_data = data.resample('M').last()

print(monthly_data)

모멘텀 계산

# 모멘텀 계산
momentum_12m = monthly_data.pct_change(periods=12) # 12개월 기준으로 수익률 계산
momentum_1m = monthly_data.pct_change(periods=1) # 1개월 기준으로 수익률 계산(월 1회 리밸런싱을 하기때문에 미리 계산해둠)
returns = pd.DataFrame(columns=['월 단위 수익률']) # 월별 수익률 저장할 데이터 프레임
cumprod = pd.DataFrame(columns=['누적 수익률']) # 누적 수익률을 저장할 데이터 프레임
strategy = monthly_data.copy()# 백테스팅 결과를 담을 데이터프레임
print("1개월 모멘텀")
print(momentum_1m) # 인덱스 1 이전의 값들은 자신 이전의 1개월 이전의 데이터를 찾을 수 없으므로 nan이다.

print("12개월 모멘텀")
print(momentum_12m)

월별 수익률 계산 함수

# 월별 수익률 계산 함수
def calculate_momentum_1m(t,ticker):
  return float(momentum_1m[[ticker]].iloc[t+1])+1 # 나중에 누적곱을 해줘야하기 때문에 +1를 더해줌

종합 듀얼 모멘텀 로직

# 종합 듀얼 모멘텀 로직
# 달마다 투자하는 자산을 바꿔주기 때문에 리밸런싱이 되고 있다.
# t가 12부터 시작하는 이유는 12보다 작을 경우 return_12m의 값이 nan이기 때문
returns.loc[monthly_data.index[12], :] = 1 # 처음 시작 수익률은 1

for t in range(12,len(momentum_12m)-1):
  total = 0

  # 파트 1 로직, SPY와 EFA
  if momentum_12m['SPY'].iloc[t] > momentum_12m['BIL'].iloc[t] or momentum_12m['EFA'].iloc[t] > momentum_12m['BIL'].iloc[t]:
    # SPY가 클경우 SPY에 투자
    if momentum_12m['SPY'].iloc[t] >= momentum_12m['EFA'].iloc[t]:
      total_1 = calculate_momentum_1m(t,'SPY') # SPY의 1개월 수익률 할당
      strategy.loc[monthly_data.index[t], ["파트 1"]] = 'SPY' # 구매한 종목 이름 저장
    # EFA가 클경우 EFA에 투자
    else:
      total_1 = calculate_momentum_1m(t,'EFA') # EFA의 1개월 수익률 할당
      strategy.loc[monthly_data.index[t], ["파트 1"]] = 'EFA' # 구매한 종목 이름 저장
  else:
    # SPY와 EFA 둘다 BIL보다 작으면 달러 현금에 투자 즉 수익률 변동이 없으므로 1할당
    total_1 = 1
    strategy.loc[monthly_data.index[t], ["파트 1"]] = '달러 현금 투자'

  # 파트 2 로직, LQD와 HYG, 파트1과 로직은 동일
  if momentum_12m['LQD'].iloc[t] > momentum_12m['BIL'].iloc[t] or momentum_12m['HYG'].iloc[t] > momentum_12m['BIL'].iloc[t]:
    # LQD가 클경우 LQD에 투자
    if momentum_12m['LQD'].iloc[t] >= momentum_12m['HYG'].iloc[t]:
      total_2 = calculate_momentum_1m(t,'LQD')
      strategy.loc[monthly_data.index[t], ["파트 2"]] = 'LQD'
    # HYG가 클경우 HYG에 투자
    else:
      total_2 = calculate_momentum_1m(t,'HYG')
      strategy.loc[monthly_data.index[t], ["파트 2"]] = 'HYG'
  else:
    # LQD와 HYG 둘다 BIL보다 작으면 달러 현금에 투자 즉 수익률 변동이 없으므로 1할당
    total_2 = 1
    strategy.loc[monthly_data.index[t], ["파트 2"]] = '달러 현금 투자'

  # 파트 3 로직, VNQ와 REM, 파트1과 로직은 동일
  if momentum_12m['VNQ'].iloc[t] > momentum_12m['BIL'].iloc[t] or momentum_12m['REM'].iloc[t] > momentum_12m['BIL'].iloc[t]:
    # VNQ가 클경우 VNQ에 투자
    if momentum_12m['VNQ'].iloc[t] >= momentum_12m['REM'].iloc[t]:
      total_3 = calculate_momentum_1m(t,'VNQ')
      strategy.loc[monthly_data.index[t], ["파트 3"]] = 'VNQ'
    # REM가 클경우 REM에 투자
    else:
      total_3 = calculate_momentum_1m(t,'REM')
      strategy.loc[monthly_data.index[t], ["파트 3"]] = 'REM'
  else:
    # VNQ와 REM 둘다 BIL보다 작으면 달러 현금에 투자 즉 수익률 변동이 없으므로 1할당
    total_3 = 1
    strategy.loc[monthly_data.index[t], ["파트 3"]] = '달러 현금 투자'

  # 파트 4 로직, TLT와 GLD, 파트1과 로직은 동일
  if momentum_12m['TLT'].iloc[t] > momentum_12m['BIL'].iloc[t] or momentum_12m['GLD'].iloc[t] > momentum_12m['BIL'].iloc[t]:
    # TLT가 클경우 TLT에 투자
    if momentum_12m['TLT'].iloc[t] >= momentum_12m['GLD'].iloc[t]:
      total_4 = calculate_momentum_1m(t,'TLT')
      strategy.loc[monthly_data.index[t], ["파트 4"]] = 'TLT'
    # GLD가 클경우 GLD에 투자
    else:
      total_4 = calculate_momentum_1m(t,'GLD')
      strategy.loc[monthly_data.index[t], ["파트 4"]] = 'GLD'
  else:
    # TLT와 GLD 둘다 BIL보다 작으면 달러 현금에 투자 즉 수익률 변동이 없으므로 1할당
    total_4 = 1
    strategy.loc[monthly_data.index[t], ["파트 4"]] = '달러 현금 투자'

  #각 파트 별로 자산의 25% 배분
  total = 0.25*total_1 + 0.25*total_2 + 0.25*total_3 + 0.25*total_4
  returns.loc[monthly_data.index[t+1], :] = total

print("월단위 수익률")
print(returns)
print()
strategy["월단위 수익률"] = returns['월 단위 수익률']

print("누적 수익률")
cumprod['누적 수익률'] = (returns['월 단위 수익률']).cumprod(axis = 0) # 누적 수익률를 구하기 위함
print(cumprod)
strategy["누적 수익률"] = cumprod['누적 수익률']

누적 수익률 그래프

# 누적 수익률 그래프 출력
plt.figure(figsize=(10,5))
plt.plot(cumprod)
plt.title('Portfolio Value over Time')
plt.show()

롤링 맥스 그래프

rolling_max = cumprod.cummax() # 월별로 누적 최대값을 저장
strategy["rolling max"] = rolling_max
# 롤링 맥스 그래프 출력
plt.figure(figsize=(10,5))
plt.plot(rolling_max)
plt.title('Rolling max over Time')
plt.show()

MDD 그래프

# CAGR 계산
# len(monthly_data)에서 12를 빼준 이유는 우리가 투자를 시작한 지점은 처음 데이터가
# 나온 2007-05-31의 1년 뒤인 2008-05-31이기 때문이다.(실투자 기간으로 잡음)
# 1년 뒤에 투자를 시작한 이유는 우리가 12개월 모멘텀을 사용함으로
# 12개월 모멘텀을 구하기 위해서는 최초데이터에서 최소한 12개월이 지나야한다.
cagr = cumprod['누적 수익률'].iloc[-1] ** (1 / ((len(monthly_data)-12) / 12)) - 1

# MDD 계산
daily_drawdown = cumprod/rolling_max - 1.0 # 누적 수익률에 롤링맥스 값 나누고 떨어진 값을 표현하기 위해 - 1.0을 더함
strategy["daily drawdown"] = daily_drawdown
max_daily_drawdown = daily_drawdown.cummin()

print("Cumulative Return: ", float(cumprod.iloc[-1]))
print("CAGR: ", cagr)
print("MDD: ", float(max_daily_drawdown.iloc[-1]))

# Plot MDD 그래프 출력
plt.figure(figsize=(10,5))
plt.plot(daily_drawdown)
plt.plot(max_daily_drawdown)
plt.title('Maximum Drawdown')
plt.show()

strategy["Cumulative Return"] = float(cumprod.iloc[-1])
strategy["cagr"] = cagr
strategy["MDD"] = float(max_daily_drawdown.iloc[-1])

정규화된 ETF 가격 그래프 출력(기타 성능 평가 요인)

# 기타 부가 성능 평가 요인
# 정규화된 ETF 가격 그래프 출력
normalize_monthly_data = monthly_data/monthly_data.iloc[0]

plt.figure(figsize=(10,5))
plt.plot(normalize_monthly_data,label = normalize_monthly_data.columns)
plt.legend(loc = "upper left")
plt.title('ETF Price')
plt.show()

엑셀 파일 다운로드

# 엑셀 파일 다운로드
from google.colab import files
strategy.to_excel('백테스팅 결과 값.xlsx',index = True)
files.download('백테스팅 결과 값.xlsx')

momentum_12m.to_excel('12개월 모멘텀 값.xlsx',index = True)
files.download('12개월 모멘텀 값.xlsx')

momentum_1m.to_excel('1개월 모멘텀 값.xlsx',index = True)
files.download('1개월 모멘텀 값.xlsx')

플로이드 워셜 알고리즘은 모든 노드에서 다른 모든 노드로 가는 최단 경로를 구하는 알고리즘이다.

즉, 다익스트라 알고리즘과 다르게 출발점이 정해져있지 않다는 것이다.

$$ D_{ab} = min(D_{ab},D_{ak}+D_{kb}) $$

플로이드 워셜 알고리즘의 핵심은 위의 점화식을 구현하는데 있다.

$D_{ab}$는 a노드에서 b노드까지 가는데 소요되는 비용을 의미한다.

여기서 a노드에서 b노드를 가는데 중간에 k노드를 거쳐서 간다고 생각해보자

기존에 $D_{ab}$ 보다 $D_{ak}+D_{kb}$(k노드를 경유)의 값이 더 작은 경우가 있을 것이다.

우리는 최단거리를 찾는 것이므로 $D_{ab}$의 값을 $D_{ak}+D_{kb}$로 갱신해준다.

이것을 모든 노드에 대하여 반복한다면 결국에는 모든 노드에서 다른 모든 노드로 가는 최단경로를 구할 수 있다.

INF = int(1e9)

n,m = map(int,input().split())

graph = [[INF] * (n+1) for _ in range(n+1)]

# 자기 자신에서 자기 자신으로 가는 비용은 0으로 초기화
for i in range(1,n+1):
    for j in range(1,n+1):
        if i == j:
            graph[i][j] = 0

# 간선 정보를 2차원 행렬에 반영
for _ in range(m):
    a,b,c = map(int,input().split())
    graph[a][b] = c

# 플로이드 워셜 알고리즘 수행
for k in range(1,n+1): # 거쳐가는 노드
    for a in range(1,n+1): # 시작 노드
        for b in range(1,n+1): # 도착 노드
            graph[a][b] = min(graph[a][b], graph[a][k]+graph[k][b])

for i in range(1,n+1):
    for j in range(1,n+1):
        if graph[i][j] == INF:
            print('INF', end = '  ')
        else:
            print(graph[i][j], end = '  ')
    print()

위에 코드에서 보다시피 인접 행렬을 기반으로 하며, 3중 for문을 이용해서 구현한다.

1. 첫 번째 for문은 거쳐가는 노드를 기준으로 한다.
2. 두 번째 for문은 출발하는 노드를 기준으로 한다.
3. 세 번째 for문은 도착하는 노드를 기준으로 한다.
4. graph[a][b], graph[a][k]+graph[k][b]를 비교해 더 작은 값으로 갱신한다.

시간 복잡도

알고리즘의 시간 복잡도는 O($N^{3}$)이다.

N개의 노드가 있을 때 거쳐가는 노드 하나당 O($N^{2}$) 연산을 시행하기 때문이다.

특징

• 다익스트라 알고리즘과 달리 음의 간선이 있어도 정상 수행(하지만 음수 사이클이 있으면 안됨)
• 다이나믹 프로그래밍 기법을 사용한다.

Plotly는 클릭에 반응하는 인터렉티브한 그래프(3D 그래프, 파이 차트 등등)를 만들 수 있고, 다양한 언어(Python, JavaScript, R 등등)를 지원하는 오픈소스 그래프 라이브러리이다. Plotly 공식 사이트(Python)

Plotly 기본이해

• Plotly를 통해 그래프를 그리는 방법은 크게 2가지가 있다.

  • plotly.graph_objects를 사용하는 경우 그래프의 구성요소를 세부적으로 지정해주는 방식으로 그래프에 대한 디테일한 커스텀이 가능하다. (본 게시글에서 다루는 방법)
  • plotly.express를 사용하는 경우 graph_objects를 API 형식으로 제공하는 방법으로 데이터만을 가공하여 API에 입력하면 그래프를 그릴 수 있다.

• Plotly의 기본구조

  • Figure

    • Plotly 작업의 기본 단위이며 graph_objects.Figure() 메소드를 통해 생성이 가능하다.
    • data와 layout를 입력으로 받고, 해당 정보를 기반으로 show() 메소드를 통해 그래프를 그려준다.

  • data

    • data는 figure가 표현할 데이터를 의미하는데 trace를 하나 또는 그이상을 파이썬 리스트로 감싸서 입력받는다.
    • trace란 그리고자 하는 그래프의 타입(ex. Bar, Scatter, Line, Box..)과 그 그래프에 시각화 하고자 하는 Raw 데이터를 품고있는 단위이다.

  • layout

    • 그래프의 data와는 무관하고 그외 모든 부분을 편집 및 가공하는 부분이다.
    • Title, legend, Colors, Hover-label, Axes, Shape 등 시각화를 높히기 위한 다양한 도구들은 모두 layout을 통해 지정한다.

Bar Chart

일반적인 Bar Chart

from plotly import graph_objects as go
langs = ['C', 'C++', 'Java', 'Python', 'PHP']
students = [23,17,35,29,12]

# x축과 y축에 해당하는 데이터를 각각 넣고 리스트로 감싸줌
data = [go.Bar(x = langs, y = students)]
# 만들어놓은 데이터 전달
fig = go.Figure(data = data)

# 그래프 출력
fig.show()

그룹화와 스택화

from plotly import graph_objects as go

branches = ['CSE', 'Mech', 'Electronics']

fy=[23,17,35]
sy=[20,23,30]
ty=[30,20,15]

# x는 동일하되 y의 값은 다른 3개의 Bar객체 생성
trace1=go.Bar(
    x = branches,
    y = fy,
    name = 'FY')

trace2=go.Bar(
    x = branches,
    y = sy,
    name = 'SY')

trace3=go.Bar(
    x = branches,
    y = ty,
    name = 'TY')

data = [trace1,trace2,trace3]

# 그룹화 된 막대 차트를 표시하려면 레이아웃 개체의 막대 모드 속성을 그룹으로 설정해야함
layout = go.Layout(barmode='group',title='Departments')
fig = go.Figure(data=data,layout=layout)
fig.show()

# 스택형 막대 차트를 표시하려면 레이아웃 개체의 막대 모드 속성을 그룹으로 설정해야함
layout=go.Layout(barmode='stack', title='Departments')
fig = go.Figure(data=data, layout=layout)
fig.show()

색상 커스터마이징

from plotly import graph_objects as go

years = [1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012]
rest = [219, 146, 112, 127, 124, 180, 236, 207, 236, 263, 350, 430, 474, 526, 488, 537, 500, 439]
china = [16, 13, 10, 11, 28, 37, 43, 55, 56, 88, 105, 156, 270, 299, 340, 403, 549, 499]

trace1=go.Bar(
    x=years,
    y=rest,
    name='Rest of the World',
    # 색상 커스터마이징을 위한 정보를 딕셔너리에 담아서 marker에 전달
    marker=dict(
        # RGB값 설정
        color='rgb(49,130,189)',
        # 불투명도 설정
        opacity=0.7
    )
)

trace2=go.Bar(
    x=years,
    y=china,
    name='China',
    marker=dict(
        color='rgb(204,204,204)',
        opacity=0.5
    )
)

data=[trace1,trace2]
layout=go.Layout(barmode='group', title='Export of Plastic Scrap')
fig=go.Figure(data=data, layout=layout)
fig.show()

Pie Chart

일반적인 Pie Chart

from plotly import graph_objects as go

langs = ['C','C++','Java','Python','PHP']
students = [23,17,35,29,12]

data = [go.Pie(
    labels = langs,
    values = students,
    # 각각의 인덱스에 배정된 조각을 원점을 기준으로 얼마나 당길건지 설정
    pull=[0.1,0,0,0,0]
)]

fig = go.Figure(data=data)
fig.show()

Pie Chart의 여러 옵션 및 subplots 활용

from plotly import graph_objects as go
from plotly.subplots import make_subplots

countries = ["US", "China", "European Union", "Russian Federation", "Brazil", "India", "Rest of World"]
ghg = [16, 15, 12, 6, 5, 4, 42] 
co2 = [27, 11, 25, 8, 1, 3, 25]

fig = make_subplots(rows=1,cols=2, 
                    specs=[[{'type':'domain'},{'type':'domain'}]]) # 1x2형식의 subplot 생성
fig.add_trace(go.Pie(labels=countries,
                    values=ghg,
                    name="GHG Emissions"),
             # 1행 1열에 위치
             row=1,col=1)

fig.add_trace(go.Pie(labels=countries,
                    values=co2,
                    name="CO2 Emissions"),
             # 1행 2열에 위치
             row=1,col=2)

# hole은 파이차트 가운데 구멍의 크기를 설정
# hoverinfo는 마우스 커서를 갖다 댔을때 띄워질 정보 설정
fig.update_traces(hole=0.4, hoverinfo="label+percent+name")

fig.update_layout(
    title_text="Global Emissions 1990-2011", # 타이틀 설정
    # annotations은 주석에 대한 정보를 딕셔너리형태로 표현하고 리스트에 넣어서 전달 받음.
    # showarrow가 True면 해당좌표를 화살표로 가리킴.
    annotations=[dict(text='GHG',x=0.19, y=0.5, font_size=20, showarrow=False),
                 dict(text='CO2',x=0.8, y=0.5, font_size=20, showarrow=False)])

fig.show()

Scatter Plot

from plotly import graph_objects as go
import numpy as np

N = 100

# 0~1사이안에서 N개의 요소를 동일한 간격으로 나누어 놓은 1차원 넘파이 배열 반환
# 예를 들어 linspace(0,10,11)이면 [0,1,2,...,9,10]를 반환한다는 것
x_vals = np.linspace(0,1,N)

# 데이터 준비
# randn: 표준정규분포를 따르는 난수 발생
y1 = np.random.randn(N)+5
y2 = np.random.randn(N)
y3 = np.random.randn(N)-5

trace1 = go.Scatter(
    x=x_vals,
    y=y1,
    # mode는 데이터 포인트의 모양을 결정
    mode='markers',
    name='markers'
)

trace2 = go.Scatter(
    x=x_vals,
    y=y2,
    mode='lines+markers',
    name='lines+markers'
)

trace3 = go.Scatter(
    x=x_vals,
    y=y3,
    mode='lines',
    name='lines'
)

data=[trace1,trace2,trace3]
fig=go.Figure(data=data)
fig.show()

Dot plot

from plotly import graph_objects as go

schools=["Brown", "NYU", "Notre Dame", "Cornell", "Tufts", "Yale",
         "Dartmouth", "Chicago", "Columbia", "Duke", "Georgetown",
         "Princeton", "U.Penn", "Stanford", "MIT", "Harvard"]

trace1=go.Scatter(
    x=[72, 67, 73, 80, 76, 79, 84, 78, 86, 93, 94, 90, 92, 96, 94, 112],
    y=schools,
    marker=dict(color='crimson', size=12),
    mode="markers",
    name="Women")

trace2=go.Scatter(
    x=[92, 94, 100, 107, 112, 114, 114, 118, 119, 124, 131, 137, 141, 151, 152, 165],
    y=schools, marker=dict(color="gold", size=12),
    mode="markers",
    name="Men")

data=[trace1,trace2]

layout=go.Layout(title="Gender Earnings Disparity",
                xaxis_title='Annual Salary (in thousands)',
                yaxis_title='School')

fig=go.Figure(data=data,layout=layout)

fig.show()

Histogram

일반적인 Histogram

from plotly import graph_objects as go
import numpy as np

np.random.seed(1)

# 표준 정규분포를 따르는 난수 500개를 ndarray로 반환
x = np.random.randn(500)
data=[go.Histogram(x=x)]

fig=go.Figure(data)
fig.show()

중첩된 Histogram

import plotly.graph_objects as go
import numpy as np

x0=np.random.randn(500)
x1=np.random.randn(500)+1

fig=go.Figure()
# go.Figure(data = []) 방법이 아닌 add_trace 메소드를 통해 직접 Trace를 추가할 수도 있음
fig.add_trace(go.Histogram(x=x0))
fig.add_trace(go.Histogram(x=x1))

# 중첩해서 표현
fig.update_layout(barmode='overlay')
# 중첩해서 보여주기 위해 불투명도 설정(각각의 trace에서 따로 설정가능)
fig.update_traces(opacity=0.75)
fig.show()

2D Histogram

import plotly.graph_objects as go
import numpy as np
np.random.seed(1)

x=np.random.randn(500)
y=np.random.randn(500)+1

# 2차원으로 표현해서 색깔이 밝을 수록 해당 구간에 데이터가 많다는 것을 표현
fig=go.Figure(go.Histogram2d(x=x,y=y))
fig.show()

Box plot

Box Plots은 주로 데이터에서 이상치를 탐지하는데 사용한다. q1은 하위 25%를 의미하고 q3는 상위 25%를 의미한다.

import plotly.graph_objects as go

yaxis = [1140,1460,489,594,502,508,370,200] 
data = go.Box(y = yaxis) 
fig = go.Figure(data) 
fig.show()

Violin plot

Violin plot은 box plot과 유사하지만 데이터의 밀도를 표현한다는 점이 특징이다.

import plotly.graph_objects as go 
import numpy as np

np.random.seed(10)
c1 = np.random.normal(100, 10, 200)
c2 = np.random.normal(80, 30, 200)

# 평균선 표시 여부 설정
trace1 = go.Violin(y=c1, meanline_visible=True)
# 박스 플롯 표시 여부 설정
trace2 = go.Violin(y=c2, box_visible=True)
data = [trace1, trace2]

fig = go.Figure(data=data)
fig.show()

참고 자료

Plotly Tutorial - 파이썬 시각화의 끝판왕 마스터하기