딥러닝 메모장

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

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

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

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

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

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://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을 업그레이드 해야함)

추가

sudo add-apt-repository ppa:

제거

sudo apt-add-repository --remove ppa:

openscenegraph 설치

https://askubuntu.com/questions/823007/building-openscenegraph-3-4-from-source-ubuntu

openrave 설치

ubuntu 16.04

https://scaron.info/teaching/installing-openrave-on-ubuntu-16.04.html

ubuntu 14.04

https://scaron.info/teaching/installing-openrave-on-ubuntu-14.04.html

trajopt 설치

http://rll.berkeley.edu/trajopt/doc/sphinx_build/html/install.html

/usr/bin/ld: warning: libpcre.so.1, needed by //home/ailab/anaconda2/lib/libpcrecpp.so.0, not found (try using -rpath or -rpath-link)

//home/ailab/anaconda2/lib/libpcrecpp.so.0: undefined reference to `pcre_exec'

//home/ailab/anaconda2/lib/libpcrecpp.so.0: undefined reference to `pcre_fullinfo'

//home/ailab/anaconda2/lib/libpcrecpp.so.0: undefined reference to `pcre_free'

//home/ailab/anaconda2/lib/libpcrecpp.so.0: undefined reference to `pcre_config'

//home/ailab/anaconda2/lib/libpcrecpp.so.0: undefined reference to `pcre_compile'

collect2: error: ld returned 1 exit status

make 시, 위와 같이 anaconda의 경로가 자꾸 참조되어 오류가 발생했다.

bashrc에 anaconda path를 지워도 다를 바 없었고, 구글링도 해봤지만 해답을 찾을 수 없었다.

결론적으로 해결한 방법은, anaconda2 폴더를 아예 없애는 것이다.

물론 지우는건 아니고, 이름을 anaconda21처럼 잠시 바꿔준 후 make를 시도한다.

정말 깔끔하게 잘되는 모습을 볼 수 있다.

이것때문에 너무 많은 시간을 허비했다...

참고로 일부 라이브러리만 저런 오류가 뜬다면, conda remove로 anaconda에서 해당 라이브러리를 지우면 해결할 수 있다.

하지만 저렇게 충돌나는게 한두개가 아니고, 지우면 후에 문제될 수 있으니

잠시 폴더명을 바꿔주는게 최선인것같다.

좀 찝찝하긴 하지만 이것 외에 해결책을 찾지 못했다.

1. PIL (Python Imaging Library) 

[한글위키 : https://ko.wikipedia.org/wiki/Python_Imaging_Library]

    파이썬 1.5~2.7 지원

    우분투에서 지원이 안되고, PIL 대신 후속 버전인 Pillow를 많이 사용함

2. Pillow

[사이트 : https://pillow.readthedocs.io/en/3.1.x/index.html#]

    PIL의 후속 버전으로, 파이썬 3.6까지 지원한다.

    PIL의 기능을 포함하며, improt PIL도 가능.

    설치 : pip install pillow

3. OpenCV 

[영문위키 : https://en.wikipedia.org/wiki/OpenCV]

[사이트 : https://opencv.org/]

    인텔이 개발한, 영상 처리 라이브러리. 크기가 크며 다양한 기능을 제공

    설치 시, conda/pip install로 설치할 수 있지만, ffmpeg 기능을 지원하지 않아, 동영상 처리가 안된다.

    cv와 cv2로 나누어지는데, cv 옛날 버전이고 더이상의 업데이트가 없다.

    cv2는 최신 버전이고, cv를 포함한다. 또한 데이터들을 numpy로 처리하는 특징이 있다.

    python에서 opencv를 사용한다는건, import cv2로 봐도 무방한 것 같다.

    설치 : 1. 직접 빌드하여 설치 [ffmpeg 기능 추가 가능]

            2. conda install -c menpo opencv [ffmpeg 기능 X]

            3. pip install opencv-python [ffmpeg 기능 X]

4. scikit-image (skimage)

[사이트 : http://scikit-image.org/]

    numpy와 scipy를 사용하는 영상 처리 라이브러리. (두 라이브러리 설치가 필요함)

    scikits.image에서 시작해서, 지금은 독립적으로 개발된다고 한다.

    설치 : pip install scikit-image

5. scikit-video (skvideo)

[사이트 : http://www.scikit-video.org/stable/io.html]

    4번과 동일한 맥락이지만, 동영상을 다룬다는 점이 다르다.

    opencv로 동영상을 처리하기가 좀 까다로운데, 이 라이브러리를 사용하면 쉽게 처리할 수 있다.

    FFmpeg 또는 LibAV를 기반으로 동영상을 처리한다. 따라서 ffmpeg 설치가 필요함

    설치 : sudo apt-get install libav-tools

            pip install scipy skvideo or scikit-video or sk-video

pytorch 또한 tensorflow와 같이 텐서의 연산으로 이루어짐

둘 다 numpy 행렬을 주로 사용함

tensorflow는 연산 전에 미리 노드 그래프를 만듦

pytorch는 동적으로 그래프를 만듦

이러한 차이로, pytorch는 print 문을 이용하여 tensor들의 값을 출력할 수 있음 (tensorflow에서 eval 함수와 비슷)

pytorch에는 일반 Tensor (e.g. torch.cuda.FloatTensor)와 Variable (e.g. torch.autograd.variable.Variable)이 있는데,

Tensor에 유틸기능을 씌운 것을 Variable로 볼 수 있음. (기울기 계산 등의 연산을 쉽게 수행)

기본적으로 Tensor와 Variable끼리의 연산은 불가하다.

Variable(Tensor)로 Variable을 만들 수 있고,

반대로 Variable.data로 Tensor를 꺼낼 수 있음

서로 다른 클래스(타입)의 텐서 끼리는 연산할 수 없음 (DoubleTensor * FloatTensor = 에러, 형변환 필요)

Tensor * Tensor 등의 사칙연산은 Tensor.mul(Tensor) 등으로 자동 치환됨

torch.from_numpy() : numpy -> Tensor (numpy가 float이나, double일 때 DoubleTensor가 되고, int일 때 LongTensor가 된다.)

Tensor.float() : FloatTensor로 캐스팅

Tensor.size() : 텐서의 shape을 출력. (tensorflow에서 tf.shape() or get_shape())

F.cross_entropy() : 자체적으로 softmax를 포함한다.

Tensor.cuda() : GPU로 데이터를 올림 (cuda에 올라간 데이터는 gpu연산을 수행)

Tensor.cpu() : CPU로 데이터를 올림

---

dataloader 정의 시

pin_memory는 메모리 사용량과 관계없음

test 시 입력 Variable에 volatile=True 인자를 추가해줘야함. (추가 안하면 메모리가 폭발함. 안쓴거랑 3000메가 정도 차이나는 경우도 봤음)

cd '해당 파일의 폴더'

chmod 777 '파일명' # 권한부여

./'파일명' # 실행

가상환경에서 특정 버전의 CUDA를 사용하고자 하면,

conda install을 활용할 수 있다.

아나콘다를 우선 설치하고,

conda install -c anaconda cudatoolkit==[version]

ex) conda install -c anaconda cudatoolkit==8.0

CUDA에 이어, cudnn이 거의 필수적으로 사용되는데, 이 역시 같은 방법으로 설치 가능

conda install -c anaconda cudnn==[version]

ex) conda install -c anaconda cudnn==5.1

각 프로젝트 환경마다 cuda와 cudnn의 요구 버전이 다른데,

이에 따라 가상환경을 만들고, 위 방법으로 설치하면 매우 편리하게 버전을 관리할 수 있다.

기존엔 global하게 특정 버전만 설치하고, 프로젝트를 바꿀 때마다 버전을 바꿔야했다.

근데 이 방법을 쓰면 매우매우 편리함. 앞으로 이 방법으로만 설치해야겠다...

global한 CUDA가 설치되어있는 상태에서

가상환경에서 새로운 cuda 설치하면 어떻게 되는지는 실험해봐야 알 듯

문제 시 글 수정