'Programming'에 해당되는 글 147건

conda 를 이용하여 특정 패키지를 설치를 시도하던 중 아래와 같은 에러를 만났다.

```

CondaVrificationError: The package for pytorch located at C:\~~~~~ 

appears to be corrupted. The path "Lib/site-packages/~~~~~.dll"

specified in the package manifest cannot be found.

```

이와 같은 경우 이전에 사용했던 버전 등에서 남은 찌꺼기로 인한 문제로 보여진다.

불필요한 파일을 싹 정리 해주고 다시 설치를 시도하면 정상적으로 설치가 가능하다.

# 불필요한 파일 제거 
>> conda clean --all

OpenCV에서 제공하는 기능 중 FileStorage라는 놈을 이용하여 xml을 읽고 쓰기가 가능하다.

대부분의 기능은 iostream과 유사한 형태로 사용 가능해서 바로 쓸 수 있지만 두가지 기능은 알아야 한다.

1. Sequence Collection ( "[", "]" )

이 놈은 데이터를 리스트 형태로 관리해 주는 놈으로써 [ ] 를 이용하여 출력한다.

2. Mapping Collection ( "{", "}" )

이 놈은 계층을 관리 해 주는 놈으로써 { } 를 이용하여 출력한다. 

이 두 기능도 직관적이라 사용이 어렵진 않다. 

샘플 코드

FileStorage fs("_sample.xml", FileStorage::WRITE);
time_t date;
time(&date);

fs << "Date" << asctime(localtime(&date));
fs << "ID" << "USER ID";
fs << "Originfilelist" << "[";
fs << "F:/test_video/kinect1/originvideo.mkv";
fs << "F:/test_video/kinect2/originvideo.mkv";
fs << "F:/test_video/kinect3/originvideo.mkv";
fs << "]";

fs << "Sample" << "{";
fs << "Sourcefile" << "F:/test_video/kinect1/originvideo.mkv";
fs << "Filename" << "2_1-r.mkv";
fs << "FilePath" << "F:/test_video/parsing/kinect1/2_1-r.mkv";
fs << "OriginTime" << "00:33:39-00:33:46";
fs << "Memo" << " ";
fs << "Function" << "{";
fs << "Name" << "Function1";
fs << "score" << "N" << "}";
fs << "Function" << "{";
fs << "Name" << "Function2";
fs << "score" << "N";
fs << "}";
fs << "}";

xml 결과

<?xml version="1.0"?>
<opencv_storage>
<Date>"Wed Oct  7 10:01:54 2020&#x0a;"</Date>
<ID>"USER ID"</ID>
<Originfilelist>
  F:/test_video/kinect1/originvideo.mkv
  F:/test_video/kinect2/originvideo.mkv
  F:/test_video/kinect3/originvideo.mkv</Originfilelist>
<Sample>
  <Sourcefile>F:/test_video/kinect1/originvideo.mkv</Sourcefile>
  <Filename>"2_1-r.mkv"</Filename>
  <FilePath>F:/test_video/parsing/kinect1/2_1-r.mkv</FilePath>
  <OriginTime>"00:33:39-00:33:46"</OriginTime>
  <Memo>" "</Memo>
  <Function>
    <Name>Function1</Name>
    <score>N</score></Function>
  <Function>
    <Name>Function2</Name>
    <score>N</score></Function></Sample>
</opencv_storage>

(20.11.26. 수정) 위 샘플은 xml 작성규칙에 맞지 않음.

동일 이름의 노드 생성은 규칙에 어긋나기 때문에 위와 같이 생성은 되지만

filestorage를 이용하여 다시 읽을때 문제가 발생한다.

동일이름의 노드 생성은 하지 않도록 하자.

대용량의 데이터베이스를 사용하다보면 가끔 폴더의 이름을 일괄 변경하고 싶은 경우가 있다.

이럴경우 양이 많지 않으면 흔히 사용하는 DarkRenamer 등의 프로그램을 쓸수도 있지만

폴더/파일의 양이 많은 빅데이터를 다룰때는 이러한 프로그램이 감당을 못한다.

그래서 폴더명만 일괄적으로 변경하는 함수를 기록해 두고 필요할때 사용하자..

# -*- coding: utf-8 -*-
import sys
import os
from os import rename, listdir


def rename_folder(sRoot):
    # 현재 위치의 파일 목록
    files = listdir(sRoot)

    # 파일명에 번호 추가하기
    count = 0
    for name in files:

        # 파이썬 실행파일명은 변경하지 않음
        if sys.argv[0].split("\\")[-1] == name:
            continue

        new_name = "{0:05d}".format(count)
        rename(os.path.join(sRoot, name), os.path.join(sRoot, new_name))
        count += 1

파이썬 코드를 보다 낯선 문법을 보고 어떤 의미인지 찾아보다 extended slices 에 대하 찾게 되었다.

https://docs.python.org/release/2.3.5/whatsnew/section-slices.html

여기서 문제가 됐던 문법은 array[::] 에 관한 부분이다. 

array[A:B:C] 라고 사용하면 이는 array중 A에서 B 까지 C 간격으로 배열을 생성한다는 의미이다.

A, B, C가 각각 None이라면

A는 처음부터 (0번 index)

B는 가능한 index까지 

C는 1을 의미한다.

간단한 예시를 보면 아래와 같다.

>> arr = range(10) 
>> arr [0,1,2,3,4,5,6,7,8,9] 
>> arr[::2] # 처음부터 끝까지 두 칸 간격으로 
   # [0,2,4,6,8] 

>> arr[1::2] # index 1 부터 끝까지 두 칸 간격으로 
   # [1,3,5,7,9] 

>> arr[::-1] # 처음부터 끝까지 -1칸 간격으로 ( == 역순으로) 
   # [9,8,7,6,5,4,3,2,1,0] 
   
>> arr[::-2] # 처음부터 끝까지 -2칸 간격으로 ( == 역순, 두 칸 간격으로) 
   # [9,7,5,3,1] 

>> arr[3::-1] # index 3 부터 끝까지 -1칸 간격으로 ( == 역순으로) 
   # [3,2,1,0] 
   
>> arr[1:6:2] # index 1 부터 index 6 까지 두 칸 간격으로 
   # [1,3,5]

이런 단순 배열 뿐만 아니라 Image를 다룰때 간단한 flip을 구현하는데도 사용 가능하다.

# image는 tensor와 같은 순서로 H, W, C 순서라 가정하고..

# h flip
img = img[:, ::-1, :]

# v flip
img = img [::-1, :, :]

anaconda 가상환경을 구축하고 사용 할 경우 특정 코드를 실행시키기 위해서는 몇번의 단계가 있다.

anaconda prompt 실행 - conda env activete - path 이동 - 코드 실행...

자주 사용 할 경우에는 매번 이렇게 반복 작업을 하기 번거로우니 batch 파일로 만들어 두면 편하다.

(왜인지는 모르겠는데 cmd에서는 단순 명령어가 바로 실행 됐는데 아나콘다 환경으로 넘어간 뒤에는 call 명령어로 불러줘야 동작하던데.. )

set root=C:\Miniconda3
call %root%\Scripts\activate.bat %root%

call conda env list
call conda activate [env_name]
call cd [path]
call python [file_name.py]

pause

위와같이 메모장 등에서 코드를 작성하고 저장할때 *.bat 파일로 저장 해 주면 

이후 해당 bat 파일을 더블클릭해서 실행하면 자동으로 환경 연결되고 프로그램 실행까지 가능하다.

std::string을 사용하다보면 sprintf나 CString 등과 같이 format 기능을 이용하여 문자열을 만들고싶을떄가 있다.

이런 상황을 위한 방법을 정리.

아래와 같이 정의된 string_format 함수를 이용하여 format 과 동일하게 사용 가능하다. 

template<typename ... Args>
std::string string_format(const std::string& format, Args ... args)
{
	size_t size = snprintf(nullptr, 0, format.c_str(), args ...) + 1; // Extra space for '\0'
	if (size <= 0) { throw std::runtime_error("Error during formatting."); }
	std::unique_ptr<char[]> buf(new char[size]);
	snprintf(buf.get(), size, format.c_str(), args ...);
	return std::string(buf.get(), buf.get() + size - 1); // We don't want the '\0' inside
}


// 사용법
std::string sResult = "";
std::string stringValue = "string...";
int intValue = 999;
sResult = string_format("string format example : %s / %d", stringValue, intValue);

C++ 에서 포인터에 고통받다 python을 쓰기 시작하면서 한동안 asterisk는 곱셈, 제곱승 등의 연산에서만 봤다

그러나 이런저런 코드를 보다보니 c++에서 많이 보던 형태로 사용되는 것을 보고 어떤 역할인지 궁금해서 

찾아보고 나중을 위해 정리 해 둔다.

맨 아래에 내가 이해하기 위해 참고한, 보다 자세한 예제가 있는 원본 주소를 추가.

Python 에서 Asterisk 의 사용처

1. 곱셈, 제곱승 

2. 리스트 확장

3. 가변인자

4. unpacking

1, 2 번은 자주 쓰고 다 아니까 넘어가고..

3. 가변인자

함수의 파라미터로 값을 넘길때 파라미터의 개수가 결정되지 않은 경우 가변인자의 형태로 사용가능

키워드 없이 위치로 결정되는 positional arguments는 * 로 (일반적으로는 *args)

키워드를 갖는 keyword arguments는 **로 사용한다. (일반적으로는 **kwargs)

두가지를 결합해서 사용 할 경우에는 일반 파라미터 규칙과 동일하게 * 를 **보다 앞서서 사용해야 한다.

이러한 형태로 전달하는 과정을 packing 이라 하고 각각 tuple과 dict에 저장된다.

def print_data(*args, **kwargs):
	print(args)
    print(kwargs)
    
print_data("data1", "data2", "data3", kwdata1="data4", kwdata2="data5")
# ("data1", "data2", "data3")
# {"kwdata1": "data4", "kwdata2": "data5"}

4. unpacking

이는 3번의 packing개념의 반대로 tuple 이나 dict 데이터를 각각의 데이터를 풀어내는 것이다.

def mult(a, b):
	return a*b
    
mult(2, 2)
# 4

c = {"a": 2, "b": 2}
mult(c["a"], c["b"])
# 4

mult(c)
# error!!

mult(**c)
# 4

참고 : https://mingrammer.com/understanding-the-asterisk-of-python/#3-%EA%B0%80%EB%B3%80%EC%9D%B8%EC%9E%90-variadic-parameters-%EB%A5%BC-%EC%82%AC%EC%9A%A9%ED%95%98%EA%B3%A0%EC%9E%90-%ED%95%A0-%EB%95%8C

프로그램을 구현하다 보면 특정 기능이 어느정도 시간을 소요하는지 확인이 필요한 경우가 있다.

이럴때 보통 아래와 같이 시간 측정을 위한 code 앞뒤에서 time 라이브러리를 이용하여 시간을 계산했다.

import time

start_time = time.time()

# 실행시간을 측정 할 code
# ~~~~~~~~~~~~~~~~~~~~~

print("Processing time : %.2f ms" % ((time.time() - start_time)*1000))

하지만 이런 방법은 한두군데 확인 하거나 잠깐 확인 할 때는 괜찮지만 

작성하는 부분이 많아질수록 가독성도 떨어지고 관리가 불편하다는 단점이 있다.

그래서 사용 가능한 기능이 파이썬의 데코레이터 라는 기능!

함수 이전에 선언이 필요하고 선언 후에는 실행 할 함수 앞에 @ 키워드와 함께 호출해주면

해당 함수를 wrapping 해줘서 decorator에 정의된 기능을 함께 수행 하게 된다.

import time

# decorator는 다른 함수보다 앞서 선언되어야 한다!
def processing_time(func):
    def wrapper_fn(*args, **kwargs):
    	start_time = time.time()
        func_result = func(*args, **kwargs)
        print("Processing time : %.2f ms" % ((time.time()-start_time)*1000))
        return func_result
    return wrapper_fn

@ precessing_time
def function_01():
    # 실행시간을 측정하고 싶은 함수 선언
    # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    print("function_01")

def function_02():
    # decorator 사용 안할 함수는 일반적으로 그대로 사용하면 된다.
    print("function_02")

if __name__ == "__main__":
    function_01()
    function_02()

이러한 기능을 이용하여 나는 deeplearning model의 inference time을 측정하는 함수를 만들어 사용 중이다.

import time

# decorator는 다른 함수보다 앞서 선언되어야 한다!
def processing_time(func):
    def wrapper_fn(*args, **kwargs):
    	start_time = time.time()
        func_result = func(*args, **kwargs)
        print("Processing time : %.2f ms" % ((time.time()-start_time)*1000))
        return func_result
    return wrapper_fn

@ processing_time
def get_forward(model, data):
    return model(data)


if __name__ == "__main__":
    # model & data 선언
    get_forward(model, data)

참고자료 : http://schoolofweb.net/blog/posts/%ED%8C%8C%EC%9D%B4%EC%8D%AC-%EB%8D%B0%EC%BD%94%EB%A0%88%EC%9D%B4%ED%84%B0-decorator/

python 개발을 하면 가상환경의 필요성이 크다.

나는 보통은 anaconda를 이용해 conda 환경을 주로 사용하였는데 anaconda를 사용하지 못하는 환경에서는

virtualenv 패키지를 이용하여 가상환경을 설정해야 하네.. 

일단 사용방법 정리

Virtualenv 설치

• 가상환경 생성을 위해 virtualenv는 시스템에 설치 필요

sudo pip install virtualenv virtualenvwrapper

가상환경 생성 및 활성화

• 환경 생성 후 활성화는 source 를 통해 가능

# python 버전 지정을 위해서는 -p 파라미터 사용 
virtualenv -p python3 [env_name] 

# 가상환경 활성화 
source [env_path]/bin/activate

VirtualenvWrapper 설정

• 일반적으로 virtualenv에 진입하기 위해서는 설정한 위치로 이동 후
  [env_name]/bin/activate를 이용하여 활성화 필요.
  모든 가상환경 경로를 기억 및 해당 경로에서 실행필요

• wrapper를 이용하면 현재 경로와 관계없이 활성화 가능하게 해줌

# .bashrc / .profile 같은 스크립트에 아래 코드 추가 
#----------- 스크립트에 추가 하기 ------------------------------------- 
# virtualenv 기본 경로 및 기본 파이썬 선언 
export WORKON_HOME=~/.virtualenvs 
export VIRTUALENVWRAPPER_PYTHON="$(which python3)" # Usage of python3 
source /usr/local/bin/virtualenvwrapper.sh 
#----------- 스크립트에 추가 하기 ------------------------------------- 
# 스크립트 활성화 
source ~/.profile # or source ~/.bashrc

VirtualenvWrapper 명령어

• wrapper를 사용하면 현재 위치 관계없이 전역에서 사용 가능.

# 가상환경 생성 
mkvirtualenv [env_name] 

# 가상환경 제거 
rmvirtualenv [env_name] 

# 가상환경 목록 보기 
workon 

# 가상환경 활성화 
workon [env_name] 

# 가상환경 비활성화 (환경 활성화 중에) 
deactivate

# 프로젝트 디렉토리 맵핑
setvirtualenvproject

# 프로젝트 디렉토리 맵핑이 된 경우
# 아래 커맨드로 바로 프로젝트 디렉토리로 이동 가능
cdproject

python을 사용하다 보면 다양한 설정값을 사용하는 경우가 있다.

이럴 때마다 매번 값을 코드에 써주자니 귀찮고.. 설정 값 저장 해두고 불러쓰면 좋잖아??

그래서 사용 할 모듈이 python 내장 모듈 중 하나인 configparser!!

언제나 그렇듯 다음번 사용을 위해 방법 정리.

# -*- coding:utf-8 -*-
import configparser

# configParser 생성
conf = configparser.ConfigParser()

# 기존 config 파일이 있을 경우
conf.read("./config.ini")
# config 파일은 아래와 같은 형태로 저장 됨.
# [section1]
# sec1_option1 = option1
# sec1_option2 = option2
#
# [section2]
# sec2_option1 = option1
# sec2_option2 = option2


##### parser read #####
# section list 읽기
section_list = conf.sections()

# section 내 option list 읽기
option_list = conf.options("section_name")

# 특정 section 존재 확인
conf.has_section("section_name")

# section 내 option 과 값 list 읽기
opt_val_list = conf.items("section_name")

# 직접 section / variable 값 읽기
train_path = conf["section_name"]["option_name"]
# 또는
train_path = conf.get("section_name", "option_name")
# 자료형에 따라 getint, getfloat, getboolean 사용하면 읽기와 형변환 같이 함


##### parser write #####
# section 생성
conf.add_section("new_section_name")

# section 삭제
conf.remove_section("remove_section_name")

# option 추가
conf.set("section_name", "option_name", value)

# option 삭제
conf.remove_option("section_name", "option_name")

# parser에 내용을 추가 해 중 뒤에는 반드시 write 해줘야 함
with open(conf_file_path, "w") as fp:
    conf.write(fp)

뭔가 연속적인 작업을 수행할때 진행률을 알고 싶은 경우가 있다.

보통은 상태로그를 만들어서 출력하는 방식으로 확인을 했었다. 

근데 이제 조금 더 깔끔하게 상태진행률을 알고싶단말이지..

그럴 떄는 tqdm 라이브러리를 사용하여 처리가 가능하다

사용법은 매우 간단하다.

1. tqdm 설치하기

# conda
conda install tqdm

# pip
pip install tqdm

2. tqdm import 하기

from tqdm import tqdm

3. tqdm 사용하기

기존의 for 문에서 range 위치에 tqdm 으로 감싸주기만 하면 끝.

# tqdm 적용 전
for ii in range(100):
	print(ii)
    time.sleep

# tqdm 적용
for ii in tqdm(range(100)):
	# print 문이 for문 안에 있으면 상태바가 새로 출력됨.
    # print(ii)
	# sleep 없으면 너무 빨리 지나가서 상태 확인용
    time.sleep(0.1)

4. tqdm 에 옵션 설정하기 (Optional)

# desc 에 진행 작업에 대한 설명을 추가 가능
# mininterval에 최소 업데이트 주기를 설정 가능
for ii in tqdm(range(100), desc="tqdm example", mininterval=0.01):
    # print(ii)
    time.sleep(0.1)

이와같이 적용하면 여러줄 출력 안하고 한줄 내에서 상태 갱신되면서 작업 진행률이 표시 된다.

tqdm example:  14%|█▍        | 14/100 [00:01<00:08,  9.95it/s]

tqdm example:  49%|████▉     | 49/100 [00:04<00:05,  9.95it/s]

tqdm example:  92%|█████████▏| 92/100 [00:09<00:00,  9.96it/s]

tqdm example: 100%|██████████| 100/100 [00:10<00:00,  9.95it/s]

보다 자세한 사용법 등을 알고 싶으면 github에서 확인 가능하다

https://github.com/tqdm/tqdm

기존 환경에 설치된 라이브러리들을 동일하게 사용할건데 개발 환경은 분리하고 싶을 경우 다시 설치하려면 시간만 엄청 오래걸리지..

이럴 경우 기존 환경을 복사하여 새로운 환경을 만드는 방법.

가상환경 복제하여 새로 생성

$ conda create -n [env-name] --clone [src-env-name]

pip를 사용하다 간혹 아래와 같은 에러를 만나는 경우가 있다.

ImportError: cannot import name 'main'

이는 pip 업데이트 과정 중에서 뭔가 경로가 꼬여서 발생하는것 같은데 정확한 원인은 모르겠다..

어쩄든 pip가 업데이트 되다 문제가 되었으니 pip를 다시 설정 해주면 해결 가능.

# python 2
sudo python -m pip uninstall pip && sudo apt-get install python-pip --reinstall

# python3
sudo python3 -m pip uninstall pip && sudo apt-get install python3-pip --reinstall

docker를 이용한 image를 배포하는 방법은 크게 두가지가 있다.

하나는 dockerhub를 이용하는 방법, 다른하나는 파일로 추출하여 이미지화 하는 방법.

그 방법에 대한 정리.

Docker hub를 이용한 배포

1. docker image commit image commit은 아래와 같은 형태로 수행한다 만약 컨테이너가 실행중이라면 -p 옵션으로 일시정지가 가능하다.

   # docker ps
   CONTAINER ID    IMAGE       ~~~    NAMES
   55a70bce5cda     nvidia/cuda:~~~    amazing_hawking
   # docker commit [container_name] [image_name]
   $ docker commit 55a70bce5cda container1

2. docker image push dockerhub에 로그인 후 태그를 달아서 push 하면 서버에 업로드 된다

   # docker login
   $ docker login
   
   # set user environment variable
   $ export DOCKER_USER_ID="user_ID"
   
   # set docker iamge tag (optional)
   # docker tag [image_name:tag]
   $ docker tag container1 $DOCKER_USER_ID:cuda8_cudnn5_for_push
   
   # push
   $ docker push $DOCKER_USER_ID:cuda8_cudnn5_for_push
   # or
   $ docker push container1

파일로 추출하여 배포

도커를 파일로 추출하는데는 save-load 와 export-import 두가지 방법이 존재한다. 추정키로는 save는 image만을, export는 image+container까지 저장하는것 같다.. (확인 후 수정)

1. docker save (image→tar) 파일명 지정을 위해 -o 옵션을 이용한다.

   # docker save [option] [save_name] [image_name]
   $ docker save -o docker_image.tar container1

2. docker load (tar→image)

   $ docker load -i docker_image.tar

3. docker export (image+container → tar)

   # docker export [container name or ID] [save_name]
   $ docker export container1 docker_container.tar

4. docker import (tar → image+container)

   $ docker import docker_container.tar

python에서 opencv를 사용하면서 한글(유니코드)로 인한 문제가 발생 할 경우가 있다.

python의 opencv에서는 유니코드를 처리하지 못하기 때문에 발생하는 문제라고 한다.

이러한 경우 아래와 같이 imencode 함수를 이용하여 우회하는 방식으로 해결 가능하다.

<imread>

import numpy as np
import cv2
def imread(filename, flags=cv2.IMREAD_COLOR, dtype=np.uint8):
    try:
        n = np.fromfile(filename, dtype)
        img = cv2.imdecode(n, flags)
        return img
    except Exception as e:
        print(e)
        return None

<imwrite>

import numpy as np
import cv2
import os
def imwrite(filename, img, params=None):
    try:
        ext = os.path.splitext(filename)[1]
        result, n = cv2.imencode(ext, img, params)

        if result:
            with open(filename, mode='w+b') as f:
                n.tofile(f)
            return True
        else:
            return False
    except Exception as e:
        print(e)
        return False

모든 경우에 해당하는지는 확인하지 못함.

내 경우는 파이썬 2.X 버전에서 pickle을 dump 하고 3.X 버전에서 load 한 경우 아래와 같은 에러가 발생

>> UnicodeDecodeError: 'ascii' codec can't decode byte 0xe2 in position 1: ordinal not in range(128)

근본적인 이유를 찾아보니 python2 버전과 3버전에서는 문자열을 다루는 방식이 다르다.

Python2 vs Python3 : string handling

• python2 : this string literal is called a "str" object but its stored as bytes. If you prefix it with "u" you get a "unicode" object which is stored as Unicode code points.
• python3 : this string literal is a "str" object that stores Unicode code points by default. You can prefix it with "b" to get a bytes object or use .encode.

즉, 2버전에서는 byte, 3버전에서는 unicode를 기본 데이터 타입으로 사용한다.

그렇다면 읽을때 바이트 타입으로 읽어주면 되겠지..

with open(filePath, 'rb') as f: 
	data = pickle.load(f, encoding='byte')

혹 pickle에 데이터를 딕셔너리로 저장 했을경우 읽을때 key 값 앞에도 'b'를 붙여줘서 byte로 읽자

sID 	 = data[b"userID"] 
sAddress = data[b"userAddress"] 
...

위 방법이 안통해서 찾은 다른방법 (20.02.11. 추가)

with open(picklePath,'rb') as file: # Binary read
    u = pickle._Unpickler(file)
    u.encoding = 'latin1'
    p = u.load()

개발환경을 구축하고 사용하다 보면 버전이 꼬이고.. 의존성 문제가 발생하고..
필요한게 설치가 안되고.. 동작 하던게 동작을 안하고... 하하.. 스트레스..

docker를 활용하여 환경을 구축하면 많은 문제를 해결 할 수 있을것 같아서 공부하면서 사용 해 보기 시작
개념은 공부하면서 천천히 다시 쌓아야지..

기본 Docker 설치

1. 오래된 버전의 도커 삭제

    $ sudo apt-get remove docker docker-engine docker.io

2. 필요 패키지 설치

    $ sudo apt-get update && sudo apt-get install -y \
        apt-transport-https \
        ca-certificates \
        curl \
        software-properties-common

3. 패키지 저장소 추가

    $ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -
    $ sudo add-apt-repository \
       "deb [arch=amd64] https://download.docker.com/linux/ubuntu \
       $(lsb_release -cs) \
       stable"
   
    $ sudo apt-get update && sudo apt-cache search docker-ce
    >> docker-ce - Docker: the open-source application container engine

4. docker-ce 설치

    $ sudo apt-get update && sudo apt-get install -y docker-ce
    $ sudo usermod -aG docker $USER # 권한설정

Nvidia-docker 설치

Nvidia GPU 사용할거면 이 방법을 이용하는것이 편리하다

이 단계를 진행하기 전에 NVIDIA 드라이버가 설치되어 있어야 한다.

1. 저장소 추가

    $ curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey | \
      sudo apt-key add -
   
    $ distribution=$(. /etc/os-release;echo $ID$VERSION_ID)
    $ curl -s -L https://nvidia.github.io/nvidia-docker/$distribution/nvidia-docker.list | \
      sudo tee /etc/apt/sources.list.d/nvidia-docker.list
   
    $ sudo apt-get update

2. nvidia-docker 설치

    $ sudo apt-get install -y nvidia-docker2
    $ sudo reboot

nvidia-docker를 설치 한 후에는 재부팅을 하거나 아래 명령어로 도커대몬을 재실행 해 준다

$ sudo systemctl daemon-reload
$ sudo systemctl restart docker

Nvidia-docker 찾기

• docker hub link : https://hub.docker.com/r/nvidia/cuda/tags/

• 접근은 nvidia/cuda:8.0-cudnn5-devel-ubuntu16.04 와 같은 형태로 한다.

• 다운로드는 다음과 같이 가능하다

    $ docker pull nvidia/cuda:8.0-cudnn5-devel-ubuntu16.04

Docker 옵션

• 컨테이너 생성 예제

    $ docker run --runtime=nvidia -it -v /data:/data nvidia/cuda:8.0-cudnn5-devel-ubuntu16.04 /bin/bash

• run :

• ps : 동작중인 컨테이너 확인 / -a 파라미터 추가하면 정지된 컨테이너도 확인 가능

• rm : 컨테이너 지우기

• rmi : 이미지 지우기

• -it : 키보드와 마우스를 사용 가능하도록 한다.

• -d :

• exec : 시작 된 컨테이너 내부로 진입

    $ docker exec -it [CANTAINER NAME] /bin/bash

GUI를 사용하는 컨테이너 생성

• 기본 생성 방법에서 공유폴더 및 설정 몇가지를 추가로 포함 해 준다.

    $ docker run --runtime=nvidia -it -v /run/user/1000:/run/user/1000 -v /dev:/dev -v /tmp/.X11-unix:/tmp/.X11-unix:ro --privileged --ipc=host --shm-size=256m --net=host -e DISPLAY=$DISPLAY -e XDG_RUNTIME_DIR=/run/user/1000 -v /home/user/docker_share/ubuntu-openpose:/home/user/docker_share/ubuntu-openpose nvidia/cuda:8.0-cudnn5-devel-ubuntu16.04 /bin/bash

• 호스트 환경에서 아래 명령어를 실행

    $ xhost +local:docker

Docker 컨테이너 환경설정

• 기본 언어 및 로케일 등 설정을 위해 컨테이너 안에서 실행

    $ apt update
    $ apt install -y dialog language-pack-en
  
    $ export LANGUAGE=en_US
    $ export LANG=en_US.UTF-8
    $ export LC_ALL=en_US.UTF-8
  
    $ update-locale

• 기본 개발을 위한 라이브러리 등 설치

    $ apt install -y sudo wget git vim cmake cmake-qt-gui python-dev python-pip python-numpy
    $ pip install --upgrade pip
  
    $ apt install -y libprotobuf-dev libleveldb-dev libsnappy-dev libopencv-dev libhdf5-serial-dev protobuf-compiler libboost-all-dev libgoogle-glog-dev liblmdb-dev libopenblas-dev libatlas-base-dev

문제 해결

• docker-ce 가 설치되지 않을 경우

    $ sudo add-apt-repository ppa:ubuntu-sdk-team/ppa
    $ sudo apt-get update
    $ sudo apt-get install docker-ce # 이제 설치 가능 (의존성 문제 해결)

• docker에 root로 진입 할 경우 환경변수 설정은?

  • user로 진입하면 /home/user/.bashrc 에서 보통 작업하지만 root로 진입 할 경우에는
    /etc/bash.bashrc 에 선언하면 된다.
  • 또는 /root/.bashrc 에 사용 가능. (여기가 조금 더 직관적이군.)

• "Could not connect to display" 문제 해결

    sudo docker run --rm -it -v /run/user/1000:/run/user/1000 -v /dev:/dev -v /tmp/.X11-unix:/tmp/.X11-unix:ro --privileged --ipc=host --shm-size=256m --net=host -e DISPLAY=$DISPLAY -e XDG_RUNTIME_DIR=/run/user/1000 /bin/bash

c 에서는 임의의 길이의 배열을 생성할때 그 길이를 넣어줘서 생성했었다.

파이썬에서는 사용법이 약간 다르니 메모메모.

1. 0으로 초기화 된 배열 생성

    $ nList = [0 for _ in range(길이)]

2. random 값으로 초기화 된 배열 생성

1번과 동일한 방식이지만 초기화 값을 random 함수를 사용한다는 점만 다르다.

    $ import random

    $ fList = [random.random() for _ in range(길이)]

list에서 최대값과 최대값의 index를 찾는 방법을 정리.

리스트 내에서 최대값을 찾는 방법은 max를 이용한다

    $ nList = [3, 5, 1, 2, 7, 8, 5]

    $ max(nList)

    > 8

리스트 내에서 최대값의 index를 찾는 방법은 list.index를 이용한다

    $ nList.index(max(nList))

    > 5

최소값을 찾을때도 마찬가지 방법으로 min을 이용하여 찾을 수 있다.

numpy를 사용하다 보면 array의 값을 파일로 저장해야 할 경우가 생긴다.

이럴경우 따로 파일 IO를 사용하기보다 numpy의 기본 기능을 이용하면 간단하게 저장하고 읽을 수 있다.

저장 할 경우 array의 차원 등의 정보도 같이 저장되기 때문에 별다른 추가 처리를 할 필요가 없다.

(이하 import numpy as np 는 기본으로 포함)

1. *npy 파일로 저장하기

    npy 파일 포멧은 하나의 numpy array를 저장하기 위한 포멧이다.

    $ x = np.array([0, 1, 2, 3, 4, 5])

    $ np.save("./save/data.npy", x)

2. *.npz 파일로 저장하기 

    npz 파일 포멧은 여러개의 리스트를 한번에 저장하기 위한 포멧이다.

    이 경우는 압축 여부에 따라 두 가지 함수가 사용된다.

    $ y = np.array([0, 1, 2])

    $ z = np.array([3, 4, 5])

    # 압축하지 않고 저장하기

    $ np.savez("./save/without_compression_data.npz", y=y, z=z)

    # 압축하고 저장하기

    $ np.save_compressed("./save/compression_data.npz", y=y, z=z)

3. 텍스트 파일로 저장하기

    array 값을 바로 확인 가능한 텍스트 파일로 저장하기 위함이다.

    텍스트 파일로 저장 할 경우 파일의 시작과 끝에 header, footer 옵션으로 주석을 달 수 있으며

    array의 값을 표현할 포멧팅도 지정 가능하다

    $ x = np.array([0, 1, 2, 3, 4, 5])

    $ np.savetxt("./save/data.txt", x, header="write start", footer="write end", fmt=".1f")

4. 저장 된 np array 불러오기

    텍스트 데이터를 제외한 나머지 경우는 np.load를 이용하여 읽을 수 있고 텍스트 데이터는 np.loadtxt를 사용한다.

    $ x = np.load("./save/data.npy")

    # 여러 array가 있는 경우 저장한 이름을 index로 사용

    $ saved_npz = np.load("./save/without_compression_data.npz")

    $ saved_npz = np.load("./save/compression_data.npz")

    $ y = saved_npz ['y']

    $ z = saved_npz ['z']

    $ x = loadtxt('"./save/data.txt")

5. load 한 np array 파일 닫기

    load 한 array 데이터는 사용이 끝나면 close()를 이용하여 파일을 닫아 준다

    또는 with 문을 이용하는 것도 방법.

    $ saved_npz.close()