딥러닝 메모장

import torch

torch.cuda.is_available()

True

torch.cuda.current_device()

0

torch.cuda.get_device_name(0)

'GeForce TITAN X'

2to3 -w 파일명  # 해당 파일 변환

2to3 -w .\        # 현재 폴더의 모든 파일 변환

위 코드를 실행하면 .bak 파일(원본)이 생김

-n 옵션을 추가하면 .bak 파일 생성을 막음

https://www.slideshare.net/ssuser7e10e4/wasserstein-gan-i

pyplot을 이용하여 영상을 저장하려고 했으나,

계속해서 공백이 생겨서 애먹었다.

구글링하면 일반적으로 tight_layou() 등의 함수를 말하는데, 씨알도 안먹힌다.

결국 이것저것 삽질하면서 다양한 공백이 있다는걸 발견했다..

1. axis 공백 (왼쪽과 아래쪽 공백)

이건 axis('off') 코드를 이용해서 없앤줄 알았으나

축 값만 안보일 뿐, 축 값들이 차지하던 공간은 그대로 남아있다.

이걸 없애려면 아래 코드를 사용해야한다.

fig.axes.get_xaxis().set_visible(False)

fig.axes.get_yaxis().set_visible(False)

만약 axis 객체를 사용한다면 (ex subplot)

ax.axes.get_xaxis().set_visible(False)

ax.axes.get_yaxis().set_visible(False)

2. padding으로 인한 공백

save 옵션에 tight를 추가해도 공백은 여전하다.

이는 padding이 존재해서 발생하는 문제다.

따라서 저장 시 padding=0 옵션을 추가해주면 해결된다.

plt.savefig(fname='image.jpg', bbox_inches='tight', pad_inches=0)

아래 링크는 그냥 pyplot 사용법

https://datascienceschool.net/view-notebook/d0b1637803754bb083b5722c9f2209d0/

에러 메시지

osmesashim.c:1:23: fatal error: GL/osmesa.h: No such file or directory

command 'gcc' failed with exit status 1`

해결 방법

sudo apt install libosmesa6-dev

http://darkpgmr.tistory.com/149

HSV는 RGB와 같은 색상 표현 포멧 중 하나이다.

HSV는 색상, 채도, 명도로 이루어져있다.

RGB 같은 경우는 3가지 요소가 모두 결합되어야 색상을 결정하는데,

HSV의 경우는 첫 번째 요소인 Hue가 색상을 결정한다.

그래서 Hue 요소만 고려해도 어느정도 색상을 분류할 수 있다는 말이다.

물론 채도, 명도에 따라 달라지긴 하지만.

HSV의 구조는 아래 사이트에 나온 그림을 참고하면 쉽게 이해될 것이다.

https://ko.wikipedia.org/wiki/HSV_%EC%83%89_%EA%B3%B5%EA%B0%84

H는 360개의 값을 (각도),

S는 100개의 값을 (반지름),

V는 100개의 값을 가진다 (높이).

코드 레벨에선 표현 방법에 따라 int 값이 아닌, 0~1의 비율 값으로 표현하곤 한다.

ex) H가 0.5면 180, S가 0.5면 50.

python에선 colormap이라는 모듈을 통해, 손쉽게 색상계를 변환시킬 수 있다.

pip install graphviz easydev

node와 edge로 이루어진 그래프를 만들며,

간단한 코드로 시각화가 가능하다.

documents

https://graphviz.readthedocs.io/en/stable/

sg = gv.Digraph() # 그래프 생성
anns_rel_n2c = annotation_util.get_rel_n2c()

for obj_idx, obj_info in enumerate(scene_info['visible_object']): # object node, 속성 node/edge 추가
    with sg.subgraph(name=str(obj_idx)) as obj_g:
        obj_g.node(str(obj_info['id']), label=obj_info['name'], shape='box')
        # is_open 추가
        obj_g.node(str(obj_info['id'])+'_isOpen', label={-1:'o_un', 0:'close', 1:'open'}[obj_info['is_open']], shape='ellipse', style='filled', color='lightgrey')
        obj_g.edge(str(obj_info['id'])+'_isOpen', str(obj_info['id']), dir='none')

        # color 추가
        obj_g.node(str(obj_info['id']) + '_color', label=obj_info['color'], shape='ellipse', style='filled', color='lightgrey')
        obj_g.edge(str(obj_info['id']) + '_color', str(obj_info['id']), dir='none')

for relaion in scene_info['relaion']: # 관계 edge 추가
    sg.edge(str(relaion['subject_id']), str(relaion['object_id']), label='  '+anns_rel_n2c[relaion['rel_class']])

sg.render('./gv_temp.gv', view=True, cleanup=True) # 랜더링

pip install colormap

documents

https://colormap.readthedocs.io/en/latest/

colormap.rgb2hsv 등의 함수가 구현되어있어서, 쉽게 변환이 가능하다.

함수들에 대한 인자는 tuple이며,

output 역시 numpy가 아닌 단순 list이다.

유의해야할 점은

rgb2hex 함수는 0~255 값을 입력 받는데,

rgb2hsv 함수는 0~1 값을 입력받는다.

왜 이렇게 구현해놓은 지는 잘 모르겠다.. 너무 불편..

https://youtu.be/MSWCQ9lRA1Y

딥러닝만은 안된다

네으워크 파라미터 초기화

http://nmhkahn.github.io/NN

http://pythonkim.tistory.com/41

https://github.com/ethereon/lycon

사이트 아래쪽에 테이블로 잘 비교되어있다.

측정된 값이 확실치는 않음

결과적으로는

OpenCV >>>>>> Pillow >>>>>>>>>>>>>>>>>>> Scikit-Image

opencv가 압도적으로 빠르다

pillow가 제일 빠를 줄 알았는데..

앞으론 opencv만 써야겠다

[Make로 레이어 만들고, 모델 돌렸을 때 나는 오류인 경우]

src/cuda/Makefile 파일들을 수정해서 해결 가능. (보통 roi_aling 등의 특별한 네트워크 추가 시에 makefile이 존재)

파일을 열어보면

-gencode arch=compute_61,code=sm_61

라는걸 볼 수 있을 텐데, 61 혹은 다른 숫자를 아래 사이트에 나온 자신의 그래픽카드 번호에 맞게 설정

https://developer.nvidia.com/cuda-gpus

그래픽카드 확인 명령어

lspci |grep -i VGA

만약 5.2라면 52라고 수정

ex) GeForce GTX TITAN X -> 52

-> -gencode arch=compute_52,code=sm_52

위와같은 Makefile은 여러개가 있는 경우가 많으니, 다 찾아서 바꿔줘야함

참고로 TITAN X는 Nvidia도 있고, GeForce GTX도 있으니 잘 구별해야함

tf.train.Saver 객체를 통해서 모델을 저장하고 불러올 수 있다.

1. 모델 저장

# saver 객체 생성.
# max_to_keep를 안쓰면, 최대 5개만 저장된다. (이전에 저장된 checkpoint가 지워짐)
saver = tf.train.Saver(max_to_keep=10)

# 세션에 있는 variable들을 저장.
# 총 3가지 파일이 한번에 저장된다.  파일명.data-00000-of-00001, .index, .meta
# 아직 세개가 뭘 의미하는 지는 잘 모르지만, meta는 모델 구조를 명시한다.
# global_step을 써주면, baseline_model-100.meta 처럼 저장되어 유용함.
saver.save(sess, "./checkpoints/baseline_model", global_step=step)

2. 모델 불러오기

두 가지 방법이 있다.

2.1 먼저 코드로 학습된 모델을 작성하고(train에 사용한 네트워크 코드를 그대로 사용), 해당하는 웨이트들에 덮어씌우는 방식 (웨이트 범위를 설정해서 특정 부분만 load할 수도 있다.)

2.2 meta 파일을 이용하여, 모델 코드 없이 바로 불러서 사용하기 (keras와 매우 유사)

일단 두 번째 방법만 정리하였다.

하나하나 설명하는 것보다 예시 코드를 보여주는게 나을거같아서 통으로 올림

import numpy as np
import tensorflow as tf
import os
import dataset

batch_size = 128
model_name = 'baseline_model'
step_list = [600, 700, 800, 900]
model_names = []
for step in step_list:
    model_names.append(model_name + '-' + str(step))

print('dataset loading... ')
DB = dataset.SVPC_Dataset('./dataset/test.csv', 'test', divide_value=10000000, round=4, normaliza=False)
print('dataset loaded !! ')


for idx, model_name in enumerate(model_names):
    writer = dataset.Result_Writer(fileName=model_name)
    saver = tf.train.import_meta_graph(os.path.join('./checkpoints',model_name + '.meta'))
    print('{}: predicting...{}/{}'.format(model_names, idx, len(model_names)))
    with tf.Session() as sess:
        saver.restore(sess, os.path.join('./checkpoints',model_name))
        graph = tf.get_default_graph()
        x = graph.get_tensor_by_name("input:0")
        y_pred = graph.get_tensor_by_name("output:0")

        for idx, (test_x, id) in enumerate(DB.generator(batch_size)):
            predicted_y = sess.run(y_pred, feed_dict={x: test_x})
            predicted_y[np.where(predicted_y < 0)] = 0.
            writer.add_rows(id, (predicted_y * 10000).astype('int32'))

    writer.save_to_csv()
    print('result saved; {}'.format(model_name + '.csv'))

kaggle의 csv 파일을 다루려다 보니, dataset을 직접 구성해야할 일이 생겼다.

dataset을 다루는데에 여러가지 방법이 있는데,

대부분의 dataset은 파일이 크기 때문에 generator 형식이 제일 좋은 것같다.

하지만 csv 포멧으로는 그게 힘들어서 파일을 전부 읽은 다음 사용했다.

그런데 읽은 dataset을 이용하는 방법 또한 두 가지로 나뉘는것같다.

하나는 gpu 메모리에 올리고 사용하는 방법. 하나는 generator 형식으로 사용 데이터만 gpu에 올리는 방법

처음엔 잘 몰라서 전자를 선택했지만, 메모리 부족으로 후자를 택해야했다.

두 방법을 모두 정리하고자 글을 썼다.

1. csv 데이터 읽은 후, tf함수 from_tensor_slices로 사용하기

# train_x, train_y는 numpy 포멧 [데이터 수, value]로 구성.
# tf.data.Dataset.from_tensor_slices을 이용하면 대규모 데이터셋은 불리하다고한다
# 참고 : https://www.tensorflow.org/api_docs/python/tf/data/Dataset

dataset = tf.data.Dataset.from_tensor_slices((train_x, train_y))

dataset = dataset.batch(batch_size)
iterator = dataset.make_initializable_iterator()

_data = tf.placeholder(tf.float32, [None, cfg.INPUT_DATA_LEN])
_labels = tf.placeholder(tf.float32, [None, 1])

next_batch = iterator.get_next()
x = tf.placeholder(tf.float32, [None, 4991], 'input')
y = tf.placeholder(tf.float32, [None, 1], 'label')

y_pred = baseline.predict(x)
y_pred = tf.identity(y_pred, 'output')

mse = tf.reduce_mean(tf.square(y - y_pred))
#optimizer = tf.train.GradientDescentOptimizer(0.01)
optimizer = tf.train.AdamOptimizer(0.01)
grad_vars = optimizer.compute_gradients(mse)
capped_grad_vars = [(tf.clip_by_value(grad, -1., 1.), var) for grad, var in grad_vars]
train_op = optimizer.apply_gradients(capped_grad_vars)
saver = tf.train.Saver()
init = tf.global_variables_initializer()

print('train start')
with tf.Session() as sess:
    sess.run(init)
    #print('1')
    for i in range(step):
        sess.run(iterator.initializer, feed_dict={_data: train_x, _labels: train_y})
        iteration = 0
        #print('2')
        while True:
            try:
                train_x, train_y = sess.run(next_batch)

                sess.run(train_op, feed_dict={x:train_x, y:train_y})
                if iteration == 0:
                    loss = sess.run(mse, feed_dict={x:train_x, y:train_y})
                    print('step: {}, mse: {}'.format(i, loss))
                iteration += 1
            except tf.errors.OutOfRangeError:
                break
        if i % 100 == 0:
            if not i == 0:
                saver.save(sess, "./checkpoints/baseline_model", global_step=i)
                print('save model [{}]'.format(i))

2. csv 데이터 읽은 후, generator 만들어서 사용하기

2.1. generator를 새로 코딩 (발코딩인점은 감안.. generator가 핵심이고 나머진 안봐도됨)

import os
import pandas as pd
import numpy as np

class SVPC_Dataset():
    def __init__(self, dataDir, data_type='train', divide_value=None, divide_label=None, round=None, normaliza=False):
        self.dataDir = dataDir
        self.data_type = data_type

        if self.data_type == 'train':
            return self.read_train_data_from_csv(divide_value, divide_label, round, normaliza)
        else:
            return self.read_test_data_from_csv(divide_value, round, normaliza)
        print('data loaded')

    def read_train_data_from_csv(self, divide_value=None, divide_label=None, round=None, normaliza=False):
        df = pd.read_csv(self.dataDir, low_memory=False)
        label_df = df.iloc[:, 1]  # label column
        value_df = df.iloc[:, 2:]  # value column

        if divide_value is not None:
            value_df = value_df / divide_value  # 나누기
        if divide_label is not None:
            label_df = label_df / divide_value  # 나누기
        df = pd.concat([label_df, value_df], axis=1, sort=False)
        if round is not None:
            df = df.round(round)  # 소수점 제거
        if normaliza:
            df = (df - df.mean()) / (df.max() - df.min())
        self.x = np.array(df.values[:, 1:], dtype=np.float32)
        y = np.array(df.values[:, 0], dtype=np.float32)
        self.y = np.expand_dims(y, axis=1)

    def read_test_data_from_csv(self, divide_value=None, round=None, normaliza=False):
        df = pd.read_csv(self.dataDir, low_memory=False)
        id_df = df.iloc[:, 0]  # id column
        value_df = df.iloc[:, 1:]  # value column

        if divide_value is not None:
            value_df = value_df / divide_value  # 나누기
        if round is not None:
            value_df = value_df.round(round)  # 소수점 제거
        if normaliza:
            value_df = (value_df - value_df.mean()) / (value_df.max() - value_df.min())
        self.x = np.array(value_df.values, dtype=np.float32)
        id = np.array(id_df.values)
        self.id = np.expand_dims(id, axis=1)

    def __len__(self):
        return len(self.x)

    def __getitem__(self, idx):
        if self.data_type == 'train':
            return self.x[idx], self.y[idx]
        else:
            return self.x[idx], self.id[idx]

    def generator(self, batch_size=1):
        length = self.__len__()
        for n_idx in range(0, length, batch_size):
            yield self[n_idx:min(n_idx + batch_size, length)]

class Result_Writer():
    def __init__(self, outDir='./', fileName='model_result'):
        self.fileDir = os.path.join(outDir, fileName + '.csv')
        self.result_df = pd.DataFrame(columns=['ID', 'target'])

    def add_row(self, id, target):
        self.result_df = self.result_df.append({'ID':id, 'target':target}, ignore_index=True)

    def add_rows(self, ids, targets):
        for i in range(len(ids)):
            self.add_row(ids[i], targets[i])

    def save_to_csv(self):
        self.result_df.to_csv(self.fileDir, mode='w', header=False)

if __name__ == '__main__':
    db = SVPC_Dataset('./dataset/test.csv', 'test')
    for idx, (x, y) in enumerate(db.generator(3)):
        print(x)
        print(y)
        if idx > 5:
            break

2.2. generator를 통한 모델 학습

DB = dataset.SVPC_Dataset('./dataset/train.csv', 'train', divide_value=10000000, divide_label=10000, round=4, normaliza=False)

x = tf.placeholder(tf.float32, [None, 4991], 'input')
y = tf.placeholder(tf.float32, [None, 1], 'label')

y_pred = baseline.predict(x)
y_pred = tf.identity(y_pred, 'output')

mse = tf.reduce_mean(tf.square(y - y_pred))
#optimizer = tf.train.GradientDescentOptimizer(0.01)
optimizer = tf.train.AdamOptimizer(0.01)
grad_vars = optimizer.compute_gradients(mse)
capped_grad_vars = [(tf.clip_by_value(grad, -1., 1.), var) for grad, var in grad_vars]
train_op = optimizer.apply_gradients(capped_grad_vars)
saver = tf.train.Saver()
init = tf.global_variables_initializer()

print('train start')
with tf.Session() as sess:
    sess.run(init)
    #print('1')
    for step in range(steps):
        #print('2')
        for idx, (train_x, train_y) in enumerate(DB.generator(batch_size)):
            sess.run(train_op, feed_dict={x:train_x, y:train_y})
            if idx == 0:
                loss = sess.run(mse, feed_dict={x:train_x, y:train_y})
                print('step: {}, mse: {}'.format(step, loss))

        if step % 100 == 0:
            if not step == 0:
                saver.save(sess, "./checkpoints/baseline_model", global_step=step)
                print('save model [{}]'.format(step))

둘 다 ram에 data를 미리 다 올리고 사용하는 방법임.

(이것도 개선해야하는데, 당장은 방법을 모르겠음)

1번은 데이터 전부를 gpu에 올리는 듯함

그래서 크기가 작은 파일은 괜찮은데, 큰 파일에서는 메모리 초과 오류가 발생

2번은 ram에 있는 데이터를 batch_size만큼 씩 gpu에 올려서 사용

메모리 초과 오류가 발생하지 않음

pip install pandas

로 간단히 설치 가능

pandas는 DataFrame 이라는 객체를 통해, 데이터들을 처리함.

### 기본 사용법 ###

import pandas as pd # np, tf처럼 대개 pd라고 사용

# DataFrame 생성 코드.   인자로 초기화값과 인덱스 값을 넣어주면 해당 크기만큼 초기화된 df를 얻을 수 있음
# 보통 DataFrame은 df라고 줄여서 표현
df = pd.DataFrame(columns=['ID', 'value'])

# 데이터 삽입 예시.   python의 append와는 다르게 반환값으로 다시 갱신해줘야함
df = df.append({'ID':'hi', 'value':50}, ignore_index=True)

# 다양한 연산자 제공. append와 마찬가지로 반환값을 통해 갱신이 필요함
df.mean(), df/10, df.round(2)

# df 분할
id_df = df.iloc[:, 0]
value_df = df.iloc[:, 1:]

# df 병합. DB에서 배운 join 등의 연산도 가능함. 검색하면 다나옴
df = pd.concat([label_df, value_df], axis=1, sort=False)

# df 객체의 value들을 numpy 배열로 반환해줌
df.values

### csv 파일 처리 ###

# csv 파일 로드 예시. index_col은 0번째(첫번째) 줄의 값들을 column id로 사용하겠다는 의미.
# index_col 값을 0으로 줘야할 때는 굳이 안써줘도 알아서 잘됨 (예시를 위해 넣음)
df = pd.read_csv(os.path.join(dataDir, 'train.csv'), low_memory=False, index_col=0)

# df로부터 csv파일 저장.
# header는 column들의 id 값 표시 여부
# index는 row들의 id 값 표시 여부
df.to_csv("filename.csv", mode='a', header=True, index=False)

sudo rm -rf <폴더명>

rm : 파일 지우기 명령어

-r : 폴더 지우기

-f : 폴더안에 파일들이 있어도 지우기

http://www.codebind.com/cpp-tutorial/install-opencv-ubuntu-cpp/

step 3에서 버전에 맞는 opencv를 설치해야함

opencv 3.4.0의 경우

(darknet/yolo 때문에 opencv를 설치하는 경우, 3.4.0을 설치해야함 3.4.1부터는 오류가 있음)

git clone -b 3.4.0 https://github.com/Itseez/opencv.git

git clone -b 3.4.0 https://github.com/Itseez/opencv_contrib.git

(위 명령어에서 오류날 경우, git을 업그레이드 해야함)

좀 지난 일이지만, 갑자기 생각나서 쓴다 ㅋㅋ

몇 달 전에 네이버에서 주최한 AI 해커톤 대회에 참가하였다.

우연한 기회로 우연히 참가하게된 대회였지만,

새로운 경험이 될 것 같아서 기쁜 마음으로 참가하였다.

처음엔 내가 공부한게 얼마나 먹힐까라는 생각으로

가벼운 마음으로 대회에 임했었다.

그런데 좋은 팀원들 덕분에, 온라인으로 두 차례의 예선을 통과하고

얼떨결에 본선까지 진출하게 되었다.

뭔가 본선에 간다고 생각하니 너무 설레고, 긴장되고.. ㅋㅋ

사실 네이버를 간다는 것 자체가 너무 좋았다 ㅋㅋ

그런데 한편으로는 내가 해야할 일들이 대회날이랑 겹쳐서,

대회 전날까지 잠도 잘 못자고 심적으로 많이 힘들었다.

그래서 대회 당일에 너무 피곤해서 비몽사몽했다 ㅋㅋ..

근데 신기하게 네이버에 들어가니까 너무 설레서

피곤한것도 잊고 열심히 구경했던거 같다 ㅋㅋ

네이버에 도착해서 받은 명찰과 간식 그리고 촬영 동의서.

이런 대회에 처음와봐서 그런지 모든게 신기했다.

네이버 본사에서 버스를 타고 연수원인 커넥트홀이라는 곳으로 이동했는데,

거긴 정말 너무 좋았다

건물도 예쁘고, 주변 경관도 너무 좋아서 거기 있는것만으로 힐링한 느낌이었다

요건 쉬는시간에 잠깐 찍은 사진.

주변이 뻥 뚤려있어서 너무 힐링됬다.

대회가 시작하고 너도나도 분주하게 코딩을했다.

살면서 이런 경관은 처음봐서 되게 설렜다.

우리팀도 열심히 코딩해서 어떻게든 상위권에 가보겠다고 노력했다 ㅋㅋ

훌륭한 팀원들 덕분에 얼떨결에 2등까지 올라갔다

너무 기뻐서 찍은 사진 ㅋㅋ

이러다가 다시 4등으로 내려가고, 3등으로 다시 올라갔다

상금은 3위까지만 받기 때문에, 정말 치열하게 코딩했다 ㅋㅋㅋ

3위로 올라왔어도, 언제 4등으로 떨어질 지 모르기 때문에

정말 열심히했었다.

결과적으로 지식인 유사도 부문에서 3위를 하게되었고

정말 너무 기뻤다

이렇게까지 기쁜적이 또 있었나 싶을정도로 기뻤다

다음 대회는 참가하기 어렵겠지만,

너무도 뜻깊고 재밌었던 경험이다.

또 네이버 클로바의 실무자분들과도 많은 이야기를 할 수 있어서 너무 좋았다.

끝을 뭐라고 해야할지 모르겠는데..

이번 대회를 통해서 이쪽 길이 정말 재밌구나를 다시 한번 느낄 수 있었다.!

아래는 대회 영상인데, 우리팀이 은근 많이 출연했다 ㅎㅎ

https://www.facebook.com/naverengineering/videos/1860622007338600/

아래는 공식 사이트

https://github.com/naver/ai-hackathon-2018