Contents Creator

import cv2
import numpy as np

# 동영상 파일 읽기
cap = cv2.VideoCapture("MS/CV/0612 객체탐지,추적/data/slow_traffic_small.mp4")

# 코너 검출기 파라미터 설정
feature_params = dict(maxCorners=100, qualityLevel=0.3,
                      minDistance=7, blockSize=7)
"""
maxCorners: 검출할 최대 특징점 수를 지정. 여기서는 최대 100개의 특징점을 검출하도록 설정
qualityLevel: 특징점으로 인정되기 위한 품질 기준. 0과 1 사이의 값,높을수록 특징점으로 인정되기 위한 조건이 엄격
minDistance: 검출된 특징점들 간의 최소 거리를 나타냄 이 거리보다 가까운 특징점은 제거
blockSize: 특징점 검출 시 사용되는 이웃 픽셀 블록의 크기. 특징점 검출 알고리즘에서 사용되는 계산에 영향을 미치는 요소
"""


# 광학 흐름 파라미터 설정
lk_params = dict(winSize=(30, 30), maxLevel=2, criteria=( # 알고리즘 중지기준
    cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT, 10, 0.03))  # eps정확도가 criteria[0]보다 작을때까지 or count는 반복회수가 criteria[1]보다 작을때 까지 추적
"""
winSize=(30, 30): 이동 벡터를 추정하기 위해 사용되는 윈도우(window)의 크기
윈도우 크기는 광학 흐름 알고리즘에서 이웃 픽셀들 간의 관계를 분석하는 데 사용되는 영역의 크기를 조절 

maxLevel=2: 피라미드 계층의 수
광학 흐름 알고리즘은 다단계의 피라미드 구조를 사용하여 이미지의 해상도를 다양하게 처리


"""
    

# 첫 프레임 읽기
ret, next_frame = cap.read()
prev_gray = cv2.cvtColor(next_frame, cv2.COLOR_BGR2GRAY)

# 초기 추적 지점 선택
prev_corners = cv2.goodFeaturesToTrack(prev_gray, mask=None, **feature_params)
prev_points = prev_corners.squeeze()

# 추적 결과를 표시하기위한 색상 설정
color = (0, 200, 0)

while True:
    # 다음 프레임 읽기
    ret, next_frame = cap.read()
    if not ret:
        break

    # 현재 프레임 변환
    gray = cv2.cvtColor(next_frame, cv2.COLOR_BGR2GRAY)

    # 옵티컬 플로우 계산
    next_points, status, err = cv2.calcOpticalFlowPyrLK(
        prev_gray, gray, prev_points, None, **lk_params)

    # 추적 결과를 좋은 포인트로 필터링
    for i, (prev_point, next_point) in enumerate(zip(prev_points, next_points)):
        x_prev, y_prev = prev_point.astype(np.int32)
        x_next, y_next = next_point.astype(np.int32)

        # cv2.line(prev_frame, (x_prev, y_prev), (x_next, y_next), color, 2)
        cv2.circle(next_frame, (x_next, y_next), 3, color, 3)

    # 화면에 출력
    cv2.imshow("OpticalFlow-LK", next_frame)

    # 다음 프레임을 위한 프레임과 포인트 저장
    prev_gray = gray.copy()
    prev_points = next_points

    # 'q'를 누르면 종료
    if cv2.waitKey(60) == ord('q'):
        break

# 해제
cap.release()
cv2.destroyAllWindows()

import cv2
import numpy as np

# kalman filter
kalman = cv2.KalmanFilter(4,2)  # 상태백터(위치와 속도 등)를 4차원으로 지정, 측정벡터(센서신호) 2차원으로 세팅) 

# 측정 행렬을 설정합니다. 이 행렬은 측정 벡터를 상태 벡터로 변환하는 역할
kalman.measurementMatrix = np.array([[1,0,0,0],[0,1,0,0]],np.float32)  
# 전이 행렬을 설정합니다. 이 행 렬은 시간에 따라 상태 벡터가 어떻게 변화하는지를 나타냄
kalman.transitionMatrix = np.array([[1,0,1,0],[0,1,0,1],[0,0,1,0],[0,0,0,1]],np.float32) 
# 프로세스 잡음 공분산 행렬을 설정합니다. 이 값은 시스템의 불확실성을 모델링
kalman.processNoiseCov = np.array([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]],np.float32) * 0.05


# 칼만 필터 추적 실습
# 영상 파일 열기
cap = cv2.VideoCapture("MS/데이터전처리/0612/data/slow_traffic_small.mp4")

# 첫 프레임에서 추적할 객체 선택
ret, frame = cap.read()
print(ret, frame) # 경로가 잘못된 경우 ret = False, frame = None / 정상일경우 ret = True, frame = 영상프레임

x, y, w, h = cv2.selectROI(frame, False, False)

"""
"Select Object": 객체를 선택할 때 표시될 창의 제목입니다.
frame: 이미지나 비디오 프레임을 나타내는 변수입니다.
False: 선택한 영역을 자동으로 크롭하지 않고, 선택한 영역의 좌표와 크기를 반환합니다.
False: 마우스 이벤트를 사용하여 객체의 영역을 선택할 수 있도록 합니다.
"""
print("선택한 박스의 좌표 >>", x, y, w, h)

# 객체 추적을 위한 초기 추정 위치 설정
# 객체의 x,y,x방향속도(초기0), y방향속도(초기0)로 지정  # 일단 속도를 알 수 없으니 0으로 초기화
kalman.statePre = np.array([[x],[y],[0],[0]],np.float32)

while True:
    # 프레임 읽기
    ret, frame = cap.read()
    if not ret:
        break

    # 칼만 필터로 예측한 위치 계산
    kalman.correct(np.array([[np.float32(x)+w/2],[np.float32(y)+h/2]]))
    kalman.predict()

    # 칼만 필터로 추정된 객체 위치
    predicted_bbox = tuple(map(int, kalman.statePost[:2,0]))
    """
    map(int, kalman.statePost[:2,0]): 상태 벡터의 값들을 int 함수를 사용하여 정수로 변환 
    map 함수는 시퀀스의 모든 요소에 함수를 적용하여 새로운 시퀀스를 생성 
    여기서는 상태 벡터의 값을 int 함수를 사용하여 정수로 변환
    """

    # 추정된 위치에 사각형 그리기
    cv2.rectangle(frame, (predicted_bbox[0]-w//2, predicted_bbox[1]-h//2), 
                        (predicted_bbox[0]+w//2, predicted_bbox[1]+h//2), 
                        (0,255,255), 2)

    # 화면에 출력
    cv2.imshow("frame", frame)


    # 'q'를 누르면 종료
    if cv2.waitKey(60) == ord('q'):
        break

# 해제
cap.release()
cv2.destroyAllWindows()

import cv2
import numpy as np

# kalman filter
kalman = cv2.KalmanFilter(4,2)
kalman.measurementMatrix = np.array([[1,0,0,0],
                                    [0,1,0,0]],np.float32)
kalman.transitionMatrix = np.array([[1,0,1,0],[0,1,0,1],[0,0,1,0],[0,0,0,1]],np.float32)
kalman.processNoiseCov = np.array([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]],np.float32) * 0.05

# 칼만 필터 추적 실습
# 영상 파일 열기
cap = cv2.VideoCapture("MS/데이터전처리/0612/data/slow_traffic_small.mp4")

# 첫 프레임에서 추적할 객체 선택
ret, frame = cap.read()
print(ret, frame) # 경로가 잘못된 경우 ret = False, frame = None / 정상일경우 ret = True, frame = 영상프레임

x, y, w, h = cv2.selectROI(frame, False, False)
print("선택한 박스의 좌표 >>", x, y, w, h)

# 객체 추적을 위한 초기 추정 위치 설정
# 객체의 x,y,x방향속도(초기0), y방향속도(초기0)
kalman.statePre = np.array([[x],[y],[0],[0]],np.float32)

while True:
    # 프레임 읽기
    ret, frame = cap.read()
    if not ret:
        break

    # 칼만 필터로 예측한 위치 계산
    kalman.correct(np.array([[np.float32(x)+w/2],[np.float32(y)+h/2]]))
    kalman.predict()

    # 칼만 필터로 추정된 객체 위치
    predicted_bbox = tuple(map(int, kalman.statePost[:2,0]))

    # 추정된 위치에 사각형 그리기
    cv2.rectangle(frame, (predicted_bbox[0]-w//2, predicted_bbox[1]-h//2), 
                        (predicted_bbox[0]+w//2, predicted_bbox[1]+h//2), 
                        (0,255,255), 2)

    # 화면에 출력
    cv2.imshow("frame", frame)


    # 'q'를 누르면 종료
    if cv2.waitKey(60) == ord('q'):
        break

# 해제
cap.release()
cv2.destroyAllWindows()

우선 전체 코드

import cv2

# 평균 이동 추적을 위한 초기 사각형 설정
track_window = None  # 객체의 위치 정보 저장할 변수
roi_hist = None  # 히스토그램을 저장할 변수
trem_crit = (cv2.TERM_CRITERIA_EPS|cv2.TERM_CRITERIA_COUNT, 10,1)  # 반복횟수 10

"""
cv2.TERM_CRITERIA_EPS: 반복 알고리즘의 정지 기준 중 하나로, 
주어진 정지 기준 오차(epsilon)를 충족하는 경우 알고리즘을 중지합니다.
cv2.TERM_CRITERIA_COUNT: 반복 알고리즘의 정지 기준 중 하나로, 
주어진 반복 횟수(count)를 충족하는 경우 알고리즘을 중지합니다.
따라서 cv2.TERM_CRITERIA_EPS | cv2.TERM_CRITERIA_COUNT는 이 두 가지 정지 기준을 모두 사용하겠다는 의미입니다. 
이러한 정지 기준을 설정한 후에는 알고리즘이 주어진 정지 기준에 도달하면 반복을 중지하게 됩니다.

또한, (10, 1)은 알고리즘의 최대 반복 횟수와 정지 기준 오차(epsilon) 값을 나타냅니다. 
예를 들어, 여기서는 최대 10번의 반복과 1의 정지 기준 오차를 설정하였습니다. 
따라서 알고리즘은 최대 10번 반복하거나 주어진 오차가 1 이하로 감소할 때까지 실행됩니다.
"""


# 영상 파일 열기 
cap = cv2.VideoCapture("MS/데이터전처리/0612/data/slow_traffic_small.mp4")

# 첫 프레임에서 추적할 객체 선택
ret, frame = cap.read()  # 영상 있냐없냐 T/F가 ret , Frame 저장
x, y, w, h = cv2.selectROI("selectROI", frame, False, False)
print("선택한 박스의 좌표 >>", x, y, w, h)


# 추적할 객체 초기 히스토그램 계산
roi = frame[y:y+h, x:x+w]  # 관심구역
hsv_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV) # (Hue 색상, Saturation 채도, Value 명도)
roi_hist = cv2.calcHist([hsv_roi], [0], None, [180], [0,180]) # 히스토그램 계산
cv2.normalize(roi_hist, roi_hist, 0, 255, cv2.NORM_MINMAX) # 히스토그램을 0부터 255로 정규화 (정확도 높일려고)

# 추적할 객체의 초기 윈도우 설정 
track_window = (x, y, w, h)
# cv2.imshow("roi test", roi)
# cv2.waitKey(0)

# 평균 이동 추적
while True:
    # 프레임 읽기
    ret, frame = cap.read()
    if not ret:  
        break

    # 추적할 객체에 대한 채도 히스토그램 역투영계산
    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
    backproj = cv2.calcBackProject([hsv], [0], roi_hist, [0,180], 1)
    """
    [hsv]: 역투영을 계산할 대상 이미지의 HSV 채널입니다. HSV 채널은 색상 정보를 갖고 있어 역투영에 활용됩니다.
    [0]: 역투영에 사용할 채널 인덱스입니다. 여기서는 색상 채널(Hue)인 0번 인덱스를 사용합니다.
    roi_hist: ROI(Region of Interest)의 히스토그램입니다. 이 히스토그램은 역투영에 사용됩니다.
    [0,180]: 히스토그램의 범위를 나타냅니다. 여기서는 Hue 채널의 범위가 0부터 180까지로 설정되었습니다.
    1: 확대 비율(scale)입니다. 픽셀의 값을 히스토그램의 값으로 나누어 정규화합니다.
    """
    

    # 평균 이동으로 새 위치 검색
    ret, track_window = cv2.meanShift(backproj, track_window, trem_crit)

    # 검색된 새 위치에 사각형 그리기
    x, y, w, h = track_window
    print("새 위치 좌표 >>", x, y, w, h)
    cv2.rectangle(frame, (x,y), (x+w, y+h), (0,255,0), 2)
    """
    frame: 이미지 또는 비디오 프레임을 나타내는 변수입니다.
    (x, y): 사각형의 왼쪽 위 모서리의 좌표입니다.
    (x + w, y + h): 사각형의 오른쪽 아래 모서리의 좌표입니다. 여기서 w는 사각형의 너비, h는 사각형의 높이입니다.
    (0, 255, 0): 사각형의 선 색상을 나타내는 RGB 값입니다. (R, G, B) 형식으로 표현됩니다. 여기서 (0, 255, 0)은 녹색을 나타냅니다.
    2: 사각형 선의 두께를 나타냅니다.
    """
    

    # 화면에 출력
    cv2.imshow("backproj", backproj)
    cv2.imshow("frame", frame)

    # 'q'를 누르면 종료
    if cv2.waitKey(60) == ord('q'):
        exit()

# 해제
cap.release()
cv2.destroyAllWindows()

import cv2

# 평균 이동 추적을 위한 초기 사각형 설정
track_window = None  # 객체의 위치 정보 저장할 변수
roi_hist = None  # 히스토그램을 저장할 변수
trem_crit = (cv2.TERM_CRITERIA_EPS|cv2.TERM_CRITERIA_COUNT, 10,1)  # 반복횟수 10

# 영상 파일 열기 
cap = cv2.VideoCapture("MS/데이터전처리/0612/data/slow_traffic_small.mp4")

# 첫 프레임에서 추적할 객체 선택
ret, frame = cap.read()
x, y, w, h = cv2.selectROI("selectROI", frame, False, False)
print("선택한 박스의 좌표 >>", x, y, w, h)


# 추적할 객체 초기 히스토그램 계산
roi = frame[y:y+h, x:x+w]
hsv_roi = cv2.cvtColor(roi, cv2.COLOR_BGR2HSV) # (Hue, Saturation, Value)
roi_hist = cv2.calcHist([hsv_roi], [0], None, [180], [0,180]) # 히스토그램 계산
cv2.normalize(roi_hist, roi_hist, 0, 255, cv2.NORM_MINMAX) # 히스토그램을 0부터 255로 정규화 (정확도 높일려고)

# 추적할 객체의 초기 윈도우 설정 
track_window = (x, y, w, h)
# cv2.imshow("roi test", roi)
# cv2.waitKey(0)

# 평균 이동 추적
while True:
    # 프레임 읽기
    ret, frame = cap.read()
    if not ret:
        break

    # 추적할 객체에 대한 채도 히스토그램 역투영계산
    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
    backproj = cv2.calcBackProject([hsv], [0], roi_hist, [0,180], 1)

    # 평균 이동으로 새 위치 검색
    ret, track_window = cv2.meanShift(backproj, track_window, trem_crit)

    # 검색된 새 위치에 사각형 그리기
    x, y, w, h = track_window
    print("새 위치 좌표 >>", x, y, w, h)
    cv2.rectangle(frame, (x,y), (x+w, y+h), (0,0,255), 2)

    # 화면에 출력
    cv2.imshow("backproj", backproj)
    cv2.imshow("frame", frame)

    # 'q'를 누르면 종료
    if cv2.waitKey(60) == ord('q'):
        break

# 해제
cap.release()
cv2.destroyAllWindows()

https://webnautes.tistory.com/1257

을 먼저보고오는게 이해가 더 잘됨

1.  threshold 

경계면 구분을 원활하게 진행함

import cv2
import matplotlib.pyplot as plt
import numpy as np

image_path= "./data/a.png"

image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
"""
230보다 큰 값은 모두 255로 설정되고 작은값은 0으로 (흰색으로 바뀜)
"""

_, mask = cv2.threshold(image, 230, 255, cv2.THRESH_BINARY_INV)

image_list = np.hstack([
    image,
    mask
])

plt.imshow(image_list, 'gray')
plt.show()

2. 확장 침식 실험 - 02

import cv2
import matplotlib.pyplot as plt
import numpy as np

image_path= "./data/a.png"

image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
_, mask = cv2.threshold(image, 230, 255, cv2.THRESH_BINARY_INV)

                        
kernel = np.ones((3,3), np.uint8)
dilation = cv2.dilate(mask, kernel, iterations=2) # iterations 반복횟수
erosion = cv2.erode(mask, kernel)                     

image_list = np.hstack([
    image,
    mask,
    dilation,  # 팽창
    erosion   # 침식
])

plt.imshow(image_list, 'gray')
plt.title('org img to mask, dilation, erosion')
plt.show()

image_path= "./data/a.png"

image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
_, mask = cv2.threshold(image, 230, 255, cv2.THRESH_BINARY_INV)

                        
kernel = np.ones((3,3), np.uint8)
dilation = cv2.dilate(mask, kernel, iterations=2) # iterations 반복횟수
erosion = cv2.erode(mask, kernel)
opening = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)
closing = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)

image_list = np.hstack([
    image,
    mask,
    dilation, 
    erosion,  
    opening,  
    closing
])

plt.imshow(image_list, 'gray')
plt.title('org img to mask, dilation, erosion, opening, closing')
plt.show()

3. 확장 침식 실험 - 03

image_path= "./data/a.png"

image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
_, mask = cv2.threshold(image, 230, 255, cv2.THRESH_BINARY_INV)

                        
kernel = np.ones((3,3), np.uint8)
dilation = cv2.dilate(mask, kernel, iterations=2) # iterations 반복횟수
erosion = cv2.erode(mask, kernel)
opening = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)
closing = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)

mg = cv2.morphologyEx(mask, cv2.MORPH_GRADIENT, kernel)   # 팽창과 침식의 차  / 경계, 윤곽선, 테두리 등을 추출에 주로 쓰임
th = cv2.morphologyEx(mask, cv2.MORPH_TOPHAT, kernel)     #                 이미지의 밝은 영역에서 뚜렷한 경계를 강조

image_list = np.hstack([
    image,
    mask,
    dilation, 
    erosion,  
    opening,  
    closing
])

image_list_01 = np.hstack([
    mg,
    th
])

plt.imshow(image_list, 'gray')
plt.title('org img to mask, dilation, erosion, opening, closing')
plt.show()

plt.imshow(image_list_01, 'gray')
plt.title('org img to mg, th')
plt.show()

1.  커스텀 필터로 data폴더안에 있는 모든 .png파일 불러오기

import cv2
import matplotlib.pyplot as plt
import numpy as np
import os
import glob


image_path = "./data"
image_list = glob.glob(os.path.join(image_path, "*.png"))  # data 폴더안에 .png를 모두 불러옴

for path in image_list :
    print(path)
    image = cv2.imread(path, 1)
    image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
    
    # custom filter 
    filter = np.array([[3,-2, -2 ], [-3, 7, -5], [5, -1, 0]])
    
    """
    각각의 a, b, c는 필터의 가중치  값을 나타냅니다. 이 값은 이미지의 각 픽셀과 이웃한 픽셀 간의 계산에 사용됩니다. 
    필터는 이미지의 각 픽셀에 적용되며, 
    필터 윈도우 내의 픽셀 값과 필터의 가중치를 곱한 후 합산합니다.
    """
    
    # custom filter 적용 
    custom_filter_img = cv2.filter2D(image, -1, filter)  # -1 : 출력이미지의 뎁스를 입력이미지와 동일하게
    
    plt.imshow(custom_filter_img)
    plt.show()

2.  세피아 필터적용

image_path = "./data"
image_list = glob.glob(os.path.join(image_path, "*.png"))

for path in image_list :
    print(path)
    image = cv2.imread(path, 1)
    
    # 효과필터 적용
    filter_ = np.array([[0.272, 0.534, 0.131], [0.119,0.686, 0.168], [0.393, 0.769, 0.189]])
    sepia_img = cv2.transform(image, filter_)
    
    plt.imshow(sepia_img)
    plt.show()
    
    
    """
    cv2.transform 함수는 이미지의 전체적인 변환 작업에 사용되며, 
    cv2.filter2D 함수는 이미지 필터링 작업을 통해 픽셀 값을 변형하는 데 사용됩니다.
    """

3. 엠보스효과

import cv2
import matplotlib.pyplot as plt
import numpy as np
import os
import glob

image_path = "./data"
image_list = glob.glob(os.path.join(image_path, "*.png"))

for path in image_list :
    print(path)
    image = cv2.imread(path, 1)
    
    # 엠보스 효과
    filter_temp = np.array([[0, 1, 0], [0, 0, 0], [0, -1, 0]])
    
    emboss_img = cv2.filter2D(image, -1, filter_temp)
    emboss_img = emboss_img + 128
    
    plt.imshow(emboss_img)
    plt.show()

학습을 시키기위해 이미지 데이터를 1차원 벡터로 변환하는  과정

import cv2
import matplotlib.pyplot as plt

image_path = "./data/box.png"

### 경계선 찾기
# 1. 픽셀 강도의 중간값을 계산
image_gray = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)

image_10x10 = cv2.resize(image_gray, (10,10)) # image 10x10 픽셀 크기로 변환 
image_10x10.flatten()  # 이미지 데이터를 1차원 벡터로 변환

plt.imshow(image_10x10, 'gray')
plt.show()

#### 머신러닝 특성 컬러 이미지 처리 결과


image_color = cv2.imread("./data/iamge01.png")
image_color = cv2.cvtColor(image_color, cv2.COLOR_BGR2RGB)

# image size 10 x 10
image_10x10_temp = cv2.resize(image_color, (10,10)) # image 10x10 픽셀 크기로 변환 
a = image_10x10_temp.flatten() # 이미지 데이터를 1차원 백터로 변환
print(a, a.shape)

# image size 100 x 100
image_100x100_temp = cv2.resize(image_color, (100,100)) # image 10x10 픽셀 크기로 변환 
b = image_255x255_temp.flatten() # 이미지 데이터를 1차원 백터로 변환


plt.imshow(image_10x10_temp)
plt.show()

plt.imshow(image_100x100_temp)
plt.show()

1. 이미지회전 

- cv2.rotate() 함수활용

- 옵션(이미지, cv2.ROTATE_{각도}_(COUNTER)CLOCKWISE)

import cv2
import matplotlib.pyplot as plt
import numpy as np

image_path = "./data/cat.png"
image = cv2.imread(image_path)

# RGB 타입으로 변경 
image_org_ = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# 이미지 회전
image_90 = cv2.rotate(image_org_, cv2.ROTATE_90_CLOCKWISE)
image_180 = cv2.rotate(image_org_, cv2.ROTATE_180)
image_270 = cv2.rotate(image_org_, cv2.ROTATE_90_COUNTERCLOCKWISE)

plt.imshow(image_90)
plt.show()

plt.imshow(image_180)
plt.show()

plt.imshow(image_270)
plt.show()

2. 상하좌우 반전 

- cv2.flip()

- cv2.flip(이미지, 1 or 0)  1은 좌우반전, 0은 상하반전

import cv2
import matplotlib.pyplot as plt
import numpy as np

image_path = "./data/cat.png"
image = cv2.imread(image_path)

# RGB 타입으로 변경 
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# 1은 좌우 반전 / 0번은 상하 반전
dst_1 = cv2.flip(image, 1)
dst_2 = cv2.flip(image, 0)

plt.imshow(dst_1)
plt.show()

plt.imshow(dst_2)
plt.show()

1. 블러처리 (이미지블러, 가우시안블러)

1. 이미지블러 cv2.blur() 함수활용

import cv2
import matplotlib.pyplot as plt

image_path = "./data/cat.png"
image = cv2.imread(image_path)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

image_blurry = cv2.blur(image, (5,5)) # cv2.blur() 를 활용함
# 33 55 77   # 블러강도를 나타냄  

plt.imshow(image)
plt.show()

plt.imshow(image_blurry)
plt.show()

2. 가우시안블러 cv2.Gaussianblur() 함수활용 

이걸 더 많이씀

import cv2
import matplotlib.pyplot as plt
import numpy as np

image_path = "./data/cat.png"
image = cv2.imread(image_path)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

image_g = cv2.GaussianBlur(image, (9,9), 0)   # cv2.GaussianBlur() 를 사용함  
# (9,9): 주변 커널수-> 세기조절이 됨
# 0 : 표준편차

plt.imshow(image)
plt.show()

plt.imshow(image_g)
plt.show()

2. 이미지 선명하게하기

import cv2
import matplotlib.pyplot as plt
import numpy as np

image_path = "./data/cat.png"
image = cv2.imread(image_path)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

kernel_ = np.array([[0,-1,0],
                    [-1,5,-1],
                    [0,-1,0]
                   ])

image_sharp = cv2.filter2D(image, -1, kernel_)

plt.imshow(image)
plt.show()

plt.imshow(image_sharp)
plt.show()

3. 이미지 대비높이기

1 . 그레이스케일 일때  : 히스토그램 평활화 cv2.equalizeHist()에 BGR2Gray 활용 : 

import cv2
import matplotlib.pyplot as plt
import numpy as np

image_path = "./data/cat.png"
image = cv2.imread(image_path)
image_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# 단일 이미지에서만 적용가능!
image_enhanced = cv2.equalizeHist(image_gray)

plt.imshow(image_gray, 'gray')
plt.show()

plt.imshow(image_enhanced, 'gray')
plt.show()

2. 컬러일때 : RGB에 YUV를 추가함

import cv2
import matplotlib.pyplot as plt
import numpy as np

image_path = "./data/cat.png"
image = cv2.imread(image_path)

# RGB 타입으로 변경 
image_org = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

# YUV 타입으로 변경 
image_yuv = cv2.cvtColor(image, cv2.COLOR_BGR2YUV)

# 히스토그램 평활화 적용 
image_yuv[:,:,0] = cv2.equalizeHist(image_yuv[:,:,0])

# YUV > RGB 
image_rgb = cv2.cvtColor(image_yuv , cv2.COLOR_YUV2RGB)


plt.imshow(image_yuv)
plt.show()

plt.imshow(image_org)
plt.show()

plt.imshow(image_rgb)
plt.show()

4. 이진화(흑백)

import cv2
import matplotlib.pyplot as plt
import numpy as np

image_path = "./data/cat.png"
image = cv2.imread(image_path)

image_gray_01 = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# 이미지 이진화 
max_output_value = 255 
neighborhood_size = 99
subtract_from_mean = 10
image_binarized = cv2.adaptiveThreshold(
                                image_gray_01,
                                max_output_value,
                                cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
                                cv2.THRESH_BINARY, # cv2.THRESH_BINARY_INV(반전)
                                neighborhood_size,
                                subtract_from_mean
)

plt.imshow(image_binarized, 'gray')
plt.show()

1.  이미지 타입, 크기 확인하기

import cv2
image_path = "./data/cat.png"

# image read 
image = cv2.imread(image_path)

# image 타입 
image_type = type(image)
print("이미지 타입 >> " , image_type)

# 이미지 크기 확인 
image_height, image_width, image_channel = image.shape
print(image_height, image_width, image_channel)

# 이미지 타입 >>  <class 'numpy.ndarray'>
# 162 310 3

2. 이미지 리사이징

import cv2
import matplotlib.pyplot as plt

image_path = "./data/cat.png"

image = cv2.imread(image_path)

image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)  # cv2로 불러오면  BGR을 RGB로 바꿔줘야함
# https://itcreator.tistory.com/141 에 적어둠

# 이미지 크기 조절 
image_resize = cv2.resize(image, (244,244))

# 이미지 크기 확인 
image_height_, image_width_, _ = image_resize.shape


# 원본 이미지 
plt.imshow(image)
plt.show()

# 리사이즈 이미지 
print(image_height_, image_width_)
# 244 244

plt.imshow(image_resize)
plt.show()

# 저장하기

import cv2
image_resize = cv2.cvtColor(image_resize, cv2.COLOR_BGR2RGB)  
cv2.imwrite("./data/resize_image.png", image_resize)  # cv2.imwrite로 저장하기

# True라고 뜨면 저장된거

3. 이미지 자르기(슬라이싱)

import cv2
import matplotlib.pyplot as plt

image_path = "./data/cat.png"
image = cv2.imread(image_path)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

image_cropped = image[10:,:200]   #  [행시작:행끝, 열시작:열끝]

plt.imshow(image)
plt.show()

plt.imshow(image_cropped)
plt.show()

3-1. 이미지자르기(좌표)

import cv2
import matplotlib.pyplot as plt

image_path = "./data/cat.png"
image = cv2.imread(image_path)
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)


x1, y1 = 50, 50 # 좌측 상단 모서리 좌표 
x2, y2 = 150,150 # 우측 하단 모서리 좌표 

cropped_image_test = image[y1:y2, x1:x2]   # y가 먼저인 이유는 좌표평면에서 행렬의 행은 y값임
plt.imshow(cropped_image_test)
plt.show()

2. 변환하기

3. 리사이즈

4. 크롭  (슬라이싱,좌표)

1.  이미지 불러오기 (png파일)

# !pip install opencv-python==4.5.5.64
import cv2
from matplotlib import pyplot as plt 


img = cv2.imread("./data/cat.png")    # cv2 라이브러리의 imread() 함수로 불러옴

# 색상의 문제 발생 -> BGR -> RGB 
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)

plt.imshow(img)
plt.show()

2. 이미지 저장하기(.npy)

넘파이를 이용하여 배열로 저장하기

.npy 파일로 저장하는 방법

import numpy as np
np.save("./data/image.npy", img)  #  현재위치에 있는 data 폴더에 image.npy로 이미지만들기


# 만약에 해당폴더가 없으면 폴더생성하는 파이썬 코드
import os

def createDirectory(directory):
    try:
        if not os.path.exists(directory):
            os.makedirs(directory)
    except OSError:
        print("Error: Failed to create the directory.")

2-1. 이미지 저장하기(PIL)

PIL은 간단한 이미지 처리와 변환 작업에 사용하기 좋음 / 컴퓨터 비전 작업에서는 OpenCV를 쓰는게 맞음

#!pip install Pillow
import numpy as np
from PIL import Image

# 이미지 불러오기 
img = Image.open("./data/cat.png").convert('L') # 그레이 스케일 변환
print(img)

img_array = np.array(img)

np.save("./data/pil_image.npy", img_array)  # .npy로 저장
img_array1 = np.load("./data/pil_image.npy")  # .npy 불러오기

# 다시 PIL 이미지로 변환 
img = Image.fromarray(np.uint8(img_array1))    # pil의 Image라이브러리 fromarray()로 변환
img.save("./data/image_numpy.png")            # pil로 png로 변환       


org_size = os.path.getsize("./data/cat.png")
np_save_size = os.path.getsize("./data/pil_image.npy")
pil_save_size = os.path.getsize("./data/image_numpy.png")

# 용량차이 확인하기 
print(org_size, "bytes")
print(np_save_size, "bytes")
print(pil_save_size, "bytes")


# 원본 : 6468 bytes
# .npy로 저장 : 50348 bytes   
# PIL를 활용하여 png로 저장 26808 bytes

3. 이미지 불러오기 (.npy)

img_data = np.load("./data/image.npy")  # 넘파이의 load()로 불러옴

plt.imshow(img_data)
plt.show()

1. 순서가 없는 범주형 데이터

import numpy as np 
from sklearn.preprocessing import LabelBinarizer, MultiLabelBinarizer

feature = np.array((['가나다라'],
                    ['가나다라'],
                    ['아바하자'],
                    ['카나다사']))

print(feature)

# 원-핫 인코더 생성
one_hot = LabelBinarizer()
one_hot.fit_transform(feature) # 특성을 원-핫 인코딩 변환 
# 특성 클래스 확인 
print(one_hot.classes_)

"""
[['가나다라']
 ['가나다라']
 ['아바하자']
 ['카나다사']]
['가나다라' '아바하자' '카나다사']
"""

2.  다중 클래스 특성에 대한 처리

multiclass_feature = [('가나다라마','아자바하나'),
                     ('자다가나라','자다나타하'),
                     ('가나다라마','아자바하나'),
                     ('아마자나가','아카나다하'),
                     ('가나다라마','아자바하나'),
                     ]
one_hot_mult = MultiLabelBinarizer()
one_hot_mult.fit_transform(multiclass_feature)
print(one_hot_mult.classes_)

# ['가나다라마' '아마자나가' '아자바하나' '아카나다하' '자다가나라' '자다나타하']

3. 문자 타깃 데이터 원-핫 인코딩

from sklearn.preprocessing import OneHotEncoder

str_feature = ([['안녕', 1],
                ['저녁', 2],
                ['안녕', 1],
                ['점심', 3],
               ])

one_hot_encoder = OneHotEncoder(sparse=False)

# One hot encoder -> 입력 특성 배열을 모두 범주형
one_hot_encoder.fit_transform(str_feature)
print(one_hot_encoder.categories_)

# [array(['안녕', '저녁', '점심'], dtype=object), array([1, 2, 3], dtype=object)]

4. 순서가 있는 범주형 특성 인코딩

- 순서가 있는 클래스는 순서 개념을 가진 수치값으로 변환 
- 딕셔너리 사용해서 -> 특성 

import pandas as pd 
# 특성 데이터 생성
dataframe = pd.DataFrame({
    'Score' : ["Low", "Low", "Medium", "Medium", "High"]
})

print(dataframe)

"""
    Score
0     Low
1     Low
2  Medium
3  Medium
4    High
"""


# 매핑 딕셔너리 생성
scale_mapper = {
    "Low" : 1,
    "Medium" : 2,
    "High" : 3
}

print(scale_mapper)
# {'Low': 1, 'Medium': 2, 'High': 3}

data = dataframe["Score"].replace(scale_mapper)
print(data)
"""
0    1
1    1
2    2
3    2
4    3
Name: Score, dtype: int64
"""

4-2. 순서가 있는 범주형 특성 인코딩

from sklearn.preprocessing import OrdinalEncoder

feature_array = np.array((['Low', 10],
                    ['High', 40],
                    ['Medium',3],))

ordinal_encoder = OrdinalEncoder() 
ordinal_encoder.fit_transform(feature_array)
print(ordinal_encoder.categories_)
# [array(['High', 'Low', 'Medium'], dtype='<U21'), array(['10', '3', '40'], dtype='<U21')]

4-3. 순서가 있는 범주형 특성 인코딩

- 특성 딕셔너리 인코딩

from sklearn.feature_extraction import DictVectorizer
# 딕셔너리 생성 
data_dict =[{"Red" : 2 , "Blue" : 4},
            {"Red" : 4 , "Blue" : 3},
            {"Red" : 1 , "Yellow" : 2 },
            {"Red" : 1 , "Yellow" : 2}]


dictVectorizer = DictVectorizer(sparse=False)

feature_dict = dictVectorizer.fit_transform(data_dict)
print(feature_dict)

feature_dict_name = dictVectorizer.get_feature_names()
print(feature_dict_name)

dict_data = pd.DataFrame(feature_dict,  columns=feature_dict_name)
print(dict_data)


"""
[[4. 2. 0.]
 [3. 4. 0.]
 [0. 1. 2.]
 [0. 1. 2.]]
['Blue', 'Red', 'Yellow']
   Blue  Red  Yellow
0   4.0  2.0     0.0
1   3.0  4.0     0.0
2   0.0  1.0     2.0
3   0.0  1.0     2.0
"""

범주형 데이터 - 누락된 클래스값 대처하기 1

- knn으로 주변 그룹을 활용하여 nan의 값 예측함

from sklearn.neighbors import KNeighborsClassifier
x = np.array([[0, 2.10, 1.48],
             [1,1.18,1.33],
             [0,1.22,1.27],
             [1, -0.20, -1.15]])

x_with_nan = np.array([[np.nan, 0.87, 1.33], [np.nan, -0.67, -0.22]]) # 일부러 nan 생성

clf = KNeighborsClassifier(3, weights='distance')

print(x[:,1:])
print(x[:,0])

"""
[[  nan  0.87  1.33]
 [  nan -0.67 -0.22]]
[[ 2.1   1.48]
 [ 1.18  1.33]
 [ 1.22  1.27]
 [-0.2  -1.15]]
[0. 1. 0. 1.]
"""

train_model = clf.fit(x[:,1:], x[:,0])
imputer_values = train_model.predict(x_with_nan[:,1:]) # 누락된 값의 클래스 예측 

x_with_imputer = np.hstack((imputer_values.reshape(-1,1), x_with_nan[:,1:]))
data = np.vstack((x_with_imputer, x)) # 두 특성 행렬을 연결 
print(data)
"""
[[ 0.    0.87  1.33]
 [ 1.   -0.67 -0.22]
 [ 0.    2.1   1.48]
 [ 1.    1.18  1.33]
 [ 0.    1.22  1.27]
 [ 1.   -0.2  -1.15]]
 """

근처의 값을 비교해서 주변 그룹에 많이 있는 라벨을 따라감 

범주형 데이터 - 누락된 클래스값 대처하기 2

- 누락된 값을 특성에서 가장 자주 등장하는 값으로 채우기

from sklearn.impute import SimpleImputer
x_complete = np.vstack((x_with_nan, x))
print("전")
print(x_complete)

impute = SimpleImputer(strategy='most_frequent')
data_impute = impute.fit_transform(x_complete)
print("후")
print(data_impute)
"""
전
[[  nan  0.87  1.33]
 [  nan -0.67 -0.22]
 [ 0.    2.1   1.48]
 [ 1.    1.18  1.33]
 [ 0.    1.22  1.27]
 [ 1.   -0.2  -1.15]]
후
[[ 0.    0.87  1.33]
 [ 0.   -0.67 -0.22]
 [ 0.    2.1   1.48]
 [ 1.    1.18  1.33]
 [ 0.    1.22  1.27]
 [ 1.   -0.2  -1.15]]
 """

PCA 클래스: Scikit-learn의 decomposition 모듈에서 제공되는 클래스 중 하나입니다. PCA는 데이터셋의 차원을 감소시키는 기술로, 데이터셋에서 가장 중요한 특성만 추출하여 새로운 차원 축으로 변환합니다. 이를 통해 데이터셋의 노이즈(noise)를 제거하고, 더욱 빠르고 효율적인 학습이 가능해집니다.

n_components: PCA 클래스의 인자 중 하나로, 추출할 주성분(principal component)의 수를 지정합니다. 여기서는 99%의 분산(variance)을 유지하도록 설정되어 있습니다. 이는 데이터셋에서 99%의 정보가 유지되도록 차원을 축소하는 것을 의미합니다.

whiten: PCA 클래스의 인자 중 하나로, True로 설정할 경우 PCA의 결과로 나오는 주성분들이 서로 독립적인 값이 되도록 백색화(whitening)를 수행합니다. 백색화를 하면 각 주성분의 분산이 1이 되고, 상관 관계가 없는 성분들로 구성된 새로운 특성 공간이 만들어집니다.

fit_transform(): PCA 클래스에는 fit()과 transform() 메서드가 있습니다. fit() 메서드는 PCA 모델을 학습하고, transform() 메서드는 학습된 모델을 사용하여 데이터를 변환합니다. fit_transform() 메서드는 이 두 단계를 한 번에 수행합니다.

위의 같이 PCA이용하면 99%의 분산을 유지하도록 새로운 특성(feature) 공간으로 변환하고 있습니다. 결과적으로, 원본 데이터셋의 특성 개수는 features.shape[1]으로 확인할 수 있고, PCA를 수행하여 감소된 특성 개수는 features_pca.shape[1]으로 확인할 수 있습니다. 이렇게 차원 축소를 수행하면, 모델의 학습 시간을 단축시키고, 과적합(overfitting)을 방지할 수 있습니다.

from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn import datasets

digits = datasets.load_digits() # 8x8 크기의 손글씨 숫자 데이터 로드 
feature = StandardScaler().fit_transform(digits.data) # 특성 행렬을 표준화 처리 

print(feature)
 [[ 0.         -0.33501649 -0.04308102 ... -1.14664746 -0.5056698
  -0.19600752]
 [ 0.         -0.33501649 -1.09493684 ...  0.54856067 -0.5056698
  -0.19600752]
 [ 0.         -0.33501649 -1.09493684 ...  1.56568555  1.6951369
  -0.19600752]
 ...
 [ 0.         -0.33501649 -0.88456568 ... -0.12952258 -0.5056698
  -0.19600752]
 [ 0.         -0.33501649 -0.67419451 ...  0.8876023  -0.5056698
  -0.19600752]
 [ 0.         -0.33501649  1.00877481 ...  0.8876023  -0.26113572
  -0.19600752]]

pca = PCA(n_components=0.99, whiten=True)  # 99% 분산을 유지하도록 PCA객체 생성 / whiten=True 평균을 0, 표준편차를 1로변경
features_pca = pca.fit_transform(feature) # PCA 수행

print("원본 특성 개수 >> " , feature.shape[1])
print("줄어든 특성 개수 >> " , features_pca.shape[1])

# 원본 특성 개수 >>  64
# 줄어든 특성 개수 >>  54

1. StandardScaler() 
 >> Scikit-learn의 전처리(preprocessing) 모듈에서 제공되는 클래스 중 하나입니다. 이 클래스는 데이터를 평균이 0, 분산이 1인 가우시안 정규 분포(standard normal distribution)로 변환합니다.

2. digits.data : digits 데이터셋에서 숫자 이미지의 각 픽셀 값을 포함하는 배열 

3. fit_transform() 메서드 
 >> StandardScaler 클래스에는 데이터를 변환하는 두 가지 단계가 있습니다. 첫째, 모델을 학습(fit)하고, 둘째, 학습된 모델을 사용하여 데이터를 변환(transform)합니다. fit_transform() 메서드는 이 두 단계를 한 번에 수행합니다. 즉, 데이터를 표준화(normalize)하고, 변환된 값을 반환합니다.
 
따라서 위의 코드는 digits 데이터셋의 특성을 가우시안 정규 분포로 변환한 후, 변환된 값을 featuress 변수에 할당 이렇게 정규화를 수행하면, 모델이 데이터를 더 잘 이해하고, 모델의 예측 성능을 향상 시킬 수 있습니다.

결과값 비교

1. 데이터불러오기

from sklearn.datasets import load_digits
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score

digits = load_digits()

# 진짜 차이가 있는지 체크 하기 위해서 -> 정규화 하지 않은 데이터로 분류 모델 훈련
print(len(digits.data))   
print(len(digits.target))
x_train, x_test, y_train, y_test = train_test_split(digits.data, digits.target , random_state=777)

print(len(x_train), len(x_test))
print(len(y_train), len(y_test))


"""
8 : 2 
2 -> 1 : 1 
8 : 1 : 1


1. 폴더 생성 (이미지 100개)
2. 폴더 읽고 -> train val test 나눠서 폴더 생성해서 거기에 이미지 저장
"""

# 1797
# 1797
# 1347 450
# 1347 450​

2. 모델불러오기

model = LogisticRegression(max_iter=10000)
model.fit(x_train, y_train)
y_pred = model.predict(x_test)

no_standardScaler_acc_score = accuracy_score(y_test, y_pred) # 정답지 예측치
print(no_standardScaler_acc_score)

# 0.9533333333333334

3. StandardScaler 적용후 -> ACC

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
x_train_norm = scaler.fit_transform(x_train)
x_test_norm = scaler.transform(x_test)
model_norm = LogisticRegression(max_iter=10000)
model_norm.fit(x_train_norm, y_train)
y_pred_norm = model_norm.predict(x_test_norm)

standardScale_acc_score = accuracy_score(y_test, y_pred_norm)
print(standardScale_acc_score)

# 0.9555555555555556 값 상승함

마이크로소프트 한국지사와 상공회의소가 진행하는 AI(CV) 트랙입니다.

전체 커리큘럼을 확인하면 

1개월차

간단한 웹관련 

2개월차

AI 기초/ 클라우드 (Azure ai/dp -900을 딸 수 있도록 4일간의 교육과 15달러 약 20만원치의 바우처를 지원합니다)

3개월차 

통계 / 전처리

4개월차 (데이터 트레이닝을 위한 Azure  공간지원 - aws 지원한다고 생각하면됨)

 AI 심화 / CNN / 이미지분류 프로젝트

5개월차 

객체프로그램 

6개월차

메인프로젝트

순으로 진행되며 자세히 보시면 알겠지만 AI 과정중에서도 NLP(자연어처리) 과정이 아닌 CV(컴퓨터비전) 과정입니다.

이건 분명히 알고 오셔야합니다. 

nlp도 다루긴 하지만 특강 형식으로 인코더/디코더가 뭔지 트랜스포머, rnn이 뭔지, 셀프어텐션 등 키워드 중심으로 이론을 설명하며

간단한 실습 정도로 끝납니다.

Q : 비전공자가 참여하기 어떤가요?

A : 충분히 따라올 수 있으나, 개발자체가 처음이시라면 많이 힘들 수 있습니다.

기초가 없는 사람들을 위해 커리큘럼상 기초과정이 들어가있긴 합니다. AI 과정은 컴공 + 통계라 생각하시면 됩니다. 

네트워크 기초 파이썬 기초등을 3일 안에 끝내버리고 통계학과 1학기 동안 배우는 내용을 8일안에 끝내는 식입니다.

필자는 6개월간 백엔드 / 4개월간 Devops 및 ml 기초의 국비수업을 이미 들었지만 쉽지 않았습니다. (컴공과 분들도 쉽지않다고 하셨음)

하루 7시간 매일 강의를 듣고, 그것을 흡수하기 위해 하루 3시간 이상의 복습시간 총 10시간 정도는 반드시 확보하셔야 합니다.

* 녹화본 미제공이라 복습 어떻게 하냐? -> 녹화본 스트리밍으로 제공해줍니다. 놓쳤던 부분 따로 공부가능 (특강은 제공x)

Q : 지원이후 면접 준비중인데 어떻게 준비하면 좋을까요?

A : 지원이유, 관련경험, 미래계획 을 확실히 말씀하시면 됩니다.

지금까지(1, 2기) 지원경쟁률이 2~5:1로 알고있습니다. 팀플이 있는 만큼 아무생각 없이 오시는분들은 서류 및 면접에서 걸러집니다.

수강생 중 전공자 비율도 30프로 정도가 되고, 학력과 직업등 좋으셨고, 미래계획이 확실하셨던 분들이였습니다.

(20대초반 부터 30대 중후반까지 나이스펙트럼은 다양하며, 대학교수님들도 몇 분 계셨습니다! 대부분 20대 중후반입니다)

 면접준비는 "나는 CV쪽 관심이 많아서 이런것을 구현 해본적이 있고, 팀원들과 이런것을 하고싶고, 미래에는 이런 회사에 취업하기 위해 지원하였습니다" 라고 말할 수 있다면 합격선이라고 생각합니다. 너무 추상적으로 말씀하시면 구체적으로 설명해달라고 물어보시니 준비 잘하세욥! ex 어떤 모델을 쓰셨나요? 로직은 어떻게 되나요? 

Q : 다른 AI 과정에 비해 장점이 있을까요?

A : Azure 지원, MS 오피스투어,  Linkedin 컨설팅, 파트너 기업 추천등 강점은 확실합니다.

필자는 네이버 부스트 과정을 준비하다가 MS AI / Aiffel 과정이 먼저와서 둘다 지원 Aiffel 에도 최종 합격하였으나, ms를 선택했습니다 (aiffel 보다 ms가 낫다는건 아닙니다. aiffel 이 더 나을 수도있습니다. hrd에서 aiffel 후기도 참조하시면 될듯합니다.)

국비교육 특히 KDT 과정을 들으면 멘토링, 취업특강, 훈련지원금등 어떤 과정을 듣던 지원받는 공통지원이 있습니다. 

하지만 다른 과정에 비해  MS AI를 선택함으로 얻는 이점은 Azure 지원, MS 오피스투어, 파트너 기업등 확실한 장점이 있습니다.

그 중 가장 마음에 들었던것은 Azure로 공부하고 지원 받는거였습니다. 네이티브 강사분이 직접 Azure를 설명하시고 리눅스 설명 또한 

Azure 가상환경에서 지원받을 수 있었고, Azure 시험을 공짜로 칠 수 있도록 무료 바우처(20만원 상당)를 지원합니다.

AI과정의 경우  AWS/Azure를 반드시 사용하는데 네이티브 환경에서 한다는건 진짜 매력적으로 느껴졌습니다.

마지막으로 Linkedin 컨설팅과 MS 오피스투어등 MS 직원, 강사분들과 네트워크 형성 및 Linked 인 컨설팅으로 해외취업에서도 굉장히 유리한 위치를 선점할 수 있다고 생각합니다.

Q : 교육은 추천할만한가요?

A : 전체적으로는 만족하며, 다시 과거로 돌아간다고 하더라도 MS ai school에 입과를 선택했을겁니다.     

필자는 올바른 국비교육에 대해 글을 남긴적이 있는데 (https://itcreator.tistory.com/165) 참고하시길 바랍니다.

국비교육에서는 강사확인이 필수입니다! 

이번 과정 강사는 MS 측 강사와 인피닉스 쪽 강사님들로 배정됩니다.

네트워크 과정/ AI 과정 / Azure 설명/ CV 과정/ CRUD 과정 등 다양한 과정에 각각 다른 강사님이 배정되며

매우 만족했던 강사님 ex) 김영욱 강사님 부터 준비가 많이 아쉬운 강사님도 계셨습니다.

그냥 대학 교수님 생각하시면 됩니다. 많은걸 아시지만 설명능력이 아쉬운 강사님부터 유튜브 운영까지면서 거의 프로MC급 진행능력을 가지신 분들도 계시지만 결국 공부는 혼자 복습하셔야합니다!

하지만 전체적으로는 만족하며, 다시 과거로 돌아간다고 하더라도 MS ai school에 입과를 선택했을겁니다.     

Q : 대학원을 가야할지 이 프로젝트를 가야할지 고민입니다

A : 데싸, 연구직 - 석박 추천 /// 데엔 - 프로젝트 추천

본인이 가고싶은 포지션으로 구인검색 하셔서 경력사항 및 우대사항을 보시면 될 듯 합니다.

중간에 대학원 선택을 위해 중도포기 하시는 분들도 많으셨습니다. AI 쪽이다보니 석박을 해야하나 는 많은 질문들이 수업시간에도 올라오는데 현 개발자, 연구자 분들은 데이터 사이언스를 희망 하거나, 연구직 이라면 대학원 추천 ///
데이터 엔지니어라면 프로젝트 추천이라고 하셨습니다. 그러면서 AI 시장은 변화속도가 워낙 빨라서 다른 학문에 비해서 석박과정에서의 학습이 매우 의미가 없을 수도 있다고 하셨습니다. AI는 컴공과 통계쪽 분들이 많이 오시는데 AI 석사이상은 컴공보다는 통계 포지션임을 기억하셔야합니다.

MS ai school 의 교육 환경은 매우 좋으며 강사진은 완벽하지는 않지만 우수한 편입니다.

문제 발생시 피드백이 굉장히 빠른편이며, 수강생들의 열정또한 정말 좋아서 지금 당장 카톡 오픈방에 ms라 치시면 각종 스터디 방 뿐만 아니라 논문, 프로젝트방 따로 모여 공부하시는 방을 쉽게 찾을 수 있습니다. (비번걸려있어서 들어갈 순 없을겁니다)

정리를 하자면

CV(컴퓨터 비전) 쪽 포트폴리오용 프로젝트를 열정있는 사람들과 함께 하고 싶고, 기본기가 튼튼하신 분들이라면

MS ai school이 좋은 선택이라 생각합니다!

추가질문이 있으시면 우측 하단으로 편하게 연락주시면 됩니다

질문 모아서 이곳에 추가합니다.

로컬에서 작업할때는 버전관리가 되지않는다 

파이썬 3.11을 쓰다가 호환을 위해 3.7이 필요하다면 3.11을 지웠다가 3.7을 써야한다 -> 불편함

그래서 필요로 하는 라이브러리에 맞게 가상환경을 만들어서 그것을 불러오면 쉽게 버전관리가 된다.

가상환경 생성 및 삭제

conda create -n 가상환경이름 python= 버전

conda env remove -n 가상환경이름

가상환경 리스트확인

conda env list
conda info envs
#  conda info -e 와 동일함

가상환경 비/활성화

conda activate 가상환경이름

conda deactivate 가상환경이름

필요한 라이브러리 설치/ 확인

conda install 라이브러리명

conda list # 설치된 라이브러리 확인

딥러닝은 가장 적합한 가중치를 찾는과정

사용용도에따라 다양한 모델이 있다 (CNN, DNN, RNN)

RNN은 주로 시계열 데이터에 사용된다. (시간의 흐름에 따라 이전 결과에 영향을 계속 받음)

CNN은 주로 이미지를 분석할때 사용 (차원감소) 

신경망의 종류

⦿ 시계열 데이터에 주로 사용됨. 앞의 결과가 뒤의 결과에 영향을 줌

⦿ 이미지 분석할때 항상 나옴

신경망 기초

함수로 표현하기

# 신경망 기초

import math
import numpy as np
import matplotlib.pyplot as plt

# 일차함수

def linear_function(x):
  a=0.5
  b=2

  return a*x+b
  
x = np.arange(-5,5,0.1)
y = linear_function(x)

plt.plot(x,y)
plt.xlabel('x')
plt.ylabel('y')
plt.title('Linear Function')

# 2차 함수
def quadratic_fuction(x):
  a = 1
  b = -1
  c = -2

  return a*x**2 + b*x + c
  
  
x = np.arange(-5,5,0.1)
y = quadratic_fuction(x)

plt.plot(x,y)
plt.xlabel('x')
plt.ylabel('y')
plt.title('Quadratic Function')

# 3차 함수

def cubic_function(x):
  a = 4
  b = 0
  c = -1
  d = -8

  return a*x**3 + b*x**2 + c*x + d
  
x = np.arange(-5,5,0.1)
y = cubic_function(x)

plt.plot(x,y)
plt.xlabel('x')
plt.ylabel('y')
plt.title('Cublic  Function')

텐서의 표현

# Tensor의 표현  (스칼라와 벡터)

# Tensor의 표현   # 스칼라와 벡터 

x = np.array(3)  #스칼라
print(x)   
print(x.shape)  # 형태, 모양
print(x.ndim)   # 차원

# 3
# ()
# 0

y = np.array([3])  # 벡터
print(y)
print(y.shape)
print(y.ndim)

# [3]
# (1,)
# 1

# 1차원 텐서

a = np.array([1,2,3,4])
b = np.array([5,6,7,8])
c = a + b
d = d + x    # x = 3     d(1차원과) + x(0차원) 합도 가능
print(c)
print(c.shape)
print(c.ndim)

# [ 6  8 10 12]
# (4,)
# 1

print(d)
print(d.shape)
print(d.ndim)

# [4 5 6 7]
# (4,)
# 1

# 차원이 달라서 부족한 값들은 그냥 같은값을 복사해서 연산한다. 브로드캐스팅이라 한다.

# 똑같이 하나의 성분이라도 리스트에 포함시키면 1차원이 되므로 벡터가 된다.

# 벡터의 곱

# 벡터의 곱

x = np.array([1,2,0])
y = np.array([0,2,1])
z = np.dot(x, y)

print(z)
print(z.shape)
print(np.ndim(z))

# 4
# ()
# 0

# 전치 행렬

# 전치 행렬
a = np.array([[1,2,3],[4,5,6]])
print(a)
print(a.shape)

# [[1 2 3]
   [4 5 6]]
# (2, 3)



a_ = a.T    # 전치행렬로 행과 열을 바꿈
print(a_)
print(a_.shape)

# [[1 4]
   [2 5]
   [3 6]]
# (3, 2)

# 2차원 텐서

# 2차원 텐서 

matrix = np.array([[1,2,3],[4,5,6]])

print(matrix)
print(matrix.shape)
print(np.ndim(matrix))

# [[1 2 3]
  [4 5 6]]
# (2, 3)
# 2


a = np.array([[1,2],[3,4]])
b = np.array([[10,10],[10,10]])

print(a * b)
# [[10 20]     
   [30 40]]

# 3차원 텐서

# 3차원 텐서

x = np.array([[[5,3,2,1],
               [5,5,3,1],
               [6,1,2,3]],
              [[1,1,1,1],
               [3,4,7,5],
               [1,8,3,4]],
              [[10,9,3,9],
               [5,4,3,2],
               [7,6,3,4]]])
print(x)
print(x.shape)
print(np.ndim(x))

#[[[ 5  3  2  1]
   [ 5  5  3  1]
   [ 6  1  2  3]]

 [[ 1  1  1  1]
  [ 3  4  7  5]
  [ 1  8  3  4]]

 [[10  9  3  9]
  [ 5  4  3  2]
  [ 7  6  3  4]]]
# (3, 3, 4)
# 3

@ 이미지는 가로축, 세로축, 색상값 의 3차원 데이터이다.

@ [w, h, [r,g,b]] 의 형태이다.

@ 시계열 데이터도 3차원텐서를 사용한다. 시계열데이터란 한쪽축이 시간축으로 시간에따른 데이터들의 변화를 나타내는 것을 의미한다. 주식, 기상 등의 값이있다.

@ 영상은 4차원텐서 w, h, f(프레임), [r,g,b] 의 형태

[4차원, 5차원 텐서]

신경망의 구조

# 논리게이트

# AND 게이트

# 논리 게이트

# AND
def AND(a,b):
  input = np.array([a,b])
  weights = np.array([0.4, 0.4])	# 가중치 +
  bias = -0.6				# 편향 강한 -
  value = np.sum(input * weights) + bias

  if value <= 0:
    return 0
  else:
    return 1
    
    
print(AND(0,0))
print(AND(0,1))
print(AND(1,0))
print(AND(1,1))

# 0
# 0
# 0
# 1

가중치와 바이어스를 컴퓨터가 스스로 찾도록 하는것이 딥러닝

x1 = np.arange(-2,2,0.01)
x2 = np.arange(-2,2,0.01)
bias = -0.6

y = (-0.4 * x1 - bias) / 0.4

plt.axvline(x=0)
plt.axhline(y=0)

plt.plot(x1, y, 'r--')
plt.scatter(0,0,color='orange', marker='o',s=150)
plt.scatter(0,1,color='orange', marker='o',s=150)
plt.scatter(1,0,color='orange', marker='o',s=150)
plt.scatter(1,1,color='black', marker='^',s=150)

plt.xlim(-0.5,1.5)
plt.ylim(-0.5,1.5)
plt.grid()

# OR 게이트

# OR 
def OR(a,b):
  input = np.array([a,b])
  weights = np.array([0.4, 0.4])	# 가중치 +
  bias = -0.3				# 편향 약한 -
  value = np.sum(input * weights) + bias

  if value <= 0:
    return 0
  else:
    return 1
    
print(OR(0,0))
print(OR(0,1))
print(OR(1,0))
print(OR(1,1))

# 0
# 1
# 1
# 1

# NAND 게이트

# NAND
def NAND(a,b):
  input = np.array([a,b])
  weights = np.array([-0.5, -0.5])      # 가중치 -
  bias = 0.7				# 편향은 강한 +
  value = np.sum(input * weights) + bias

  if value <= 0:
    return 0
  else:
    return 1
    
print(NAND(0,0))
print(NAND(0,1))
print(NAND(1,0))
print(NAND(1,1))

# 1
# 1
# 1
# 0

x1 = np.arange(-2, 2, 0.01)
x2 = np.arange(-2, 2, 0.01)
bias = 0.7

y = (0.6 * x1 - bias) / -0.5

plt.axvline(x=0)
plt.axhline(y=0)

plt.plot(x1, y, 'r--')
plt.scatter(0,0,color='black',marker='o',s=150)
plt.scatter(0,1,color='black',marker='o',s=150)
plt.scatter(1,0,color='black',marker='o',s=150)
plt.scatter(1,1,color='orange',marker='^',s=150)
plt.xlim(-0.5,1.5)
plt.ylim(-0.5,1.5)
plt.grid()
plt.show()

# XOR 게이트

def XOR(x1, x2):
  s1 = NAND(x1, x2)
  s2 = OR(x1, x2)
  y = AND(s1, s2)

  return y
  
print(XOR(0,0))
print(XOR(0,1))
print(XOR(1,0))
print(XOR(1,1))

# 0
# 1
# 1
# 0

하... 진짜 궁금한게 보증보험 드는 과정을 왜 이렇게 복잡하게 만들었는지 도저히 이해가 안된다...

HUG 메인 페이지는 폐기했다던 공인인증서를 요구해서 바로 칼차단

갓네이버 전세보증보험으로 우회해서 들어갔는데

1. 주소 검색이 안되서  1566-9009 전화를 했는데 한 3시간동안 계속 통화연결 도전했다가 안됨... 빡쳐서 폭풍검색 

우선 주소가 안뜨면 무조건 은행가야함!!

2.알아보니 신한, 국민, 우리, 광주, KEB하나, 기업, 농협, 경남은행에서 바로 신청이 가능하다는걸 알게 되었다. 

(전세대출을 받았다면 대출을 받은 지점으로가서 해야한다!!!!)

3. 지도를 보니 국민은행이 가장 가까워서 필요한 서류를 알아보기 시작

  (1) 본인신분증(주민등록증 등 본인확인증표)  - 전자지갑으로 받으면 프린트 안해도됨
  (2) 확정일자부 임대차계약서 원본(공인중개사 중개)
  (3) 전세보증금 수령 및 지급확인서류(무통장 입금증, 계좌이체 내역 등)

  (4) 대상목적물 건물등기사항전부증명서 (1개월 이내 발급분) 
  (5) 건축물관리대장(단독, 다가구 주택의 경우에만 제출) 
  (6) 주민등록등본(1개월 이내 발급분) 
  (7) 선순위 임차인들의 임차계약서(단독, 다가구주택의 경우에만 제출) 
  (8) 전입세대 열람내역 - 동사무소 가서 받아야함. 현금만 가능하니 천원짜리 챙겨서가셈

  (9) 기타 필요서류 (보증 등에서 필요 시) 

  (10) 확정일자부여현황, 상가건물임대차현황서(목적물에 근린생활시설 등 상가 확인되는 경우) ☞ 단독, 다가구 주택인 경우로 보증심사 완화대상으로 심사하는 경우 개인에 따라 추가 서류 발생될수있습니다

샘알트만 온다는데 안간다고?

https://openai.com/form/openai-tour-2023

https://aws.amazon.com/ko/events/summits/seoul/

메타에서 SAM(Segment Anything Model)이라는 모델을 무려 오픈소스(Apache-2.0 license)로 공개하였습니다. 이미지 속 개체를 인식하여 영역을 분할하는 모델로 기존 대비 훨씬 더 많은 데이터로 학습하여 뛰어난 성능을 보여줍니다.

SAM 소개 페이지

https://segment-anything.com/ https://ai.facebook.com/blog/segment-anything-foundation-model-image-segmentation

SAM 깃허브  

https://github.com/facebookresearch/segment-anything

SAM 데모 써보기

https://segment-anything.com/demo

1.  mac alfred 

https://www.alfredapp.com/

진짜 핵강추 어플!!  생산성 확 올라갑니다!
예시) 지도 검색하려면 -> 네이버키고 -> 지도 검색해서 -> 목적지 검색 -> 검색완료라면
알프레드는 opt + space -> ㅈㄷ 시청 (세팅해야함) -> 네이버 지도 검색 끝 

영어사전도 마찬가지 -> ㅇㅅㅈ 사과 -> 네이버 사전에서 검색끝

등등 부터해서 여러가지 꿀기능 많음!!

2. maccy

맥북 클립보드 어플 

사진 및 글자 복사한거 모아두기 가능 option + c  로 목록확인  및 command + shift + s 스샷 찍어 리스트에 저장 후 사용(바탕화면 아낄수 있음)

스토어에 10유로에 사지말고 개발자라면 깃허브 오픈소스 쓰자. 

https://github.com/p0deje/Maccy/releases

3. bettertouchtool

https://folivora.ai/

4. 압축풀기 keka

https://www.keka.io/ko/

거의 모든 포맷 커버가능

5. 영상재생 IINA

https://iina.io/

거의 모든 포맷 재생가능

6. 배터리 관리

https://github.com/davidwernhart/AlDente-Charge-Limiter/releases