DARAM BLOG

에러 : botocore.exceptions.ProfileNotFound: The config profile (프로필이름) could not be found

해결법 : https://intellipaat.com/community/2778/aws-the-config-profile-myname-could-not-be-found

aws configure --profile "프로필이름"

이렇게 지정해주기

에러 : botocore.exceptions.ClientError: An error occurred (UnrecognizedClientException) when calling the ListAccounts operation: The security token included in the request is invalid.

-> 위에서 입력한 aws_access_key_id / aws_secret_access_key 이 잘못 입력됬다는 뜻. 제대로 된 값으로 다시 설정해준다

Anomaly detection 종류

1. Supervised Anomaly Detection  : 트레이닝 데이터에 비정상,정상 Label이 모두 적절히존재했을 때
2. Semi-supervised Anomaly Detection : 정상 데이터만을 가지고 학습한 경우 (비정상 라벨이 심각하게 적은경우)
3. Unsupervised Anomaly Detection : 트레이닝 데이터에 정상, 비정상 Labeling이 안 된 경우

X_train = x_m
y_train = y_m  # 라벨
X_test = x_f
y_test = y_f # 라벨
X_val = x_w
Y_val = y_w # 라벨

gmm_clf = GaussianMixture(covariance_type='full', n_components=3 ,max_iter=int(1e5))  # Obtained via grid search
# covariance_type : full  tied  diag  spherical
gmm_clf.fit(X_train)
log_probs_val = gmm_clf.score_samples(X_val)
isotonic_regressor = IsotonicRegression(out_of_bounds='clip')
isotonic_regressor.fit(log_probs_val, Y_val)  

log_probs_test = gmm_clf.score_samples(X_test)
test_probabilities = isotonic_regressor.predict(log_probs_test)
test_predictions = [1 if prob >= 0.5 else 0 for prob in test_probabilities]

cm = confusion_matrix(y_test,test_predictions )
print(cm)
print(accuracy_score(y_test,test_predictions))
sns.heatmap(cm,annot=True,fmt='g')

covariance_type 매개변수에 다음 값 중 하나를 설정  

1. "spherical”: 모든 클러스터가 원형이지만 지름은 다를 수 있음(분산이 다름) 
2. "diag”: 클러스터는 크기에 상관없이 어떤 타원형도 가능하지만 타원의 축은 좌표 축과 나란핬야 함(공분산 행렧이 대각 행렧이어야 함)  
3. "tied”: 모듞 클러스터가 동일한 타원 모양, 크기, 방향을 가짐(모든 클러스터는 동일핚 공분산 행렧을 공유)  
4. “full” : covariance_type 매개변수의 기본값은 "full＂ 인데 각 클러스터는 모양, 크기, 방향에 제약이 없음(각자 제약이 없는 공분산 행렧을 가짐)

# 시작할때 세팅
import turtle as t
t.shape("turtle")

#거북이없이 그냥열기
s = t.Screen() #스크린객체 생성(스크린열기)

t.color("yellow","blue") # 선은 노랑, 거북이는 파랑
t.color("white") # 선색상이 하얀색
t.bgcolor("black") # 배경색 검정
t.pensize(5) # 펜두께
t.fd(100) # 100 만큼 앞으로이동
t.lt(120) # 120도 왼쪽으로 회전함
t.speed(0) # 1가장느림,10빠르게,0가장빠르게

home = t.textinput("집주소","집주소는?:")
t.write("안녕하세요?"+home+"에 사시는군요")
for i in range(5):  # 별그림
	t.left(144)
	t.fd(200)
    
t.fillcolor("white") #색상채우기
t.begin_fill() #색상채우기 시작
t.end_fill() #색상채우기 종료
t.ht() # 거북이 숨기기

image1 = "a.gif"
image2 = "b.gif"
s.addshape(image1) 
s.addshape(image2)
image_choice =  0
if vacation_spot == 0 :
	t.shape(image1)
else :
	t.shape(image2)

AWS 에서는 SSH 에러난적이 손에 꼽는데

IBM CLOUD 를 사용하면 SSH 에러가 다양한원인으로 자주 발생한다...

timout 문제는 인스턴스가 프로비저닝중인지 실행중인지 다시 확인해보고, 실행중인데 안되면 아래처럼 하면된다.

시스템환경설정 -> 공유 -> 원격로그인 체크 -> 모든사용자체크 

IBM CLOUD 로그인하기

chmod 400 ibm.pem

ssh root@75.126.299.28 -i ibm.pem
uUy2sCK6u (비밀번호)

python 3.7 세팅

sudo apt update
sudo apt install python3.7 # 설치하려는 버전 

update-alternatives --config python3
(에러나오면)
which python3.7  #위치 다시한번 확인

sudo update-alternatives --install /usr/bin/python python /usr/bin/python3.7 1
-> python을 치면 3.7 을 기본으로 하라는 뜻
sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.7 1
=> python3을 치면 3.7 을 기본으로 하라는 뜻

CUDA 11.4 설치 ( nvidia driver 도 같이 깔린다 )]

• https://developer.nvidia.com/cuda-toolkit-archive (cuda 버전별로 확인가능)
• https://developer.nvidia.com/cuda-11-4-1-download-archive?target_os=Linux&target_arch=x86_64&Distribution=Ubuntu&target_version=18.04&target_type=deb_local
• 다설치하고 nvidia-smi 정상, nvcc -V 작동안됨

sudo apt-get update # 에러나면 아래두줄 실행
sudo apt-get remove  python3-apt
sudo apt-get install python3-apt

sudo apt-get install python3-pip   # pip3 이 없어서 설치해줘야한다.

wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/cuda-ubuntu1804.pin
sudo mv cuda-ubuntu1804.pin /etc/apt/preferences.d/cuda-repository-pin-600
wget https://developer.download.nvidia.com/compute/cuda/11.4.1/local_installers/cuda-repo-ubuntu1804-11-4-local_11.4.1-470.57.02-1_amd64.deb
sudo dpkg -i cuda-repo-ubuntu1804-11-4-local_11.4.1-470.57.02-1_amd64.deb
sudo apt-key add /var/cuda-repo-ubuntu1804-11-4-local/7fa2af80.pub
sudo apt-get update
sudo apt-get -y install cuda
# 마지막줄 오래걸림

nvcc -V 작동을 위한 환경설정

export CUDA_HOME=/usr/local/cuda
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda/lib64:/usr/local/cuda/extras/CUPTI/lib64
export PATH=$PATH:$CUDA_HOME/bin

cuDNN 설치 ( Tensorflow 에서 GPU를 사용하기위해 깔아주어야함) - 순서대로 깔아야함

wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/libcudnn8_8.2.4.15-1+cuda11.4_amd64.deb
sudo dpkg -i libcudnn8_8.2.4.15-1+cuda11.4_amd64.deb
wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/libcudnn8-dev_8.2.4.15-1+cuda11.4_amd64.deb
sudo dpkg -i libcudnn8-dev_8.2.4.15-1+cuda11.4_amd64.deb

tensorflow 2.7.0 설치

pip3 install --upgrade setuptools
sudo -H pip3 install --upgrade pip
pip3 install tensorflow==2.7.0

tensorflow 에서 gpu 인식가능한지 확인 /  True 라고 나오면 정상설치완

python3.7
import tensorflow
tensorflow.test.is_gpu_available()

< 올인원 버전 >

cuda_setting.sh 생성하고 sudo bash cuda_setting.sh 실행

sudo apt update
sudo apt install python3.7 # 설치하려는 버전 
sudo update-alternatives --install /usr/bin/python python /usr/bin/python3.7 1
sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.7 1
sudo apt-get remove  python3-apt
sudo apt-get install python3-apt
sudo apt-get update 
sudo apt-get install python3-pip   # pip3 이 없어서 설치해줘야한다.
wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/cuda-ubuntu1804.pin
sudo mv cuda-ubuntu1804.pin /etc/apt/preferences.d/cuda-repository-pin-600
wget https://developer.download.nvidia.com/compute/cuda/11.4.1/local_installers/cuda-repo-ubuntu1804-11-4-local_11.4.1-470.57.02-1_amd64.deb
sudo dpkg -i cuda-repo-ubuntu1804-11-4-local_11.4.1-470.57.02-1_amd64.deb
sudo apt-key add /var/cuda-repo-ubuntu1804-11-4-local/7fa2af80.pub
sudo apt-get update
sudo apt-get -y install cuda

export CUDA_HOME=/usr/local/cuda
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda/lib64:/usr/local/cuda/extras/CUPTI/lib64
export PATH=$PATH:$CUDA_HOME/bin

wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/libcudnn8_8.2.4.15-1+cuda11.4_amd64.deb
sudo dpkg -i libcudnn8_8.2.4.15-1+cuda11.4_amd64.deb
wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu1804/x86_64/libcudnn8-dev_8.2.4.15-1+cuda11.4_amd64.deb
sudo dpkg -i libcudnn8-dev_8.2.4.15-1+cuda11.4_amd64.deb

pip3 install --upgrade setuptools
sudo -H pip3 install --upgrade pip
pip3 install tensorflow==2.7.0

python3.6 -> python3.7로 바꾸고 나타난 문제

Traceback (most recent call last):
  File "/usr/lib/cnf-update-db", line 8, in <module>
    from CommandNotFound.db.creator import DbCreator
  File "/usr/lib/python3/dist-packages/CommandNotFound/db/creator.py", line 11, in <module>
    import apt_pkg
ModuleNotFoundError: No module named 'apt_pkg'
Reading package lists... Done
E: Problem executing scripts APT::Update::Post-Invoke-Success 'if /usr/bin/test -w /var/lib/command-not-found/ -a -e /usr/lib/cnf-update-db; then /usr/lib/cnf-update-db > /dev/null; fi'
E: Sub-process returned an error code

아래 명령어로 해결 (https://askubuntu.com/questions/480908/problem-with-update-manager-no-module-named-apt-pkg-in-ubuntu-13-10-having-i)

apt-get remove  python3-apt
apt-get install python3-apt

sudo apt-get install --reinstall python3-apt

sudo apt update
sudo apt install python3.7  # 일단 설치부터

update-alternatives --config python3
(에러나오는게 정상)
which python3.7  #위치 다시한번 확인

sudo update-alternatives --install /usr/bin/python python /usr/bin/python3.7 1
-> python을 치면 3.7 을 기본으로 하라는 뜻
sudo update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.7 1
=> python3을 치면 3.7 을 기본으로 하라는 뜻

ㄴ원래 python3 버전이 3.6이였던게 지정해준뒤로 3.7로 바뀐걸 확인

초기세팅

import pandas as pd
import glob
import pickle
import matplotlib.pyplot as plt

pd.set_option('display.max_columns', None) # dataframe 잘림없이 출력
pd.set_option('display.max_rows', None)
pd.set_option('display.max_seq_items', None) # 리스트 잘림없이 출력
pd.options.display.float_format = '{:.5f}'.format  # e, 지수없이 출력
pd.set_option('display.max_colwidth', -1) #pd로 볼때 ...없이 출력
import warnings # warning 무시
warnings.filterwarnings('ignore')
pd.set_option('mode.chained_assignment',  None) # SettingWithCopyWarning 경고끄기

< 행열 이름바꾸기 >

# 행 인덱스, 열 이름 변경하기
df.index=['학생1', '학생2']
df.columns=['연령','남녀','소속']

# 열 이름을 변경한다
df.rename(columns={'연령':'나이', '남녀':'성별', '소속':'학교'}, inplace=True)
# 행 인덱스를 변경한다
df.rename(index={'학생1':'준서', '학생2':'예은'}, inplace=True)

<행열 삭제>

del df['A']

df.drop(["B", "C"], axis=1)
df.drop(columns=["B", "C"],inplace=True)
df.pop("A") # A열만 반환해준다음,df확인해보면 A 빠져있을것

df = df.drop(index=0, axis=0)
df = df.drop(index=[0, 1, 2], axis=0)
new_iris = iris.drop([1,2])
df.drop(["B", "C"], axis=0)

# 특정문자(save_fig2리스트에저장) 가 포함된 열 삭제
for i in save_fig2:
    print(i)
    df2 = df2[df2.columns.drop(list(df2.filter(regex=i)))]

<행열 타입 바꾸기>

df = df.astype({'시가':'int'}) # 특정열만 바꿔주기

<판다스 오름차순>

df['a'].sort_values()   # 작은수부터
df['a'].sort_values(ascending=False)   # 큰수부터

# 이건 해당 열에 맞춰서 모든 dataframe순서바꿈 / 큰수부터
per_model = per_model.sort_values(by=["noclust"], ascending=[False])

<데이터프레임 저장/불러오기>

# 저장
df.to_csv('./df.csv')
# 불러오기
df = pd.read_csv('./Data.csv')

<데이터프레임 잘리는거없이 전부 출력>

import warnings #dataframe 전체다출력
warnings.filterwarnings('ignore')
pd.set_option('display.max_columns', None)
pd.set_option('display.max_rows', None)

<리스트 잘리는거없이 모두 출력 - dataframe columns너무많을때 잘림>

pd.set_option('display.max_seq_items', None)  # 리스트 잘리는거없이 전부 출력
df.columns

<데이터프레임 생성(컬럼,인덱스 지정)>

Data_T = pd.DataFrame(index = list(index_list),columns = list(columns_list))

<아래 행추가>

Total_latency.loc[len(Total_latency)] = [column1_value, column2_value]

< untilied:0 없이 / 저장한 포맷그대로 열기>

epoch_latency = pd.read_csv('epoch_latency.csv',index_col = 0)

< 얕은 복사>

import copy
b = copy.copy(a)

< index 재정렬 >

  df = df.reset_index(drop=True)

<특정열 제외하고 보기>

DATA[DATA.columns.difference(['Target_Instance', 'Target_latency'])].head()

< 특정행 제거>

gojung2 = gojung.drop(['CLOUD','GPU TYPE'])

<데이터프레임 type 바꾸기>

df.astype('float')

< 데이터프레임 오른쪽에 붙이기>

new = pd.concat([a, b],axis=1)

< 데이터프레임 아래에 붙이기>

pd.concat([df1, df2], axis = 0)

< replace >

df.replace(0, 5)  # 0을 5로 바꿔주기

< 원핫인코딩 >

pd.get_dummies(data['Embarked'])

< 쥬피터 동시에 여러개 실행 >

from multiprocessing import Pool
if __name__ == '__main__':
    with Pool(len(devide_3000)+1) as p:
        p.map(MADE_HN, devide_3000)
def MADE_HN(N):
	블라블라

< 리스트 차집합, 뺼셈 >

complement = list(set(lst1) - set(lst2))

< 얕은 복사 >

CROSS_column_DATA_scaled = CROSS_column_DATA.copy()

< 리눅스 파일복사>

cp -r /tf/Yoonseo/Github/DCGMI/dcgm/a100 /tf/Yoonseo/Github/DCGMI2/DATA/
# cp -r 복사할파일 복사해줄위치

< 상관관계 3가지 >

corr_kendall_DATA_NEW = DATA_NEW.corr(method="kendall")  # kendall pearson spearman
spearman_DATA_NEW = DATA_NEW.corr(method="spearman")  # kendall pearson spearman
pearson_DATA_NEW = DATA_NEW.corr(method="pearson")  # kendall pearson spearman

< 보기편하게 모아서 보기 >

show_data.groupby(['train','instance']).first()

< 피클파일 열기 >

with open('../DATA/raw-data/exp09/g5.xlarge/times-EC2-128-InceptionV3.pickle', 'rb') as f: df = pickle.load(f)

< 교집합 >

intersection = list(set(lst1) & set(lst2))

< 특정문자 포함 파일 지우기>

sudo rm -f *.csv

<여러개파일 zip>

zip zipfile.zip 파일1 파일2 파일3

< 행값 합 구하기 >

df.sum(axis=1)

< time >

start = time.time()
math.factorial(100000)
end = time.time()

print(f"{end - start:.5f} sec")

< Lambda 예제 >

# lambda 매개변수 : 표현식
# map(함수, 리스트)
# reduce(함수, 시퀀스)
# filter(함수, 리스트)

##################################################
>>> (lambda x,y: x + y)(10, 20)
30
>>> plus_ten = lambda x: x + 10
>>> plus_ten(1)
11
##################################################
>>> list(map(lambda x: x ** 2, range(5)))    
[0, 1, 4, 9, 16]
##################################################
>>> from functools import reduce   
>>> reduce(lambda x, y: x + y, [0, 1, 2, 3, 4])
10
>>> reduce(lambda x, y: y + x, 'abcde')
'edcba'
##################################################
>>> list(filter(lambda x: x < 5, range(10))) 
[0, 1, 2, 3, 4]
>>> list(filter(lambda x: x % 2, range(10)))  
[1, 3, 5, 7, 9]
# 4을 2로 나눈 나머지는 0, 0은 '거짓'이니까 버려짐.
##################################################
>>> test = 'A, B, C, D'
>>> result = test.split(',')
>>> result
['A', ' B', ' C', ' D']
##################################################
>>> test = 'A, B, C, D'
>>> result = list(map(lambda x : x.strip(), test.split(',')))
>>> result
['A', 'B', 'C', 'D']

< 특정문자열 포함 파일찾기 >

grep -r [문자열] [찾으려는위치]
# ex) grep -r 112 ./*

< plt.plot 폰트 >

import matplotlib.pyplot as plt 
plt.figure(figsize=(16, 5))    # figure가로세로크기
plt.rc('font', size=20)        # 기본 폰트 크기
plt.rc('axes', labelsize=20)   # x,y축 label 폰트 크기
plt.rc('xtick', labelsize=50)  # x축 눈금 폰트 크기 
plt.rc('ytick', labelsize=20)  # y축 눈금 폰트 크기
plt.rc('legend', fontsize=20)  # 범례 폰트 크기
plt.rc('figure', titlesize=50) # figure title 폰트 크기

plt.rcParams['legend.fontsize'] = 16
plt.rcParams['figure.titlesize'] = 18
plt.rcParams['axes.titlesize'] = 18
plt.rcParams['lines.linewidth'] = 2.0
plt.rcParams['axes.labelsize'] = 18
plt.rcParams['xtick.labelsize'] = 16
plt.rcParams['ytick.labelsize'] = 16

< ipynb -> py >

# 확장자가 ipynb인 Jupyter Notebook 파일을 아래 명령어를 이용하여 python 파일로 변환. 아래 명령은 xgboost-wine-quality.ipynb 파일을 step0-xgboost-wine-quality.py 로 변환하는 예시.
jupyter nbconvert xgboost-wine-quality.ipynb --to script --output step0-xgboost-wine-qual

< 행추가 > 

latency_all.loc['best_gpu'] =  [0 for i in range(len(latency_all.columns))]

<>

+++

<특정문자가 문자열안에 포함되어있는지>

    check_models = ['MNIST_CNN','AlexNet','CIFAR10','InceptionV3',
                     'VGG19','ResNet50','InceptionResNetV2','LeNet5',
                   'ResNetSmall']
    for i in (check_models):
        if i in save_name:
            model = i

Save devicequery result as csv

• Original_deviceQuery : origianl deviceQuery.cpp
  (위치는 우분투기준 /usr/local/cuda-11.4/samples/1_Utilities/deviceQuery)
• Outputcsv_deviceQuery : deviceQuery.cpp file that saves the devicequery result as csv

< Make csv file and permission setting >

sudo touch devicequery.csv // devicequery 값을 저장해줄 csv 파일 생성
sudo chmod ugo+rwx devicequery.csv // read only -> write & read only

< Compile >

1. deviceQuery.cpp 수정 (위에 outputcsv_deviceQuery.cpp로 바꿔주기)
2. sudo make ( 에러나면 sudo make clean )
3. ./deviceQuery

< 추가해준 부분 간단히보기 >

#include <fstream> 
std::ofstream myfile;
myfile.open ("devicequery.csv");
myfile << "Maximum Texture Dimension Size (x,y,z)," << deviceProp.maxTexture1D;
myfile.close();

finally save the devicequery.csv locally

scp -i /Users/hhhhhyyyyy/desktop/aws_pem/ys.pem -r ubuntu@1.11.11.11:/usr/local/cuda-11.4/samples/1_Utilities/deviceQuery/devicequery.csv  .

온칩 : (=레지스터 메모리)

• 온칩메모리는 GPU 칩 안에 있는 메모리로, 레지스터 메모리 / 로컬 메모리 라고 부릅니다.
• 레지스터는 GPU 커널 안에 선언되는 변수로, GPU 칩안에 있기 때문에 접근 속도가 빠릅니다.
• 레지스터 변수는 코어에 할당된 스레드가 분배해서 사용하는데, 커널 안에서 사용해야 할 변수가 많아지면 로컬 메모리에 레지스터 변수를 할당할 수 있습니다.
• 온칩은 속도가 빠른 대신에 비용 등의 이유로 인해 메모리 사이즈가 비교적 작습니다.
• 직접 연산수행하는 제일빠른 메모리 (싸인,코싸인 함수계산도 레지스터메모리사용함)

오프칩 : (=글로벌 메모리)

• 그래픽 카드에 장착한 DRAM으로
• CUDA에서는 이 off칩을 글로벌 메모리 / 디바이스 메모리라고 합니다.
• 메모리를 할당 및 해제하는 방법은 GPU 포인터를 선언 -> cudaMalloc 명령으로 메모리 할당해주기 -> 메모리 해제(cudaFree)
• 계산에 필요한 입력 데이터는 GPU가 아닌 CPU 메모리 영역에 있기 때문에 PCI-e 인터페이스를 통해서 GPU로 메모리를 전송합니다.
• 속도는 공유메모리랑 레지스터에 비하면 느린편이지만 cpu 메모리에 비교하면 상당히 빠른편

Shared Memeroy 

• 글로벌 메모리(오프 칩)는 칩 안에 있지 않기 때문에 접근 시간이 많이 걸립니다. 그래서 GPU에서도 CPU처럼 캐시 기능을 사용할 수 있습니다.다른 점은 개발자가 캐시를 직접 제어할 수 있다는 점입니다.
• 블록 안의 스레드는 shared 메모리를 모두 공유합니다. (큰 메모리 개념)
• 블록은 블록마다 자신의 shared 메모리를 가집니다.
• shared 메모리는 항상 __syncthreads() 함수를 사용해야 합니다. 왜냐면 shared는 global의 데이터를 캐시처럼 shared에 올린 뒤 사용해야 하는데, 각각의 스레드가 shared에 올리는 작업을 수행합니다.이 때 sync를 걸지 않으면, 모두 메모리에 올라오지 않은 상태에서 값을 참조하여 쓰레기값을 가져올수 있기 때문입니다.

Texture Memory

• 3d 그래픽에서 사용하는 메모리
• read only memory

로컬 메모리

로컬메모리도 온칩메모리.보통은 커널내에 레지스터에 저장되지만 레지스터 공간에 맞지않는 변수는 로컬메모리에 저장된다고함. 아래같은것들은 컴파일러가 로컬메모리에 위치시키는 변수들이라고함.

• Local arrays referenced with indices whose values cannot be determined at compile-time
• Large local structures or arrays that would consume too much register space
• Any variable that does not fit within the kernel register limit

Constant memory

• 상수 메모리는 device 메모리에 위치하며 각 SM 의 컨스턴트 캐시에 캐싱된다. (gpu그림에서 c캐시부분)
• 커널은 상수메모리를 읽을수만 있다.
• 상수메모리는 워프의 모든 스레드가 동일한 메모리를 읽을때 가장베스트하다고함. 한마디로 각각의 데이터에 대해 동일한 계산을 수행하기위해 동일한 계수를 사용하기 떄문.

추가적으로 GPU 구조 관련해서도 간단히 정리

**커널 함수 : 병렬 함수 및 데이터 구조를 명시하는 키워드들을 확장한 형태로 작성된 코드로서, 디바이스가 실행하는 부분 (병렬 처리가 가능한 부분)

** 스레드 : 최소 명령어 처리단위 , 기본연산(Computation) 하나라를 스레드로 표현한다. (= 멀티프로세서 내에서 작동되는 코어하나에 할당된 명령어를 의미) / 커널함수의 한 인스턴스로써 gpu의 sp에 의해 실행

** 블럭 : 스레드 묶음 (=그리드내의 스레드들을 적절한수의 스레드들로 분할한 단위로 하나의 sm에게 할당한다)

** 그리드 : 블록이 모이면 그리드가 된다. (하나의 병렬 커널에 의해 실행되는 스레드 전체를 의미함)

+)TPC 는 fermi 이전에 있던것

** 멀티프로세서 : GPU를 구성하는 기본요소로 구성된 최소돤위, GPU 는 멀티프로세서내에 여러개의 GPU 코어를 지니고있다.

**GPU는 1개칩안에 최대 15개의 멀티프로세서를 가지고있음. 이 멀티프로세서안에 각각 192개의 코어 (계산유닛)을 가지고있다 그러므로 총 2880개의 코어를 가지고있는셈

** 커널 : GPU에서 병렬실행하는 명령의모음

**Wave(=Wavefront = WARP) : 32개 스레드들을 단위로 묶은것 (갯수는다를수있음), 대부분 엔비디아 gpu 는 32스레드를 1개워프로 치고있다고 한다.

Warp는 SM(Streaming Multi-processor)의 기본 실행 단위(unit of execution). 스레드 블록의 그리드를 실행하면, 그리드의 스레드 블록들은 SM들로 분배됩니다. 스레드 블록이 SM에 스케쥴링되면 스레드 블록의 스레드들은 warp로 파티셔닝됩니다. 32개의 연속된 스레드들로 구성된 하나의 warp는 SIMT(Single Instruction Multiple Thread) 방식으로 실행됩니다. 즉, 모든 스레드는 동일한 명령어를 실행하고, 각 스레드는 할당된 private data에 대해 작업을 수행합니다.

+) GPU DEVICE 에는 4가지 타입의 캐시가 존재

각 SM에는 하나의 L1 캐시가 있고, 모든 SM에서 공유되는 하나의 L2 캐시가 있는데(그림참). L1과 L2 캐시는 모두 local / global 메모리에 데이터를 저장하는데 사용됨. GPU에서는 오직 메모리 load 동작만 캐싱될 수 있고 메모리 store 동작은 캐싱될 수 없다고함. SM 또한 read-only constant 캐시와 read-only texture 캐시가 있는데, 이는 device memory의 각각의 메모리 공간에서 읽기 성능을 향상되는데 사용된다.

• L1
• L2
• Read-only constant
• Read-only texture

html

markdown

PDF

1. AWS 인스턴스 시작 (쿠다 깔려있는걸로)

Deep Learning AMI GPU CUDA 11.4.1 (Ubuntu 18.04) 20211204 사용함 (CUDA 11.4)

2. CUDA TOOLKIT 깔기

https://developer.nvidia.com/cuda-11-4-0-download-archive?target_os=Linux&target_arch=x86_64&Distribution=Ubuntu&target_version=18.04&target_type=deb_local

위에 참조해서 깔기

— nvcc -V 제대로 나오면 설치완 —

3. 아래 터미널에 입력

cd /usr/local/cuda-11.4/samples/1_Utilities/deviceQuery
sudo make
./deviceQuery

4. 결과

CUDA Device Query (Runtime API) version (CUDART static linking)

Detected 1 CUDA Capable device(s)

Device 0: "Tesla T4"
  CUDA Driver Version / Runtime Version          11.4 / 11.4
  CUDA Capability Major/Minor version number:    7.5
  Total amount of global memory:                 15110 MBytes (15843721216 bytes)
  (040) Multiprocessors, (064) CUDA Cores/MP:    2560 CUDA Cores
  GPU Max Clock rate:                            1590 MHz (1.59 GHz)
  Memory Clock rate:                             5001 Mhz
  Memory Bus Width:                              256-bit
  L2 Cache Size:                                 4194304 bytes
  Maximum Texture Dimension Size (x,y,z)         1D=(131072), 2D=(131072, 65536), 3D=(16384, 16384, 16384)
  Maximum Layered 1D Texture Size, (num) layers  1D=(32768), 2048 layers
  Maximum Layered 2D Texture Size, (num) layers  2D=(32768, 32768), 2048 layers
  Total amount of constant memory:               65536 bytes
  Total amount of shared memory per block:       49152 bytes
  Total shared memory per multiprocessor:        65536 bytes
  Total number of registers available per block: 65536
  Warp size:                                     32
  Maximum number of threads per multiprocessor:  1024
  Maximum number of threads per block:           1024
  Max dimension size of a thread block (x,y,z): (1024, 1024, 64)
  Max dimension size of a grid size    (x,y,z): (2147483647, 65535, 65535)
  Maximum memory pitch:                          2147483647 bytes
  Texture alignment:                             512 bytes
  Concurrent copy and kernel execution:          Yes with 3 copy engine(s)
  Run time limit on kernels:                     No
  Integrated GPU sharing Host Memory:            No
  Support host page-locked memory mapping:       Yes
  Alignment requirement for Surfaces:            Yes
  Device has ECC support:                        Enabled
  Device supports Unified Addressing (UVA):      Yes
  Device supports Managed Memory:                Yes
  Device supports Compute Preemption:            Yes
  Supports Cooperative Kernel Launch:            Yes
  Supports MultiDevice Co-op Kernel Launch:      Yes
  Device PCI Domain ID / Bus ID / location ID:   0 / 0 / 30
  Compute Mode:
     < Default (multiple host threads can use ::cudaSetDevice() with device simultaneously) >

deviceQuery, CUDA Driver = CUDART, CUDA Driver Version = 11.4, CUDA Runtime Version = 11.4, NumDevs = 1
Result = PASS

STRATIX 10 NX 의 구조랑 성능비교 ....

1. Brainwave NPU overlay architecture

2. tensor block 구조

텐서 블록에는 3개의 내적 단위가 포함되어 있으며, 각 단위에는 10개의 8×8 승수와 3개의 선택적 누산기(ACC) 가 있음.

** DOT (곱셈) - 벡터끼리의 곱셈을 의미함

** 승수 : 승수란 어떤 수에 다른 수를 나누거나 어떤 식에 다른 식을 곱할 때, 그 나중의 수나 식을 말한다. 

** ACC (누산기) : 연산된 결과를 일시적으로 저장해주는 레지스터로 연산의 중심

** 레지스터 

레지스터는 비트 패턴을 저장하는 플립플롭 그룹입니다. FPGA의 레지스터에는 클럭, 입력 데이터, 출력 데이터 및 활성화 신호 포트가 있습니다. 클록 주기마다 입력 데이터가 래치되어 내부에 저장되고 출력 데이터가 내부에 저장된 데이터와 일치하도록 업데이트됩니다. 

그림 3은 이 모드에서 AI 텐서 블록의 동작을 보여줌

 각 주기에 내적 단위를 공급하는 레지스터 뱅크는 점선 상자로 표시됩니다. 3 클럭 사이클 후에 해당 피연산자의 모양과 색상을 사용하여 출력이 생성됩니다.

주황별 :역시 인풋벡터인데 무색 모양은 3개의 내적 단위로 브로드캐스트되는 텐서 블록의 데이터 포트에 대한 입력 벡터입니다.

유색원 : 레지스터 뱅크로 들어온 인풋벡터값

3. baseline 기반으로한 리얼구조 

아까 베이스라인 npu 구조 에서 더 발전시킨것이 Stratix 10 NX Npu

• ** 타일이 왜 두개로 나뉨? (인풋레인이 2개라서)
• 베이스라인 NPU에서 2개의 타일 및 DPE를 갖는 MVU에 대한 매트릭스-벡터 연산의 매핑을 예제로 들고있다.
• DPE는 여러 주기에 걸쳐 입력 벡터의 블록과 행렬 행 블록 간의 내적을 수행
• 그런 다음 다른 타일에서 해당 DPE의 출력을 줄여 행렬의 다음 행 블록으로 진행하기 전에 최종 결과를 생성

- 대신에 다음그림처럼 여러가지 결과를 저장하기위해 BRAM 기반 누산기(=MVU)를 구현. (BRAM = block ram)

- dual-port RAM. 듀얼 포트 램이므로 한 사이클에 2개의 주소로부터 값을 읽거나 쓰기가 가능

- BRAM 이 여기서 하는일은 기본적으로 스토리지의 역할을 하며 read/write 속도가 매우 빠르다고함/ On-Chip 메모리 ( 메모리가 칩위에 있다는 의미/ 메모리가 칩 위에 있기 때문에 버스(Bus)를 사용하지 않고 바로 메모리에 접근할 수 있다 / BRAM 은 기본적으로 FPGA안에 필요한 정보, data를 저장하는 공간이다 )

*BRAM ? Xilinx FPGA 내부의 SRAM 의 한 종류를 BRAM 이라 부릅니다. (Xilinx FPGA 에는 URAM 도 있습니다.)  Intel FPGA 은 BRAM 역할을, Embedded Memory 라고 부르구요.

• 결과적으로 타일 간 감소를 수행하기 위해 각 타일에서 중앙 가산기 트리로 넓은 버스를 라우팅하면 상당한 라우팅 혼잡이 발생할 수 있습니다

• 라우팅 혼잡을 완화하기 위해 그림 4c와 같이 각 타일이 이전 타일의 결과를 가져오고 로컬 이진 축소를 수행하고 결과를 다음 타일로 전달하는 데이지 체인 아키텍처를 갖도록 MVU를 재설계합니다. . 
• 이 아키텍처는 각각의 두 개의 연속 타일 사이에 더 짧고 더 지역화된 라우팅을 사용하며 몇 사이클 더 높은 대기 시간을 희생하면서 더 효율적이고 라우팅 친화적인 것으로 밝혀졌다.

4. 성능비교

** ALM = 해당 제품군의 베이직 빌딩블록

** 빌딩블록 = 컴터를 구성하는 여러가지종류의 기본 회로들을 지칭함

** TOPS = 초당 1조 연산속도  (15TOPS = 1초에 15조번 연산)

**PEAK TOPS 는 MVU 에서만 국한지음

** GEMV = 일반 행렬곱

** GEOMEAN = 기하평균 ( n개 양수값을 모두 곱한다음 n제곱근을 구함)

** 1개의 배치로부터 loss를 계산한 후 Weight와 Bias를 1회 업데이트하는 것을 1 Step이라고 한다.

** 오프칩 : CPU와 주기억장치, I/O Port가 외부에 존재하는 것

** DIE size = 집적회로의 물리적인 크기 (길이,너비) https://en.wikichip.org/wiki/die_size

** TSMC 반도체 위탁제조회사

**12nm 제조공정에서 만들어진 프로세서 이름

** V100 p3 / T4 g4dn

그림 6은 T4 및 V100 GPU에서 fp32, fp16 및 int8 정밀도에 대한 GEMM 마이크로 벤치마킹 결과를 보여줍니다. 

빨간점선 :  2048 이하의 매트릭(행렬) 크기에서 최고 성능(빨간색 점선)

** GEMM = 행렬곱

** throughput 한마디로 단위시간당 처리할수 있는양이라고 보면됨. 

• 결과는 텐서 코어가 비활성화된 경우(파란색 선)에 비해 텐서 코어가 GEMM(빨간색 선)에서 GPU의 성능을 크게 향상시킬 수 있음을 보여줌
• T4 및 V100의 텐서 코어는 fp32 정밀도를 지원하지 않습니다. 대신 fp32 데이터는 텐서 코어에서 곱셈 연산을 실행하기 전에 fp16으로 변환됩니다[45]. 이 데이터 변환 오버헤드는 순수 fp16 GEMM에 비해 텐서 코어 성능을 감소시킵니다
• 결과적으로 텐서 코어(마커가 없는 빨간색 선)에서 달성된 int8 성능은 매우 큰 8192 × 8192 행렬을 처리할 때도 최고 성능의 45% 미만
• GEMM 워크로드에서 T4와 유사한 성능을 달성합니다. ++ FPGA의 재구성 가능성을 활용하여 NX 텐서 블록을 조금 변환하여 GEMM용 NPU 오버레이를 사용자 정의할 수 있습니다. 그런데 이건 이 논문의 주제랑 조금 벗어나다고 하여 거기까지는 하지않았음

** GRU ( lstm 이랑 비슷한데 다른모델임)

** GENV 일반행렬 벡터곱

**GEOMEAN 기하평균값

- Stratix 10 NX의 향상된 NPU 성능을 최고의 T4 및 V100 성능과 비교합니다. NPU 성능은 크기가 3과 6인 소규모 배치의 경우 두 GPU보다 항상 훨씬 높습니다.

=>  NPU는 배치 6(각각 배치 3에서 2개의 코어용으로 설계됨)에서 24.2배 및 11.7배 더 높은 성능을 보입니다.

=> 이러한 결과는 FPGA가 low- 배치를 사용한 실시간 추론에서 GPU보다 10배 더 나은 성능을 달성할 수 있다.

** TACC - 텍사스 대학교 컴퓨팅 센터

** BW = bandwidth

** virt linux = EC2 g4dn

다음을 보면 GPU개랑 NPU 에서 대역폭을 측정하고 있습니다. (좌 -  대역폭 / 우 : 대역폭 활용률)

측정된 대역폭은 먼저 데이터 크기가 증가할수록 늘어나는것을 볼수 있다.

T4 는 aws 가상화로 인해서 훨씬더 낮은 대역폭을 보인다. (가상 머신의 물리적 메모리에 고정된 메모리 공간에서 GPU 입력 데이터를 보낼 때)

(두번쨰그림) FPGA는 최대 90% 활용으로 100G 이더넷 인터페이스를 최대한 활용하는 반면, V100은 최대 128Gbps PCIe 대역폭의 최대 80%만 활용할 수 있습니다.

NPU ?

• 지금 개발된 고도화된 AI 기술 구현에는 GPU(그래픽처리장치)의 공이 크다.
• GPU의 원래 목적은 컴퓨터 그래픽 처리다. AI용으로 GPU를 쓰는 이유는 그래픽 처리와 AI 연산이 비슷한 방법으로 이뤄지기 때문.
• 그러나, GPU의 원래 목적이 AI 연산은 아니기 때문에 비용이나 전력소모 등 비효율적인 부분이 발생. 
• 이를 극복하기 위해 최근에는 FPGA를 사용하거나 NPU, TPU 등 새로운 프로세서를 개발해 사용하고 있다.
• 한마디로 NPU 는 인공지능을 위해 만든 프로세서
• TPU 도 구글에서 인공지능을 위해 만든 NPU이다.

FPGA ?

• FPGA(field programmable gate array)는 CPU나 GPU 등 회로 변경이 불가능한 다른 프로세서와 달리 프로그래밍이 가능한 프로세서로 용도에 맞게 회로를 변경할 수 있다. 
• FPGA는 인공지능에 중요하게 쓰인다. 병렬연산 등 새로운 설계가 가능하기 때문에 머신러닝(ML)에 적합한 프로세서 설계에 적합하다.
• 짧은 대기 시간과 높은 처리량은 FPGA의 가장 큰 장점. 
• FPGA는 GPU보다 전력효율이 높다
• BING 검색엔진에 FPGA 를 활용

아래글  읽어보면 FPGA ,NPU 가 뭘 의미하는지 대충감이옴

http://www.aitimes.com/news/articleView.html?idxno=137640 

http://www.aitimes.com/news/articleView.html?idxno=134014 

chmod +x a.sh
chmod +x b.sh
nohup ./a.sh >nohup.out & nohup ./b.sh >nohup2.out &

일단 nohup 시작하기전에 chmod +x a.sh 로 permission을 줘야 에러가 안남.

그리고 동시에 실행할땐 &, 차례차례 실행할거면 &&, ; 

• ; - 앞의 명령어가 실패해도 다음 명령어가 실행
• && - 앞의 명령어가 성공했을 때 다음 명령어가 실행
• & - 앞의 명령어를 백그라운드로 돌리고 동시에 뒤의 명령어를 실행

>nohup.out 이거는 출력을 여기에 저장하겠다는 의미. 예를들어 print("hello") 라는 파이썬 파일을 실행하면 nohup.out 을 열어보면 hello 출력이 되어있을것.

잘 실행되고있는지 궁금하면 nohup.out 파일열어보면 된다.

- 종료하기

ps -ef
kill -9 [PID]

ps -ef | grep 쉘스크립트파일명

푸리에 변환이란??

• 시간을 기준으로 그린 그래프에서 → 주파수 기준 그래프로 변환해줌.
• 한마디로 주어진 신호를 다양한 주파수를 가지는 주기함수들의 합으로 나타내는 것이다.
• 여기서 주기함수란? 우리가 일반적으로 알고 있는 사인(sin), 코사인(cos) 함수를 의미.

시간기준 -> 주파수 그래프 바뀌는 원리만 정확히 이해하면  감이온다. 

아래그림처럼 해당 주파수가 sin,cos그래프들이 몇개 모여 이루어졌나 보는것이다. 

푸리에 변환도 여러가지가 있는데 그중에서 FFT 를 사용한 초간단 예제. (빠르다!)

사실 지금까지 호환성에 대해서는 그렇게 크게 신경쓰지 않았고,기존에 사용한 AMI 이미지를 사용했으나 이제껏 전혀 문제가 없었기 때문에 호환성에 대해 무지했고 버전에 중요성에 대해 크게 생각하지 않았다. 

그런데 꽤 최근에 나온 GPU에서 구 버전 CUDA를 사용하다가 생각도 못한 에러폭탄을 맞아서 호환성의 중요성에 대해 느끼게 되었다...

아래는 텐서플로우, 쿠다, 파이썬 버전 호환성 확인 (쿠다 11.2 이상부터는 파이썬도 3.7이상 사용해야함)

< G5 인스턴스 >

g5 인스턴스는 CUDA11.4 이상 사용을 권장

(aws repost 라고 aws호환성관련해서는 답은좀 느리지만 궁금한게 있으면 여기에 질문하는게 정확한것 같다. )

https://repost.aws/questions/QUNR0L1sSIRd-e1zeRIoEc1Q/gpu-fails-to-intialize-on-g-5-xlarge-instance

< p4d.24xlarge 인스턴스 >

아래는 내가 물어본질문이다. 

쿠다 10.1에서는 도저히 에러해결이 안되서 동일한 암페어 GPU (2020년 9월 출시한 RTX 3000 시리즈는 공식적으로 쿠다11이상만 지원하고있다 )가 쿠다 11이상을 지원하는걸보고 11.4로 실행했더니 해결했다. 

뒤늦게 답이 달렸는데 쿠다버전, 텐서플로우버전, 심지어 이미지까지 알려주셨다. 

https://repost.aws/questions/QUdPFPsWPcSh6TIozmOGBidw/runtime-error-cuda-runtime-implicit-initialization-on-gpu-0-failed-status-device-kernel-image-is-invalid

CLI 연결하기

https://cloud.google.com/sdk/docs/quickstart?hl=ko#linux 참조

1. 맥 : google-cloud-sdk-367.0.0-darwin-x86_64.tar.gz 다운로드
2. ./google-cloud-sdk/install.sh 로 설치
3. ./google-cloud-sdk/bin/gcloud init 로 초기화
4. gcloud init
5. 확인용 gcloud auth list / gcloud config list / gcloud info

(** region : 본인은 us-central1-a 사용 )

이미지 찾기

https://cloud.google.com/deep-learning-vm/docs/images 참조

gcloud compute images list \
        --project deeplearning-platform-release \
        --no-standard-images

ㄴ결과값 너무많아서 보기 힘듬

cu100-ubuntu-1804 를 검색 (cuda10, ubuntu18 )

⇒ ‘common-cu100-ubuntu-1804’

아래 명령어로 해당 인스턴스 검색 (cuda10 깔려있고, 텐서플로우는 없는듯하다)

gcloud compute images describe-from-family common-cu100-ubuntu-1804 \
    --project deeplearning-platform-release

GCP 는 region 마다 사용가능한 GPU가 모두 다르다. 아래 링크에서 확인가능

https://cloud.google.com/compute/docs/gpus/gpu-regions-zones

사용하기 앞서서 본인 GPU quotas 할당량을 살펴보면 , 그와중에 어디는 허용이고 어디는 허용 불가능이고 해서 region -> 사용가능한 GPU 뭐있나 -> 해당리전의 GPU quotas =1 인지  하나하나 맞춰보기 너무 헷갈리고 에러도 나고 해서

리전에서 사용가능한 GPU를 모두 사용할수있게 신청했다.

IAM -> Quotas 들어가서 GPU(all region) 검색후 선택 -> 할당량 수정 누름된다.

사용하려는 이유를 함꼐 써서 제출하면 된다.

보냈는데 1분안에 답이 왔다.

그럼 전에는 한도가 0 이였던게 요청후에는 1로 늘어나있는거러 확인가능하다.

DSVM 에 뭐가 세팅되어있는지 확인 : https://docs.microsoft.com/ko-kr/azure/machine-learning/data-science-virtual-machine/tools-included

DVSM 에서 사용가능한 GPU 인스턴스가 한정적이다. 이유는 vCPU 제한이 있기 때문

vCPU 한도를 4 ->6 으로 증가요청을 하여 막힌 vm 인스턴스 사용하겠다고 할당량증가 요청을 해줌 된다.

p100 GPU 인스턴스를 요청했는데 거절당했다. (이유는 22.8.31 에 곧 종료될 인스턴스라 노후화되었다고 판단하여 할당해주지않은듯하다)