오픈암스

Machine Learning Implementation example: Using Dota2 Games Results Data Set

돈룩백 — Wed, 23 Dec 2020 22:48:43 +0900

Yes~

You might be trapped by my fancy little big Title "Machine Learning Implementationd example".

First, I would like letting you know that my implementation does not show great performance for

Dota2 Game Results Dataset.

However, I will add my thorough explanation and some remedy you might try your own to perform better.

Before the real starter, the source code credit goes to Professor Sung Kim!

His original source code URL: github.com/hunkim/PyTorchZeroToAll/blob/master/06_logistic_regression.py

hunkim/PyTorchZeroToAll

Simple PyTorch Tutorials Zero to ALL! Contribute to hunkim/PyTorchZeroToAll development by creating an account on GitHub.

github.com

Let's go!

Step 1: Import the necessary Modules

from torch import nn, optim, from_numpy
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import numpy as np

I won't explain much about the lines above.

You will eventually find it out~

Just stay tuned and follow me closely.

Step 2: Prepare Dota2 Game Results Dataset

xy = np.loadtxt('/Users/kimkwangjae/Downloads/dota2Dataset/dota2Train.csv', delimiter=',', dtype=np.float32)

xy[:,0][xy[:,0]>0.0] = 1.0
xy[:,0][xy[:,0]<0.0] = 0.0
#print(np.shape(xy))

x_data = from_numpy(xy[:, 1:])
y_data = from_numpy(xy[:, [0]])
#print(f'X\'s shape: {x_data.shape} | Y\'s shape: {y_data.shape}')

X_train, X_test, y_train, y_test = train_test_split(x_data, y_data, test_size=0.33, random_state=42)

I won't describe the dataset here~

It's better for you to be familiar with the UCI dataset website man:

archive.ics.uci.edu/ml/datasets/Dota2+Games+Results

UCI Machine Learning Repository: Dota2 Games Results Data Set

Dota2 Games Results Data Set Download: Data Folder, Data Set Description Abstract: Dota 2 is a popular computer game with two teams of 5 players. At the start of the game each player chooses a unique hero with different strengths and weaknesses. Data Set C

archive.ics.uci.edu

As you see, "xy" is your boy who have the full attribute.

The first column of the dataset is the target (Y).

(Spoiler: reason for my bad performance) I'm gonna use Logistic Regression model.

So, I need those 2nd ~ 3rd lines of codes to change the targetting binary values from (-1 & 1) to (0, 1), which refers to "lost" and "won" respectively.

4th-6th lines of codes are needed for splitting {attributes, label} and {train and test data}

Step 3: Prepare Model (Logistic Regression)

class Model(nn.Module):
    def __init__(self):
        """
        In the constructor we instantiate two nn.Linear module
        """
        super(Model, self).__init__()
        self.l1 = nn.Linear(116, 80)
        self.l2 = nn.Linear(80, 50)
        self.l3 = nn.Linear(50, 20)
        self.l4 = nn.Linear(20, 1)

        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        """
        In the forward function we accept a Variable of input data and we must return
        a Variable of output data. We can use Modules defined in the constructor as
        well as arbitrary operators on Variables.
        """
        out1 = self.sigmoid(self.l1(x))
        out2 = self.sigmoid(self.l2(out1))
        out3 = self.sigmoid(self.l3(out2))

        y_pred = self.sigmoid(self.l4(out3))

        return y_pred
        
        
# our model
model = Model()

# Construct our loss function and an Optimizer. The call to model.parameters()
# in the SGD constructor will contain the learnable parameters of the two
# nn.Linear modules which are members of the model.
criterion = nn.BCELoss(reduction='mean')
optimizer = optim.SGD(model.parameters(), lr=0.001)

Model structure is the one of the crucial parts of the performance.

I might have failed over here.

You can play with different learning rate or different optimizer if needed!

If you have better structure, letting me know friends :)

Step 4: Training Loop

# Training loop
for epoch in range(2500):
    # Forward pass: Compute predicted y by passing x to the model
    y_pred = model(X_train)

    # Compute and print loss
    loss = criterion(y_pred, y_train)
    print(f'Epoch: {epoch + 1}/2000 | Loss: {loss.item():.6f}')

    # Zero gradients, perform a backward pass, and update the weights.
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

This is the trainig loop code.

You could play with epoch size over here!

Step 5: Test the Model and Evaluation

y_pred = model(X_test)

y_pred = y_pred.detach().numpy()
y_test = y_test.detach().numpy()

y_pred[y_pred[:,0]>0.5] = 1.0
y_pred[y_pred[:,0]<0.5] = 0.0

y_pred[:,0].astype(np.int16)
y_test[:,0].astype(np.int16)

accuracy = accuracy_score(y_test, y_pred)
accuracy *= 100
print('The accuracy in percentage is ')
print(accuracy)

If you try my full code below, the performance barely pass the 50% of accuracy.

This might be my fault but I would like to say that deep learning might be the better suit for the dataset.

While trying out the model and the dataset, please also let me know the updates or correction you have under the comments.

Best wishes for all your Machine Learning related Project~

from torch import nn, optim, from_numpy
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
import numpy as np


xy = np.loadtxt('/Users/kimkwangjae/Downloads/dota2Dataset/dota2Train.csv', delimiter=',', dtype=np.float32)
xy[:,0][xy[:,0]>0.0] = 1.0
xy[:,0][xy[:,0]<0.0] = 0.0
#print(np.shape(xy))
x_data = from_numpy(xy[:, 1:])
y_data = from_numpy(xy[:, [0]])
print(f'X\'s shape: {x_data.shape} | Y\'s shape: {y_data.shape}')

X_train, X_test, y_train, y_test = train_test_split(x_data, y_data, test_size=0.33, random_state=42)

class Model(nn.Module):
    def __init__(self):
        """
        In the constructor we instantiate two nn.Linear module
        """
        super(Model, self).__init__()
        self.l1 = nn.Linear(116, 80)
        self.l2 = nn.Linear(80, 50)
        self.l3 = nn.Linear(50, 20)
        self.l4 = nn.Linear(20, 1)

        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        """
        In the forward function we accept a Variable of input data and we must return
        a Variable of output data. We can use Modules defined in the constructor as
        well as arbitrary operators on Variables.
        """
        out1 = self.sigmoid(self.l1(x))
        out2 = self.sigmoid(self.l2(out1))
        out3 = self.sigmoid(self.l3(out2))

        y_pred = self.sigmoid(self.l4(out3))

        return y_pred


# our model
model = Model()


# Construct our loss function and an Optimizer. The call to model.parameters()
# in the SGD constructor will contain the learnable parameters of the two
# nn.Linear modules which are members of the model.
criterion = nn.BCELoss(reduction='mean')
optimizer = optim.SGD(model.parameters(), lr=0.001)

# Training loop
for epoch in range(2500):
    # Forward pass: Compute predicted y by passing x to the model
    y_pred = model(X_train)

    # Compute and print loss
    loss = criterion(y_pred, y_train)
    print(f'Epoch: {epoch + 1}/2000 | Loss: {loss.item():.6f}')

    # Zero gradients, perform a backward pass, and update the weights.
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

y_pred = model(X_test)

y_pred = y_pred.detach().numpy()
y_test = y_test.detach().numpy()

y_pred[y_pred[:,0]>0.5] = 1.0
y_pred[y_pred[:,0]<0.5] = 0.0

y_pred[:,0].astype(np.int16)
y_test[:,0].astype(np.int16)

accuracy = accuracy_score(y_test, y_pred)
accuracy *= 100
print('The accuracy in percentage is ')
print(accuracy)

안드로이드를 발전시킬 새로운 3가지 기능

돈룩백 — Sat, 23 May 2020 02:35:56 +0900

나의 기기 찾기 기능

맞다! iOS의 “나의 iPhone 찾기”와 같은 안드로이드만의 휴대폰 찾기가 있으면 좋겠다.

스마트폰 이외에도 여러 기기를 소유하고 있는 사람들을 어렵지 않게 찾을 수 있기 때문에,

기기들간에 ioT 기술로 기기 위치 파악 기능이 추가될 수 있다면 더할 나위 없이 좋을 것이다.

지금도 안드로이드 분실 기기 찾는 방법을 검색하면 google 계정을 통해서 전화벨을 울리는 수준이다.

혹은, 개인의 통신사로 접속해서 여러 검증 단계를 거치고 나서야 위치를 추적할 수 있다.

따라서, 안드로이드 기기 찾기 기능이 추가되면, 소프트웨어의 가치가 한 단계 업그레이드 될 수 있다.

제스쳐 커스터마이징

사용자 경험이 가장 민감하게 나타나는 것이 UI/UX 와 터치 스크린 제스쳐링이다.

정해진 제스쳐를 따라야하는 것이 아니라, 제스쳐 자체를 커스터마이징 할 수 있게 한다면,

이전보다 훨씬 개선된 고객 경험을 선사할 것이다.

사람들이 iOS 혹은 MacOS를 선호하는 이유도, (물론 디자인이 예쁜 것도 있지만,)

제스쳐 커스터마이징이 가져다 주는 자율성이 한 몫하고 있기 때문이다.

보안

안드로이드 어플리케이션은 오픈소스 코드로 만들어졌기 때문에 운영체제 자체의 보안을 높여야할 필요가 있다.

따라서 어플리케이션의 실행을 위해서 사용자의 패스워드를 요구하는 등, 불안정한 앱의 상태를 감지하고 이를 사용자에게 경고하는 기능이 강화되어야 한다.

단순히 어플리케이션 출처로만 경고문이 뜨는 것이 아니라,

코드 레벨에서의 불안정성을 경고하는 기능이 추가되면, iPhone의 보안이 안겨주는 신뢰를 안드로이드에서도 제공할 수 있다.

안드로이드 3가지 문제점 개선안

돈룩백 — Sat, 23 May 2020 02:31:15 +0900

1. 불편한 제스처 기능

Android 설정을 통해, 사용자가 과거에 사용했던 3버튼 방식과 제스처기능을 선택할 수 있습니다.

또는 번거롭지만, 사용자가 Google play store에서 서드파티 런처를 설치하여 다른 제스처 기능을 사용할 수도 있습니다.

하지만, 가장 좋은 방법은 안드로이드 자체 제스처 기능을 경쟁사인 아이폰과 같이 직관적이고 사용하기 쉽게 만드는 것입니다.

2. 기기간 편차

Android 10 부터는 Project Mainline 을 통해서 보안 시스템의 업데이트 편차를 줄여 나가고 있습니다.

하지만, 사용자가 느끼는 업데이트 속도에 가장 직접적인 영향을 미치는 영역은 I/O 전환과 어플리케이션의 버그 수정입니다.

따라서, Project Mainline의 목표설정을 확대하여 기기간의 업데이트 편차를 줄여나갈 수 있을 것입니다.

3. 불안정한 다크모드 기능

IOS13의 다크모드는 서드파티 앱 내에서 쉽게 구현할 수 있는 API를 제공합니다.

다크모드를 켜고 끄는 동작 역시 자연스럽고 부드럽게 동작합니다.

안드로이드 다크모드의 완성도를 높이기 위해서, 다크모드 관련 API를 정돈 할 필요가 있습니다.

그리고 프로그래머가 앱을 출시할 때 다크모드와 관련된 옵션을 충분히 확인하고 테스트해 볼 수 있도록 유도해야 합니다.

안드로이드 3가지 문제점

돈룩백 — Sat, 23 May 2020 02:28:54 +0900

1. 불편한 제스처 기능

Android 10 버전부터 새로운 제스처 네비게이션이 적용됩니다.

제스처 네비게이션은 버튼을 사용하지 않고 화면을 스와이프 하는 방식으로 탐색할 수 있는 방식입니다.

Android 10 에서 지원하는 제스처 방식은 IOS의 제스처와 닮아있지만 불편하다는 평가가 많습니다.

뒤로가기는 스마트폰 사용시 가장 많이 사용하는 기능입니다.

Android 10은 뒤로가기와 앱 내에서 메뉴바를 여는 동작이 같아 tap and hold 방식으로 두 동작을 구분하는데,

이 기능이 매우 불편하다는 평가를 받고 있습니다.

뿐만아니라, 서드파티 런처와 함께 사용하면, 제스처가 작동하지 않는 호환성의 문제도 있습니다.

2. 기기간 편차

Android os는 업데이트와 관련해서 기기마다, 그리고 제조사마다 편차가 크다는 문제점이 있습니다.

오픈소스 프로젝트이기 때문에 플랫폼 점유율 경쟁에서는 높은 이점을 가지고 있습니다.

하지만, 휴대폰 제조사들은 안드로이드를 순정상태로 사용하지 않고 각 제조사 별로 커스터마이징을 하고 있습니다.

안드로이드를 순정만을 가지고 사용하기에는 불편한 점들이 많기 때문인 것과,

안드로이드 OS가 모든기기에 완벽하게 호환되는 것이 아니기 때문에 각 제조사들이 자신이 제조하는 기기에 맞게 수정하는 것입니다.

즉, 안드로이드가 오픈소스이며 뛰어난 모바일 플랫폼 인 것은 맞으나 안정성과,

사용성 측면에서 경쟁사의 IOS에 비해 다소 아쉬운 부분이 있습니다.

3. 불안정한 다크모드 기능

Android 10 이상에서는 강화된 다크모드가 제공됩니다.

위 그림의 예시와 같이, 다크모드를 활성화 할 경우 안드로이드 UI 전반에 걸쳐 어두운 색으로 톤다운이 일어납니다.

안드로이드 기본탑재된 시스템 어플리케이션 이외에도 개발자 옵션을 활성화 시키면,

다크모드를 공식적으로 지원하지 않는 서드파티 앱들의 다크모드 강제적용 기능도 지원합니다.

https://developer.android.com/guide/topics/ui/look-and-feel/darktheme

다크모드는 전력소모량 감소, 저 시력자 가시성 개선 등의 장점을 가진다고 소개하고 있습니다.

그러나 다크모드는 아직 지원되는 앱들이 거의 없을 뿐더러 강제적용시 화면 상단바가 사라지거나, 폰트가 제대로 보이지 않는 버그, 그리고 앱 실행중에 다크모드 변환시 앱이 재실행되는 문제점들이 있습니다.

다음글에서는 당연히 개선안을 소개하겠죠? ㅋㅋㅋ

[소프트웨어 분석] 경쟁사와의 장단점 분석

돈룩백 — Sat, 11 Apr 2020 17:29:39 +0900

사용자 측면에서 장단점 비교

더 많은 기기 회사들이 안드로이드 플랫폼을 사용하고 있으므로 접근성이 높아서 사용자에게는 안드로이드 환경이 더 편하다. 실제로 모바일 OS 시장 점유율을 보면 Android가 72.26%로 ios의 27.03% 보다 크게 앞선다.

IOS 를 이용하는 사용자라면 높은 보안 신뢰가 플랫폼을 선택하는 데에 있어서 크게 작용할 것이며, 프라이버시에 민감한 고객들에게는 더할나위 없는 선택이 될 수 있다.

따라서, 사용자들은 높은 접근성과 보안성 사이에서 안드로이드와 IOS 플랫폼을 고민한다.

또한, voice assistant 에서 android가 기술적으로 ios의 siri 를 앞선다는 의견이 많다. 이유인 즉슨, Android는 일정과 교통상황을 반영하여 의미있는 조언을 해주는 등 사용자와의 상호작용이 양방향적이지만, siri는 간단한 업무를 지시하는 데에 그쳐서 일방향적 소통 구조에서 벗어나지 못한다고 평가받고 있다.

UI/UX 측면에서 장단점 비교

참고 사이트: https://appinventiv.com/blog/ios-vs-android-app-design-difference/

네비게이션부터 살펴보면,스크린의 최상단에서 iOS는 previous tab, current tab 그리고 action 버튼이 주어진다. 안드로이드에서는 Drawer menu, current tab의 이름, search bar, 그리고 back button이 있는 Overflow menu가 있다 (아래 사진 참고)

Primary Navigation에서 iOS 는 2-5 개 아이콘이 가로로 정렬이 되어 있지만, 안드로이드에서는 인터페이스 전면에 걸쳐서 나타나있다. (아래 사진 참고)

Secondary Navigations에서 iOS는 “더보기” 탭에서 발견할 수 있으며, 안드로이드에서는 hamburger 메뉴를 누르면 나온다.

Back Navigation에서 iOS는 “Back” action 을 누르거나 화면 자체를 왼쪽 혹은 오른쪽으로 슬라이드하면

되지만, 안드로이드에서는 화면 최하단에 있는 back 버튼을 누르면 된다. (아래 사진 참고)

Typography를 보면, iOS는 San Francisco 를 시스템 typeface로 지정했고, 안드로이드는 Roboto 를 표준 시스템 typeface로 지정했다. (아래 사진 참고)

결론적으로, 누구의 UI/UX 디자인이 좋다고 딱잘라 말할 수는 없지만, 사용자들이 선호하고 공감대를 형성하는 의견은 iOS 의 것이 안드로이드보다 더 좋다는 것이다.

기능적인 큰 차이가 있다라고 하기보다, 애플 제품이 주는 감성과 느낌 때문일 것이다.

개발자 측면에서 장단점 비교

위의 보안 측면에서의 장단점이 개발자 입장에서는 다르게 작용할 수 있다.

안드로이드에서 앱 개발을 하는 개발자는 다른 사람의 소스 코드를 자유롭게 열람할 수 있으며 오픈 소스의 일환으로 자신의 앱을 개발하는데에도 큰 도움이 될 수 있다. 자유도가 높은 상황에서 더 창의적이고 앞서가는 소스 코드를 실험적으로 적용해볼 수 있는 좋은 장소이다. IOS 에서는 소스코드의 통제가 많기때문에. 비교적으로 개발 자유도가 떨어지는 문제점이 있다.

경영자 측면에서 장단점 비교

안드로이드와 iOS의 수익 모델은 상당 부분 비슷하다

스마트 폰을 활용한 광고 매출과 앱스토어를 통해 올리는 매출 생성 모델이 가장 일반적인 두 수익 구조이다.

하지만, 경영자 단순히 더 많은 광고 유출과 유료 앱 판매가 사업의 목적이라고 보기는 어렵다. OS 싸움은 플랫폼 싸움이다. 플랫폼 싸움은 네트워크 싸움이다. 네트워크의 점유율이 높을수록 inner-network-communication을 촉진시키는 대부분의 사업모델은 수익 내지 않는 것이 더 힘들다.

따라서, 각 제품의 경영자는 고객경험에 초점을 맞추어서 사용자의 편의와 사용자들간의 소통을 장려하기 위한 시스템 환경을 설정해 나갈 것이다. 그런 의미에서 안드로이드의 것이 애플의 것보다 더 유리하다. 더 많은 휴대폰이 안드로이드를 사용하고 있어서 사용자의 접근성이 더 높아서 시장 점유율이 높기 때문이다. 물론 휴대폰 회사마다 업데이트의 속도가 다른 문제점이 있지만, 이 확보해 놓은 고객수로는 확실히 수익창출에 유리한 비즈니스 구조를 가지고 있다.

[소프트웨어 분석] 소프트웨어 특징

돈룩백 — Sat, 11 Apr 2020 17:28:12 +0900

<안드로이드란?>

Android는 휴대기기용 오픈소스 운영체제이며 Google이 주도하는 관련 오픈소스 프로젝트입니다.

<특징>

1. Linux 커널

Android 플랫폼의 기반은 Linux 커널입니다. 예를 들어, ART(Android 런타임)는 스레딩 및 하위 수준의 메모리 관리와 같은 기본 기능에 Linux 커널을 사용합니다.

Linux 커널은 수년간 널리 사용되어 왔으며 보안에 민감한 수백만 개의 환경에서 사용되고 있습니다. Linux는 수천 명의 개발자가 끊임없이 연구하고 공격받고 문제를 해결한 역사를 통해 많은 기업과 보안 전문가들이 신뢰하는 안정적이고 안전한 커널이 되었습니다.

2. HAL

HAL(하드웨어 추상화 계층)은 상위 수준의 Java API 프레임워크에 기기 하드웨어 기능을 노출하는 표준 인터페이스를 제공합니다. HAL은 여러 라이브러리 모듈로 구성되어 있으며, 카메라 또는 블루투스 모듈과 같은 특정 유형의 하드웨어 구성 요소를 위한 인터페이스를 구현합니다. 프레임워크 API가 기기 하드웨어에 액세스하기 위해 호출을 수행하면 Android 시스템이 해당 하드웨어 구성 요소에 대한 라이브러리 모듈을 로드합니다.

3. Android 런타임

ART(Android RunTime)는 구글이 안드로이드에서 자바 바이트 코드를 실행하기 위해 만든 가상머신입니다.

Android 버전 5.0(API 레벨 21) 이상을 실행하는 기기의 경우, 각 앱이 자체 프로세스 내에서 자체 ART(Android 런타임) 인스턴스로 실행됩니다. ART는 DEX 파일을 실행하여 저용량 메모리 기기에서 여러 가상 머신을 실행하도록 작성되었습니다. DEX 파일은 Android용으로 특별히 설계된 바이트코드 형식으로, 최소 메모리 공간에 맞게 최적화되어 있습니다.

Android 버전 5.0(API 레벨 21) 이전 버전에서는 Dalvik이 Android 런타임이었습니다. 앱이 ART에서 제대로 실행되면 Dalvik에서도 제대로 실행되지만, 그 반대의 경우 제대로 실행된다는 보장은 없습니다.

4. Java API 프레임워크

Android OS의 전체 기능 세트는 Java 언어로 작성된 API를 통해 액세스할 수 있습니다. 이러한 API는 핵심 모듈식 시스템 구성 요소 및 서비스 재활용을 단순화하여 Android 앱을 제작하는 데 필요한 빌딩 블록을 구성합니다.

5. 시스템 어플리케이션

Android는 이메일, SMS 메시징, 캘린더, 인터넷 검색, 주소록 등의 주요 앱 세트와 함께 제공됩니다. 시스템 앱은 사용자를 위한 앱으로도 작동하고 개발자가 자신의 앱에서 액세스할 수 있는 주요 기능을 제공하기 위한 용도로도 작동합니다.

Reference : https://developer.android.com/guide/platform?hl=ko#top_of_page

다음글은 소프트웨어 분석 관련 마지막 포스팅입니다~

제목: 경쟁사와의 장단점 비교

[소프트웨어 분석] 소프트웨어 선택 배경

돈룩백 — Sat, 11 Apr 2020 17:26:31 +0900

Android는 우리가 쉽게 일상에서 가장많이 접하고있는 소프트웨어 중 하나이다.

하지만 이렇게 일상과 닿아있는 소프트웨어를 우리는 자세히 알고 사용하진 않는다.

우리의 가장 가깝고 가장 많은 시간을 함께 하고있는 Android를 분석함으로써

"icon made by pixel perfect from flaticon.com"

Android를 더 잘 이해하고 사용할 수 있을 거 같아서 선정 했어유~

[오픈소스] Prophet을 이용한 Stock Prediction 활용 및 후기 (3/3)

돈룩백 — Fri, 13 Mar 2020 22:41:32 +0900

자 그럼 colab에 ipynb 파일을 업로드하고 돌려보자

import pandas as pd
from fbprophet import Prophet

import pandas as pd
import matplotlib.pyplot as plt

import pandas_ta as ta
from alphaVantageAPI.alphavantage import AlphaVantage ##pip install alphaVantage-api##

첫 번째로 필요한 모듈들을 불러온다.

AlphaVantage는 설치되어 있지 않을 경우가 많기 때문에 혹시 ModuleNotFound error 가 뜬다면

코멘트 처리된 부분을 복사해서 pip install alphaVantage-api 를 실행시키기 바란다.

ticker='CW'
AV = AlphaVantage(
        api_key='paste your api-key',
        premium=False,       
        datatype='json',
        export=False,
        export_path= '/Users/kimkwangjae/fbprophet-price-prediction',
        output='csv',
        output_size='full',
        clean=True,
        proxy={})

df = AV.data(symbol=ticker, function='DA')
predper = 60 #number of days to predict ahead
print(f"Shape: {df.shape}")
df.set_index(['date'], inplace=True)
df.head()

다음으론 AlphaVantage에서 데이터를 불러오기 위해서 api-key를 발급받아야한다.

api-key는 가입만 하면 무료로 발급되므로 https://www.alphavantage.co/에서 발급받으면 된다.

실행 결과가 다음과 같이 뜬다면 데이터가 성공적으로 다운로드된 것이다

계산 에러를 방지하기 위해서 혹시 모를 N/A 값들을 0으로 바꿔주는 코드를 실행한다

df.fillna(0.0, inplace=True)

df에 저장된 데이터를 다음에 또 쓸 수도 있기 때문에 csv파일 형식으로 저장한다

그러기 전에 colab에서는 다음과 같은 유용한 기능을 제공한다

from google.colab import drive
drive.mount('/content/drive')

위 코드를 실행하면 나의 구글 드라이브 폴더에 접속해서 데이터를 저장하고 읽어 올 수 있다

내 pc의 메모리도 안 잡아먹으면서 매우 편리한 기능이다

연동이 되면 아래 코드를 실행해서 가격 데이터를 저장하자

df.to_csv (r'/content/drive/My Drive/pricedataCW.csv', index = 'date', header=True)

그리고 데이터를 불러오는 연습도 할 겸, dataframe을 변경할 겸 저장한 csv 파일을 다시 불러온다

df = pd.read_csv('/content/drive/My Drive/pricedataCW.csv',
                usecols=['date','close'])
df.head()

아래와 같이 나왔다면 파일을 성공적으로 불러들인 거다!

위에서 저장한 dataframe과의 차이점이 보이는가?

date와 close (종가) 만을 가져와서 전형적인 시계열 데이터 형식으로 변형시켰다

df.columns = ['ds', 'y']

여기서 column 이름을 다시 바꿔주는데, Prophet 모델이 원하는 형식을 맞춰주기 위함이다

이제 거의 다 왔다!!

드디어 우리의 주인공 prophet을 사용해서 예측을 할 차례..... 에 앞서,

모델을 fit 시켜준다

m = Prophet(
    growth="linear",
    #holidays=holidays,
    #seasonality_mode="multiplicative",
    changepoint_prior_scale=30,
    seasonality_prior_scale=35,
    ###cap=3.00,
    ###floor=.65*125,
    holidays_prior_scale=20,
    daily_seasonality=False,
    weekly_seasonality=False,
    yearly_seasonality=False,
    ).add_seasonality(
        name='monthly',
        period=30.5,
        fourier_order=55
    ).add_seasonality(
        name='daily',
        period=1,
        fourier_order=15
    ).add_seasonality(
        name='weekly',
        period=7,
        fourier_order=20
    ).add_seasonality(
        name='yearly',
        period=365.25,
        fourier_order=20
    ).add_seasonality(
        name='quarterly',
        period=365.25/4,
        fourier_order=5,
        prior_scale=15)
m.fit(df)

위의 코드에서 나오듯이 우리는 총 5가지 형태(월, 일, 주, 년, 분기)로 주가를 예측할 계획이다

future = m.make_future_dataframe(periods=predper)
future.tail()

"predper"에 명시된 days 만큼 주가를 예측하는 것인데, 이 프로젝트에서는 60일이었다.

즉 다음과 같은 형태의 datestamp 가 찍힌다.

이제 진짜 예측을 할 차례이다

forecast = m.predict(future)
forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail()

예측 결과를 조금 더 직관적으로 보기 위해 다음 코드를 실행하면 그래프가 나온다

fig1 = m.plot(forecast)

방금 언급한 5가 형태의 예측을 보려면,

fig2 = m.plot_components(forecast)

다음으론 수익률을 평가해 보기 위해한 코드를 설명해 보려고 한다.

df2 = AV.data(symbol=ticker, function='DA') # Daily Adjusted
df2.name = ticker
df2.set_index(['date'], inplace=True)
df2.drop(['dividend', 'split_coefficient'], axis=1, inplace=True) if 'dividend' in df2.columns and 'split_coefficient' in df2.columns else None

opendf2 = df2['open']
closedf2 = df2['close']
volumedf2 = df2['volume']

df3 = forecast[['ds','yhat']]
df3.tail()

df3 = df3.iloc[:-predper]
df3.columns = ['date','close']
df3.set_index(['date'], inplace=True)
df3.tail()

last_ = df2.shape[0]

def stratty(cumulative=True, last=last_):
    """A very basic analysis of the closing price being greater than each moving average"""
    last = last if last is not None else df2.shape[0]
    closedf2 = df2['close']
        
    pred = df3['close']
    
    tdf2 = pd.DataFrame({
        f"{pred.name} cumlog ret": ta.trend_return(closedf2, pred < .95*closedf2, cumulative=cumulative),
        })
    tdf2.set_index(closedf2.index, inplace=True)
    window = tdf2.tail(last)
    title = f"{df2.name}: Prophet Logic Trend Return from {window.index[0]} to {window.index[-1]}"
    window.plot.area(figsize=(16, 4), color=['green', 'orange', 'yellow'], linewidth=1, alpha=0.25, title=title, stacked=False, grid=True).axhline(y=0, color="black", lw=1.1)

stratty(last=2000) #last 2000 days of activity to show in the cumlog return plot

이로써 prophet으로 돌렸을 때 어느 정도의 수익을 예상할 수 있는지에 대한 예측 결과가 나왔다

하지만, 이 코드만을 가지고 실제 투자에서 수익률을 올리려는 시도는 자제하는 것이 좋다

수많은 백테스팅을 거쳐서 안정적인 수익 모델을 만들어내는 것이 중요하기 때문이다

위의 모델을 발전시키기 위해서 여러 가지 parameter들이 있다

그리고 ticker를 변경해서 다른 주식회사들의 historical data로 학습해보기를 권한다

필자는 AAPL (애플)을 넣어서 다음과 같은 결과를 얻어 봤다

후기

먼저 andynorris의 detail한 코드 설명에 감사를 드린다

Prophet을 활용해선 더 많은 사람이 시계열 데이터와 주가 데이터에 관심을 갖게 되는 계기를 제공해줬다

Code Lab 또한 너무나도 소중한 개발환경이라는 것을 다시 한 번 느꼈다

특히 Prophet 모듈을 설치하는 문제가 너무 많았는데 Code Lab에서는 단숨에 해결 됐다.

이번 기회에 블로깅을 꾸준히 해나가는 목표가 생겼다

더 많은 오픈소스 프로젝트를 경험해보면서 나 또한 새로운 오픈소스 프로젝트를 론칭할 수 있는 날이 올 수 있기를 바라며

글을 마친다

[오픈소스] Prophet을 이용한 Stock Prediction 환경 설치 (2/3)

돈룩백 — Fri, 13 Mar 2020 21:40:15 +0900

코드를 실행하기 위해서

우선 https://github.com/irvineAlgotrading/fbprophet-price-prediction 에 접속해서 git 주소를 복사해 온다.

그다음엔 터미널에서 git clone [주소 붙여 넣기]를 실행한다.

혹시 git 사용이 아직 익숙지 않은 분들은 간단한 git tutorial을 보고 오시기를 바란다 (google it~!)

그리고 우리는 다운 받은 facebook-prophet-price-prediction.ipynb 파일을

google colab에 업로드해서 실행시킨다.

왜냐하면 prophet 모듈을 다운로드하는 방법이 까다롭기 때문이다.

prophet은 pystan과 cython에 dependency가 있기 때문에 설치 순서에 매우 민감하다.

필자도 간지(?)나게 pc 환경에서 코드를 돌려보고 싶었지만 실패했다.

혹시 성공한 분들이 계시면 아래 댓글 남겨주시면 땡큐~!

[오픈소스] Prophet을 이용한 Stock Prediction 소개 (1/3)

돈룩백 — Fri, 13 Mar 2020 21:07:41 +0900

Facebook Prophet

이번 포스팅은 페이스북(Facebook)의 오픈소스 프로젝트인 Prophet을 이용하여

주식 가격을 예측해본 andynorris의 소규모 프로젝트를 소개하는 글이다.

https://github.com/irvineAlgotrading/fbprophet-price-prediction

irvineAlgotrading/fbprophet-price-prediction

Jupyter notebook for performing price predictions of stock data using Facebook's Prophet package. - irvineAlgotrading/fbprophet-price-prediction

github.com

andynorris는 Alphavantage api를 사용해서 주식 데이터를 확보하고,

Data preprocessing을 진행한 다음,

prophet을 이용해서 time series data forecasting을 실행했다.

시계열 데이터 (Time Series Data)를 간단하게 설명하면 특정한 시간 t에서 측정된 관측값이다.

시계열 데이터 예측 (Time Series Data Forecasting)은 주로 금융에서 많이 쓰이지만,

날씨, 항공기 이용객, 상품 판매 등등 다양한 분야에서 널리 사용되고 있다.

필자는 특히 주가 예측에 관심이 많아서 주가예측에 관한 시계열 데이터 프로젝트를 소개하는 바이다

다음 글에서는 환경설치 과정과 코드 실행 방법을 다룬다