현업에서 ORACLE도 많이 사용하고 MY SQL과 문법이 조금씩 다르지만 일단 우선 MY SQL부터 도장 깨기

✏️ BASIC

SQL 작성 순서

SELECT - FROM - WHERE - GROUP BY - HAVING - ORDER BY - LIMIT

SQL 실행 순서

FROM - WHERE - GROUP BY - HAVING - SELECT - ORDER BY - LIMIT

💡 함수(Funtions) vs 연산자 (Operator)

• 함수 영문 함수 이름 + 괄호

함수

✏️ 숫자 함수

💡 평균 (AVG)

💡 반올림 (ROUND)

💡 MIN / MAX

✏️ NULL 처리

💡 IFNULL

컬럼이 NULL을 반환할 때, 다른 값으로 출력하는 함수

SELECT IFNULL(컬럼명, 대체값) FROM 테이블명

**MSSQL**
ISNULL(VALUE1, VALUE2)

**ORACLE**
NVL(VALUE1, VALUE2)

✏️ 날짜 함수

💡 DATE_FORMAT

날짜를 지정한 형식으로 출력

SELECT DATE_FORMAT(컬럼명,'%Y-%m-%d') FROM 테이블명

# 2016년09월22일 17시00분05초
SELECT DATE_FORMAT(컬럼명,'%Y년%m월%d일 %H시%i분%S초') FROM 테이블명

- FORMAT

💡 DATE vs DATETIME

연산자

연산자들은 조건으로 필터링하는 역할이므로 WHERE절에 위치

WHERE 절 WHERE 절에서는 단일 행 기준의 조건을 사용해야 하므로, 집계 함수를 직접 사용할 수 없습니다. EX) WHERE MIN(DATETIME)

✏️ 특수조건 검색

💡 IN / NOT IN

• 연속적이지 않은 여러값 조회
• 컬러명 IN ("")

#SELECT * FROM 테이블명 WHERE 컬럼명 = VALUE 1, 컬럼명 = VALUE 2, 컬럼명 = VALUE 3
SELECT * FROM 테이블명 WHERE 컬럼명 IN ("VALUE 1", "VALUE 2", "VALUE 3")

💡 BETWEEND, AND

• 연속적인 값 조회

  #SELECT * FROM 테이블명 WHERE 컬럼명 >= VALUE 1 AND Column <= VALUE 2
  SELECT * FROM 테이블명 WHERE 컬럼명 BETWEEN VALUE 1 AND VALUE 2

💡 LIKE

• 문자열 검색
• _ : 글자수 1개 , % : 모든 글자
• 컬럼명 LIKE ""

#A로 시작하는 문자 찾기
SELECT * FROM 테이블명 WHERE 컬럼명 LIKE 'A%'

#A로 끝나는 문자 찾기
SELECT * FROM 테이블명 WHERE 컬럼명 LIKE '%A'

#A를 포함하는 문자 찾기
SELECT * FROM 테이블명 WHERE 컬럼명 LIKE '%A%'

#A로 시작하는 두글자 문자 찾기
SELECT * FROM 테이블명 WHERE 컬럼명 LIKE 'A_'


#A로 시작하는 두글자 문자 찾기
SELECT * FROM 테이블명 WHERE 컬럼명 LIKE 'A_'

-----

#첫번째 문자가 'A''가 아닌 모든 문자열 찾기
SELECT * FROM 테이블명 WHERE 컬럼명 LIKE'[^A]'

#첫번째 문자가 'A'또는'B'또는'C'인 문자열 찾기
SELECT * FROM 테이블명 WHERE 컬럼명 LIKE '[ABC]'
SELECT * FROM 테이블명 WHERE 컬럼명 LIKE '[A-C]'

✏️ NULL 처리

💡 IS NULL / IS NOT NULL

SELECT * FROM 테이블명 WHERE 컬럼명 IS NULL

지금까지 데이터 위주의 프로젝트만 진행했었는데, 처음 경험해보는 백앤드 & 프론트앤드와 함께하는 서비스 기반 프로젝트라 기대를 안고 참여를 하게됐다.

가짜연구소는 머신러닝/데이터사이언스를 중심으로 모인 비영리 커뮤니티입니다.
예측할 수 없는 비선형적인 성장과 너드 문화를 선도하며 사소하고 재밌는 일들을 해오고 있습니다. 
가짜연구소에서는 기초 이론 공부, 논문 리뷰, 연구개발 프로젝트, 논문 작성, 펠로우쉽, 멘토링, 컨퍼런스 등을 진행하며 함께 성장하고 있습니다. 
가짜연구소에 오셔서 동기부여가 가득한 사람들과 관심 있는 주제로 즐겁게 함께하세요!

- 가짜연구소 홈페이지 : https://pseudo-lab.com
- 가짜연구소 디스코드 : https://discord.gg/EPurkHVtp2
- 가짜연구소 블로그 : https://pseudolab.github.io/
- 가짜연구소 유튜브 : https://bit.ly/pseudo-lab-youtube

현재까지 진행한 과제

• 웹 크롤링
  • 꽃 이미지 데이터 웹 크롤링
  • '서울'지역 2020 ~ 2024년 2,3월 기상 정보 웹 크롤링 (최고기온, 최저기온, 일강수량,최대 순간 풍속)
• 기상 정보 시각화

✨ 웹 크롤링

🌸 꽃 이미지 데이터 추출 🌸

본격 진행함에 있어 가장 우선시된 타겟은 봄의 시작을 알리는 가장 상징적인 꽃 벚꽃이였다.

그리고 기존 데이터 셋에는 벚꽃 이미지가 없었기 때문에 십시일반으로 각 멤버들 모두 300개의 이미지 데이터 수집을 하기로 하였다. 나는 많은 코드 자료가 있기도 하고, 팀원이 올려준 코드가 있는 google image 크롤링을 택했다.

제공받은 코드로 하면 금방 끝날 줄 알았는데, 역시나... 어디서부터 꼬였는지, 약 50개 단위로 이미지들이 중복되어 다운이 받아졌고, 패턴을 찾아보니 아래와 같이 중간에 껴있는 관련 검색어때문에 코드가 잘못 처리된 것으로 보였다.

중복되지않는 이미지만 다운로드 받기 위한 해결 방법으로 아래와 같이 처리하였고, 무사히 300개 데이터 다운로드 완 🤘🏻

downloaded_images = set()  # 이미 다운로드한 이미지 URL을 저장하는 집합 생성
.
.
.
# 이미지 다운로드
for image_info in image_info_list:
    if download_cnt >= image_cnt:
        break
    if 'src' in image_info.attrs:
        image_url = image_info['src']
        if image_url not in downloaded_images:  # 이미지 중복 체크, 중복되지 않은 것만 다운 받도록 조건 설정
            downloaded_images.add(image_url)
            image_filename = f"{keyword.replace(' ', '_')}_{download_cnt}.jpg"
            image_path = os.path.join(save_dir, image_filename)
            urllib.request.urlretrieve(image_url, image_path)
            logging.info(f'{image_filename} image download')
            download_cnt += 1

🌸 기상정보 크롤링 🌸

기상청 사이트에서 2020~2024년, 그 중 개화 시기에 큰 영향을 끼친다 2,3월 위주의 기상 정보를 크롤링하여 가져왔다. 위와 같이 사이트 주소에서 날짜와 지역 코드를 넣으면 자료를 추출할 수 있는 구조였기에, 기상청에서 사용하고 있는 지역 코드를 가장 우선으로 리스트화 하여 정리한 다음, 이걸 주소에 대입시켜 보며 기상 정보 추출까지 완료!🤘🏻

총 11826 rows × 7 columns의 데이터 셋을 만들어 냈다.

✨ 데이터 시각화

소개받은 새로운 인터랙티브 시각화 라이브러리 중 2023년 성장세 1위라는 pygwalker를 사용하여 위 기상정보의 시각화를 진행했다.

- Top 10 growing data visualization libraries in Python in 2023 - pygwalker.Github (한글버전 가이드도 있음!)

이 라이브러리를 사용한 소감은 한 마디로 'tableau', 한 마디 덧붙이면 '간단 그 자체'. matplot이든 seaborn이든 코드를 원하는 그림을 어느정도 구상하고 코드 쿼리를 작성해야 하는데,

이건 그냥 아래처럼 2줄 작성하면

import pygwalker as pyg
walker = pyg.walk(df)

이런 tableau같은 인터랙티브 창이 나온다. 그럼 입맛에 맞게 x,y열에 데이터 끌어다 넣고 sum이든 avg든 필요한 연산만 클릭하면 자동으로 그래프가 완성된다.

아무리 tableau 같다고 하더라도, 데이터를 추가 연결은 불가(원한다면 df1을 다른 df2와 merge 시켜야함), 투명도/컬러 등 자우 셋팅 불가 (데이터 값으로만 조정 가능) 등 자유롭지 않다는 한계점이 있었다. 그래도 에러-수정-에러-수정이 있는 코드 쿼리 작성보다는 확실히 편했다.

아래처럼 map 시각화도 가능하긴 한다는데, 음..이 자료로는 효과적이지 못해서 작동 방법만 몇 번 클릭만 해봤다.

✨ 회고

오랜만에 셀레니움, 웹 크롤링을 해보며 '역시 코딩은 계속 꾸준히 직접 짜봐야한다'는걸 되새기고, 새로운 라이브러리들을 보면서 '역시 세상엔 천재들이 많구나' 깨우쳤다.

✨ 기타 자료

데이터를 통해 통찰력을 얻기 위한 최고의 파이썬 시각화 라이브러리

• 이미지 분류에 유용
• 가장 간단한 인공 신경망

  from sklearn.model_selection import cross_validate
  from sklearn.linear_model import SGDClassifier
  sc = SGDClassifier(loss='log', max_iter=5) # max_iter=5 : 5번 에포크
  scores = cross_validate(sc, train_X, train_y, n_jobs=-1)
  print(np.mean(scores['test_score']))

✏️ 텐서플로 (TensorFlow)

• 딥러닝 라이브러리

• CPU, GPU를 사용해 인공 신경망 모델을 효율적으로 훈련

from tesorflow as tf

💡 케라스(Keras)

• 텐서플로 내 고수준 API
• 직접 GPU 실행 X, 백앤드(텐서플로, 씨아노, CNTK 등)와 함께
• 기본적으로 '미니배치 경사 하강법'사용

  from tesorflow import keras

• 용량이 크기 때문에 교차 검증을 잘 사용 X => 검증 세트는 별도로 덜어내어 사용

  from sklearn.model_selection import train_test_split
  train_X, val_X, train_y, train_y= \
  train_test_split(train_X, train_y, test_size=0.2) 
  #test_size=0.2 : 검증 세트는 20%로

1-1.밀집층 만들기

• 머신러닝과 다른 추가 단계
• 신경망 중 가장 기본층
• Dense
  • 밀집층을 만드는 클래스
  • n : 뉴런 개수
  • activation='abc' : 뉴런 출력에 적용할 함수 (보통 'softmax'), 회귀에선 아무 값도 지정 안함
  • input_shape=(x,y) : 입력의 크기

    dense = keras.layers.Dense(n,activation='abc',input_shape=(x,y))

• 이진 분류일 경우 : activation='sigmoid'
• 뉴런이 3개 이상의 다중 분류일 경우 (이진분류 X) : activation='softmax' (참고-분류 파트)

1-2. Dense - 은닉층 만들기 for 심층 신경망 1️⃣

• 출력층(이진-시그모이드, 다중-소프트맥스)에 비해 사용할 수 있는 활성화 함수가 자유로움/ '시그모이드' & '볼 렐루' 함수 주로 사용

1-3. '1-2'단계 말고 '2-2'로 바로 넘어가기

2-1. 밀집층을 가진 신경망 모델 만들기

• 케라스의 Sequential() 사용

# model : 신경망 모델
model = leras.Sequential(dense)

# layer(층)이 2개 이상 일 경우 (은닉층 같이)
# 순서 중요 : 출력층을 가장 마지막에 위치
model = kearas.Sequential([dense1,dense2])

• model 분석하기 - .summary()
  • Output Shape에서 첫번째 차원 : 샘플 개수 (None / 어떤 배치 크기에도 유연하게 대응 가능) fit()메서드에서 batch_size=로 수정 가능
  • Output Shape에서 두번째 차원 : 출력 개수 (100,10 / 입력층보다 적어야 정상
  • Total = dense 1(784*100+10) + dense 2 (100*10+10) = 79510

    model.summary()
    >>>
    Model: "sequential_1"

Layer (type) Output Shape Param #

dense_1 (Dense) (None, 100) 78500

dense_2 (Dense) (None, 10) 1010

================================================================= Total params: 79510 (310.59 KB) Trainable params: 79510 (310.59 KB) Non-trainable params: 0 (0.00 Byte)

#### 2-2. Sequential() - 은닉층 만들기 2️⃣
```python
model = keras.Sequential([
    keras.layers.Dense(100,activation='sigmoid', input_shape =(784,), name = 'hidden'),
    keras.layers.Dense(10,activation='softmax',name='output')
],name='패션 MNIST 모델')

model.summary()
>>>
Model: "패션 MNIST 모델"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 hidden (Dense)              (None, 100)               78500     

 output (Dense)              (None, 10)                1010      

=================================================================
Total params: 79510 (310.59 KB)
Trainable params: 79510 (310.59 KB)
Non-trainable params: 0 (0.00 Byte)
_________________________________________________________________

2-3. add() 메서드 - 은닉층 만들기 3️⃣

model = keras.Sequential()
model.add(keras.layers.Dense(100,activation='sigmoid', input_shape=(784,),name='hidden'))
model.add(keras.layers.Dense(10,activation='softmax',name='output'))

model.summary()
>>>
Model: "sequential_2"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 hidden (Dense)              (None, 100)               78500     

 output (Dense)              (None, 10)                1010      

=================================================================
Total params: 79510 (310.59 KB)
Trainable params: 79510 (310.59 KB)
Non-trainable params: 0 (0.00 Byte)
_________________________________________________________________

2-4. 렐루 함수 - 은닉층 만들기 3️⃣

• [참고] Flatten() 메서드 train_X= train_X.reshape(-1,n)을 통해 1차원으로 변환하던 것을 Flatten 메서드로 간편하게 진행

  model = keras.Sequential()
  #input_shape=(n,m) : 데이터 크기 n x m
  model.add(keras.layers.Flatten(input_shape=(n,m)))
  model.add(keras.layers.Dense(100, activation='relu'))
  model.add(keras.layers.Dense(10,activation='softmax'))
  model.summary()
  >>>
  #Flatten 층이 추가로 생김 -> 784개의 입력이 1차원으로 변환하여 은닉층에 전달
  Model: "sequential_5"

Layer (type) Output Shape Param #

flatten (Flatten) (None, 784) 0

dense_5 (Dense) (None, 100) 78500

dense_6 (Dense) (None, 10) 1010

================================================================= Total params: 79510 (310.59 KB) Trainable params: 79510 (310.59 KB) Non-trainable params: 0 (0.00 Byte)

#### 3. 훈련 전 설정
* model 객체의 compile()메서드 수행 - 손실 함수 & 측정 지표등 지정
* "손실 함수 종류" 중요
* metrics=accuracy : 에포크마다 손실도를 알려줄 때, 정확도도 함께 출력
```python
# 원-핫 인코딩이 준비되지 않았을 경우,
model.compile(loss='sparse_categorial_crossentropy', metrics='accuracy')

# 원-핫 인코딩 준비됐을 경우,
model.compile(loss='categorial_crossentropy', metrics='accuracy')

4. 모델 훈련하기

model.fit(train_X, train_y, epochs=5, verbose=1)
#verbose=1 : default / 에포크마다 진행 막대 & 지표 등 표시
#verbose=0: 에포크마다 진행 막대 & 지표 등 표시 X
#verbose=2 : 에포크마다 지표 표시 (진행 막대 표시 X)
>>>>
Epoch 1/5
1500/1500 [==============================] - 8s 3ms/step - loss: 0.6105 - accuracy: 0.7931
Epoch 2/5
1500/1500 [==============================] - 4s 3ms/step - loss: 0.4744 - accuracy: 0.8387
Epoch 3/5
1500/1500 [==============================] - 4s 2ms/step - loss: 0.4509 - accuracy: 0.8481
Epoch 4/5
1500/1500 [==============================] - 4s 2ms/step - loss: 0.4369 - accuracy: 0.8514
Epoch 5/5
1500/1500 [==============================] - 4s 3ms/step - loss: 0.4292 - accuracy: 0.8549
<keras.src.callbacks.History at 0x7c8e7d74d870>

5. 모델 검증하기

머신러닝에서 일종의 .score과 동일한 구조

model.evaluate(val_X,val_target)

💡 콜백^callback

• ModelCheckpoint 콜백
  • 에포크마다 모델을 저장
  • save_best_only = True : 가장 낮은 검증 점수를 만드는 모델 저장
  • 혼공머신 408p 참고

💡 조기 종료^{early stopping}

• 과대 적합 전에, 훈련을 중지하는 것 (훈련 epoch 횟수 제한)
• 콜백 종류 중 하나
• 파라미터
  • patience = n : n번 연속 검증 점수가 향상 되지 않으면 훈련 중지
  • restore_best_weights=True : 가장 낮은 검증 손실을 낸 모델 파라미터로 되돌림
• 혼공머신 409p 참고

  model = model_fn(keras.layers.Dropout(0.3))
  model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics='accuracy')
  checkpoint_cb = keras.callbacks.ModelCheckpoint('best-model.h5',save_best_only=True)
  early_stopping_cb = keras.callbacks.EarlyStopping(patience=2,restore_best_weights=True)
  history=model.fit(train_scaled, train_target, epochs=20,verbose=0, validation_data=(val_scaled, val_target),callbacks=[checkpoint_cb,early_stopping_cb])

💡 딥러닝 하이퍼파라미터

• 추가할 은닉층의 개수

• 뉴런 개수

• 활성화 함수

• 층의 종류

• 배치 사이즈 매개변수

• 에포크 매개변수

• compile 옵티마이저 설정

  • SGD : 가장 기본 옵티마이저
    • 학습률 sgd=keras.optimizers.SGD(learning_rate=0.1)
    • 모멘텀 최적화 보통 모멘텀 매개변수는 0.9 이상 지정
    • 네스테로프 기본값인 False를 True로 설정 -> 네스테로프 모멘텀 최적화 (네스테로프 가속 경사) sgd = keras.optimizers.SGD(momentum=0.9, nestrov=True)

      model.compile(optimizer='sgd',     loss='sparse_categorical_crossentropy',   metrics='accuracy')
      

  혹은

  sgd=keras.optimizers.SGD() model.compile(optimizer=sgd, loss='sparse_categorical_crossentropy', metrics='accuracy')

   * Adagrad : '적응적 학습률'을 사용하는 옵티마이저 1 (default =0.001)
   '적응적 학습률' : 모델이 최적점에 가까울수록 학습률을 낮춤 -> 안정적으로 최적점 수렴
  ```python
  adagrad=keras.optimizers.Adagrad()
  model.compile(optimizer=adagrad, loss='saprse_categorical_crossentropy',   metrics='accuracy')

  • RMSprop : '적응적 학습률'을 사용하는 옵티마이저 2 (default = 0.001)

    rmsprop=keras.optimizers.RMSprop()
    model.compile(optimizer=rmsprop, loss='saprse_categorical_crossentropy',   metrics='accuracy')

  • Adam : 모멘텀 최적화 + RMSprop

    model.compile(optimizer='adam',   loss='saprse_categorical_crossentropy',   metrics='accuracy')

• 드롭아웃

  • 훈련이 끝난 뒤, 평가 & 예측시에는 드롭아웃을 적용 X
  • 텐서프로 & 케라스는 자동으로 드롭아웃 적용 X

    #30 % 드롭 아웃함
    model.add(keras.layers.Dropout(0.3))

• 등등

✏️ 출처

교재 '혼자 공부하는 머신러닝 + 딥러닝'

"회귀"보다 평가 항목이 많은 편

• 분류 모델 성능 평가 지표(Accuracy, Precision, Recall, F1 score 등)
• Confusion Matrix(혼동 행렬, 오차 행렬) / Accuracy(정확도) / Precision(정밀도) 등등

💡 Confusion Matrix(혼동 행렬, 오차 행렬)

• Predicted Values (예측)

  • P(Positive): 모델이 positive라고 예측 (1)
  • N(Negative): 모델이 negative라고 예측 (0)

• Actual values (실제)

  • T(True): 예측한 것이 정답 (1)
  • F(False): 예측한 것이 오답 (0)

• Actual + Predicted

  • TP(True Positive): 모델이 positive라고 예측했는데 실제로 정답이 positive (정답)
  • TN(True Negative): 모델이 negative라고 예측했는데 실제로 정답이 negative (정답)
  • FP(False Positive): 모델이 positive라고 예측했는데 실제로 정답이 negative (오답) => 1종 오류 (Type 1 error)
  • FN(False Negative): 모델이 negative라고 예측했는데 실제로 정답이 positive (오답) => 2종 오류 (Type 2 error)

💡 Accuracy(정확도)

• .score
• 전체 데이터 중 맞게 예측한 것의 비율
• 0 ~ 1 사이의 값을 가지며, 1에 가까울수록 좋다.
• 데이터가 불균형할 때, (ex) positive:negative=9:1)는 Accuracy만으로 제대로 분류했는지는 알 수 없기 때문에 Recall과 Precision을 사용한다.

$$ Accuracy=\frac{TP+TN}{TP+TN+FP+FN}$$

💡 Precision(정밀도) = PPV(Positive Predictive Value)

• Predict가 Positive(양성)인 것중 실제 양성 비율 $$ Precision=\frac{TP}{TP+FP}$$

💡 Recall(재현율) = Sensitivity(민감도) = TPR(True Positive Rate)

• Actual이 Positive(양성)인 것 중 양성이라고 예측한 비율 (실제 1 중에서 1이라고 예측) $$ Recall=\frac{TP}{TP+FN}$$

💡 Fall Out(위양성률) = FPR(False Positive Rate)

• 실제 정답이 negative인 것들 중에서 모델이 positive라고 예측한 비율 $$ Fall Out=\frac{FP}{FP+TN}$$

💡 5. F1 score

• Recall + Precision
• Precision과 Recall이 한쪽으로 치우쳐지지 않고 모두 클 때 큰 값을 가진다.
• 0 ~ 1 사이의 값을 가지며, 1에 가까울수록 좋다. $$ F1=\frac{2×Precision×Recall}{Precision+Recall}$$

✏️ 출처

제로베이스 '데이터 취업스쿨' 수강중 교재 '혼자 공부하는 머신러닝 + 딥러닝' 분류 모델 성능 평가 지표(Accuracy, Precision, Recall, F1 score 등) Rebro의 코딩 일기장:티스토리

• 임의의 수치(연속적인 값)를 예측하는 문제
• score 확인시, "결정 계수(R²)"로 평가
• 손실 함수 확인시, '평균 제곱 오차^{mean squared error}'사용
• mean_absolute_error() : 회귀 모델에의 평균 절댓값 오차 계산 ```python from sklearn.metrics import mean_absolute_error test_prediction = knr.predict(test_input) #예측값 mae = mean_absolute_error(test_target,test_prediction) #test_target : 정답값, test_prediction : 예측값 print(mae)

19.157142857142862 #예측이 타깃값과 19 정도 차이가 난다는 뜻

### 💡 K-최근접 이웃 회귀
* 사례 기반 학습
* 학습된 범위 이상 예측이 어려움
* 데이터 스케일링 필요할 수도 있음

```python
from sklearn.neighbors import KNeighborsRegressor
knr = KNeighborsRegressor()

💡 선형 회귀 (Linear Reg.)

from sklearn.linear_model import LinearRegression
lr = LinearRegression()

• 모델 기반 학습
• 특성 & 타깃간 관계를 가장 잘 나타내는 선형 방정식을 구함 (a=기울기, b= y절편) $$ y=ax×b$$

  # a & b 구하기
  print(lr.coef_, lr.intercept_)
  

a = lr.coef_ / 특성에 대한 계수를 포함한 배열 = 특성의 개수

b = lr.intercept_ / 절편

* 선형 회귀가 찾은 특성 & 타깃 관계는 선형 방정식의 '계수' 혹은 '가중치'에 저장
* 잔차 (residue)
  * 에러 값
  * 어떤 모델이 데이터의 정보를 적절하게 잡아냈는지 여부를 확인할 때 유용
  * 잔차의 평균이 0인 정규 분포를 따라야 함
  * 잔차 평가 : 잔차의 평균이 0이고 정규분포를 따르는지 확인
* <span style="color:grey">2차방정식 (다항회귀/곡선형/비선형) : 혼공머신 139p 확인</span>
  * get_feature_names_out()
 ```python
poly=PolynomialFeatures(include_bias=False)
poly.fit(train_input)
train_poly=poly.transform(train_input)
poly.get_feature_names_out()
#[19.6, 5.14 , 3.04 , 384.16, 100.744 , 59.584, 26.4196, 15.6256, 9.2416]의 값은
#array(['x0', 'x1', 'x2', 'x0^2', 'x0 x1', 'x0 x2', 'x1^2', 'x1 x2','x2^2'], dtype=object)으로 계산됨

💡 다중 회귀

• 2개 이상의 여러 개의 특성을 사용한 선형 회귀
• 선형 회귀 모델과 동일한 from sklearn.linear_model사용
• 특성이 많 -> 선형 모델의 고성능 발휘

💡 릿지 & 라쏘 회귀

• 선형 회귀 모델에 규제^{regularzation}를 추가한 모델
• 해서 선형 모델과 동일하게 from sklearn.linear_model사용
• 두 모델 모두 계수의 크기를 줄이지만 '라쏘'는 0까지 가능

  1. 릿지 회귀

• 계수를 제곱한 값을 기준으로 규제 적용
• '릿지'를 '라쏘'보다 더 선호하는 추세

  from sklearn.linear_model import Ridge
  ridge=Ridge()
  ridge.fit(train_X,train_y)

  2. 라쏘 회귀

• 계수의 절대값을 기준으로 규제 적용

  from sklearn.linear_model import Lasso
  lasso=Lasso()
  lasso.fit(train_X,train_y)

  💡 회귀 result 확인하기

  

  💡 비용함수 (Coste Func.)

  [머신러닝] 비용함수(Cost Function)란

✏️ 분류(Classification)

특징

• 예측값으로 이산적인 값을 출력

  • 이산값 : 0과1로 처리할 수 있는 값으로써 연속적이 아닌 단속적인 값
  • 아이리스 문제, 와인 종류, 부도 여부(yes/no), 여신 승인 여부, 동물 분류(dog/cat) 등

• 종류 (혼공머신 - 190p, 356p)

  • 이진 분류 : Yes/ No처럼 두가지의 답으로 분류하는 것
  • 다중 분류 : 다양한 답으로 분류 (타깃 데이터에 클래스가 2개 이상)

• 이진 분류 (딥러닝 관련)

• 다중 분류 (딥러닝 관련)

다중 분류

• 다중 분류 : 다양한 답으로 분류 (타깃 데이터에 클래스가 2개 이상)
  • 타깃을 1과0이 아닌 알파벳 그대로 사용 가능하나, 알파벳 순서로 정렬됨
  • 클래스 배열 확인하기

💡 K-최근접 이웃 알고리즘

• KNeighborsClassifier(n_neighbors=n)
• sklearn.neighbors.KNeighborsClassifier
• 사례 기반 학습
• 거리기반 분류분석 모델
  • 가장 가까운 유사 속성에 따라 분류하여 라벨링하는 것
  • 거리가 가까운 'k'개의 다른 데이터의 레이블을 참조하여 분류하는 알고리즘
  • 다수를 보고! 다수를 차지!하는 것을 정답으로 사용
  • 사전에 기준치(단위,스케일)를 맞춰야 함 => 특성공학 차원에서 표준 편차, 표준 점수를 이용 하는 편
  • 거리 측정시 '유클리드 거리' 계산법 사용
• 데이터가 아주 많은 경우 사용하기 어려움
• 데이터 스케일링이 필요할 수도 있음 `혹은 plt.axis('equal')로 x축, y축 동일하게 만들어서 산점도 확인해보기

  from sklearn.neighbors import KNeighborsClassifier
  kn=KNeighborsClassifier()
  #train_y 는 다중 클래스
  kn.fit(train_X, train_y)
  kn.classes_

  파라미터 (Parameters)	설명
  n_neighbors	- n_neighbors=int (참고할 데이터 개수,default=5) ex) kn49=KenighborsClassifier(n_neighbors=49) 가장 가까운 49개 데이터에서 다반수인 것을 예측 - 분류가 가능하도록 K는 홀수로 설정하는 것이 좋으며, 일반적으로는 총 데이터 수의 제곱근 값을 사용
  weights	- {‘uniform’, ‘distance’}, callable or None, default=’uniform’
  algorithm	- {‘auto’, ‘ball_tree’, ‘kd_tree’, ‘brute’}, default=’auto’
  n_jobs	- n_neighbors=int (default=None)
  ```python
  print(kn._fit_X) #knn으로 훈련된 x 프린트
  print((kn._y) #knn으로 훈련된 x 프린트
  ```
  #### - 가장 가까운 이웃 값들 구하기 (이웃 개수 : 기본값 5일 때)
  ```python
  distance, indexes= kn.kneighbors([[25,150]])

train_input[indexes]

array([[[ 25.4, 242. ], [ 15. , 19.9], [ 14.3, 19.7], [ 13. , 12.2], [ 12.2, 12.2]]])

### 💡 ⭐️로지스틱 회귀
* 이진 분류 & 다중 분류에 사용되므로 '분류'파트에 작성
* 선형 회귀와 같이 '선형 방정식' 사용하지만 값을 0~1사이로 압축 ('타깃'일 확률을 계산함)
  * 다중 분류-원 핫 인코딩 : 타깃 값 클래스만 1, 나머지 0인 배열로 만드는 것
* 선형 회귀와 달리 '시그모이드 함수', '소프트맥스 함수' 사용

```python
from sklearn.linear_model import LogisticRegression
lr= LogisticRegression()

💡 ⭐️SGD Classifier (확률적 경사 하강법)

• 머신러닝, 특히 딥러닝에서 사용되는 가장 대표적인 최적화 알고리즘
• 한 번에 하나 또는 일부의 훈련 샘플을 사용하여 그라디언트를 계산하고 매개 변수를 업데이트
• 수렴 속도가 느리고, 최적화 문제에 따라 최솟값을 찾는 데 어려움이 있을 수 있음
• 2차원 배열 X, 1차원 배열 O train_X= train_X.reshape(-1,n) train_X= train_X.reshape(1,n)

  from sklearn.linear_model import SGDClassifier
  sc=SGDClassifier(loss='log_loss',max_iter=10,random_state=42)
  #loss='log_loss' : 로지스틱 손실 함수 -> 클래스가 많아도 이진 분류 모델 생성 (a=양성, 나머지는 다 음성)
  #loss 기본값 : hinge
  #max_iter=10 : 10번 반복
  sc.fit(train_X train_y)

  이어서 모델 수행하기

  sc.score(train_X, train_y)

  에포크 300번 반복

  # _ : 임시로 두는 것, 그냥 버리는 값
  for _ in range(0,300):
    sc.partial_fit(train_X, train_y, classes=classes)
    train_score.append(sc.score(train_X,train_y))
    test_score.append(sc.score(test_X, test_y))

✏️ 출처

제로베이스 '데이터 취업스쿨' 수강중 교재 '혼자 공부하는 머신러닝 + 딥러닝' 머신러닝 - 회귀(Regression) VS 분류(Classification) 회귀문제와 분류문제(Regression & Classification)

• 머신러닝에서 모델의 성능 향상을 위해 쓰이는 기법 중 하나

• 최고의 hyperparameter를 찾기 위해 사용

from sklearn.model_selection import GridSearchCV

sklearn.model_selection.GridSearchCV(estimator, param_grid, *, scoring=None, n_jobs=None, refit=True, cv=None, verbose=0, pre_dispatch='2*n_jobs', error_score=nan, return_train_score=False)[source]¶

✏️ 출처

머신러닝 GridSearchCV 로 하이퍼 파라미터 학습과 최적화 GridSearchCV란? 뭘까? 사용 방법(예시)

관련 게시글

• [EDA] 데이터 시각화 (Matplotlib) - 2d 그래프
• [머신러닝] 타이타닉 생존자 예측

✏️ 종류

💡 matplotlib 라이브러리

• python 프로그래밍 언어 및 수학적 확장 NumPy 라이브러리를 활용한 플로팅 라이브러리
• https://matplotlib.org/

  import matplotlib.pyplot as plt    
  from matplotlib import rc  #폰트 설정
  rc("font",family="Arial Unicode MS")
  

%matplotlib inline #혹은 get_[python().run_line_magic("matplotlib","inline"]

plt.figure(figsize=(10,6)) plt.plot(X축, Y축) #x축,y축 plt.show()

### 💡 seaborn 라이브러리
* matplotlib 를 기반으로 하는 Python 데이터 시각화 라이브러리
* [https://seaborn.pydata.org/index.html](https://seaborn.pydata.org/index.html)
```python
import seaborn as sns

💡 Matplotlib vs Seaborn 라이브러리

Matplotlib 는 지속적으로 개발되고 있는 인기 있는 플로팅 패키지. 수많은 렌더링 백엔드를 제공하고 장황한 구문을 사용하여 플롯에 높은 수준의 유연성과 사용자 정의 가능성을 제공

• 그래프를 임의로 그려야 하는 경우
• 고도로 맞춤화된 플롯을 생성하거나 seaborn 뒤에 있는 플로팅 도구를 배우려는 경우, Matplotlib 고려

seaborn 은 Matplotlib 위에 구축된 Python 플로팅 라이브러리. Matplotlib보다 더 보기 좋은 스타일 기본값으로 데이터 세트를 빠르게 시각화하는 간결하지만 제한된 접근 방식을 허용합니다.

• DataFrame을 가지고 그리는 경우
• 간결한 코드를 작성하고 더 짧은 시간에 더 매력적인 기본 스타일로 플롯(특히 통계 플롯)을 생성하려면 seaborn을 고려.

✏️ Seaborn

** plot 정리 : Seaborn - 데이터를 시각화하는 17가지 방법

💡 countplot()

1. seaborn.countplot

seaborn.countplot(data=None, *, x=None, y=None, hue=None, order=None, hue_order=None,
orient=None, color=None, palette=None, saturation=0.75, fill=True, hue_norm=None,
stat='count',width=0.8, dodge='auto', gap=0, log_scale=None,
native_scale=False,formatter=None, legend='auto', ax=None, **kwargs)

2. 예시

plt.subplots(figsize=(15, 6))
sns.countplot(data=DF이름, x='column명', palette='RdYlGn(컬러명)', 
              edgecolor=sns.color_palette('dark', 7))
plt.xticks(rotation=90)
plt.title('제목')
plt.show()

💡 seaborn을 위해 DF 바꾸기

* .melt(df, id_vars="기준", var_name="컬럼을 value로", value_name="value를 컬럼으로")

    class       men       woman   children
0   first   0.91468    0.667971   0.660562
1   second  0.30012    0.329380   0.882608
2   third   0.11899    0.189747   0.121259

▼▼▼▼▼▼

df = pd.melt(df, id_vars="class", var_name="sex", value_name="survival rate")
df
Out: 
    class       sex  survival rate
0   first       men       0.914680
1  second       men       0.300120
2   third       men       0.118990
3   first     woman       0.667971
4  second     woman       0.329380
5   third     woman       0.189747
6   first  children       0.660562
7  second  children       0.882608
8   third  children       0.121259

💡 palette

matplotlib 컬러명(color name), 팔레트(palette) 이름

• 색상을 반대로 하고 싶다면 : 색상 뒤에 _r붙이기

✏️ 출처

파이썬 데이터분석을 위한 시각화 라이브러리(matplotlib, seaborn,etc) [Python] Seaborn 패키지 - countplot(), rugplot() Python >> Seaborn - (1) Seaborn을 활용한 다양한 그래프 그리기

• 모델 학습 시 데이터를 훈련용과 검증용으로 교차하여 선택하는 방법

• 종류
  • K-Fold Cross-Validation
  • Hold-out Cross-Validation
  • Leave-p-Out Cross-Validation(LpOCV)
  • Leave-One-Out CV(LOOCV)
• accuracy 검증시, 항상 같은 값이 나오는 것이 아니지만, np.mean(평균값)이 대표값을 확인 할 수 있다.

💡 이유

• 과적합을 피하면서 파라미터를 튜닝하고 일반적인 모델을 만들고 더 신뢰성 있는 모델 평가를 진행하기 위함
• 그 어떤 글보다 아래 글이 가장 잘 정리되어 있는 것 같아서 캡쳐했다.

💡 장단점

✏️ K-Fold Cross-Validation

• 전체 데이터셋을 K개의 fold로 나누어 K번 다른 fold 1개를 test data로, 나머지 (K-1)개의 fold를 train data로 분할하는 과정을 반복함으로써 train 및 test data를 교차 변경하는 방법론

• 학습 데이터 세트와 검증 데이터 세트를 점진적으로 변경하면서 마지막 K번째까지 학습과 검증을 수행하는 것

from sklearn.model_selection import KFold
kf=KFold(n_splits=보통 3 or 5)

💡 특징

• K는 하이퍼파라미터로서 주로 5~10 fold 사용
• 최적의 K값을 찾기 위한 실험적 검증 필요
• 가장 일반적인 교차검증 방법론
• k가 적어질 수록 bias는 커질 것이고 k가 커진다면 variance가 커짐. 또한 k가 크다면 시간도 많이 걸릴 것
• 학습 데이터 (Training set) - 문제집의 문제은행
• 검증 데이터 (Validation set)* - 문제집에 속한 기출 모의고사 (성능 검증 / 학습에는 활용되지 않음)
• 시험 데이터(Test set)* - 실제 시험

💡 절차

1. 전체 데이터를 K개 fold로 분할
2. 분할된 fold 중 test data로 할당된 적이 없는 fold 1개를 test data로 할당
3. 위 2. 과정을 K번 반복
4. K개의 모델 성능 평가 결괏값을 평균 내어 최종 결괏값으로 활용

💡 장단점

💡 예시: k = 5인 경우

• k를 5로 지정(k는 변동 가능), 전체 데이터를 임의로 1/5로 나누어서 validation set을 한 번씩 번갈아가면서 데이터셋을 구성
• 각 데이터를 학습하고 validation으로 평가를 한 다음 5개의 결과에 대해 평균을 내어 최종 성능을 구함

✏️ Stratified K-fold Cross Validation

• 층화 K-fold CV는 기존 K-fold CV와 비슷한 방법으로 수행되나 계층을 고려하는 방법

✏️ Train score 확인

from sklearn.model_selection import cross_validate
cross_validate(estimator, X, y=None, cv=skfold, return_train_score=True)

✏️ 출처

'제로베이스 데이터 취업 스쿨' 수강중 [Machine learning] 쉽게 설명하는 Cross Validation 교차검증 [머신러닝] 교차검증(Cross-validation) 필요성 및 장단점 파이썬 머신러닝 교차검증 - KFold, StratifiedKFold, cross_val_score, GridSearchCV [바람돌이/머신러닝] 교차검증(CV), Cross Validation, K-fold, TimeSeries 등 CV 종류 및 이론|작성자 바람돌이

• 규칙을 일일이 프로그래밍 하지 않아도 자동으로 데이터에서 규칙을 학습하는 알고리즘을 연구하는 분야

• 통계학과 관련
• 대표 머신러닝 라이브러리 : 사이킷런 (scikit -learn)

💡 사이킷 런(sklearn)이란?

• 2007년 구글 썸머 코드에서 처음 구현됐으며 현재 파이썬으로 구현된 가장 유명한 기계 학습 오픈 소스 라이브러리
• 다양한 분류기를 지원하며 머신러닝 결과를 검증하는 기능 보유
• 또한 분류, 회기, 클러스터링, 차원 축소처럼 머신러닝에 자주 사용되는 다양한 알고리즘을 지원

  import sklearn

💡 명령어 & 용어 정리

1. zip()

name = ['merona', 'gugucon']
price = [500, 1000]

z = zip(name, price)
print(list(z))

>>> [('merona', 500), ('gugucon', 1000)]

name = ['merona', 'gugucon']
price = [500, 1000]

for n, p in zip(name, price):
    print([n, p])
혹은
[n, p] for n, p in zip(name, price)
>>>
[[merona,500],[gugucon,1000]]

2. numpy

• 배열 라이브러리 (고차원적인 배열 가능)

  2-1. .column_stack : numpy로 zip같은 기능 사용하기

  import numpy as np
  f_data=np.column_stack(([1,2,3],[4,5,6]))
  f_data
  >>>
  array([[1, 4],
       [2, 5],
       [3, 6]])

  import numpy as np
  f_data=np.column_stack((f_length, f_weight)
  f_data[:5]
  >>>
  array([[ 25.4, 242. ],
       [ 26.3, 290. ],
       [ 26.5, 340. ],
       [ 29. , 363. ],
       [ 29. , 430. ]])

  2-2. 배열 : 열(특성수), 행(샘플수)

  import numpy as np
  name = ['merona', 'gugucon','pigbar']
  price = [500, 1000, 600]
  

list = [n, p] for n, p in zip(name, price) list_array= np.array(list)

[[merona,500] [gugucon,1000] [pigbar, 600]

print(list_array.shape) #numpy array로 정렬된 형태 확인하기

(3,2) #3행2열

##### 2-3. 1씩 증가하는 인덱스 만들기
```python
# 0 ~ 48까지 1씩 증가하는 배열
index=np.arrage(49)
print(index)
>>>
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
       17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
       34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48])

2-4. train_test_split 하거나 numpy로 무작위 셔플링하기

np.random.shuffle(index)
print(index)
>>>
[13 45 47 44 17 27 26 25 31 19 12  4 34  8  3  6 40 41 46 15  9 16 24 33
 30  0 43 32  5 29 11 36  1 21  2 37 35 23 39 10 22 18 48 20  7 42 14 28
 38]

2-5. 배열에서 가장 큰 값의 인덱스 반환

배열의 첫 번째 원소가 가장 큰 값일 경우, 인덱스 0 반환

val_labels = np.argmax(model.predict(val_scaled),axis=-1)
#predict(val_scaled)의 마지막 차원(-1)의 최대 인덱스 값
print(np.mean(val_labels == val_target))
#val_labels & val_target 비교후 위치가 같으면 1, 다르면 0
#이를 평균하면 정확도

3. 파라미터(매개변수) & 하이퍼파라미터

✏️ 머신러닝 시작

💡 특성 공학 (feature engineering)

• 기존의 특성을 사용해 새로운 특성을 뽑아내는 작업 (혼공머신 4쇄 :99p

  #평균
  mean = np.mean(X_train, axis=0)
  

#표준편차 std=np.std(X_train, axis=0)

#표준점수 std_score=(X_train-mean)/std

#polynomialFeatures from sklearn.preprocessing import PolynomialFeatures poly = PolynomialFeatures() poly.fit([[n,m]]) poly.transform([[n,m]])

1,n,m,n^2,n*m,m^2 #1을 없애고 싶으면 poly = PolynomialFeatures(include_bias=False) #5제곱까지 하고 싶으면 poly = PolynomialFeatures(degree=5) ##하지만 너무 상세히 특성을 정리하면 과대적합(overfitting)됨

### 💡 train\_test_split
>* [sklearn.model_selection.train_test_split](https://scikit-learn.org/stable/modules/generated/sklearn.model_selection.train_test_split.html)
* <span style="color:yellowgreen">train set(학습 데이터 세트)과 test set(테스트 세트)을 분리</span>
  * X_train : 학습 데이터 셋의 feature 부분
X_test : 테스트 데이터 셋의 feature 부분
y_train : 학습 데이터 셋의 label 부분
y_test : 테스트 데이터 셋의 label 부분
* stratify 파라미터로 무작위 섞은 후 트레인 세트와 테스트 세트 분리


```python
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y)

💡 label_encoder

• sklearn.preprocessing.LabelEncoder

• 문자를 0부터 시작하는 정수형 숫자로 바꿔주는 기능
• 코드숫자를 이용하여 원본 값 구함 (반대 기능)

from sklearn.preprocessing import LabelEncoder

>>> from sklearn.preprocessing import LabelEncoder
>>> le = LabelEncoder()

# fit : [1,2,2,6]을 학습 시킴
>>> le.fit([1, 2, 2, 6])
LabelEncoder()

#.class_ : fit시킨 le라는 변수에 학습된 소스 확인
>>> le.classes_
array([1, 2, 6])

# fit을 한 다음에 transform 시키기
>>> le.transform([1, 1, 2, 6])
array([0, 0, 1, 2]...)

>>> le.inverse_transform([0, 0, 1, 2])
array([1, 1, 2, 6])

💡 .score : 평가하기

• 정확도 = (정확히 맞힌 개수) / (전체 데이터 개수)
• 과대적합 : 훈련 세트 점수는 좋으나 테스트 세트 점수가 안 좋을 경우
• 과소적합 : 훈련 세트보다 테스트 세트 점수가 높을 경우, 두 점수 모두 낮을 경우 (모델이 단순할 경우 발생함) => 훈련 세트의 점수를 높여줌 ex)KNN일 경우, n_neighbors를 5에서 3으로 낮추기

  kn=KNeighborsClassifier()
  kn.fit(a_data, a_target)
  kn.score(b_data, a_target) #b_data의 답을 b_target이라고  kn머신 학습된 것에 돌렸을 때의 점수(..이게 맞는건강..?)

  💡 .predict : 학습된 데이터로 예측하기

  #위 데이터 이어서
  kn.predict([[30,600]])
  >> array([1]) #"1(도미)에 해당한다"

💡 .predict_proba : 예측 확률

#lr 타겟이 2개 일 경우 (타겟 알파벳순)
lr.predict_proba(train_X[:5])
>>>
array([[0.99759855, 0.00240145],
       [0.02735183, 0.97264817],
       [0.99486072, 0.00513928],
       [0.98584202, 0.01415798],
       [0.99767269, 0.00232731]])

💡 .evaluate()

• 성능 평가
• compile() 메서드 (딥러닝)가 먼저 실행되어야 함

💡 accuracy

from sklearn.metrics import accuracy_score

.score() / .evaluate() / .accuracy() 차이 비교해보기

✏️ 학습 & 훈련

💡 학습

array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])

* 특성 : 데이터를 표현하는 하나의 성질
<span style="color:grey">ex) 생선 데이터 각각의 길이와 무게</span>

### 💡 지도 학습 - 훈련
- 샘플링 편향 : 샘플링이 한쪽으로 치우쳐져 있는 상황
  * 샘플링 편향을 피하기 위해 훈련 세트와 테스트 세트를 나누기 전 데이터를 충분히 골고루 섞여있어야 함
  * 참고 페이지 : [[머신러닝] ✨머신러닝 베이직  & 모델 클래스 (feat. sklearn, 사이킷 런)✨ >> 💡 샘플 섞기](https://velog.io/@soo_oo/%EB%A8%B8%EC%8B%A0%EB%9F%AC%EB%8B%9D-%EB%A8%B8%EC%8B%A0%EB%9F%AC%EB%8B%9D-%EC%8B%9C%EC%9E%91%ED%95%98%EA%B8%B0#-%EC%83%98%ED%94%8C-%EC%84%9E%EA%B8%B0)

|<center>훈련 종류</center>|<center>설명</center>|
|------|---|
|<center>훈련 세트</center>|- 모델을 훈련할 때 사용<br>- 훈련세트가 클수록 좋음<br>- 테스트 세트를 제외한 모든 데이터 사용<br>- 2차원 배열이여야 함 (1차 배열이라도 2차원 배열로 만들기)<br> ex) <span style="color:yellowgreen">.reshape(n행,y열)</span> 사용|
|<center>테스트 세트</center>|- 통상 전체 데이터에서 20~30% 사용|
* <span style="color:yellowgreen">numpy.reshape(a, newshape, order='C') </span>
  * a: 변경하려는 배열
  * newshape: 변경하려는 배열의 새로운 shape
  * order: 배열의 요소 순서. 'C'(기본값)는 C 언어 스타일의 요소 순서, 'F'는 포트란 스타일의 요소 순서 ({‘C’, ‘F’, ‘A’},optional)
  * a.reshape(-1,n) : n열에 맞춰서 행 자동 셋팅
  * a.reshape(n,-1) : n행에 맞춰서 열 자동 셋팅

```python
a = np.arange(9)
# array([0, 1, 2, 3, 4, 5, 6, 7, 8])
a.reshape(3, 3)

>>>
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])

a = np.arange(9)
# array([0, 1, 2, 3, 4, 5, 6, 7, 8])
np.reshape(a, (3, 3))

>>>
array([[0, 1, 2],
       [3, 4, 5],
       [6, 7, 8]])

💡 지도 학습 - 과대적합 & 과소적합

1. 과대적합 -> 규제

• 훈련 세트가 과도한 학습을 못하도록 훼방
• 예시 선형 회귀 모델 : 특성에 곱해지는 계수 (혹은 기울기)의 크기 축소

  2. 과소적합 -> 특성 세분화

• 모델을 더 복잡하게 만들기
• 예시 이웃 : 이웃 범위를 줄이기

💡 Data Scaling

[Python] 어떤 스케일러를 쓸 것인가? [ML] 데이터 스케일링 (Data Scaling) 이란? [데이터 전처리] 데이터 스케일링(StandardScaler, MinMaxScaler, RobustScaler)

• 서로 다른 변수의 값 범위를 일정한 수준으로 맞추는 작업을 의미
• 수치형 변수에만 적용
• 예시 ) K 이웃 모델, 계수에 곱이 들어갈 경우(릿지 혹은 라쏘)

1. 표준 점수

#표준점수
std_score=(X_train-mean)/std

2. 표준화 (Standard Scaler)

• sklearn.preprocessing.StandardScaler

• 모든 피처들을 평균이 0, 분산이 1인 정규분포를 갖도록 만듬 (표준화해주는 방법) => 전체 피처를 ttl로 보고 그 중간을 평균 0
• 데이터 내에 이상치가 있다면 데이터의 평균과 분산에 크게 영향을 주기 때문에 스케일링 방법으로 적절하지 않음

from sklearn.preprocessing import StandardScaler
ss=StandardScaler()
ss.fit(X_train)
train_scaled=ss.transform(X_train)
test_scaled=ss.transform(X_test)

3. 최소 최대 정규화 (MinmaxScaler)

• sklearn.preprocessing.MinMaxScaler

• 제일 작은 값을 0, 제일 큰 값을 1로 두어 계산

from sklearn.preprocessing import MinMaxScaler

4. RobustScaler

• sklearn.preprocessing.RobustScaler

• StandardScaler와 비슷하지만 평균과 분산 대신 중간값(median)과 사분위값(quartile)을 사용
• 아주 동 떨어진 데이터(이상치)를 제거
  • 이상치: 측정된 데이터 사이의 경향성을 지나치게 해치는 데이터 ex)측정 에러

from sklearn.preprocessing import RobustScaler

from sklearn.preprocessing import RobustScaler
rs = robustscaler()

# df = robustscaler().fit_transform(df)
df=rs.fit_transform(df)

모델 평가 (Model Evaluation) 머신러닝을 통해 예측하고자 하는 값에 따라 회귀와 분류로 모델 평가를 나눌 수 있다.

✏️ 클래스

💡 의사결정트리(Decision Tree)

• sklearn.tree.DecisionTreeClassifier

• 노드(node)
  • 루트노드(Root Node) : 시작점
  • 리프노드(Leaf Node) : 결정된 클래스 값
  • 규칙노드/내부노드(Decision Node / Internal Node) : 데이터세트의 피처가 결합해 만들어진 분류를 위한 규칙조건

from sklearn.tree import DecisionTreeClassifier
변수명= DecisionTreeClassifier(random_state=0 ...)

✏️ Pipeline

💡 파이프라인이란?

• sklearn.pipeline.Pipeline

• 전처리 ~ 학습까지의 과정을 하나로 연결

from sklearn.pipeline import Pipeline

💡 코드

# 파이프 라인 만들기
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

pipe = Pipeline([('scaler', StandardScaler()), ('svc', SVC())])
#or
#estimaters = [('scaler', StandardScaler()), ('svc', SVC())]
#pipe = Pipeline(estimaters)

pipe.steps
>>> [('scaler', StandardScaler()), ('svc', SVC())]
pipe.steps[0]
>>>('scaler', StandardScaler())
pipe.steps[1]
>>>('svc', SVC())
pipe[0]
>>> StandardScaler
pipe['scaler']
>>> StandardScaler

pipe.set_params(svc__C=10).fit(X_train, y_train).score(X_test, y_test)
#or
#(svc__max_depth=2)
#(svc__random_state=13)

# 학습 & 테스트
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(
     X, y, test_size=0.2, random_state=13)

## 원래대로라면 스케일링을 하고 분류기를 학습시키는 과정 필요
## but 이미 pipe에 진행 완료. 해서 아래 진행

pipe.fit(X_train,y_train)

# 정확성 확인
from sklearn.metrics import accuracy_score

y_pred_tr = pipe.predict(X_train)
y_pred_test = pipe.predict(X_test)

print('Train Acc' : accracy_score(y_train, y_pred_tr)
print('Test Acc' : accracy_score(y_test, y_pred_test)

✏️ 출처

'제로베이스 데이터 취업스쿨' 수강중 교재 '혼자 공부하는 머신러닝 + 딥러닝' 사이킷런으로 머신러닝 시작하기 토닥토닥 sklearn - 머신러닝 sklearn으로 데이터 스케일링(Data Scaling)하는 5가지 방법🔥 train_test_split 모듈을 활용하여 학습과 테스트 세트 분리 [Chapter 4. 분류] Decision Tree Classifier Decisiontreeclassifier 함수의 파라미터 random_state란? 머신러닝 파이프라인 머신 러닝 - PipeLine 2.5.10. 싸이킷런(Scikit-learn)(Sklearn)

* 분명히 matplot과 seaborn을 활용한 다양한 시각화 라이브러리를 저번에도 다룬 것 같은데 왜 이렇게 낯선지 모르겠다. 이렇게 복습해야할 것들이 점점 늘어난다📚

✏️ EDA

💡 생존률 (38.2%)

• autopct='%1.1f%%' : 소수점 첫째자리까지 비율 표시

  titanic['survived'].value_counts().plot.pie(autopct='%1.1f%%')

  out>>

f,ax = plt.subplots(1,2,figsize=(16,8)) #1행 2열

titanic['survived'].value_counts().plot.pie(ax=ax[0],autopct='%1.1f%%',shadow=True, explode=[0,0.05])
ax[0].set_title('Pie plot - survived')
ax[0].set_ylabel('')

sns.countplot(x='survived',data=titanic,ax=ax[1])
ax[1].set_title('Count plot = survived')

plt.show()

💡 성별에 따른 생존 상황

: 남성의 생존 가능성이 더 낮다.

f,ax = plt.subplots(1,2,figsize=(16,8)) #1행 2열

titanic['sex'].value_counts().plot.pie(ax=ax[0],autopct='%1.1f%%',shadow=True, explode=[0,0.05])
ax[0].set_title('Pie plot - Count of passengers of sex')
ax[0].set_ylabel('')

sns.countplot(x='sex',data=titanic,hue='survived',ax=ax[1])
ax[1].set_title('Count plot = sex : survived')

plt.show()

💡 좌석 등급 대비 생존률

• 1등실일수록 생존 가능성이 높음
• 여성의 생존률이 높음 => 여성들은 1등실에 많이 타고 있었는가?

  pd.crosstab(titanic['pclass'],titanic['survived'],margins=True) #margins : 합계

  

💡 등급 & 성별 관계 (기준 : 나이)

grid=sns.FacetGrid(titanic, row='pclass',col='sex', height=4,aspect=2)
grid.map(plt.hist,'age', alpha=0.8, bins=20) # alpha : 투명도
grid.add_legend()

<<틈새 정리 - 시각화 라이브러리>>
_matplotlib
: 파이썬으로 기본적인 차트들을 쉽게 그릴 수 있도록 도와주는 시각화 라이브러리

_seaborn
: matplotlib 기반으로 만들어진 통계 데이터 시각화 라이브러리

💡 나이별 승객 현황

import plotly.express as px
fig=px.histogram(titanic,x='age')
fig.show()

💡 등실별 생존율

grid=sns.FacetGrid(titanic, row='pclass',col='survived', height=4,aspect=2)
grid.map(plt.hist,'age', alpha=0.5, bins=20) # alpha : 투명도
grid.add_legend()

💡 연령 5단계로 구분하기

#새로운 컬럼 추가하기
titanic['age_cat']=pd.cut(titanic['age'], bins=[0,7,15,30,60,100],
                include_lowest=True,
                labels=['baby','teen','young','adult','old'])
titanic.head()

💡 나이, 성별, 등급별로 생존율

: 1로 갈수록 생존

plt.figure(figsize=(14,6))

plt.subplot(131) #1행 3열 중 1번째
sns.barplot(x='pclass',y='survived',data=titanic)

plt.subplot(132) #1행 3열 중 2번째
sns.barplot(x='age_cat',y='survived',data=titanic)

plt.subplot(133) #1행 3열 중 3번째
sns.barplot(x='sex',y='survived',data=titanic)

plt.show()

fig,axes = plt.subplots(nrows=1, ncols=2, figsize=(14,6))

women = titanic[titanic['sex']=='female'] #이거 자체가 df 형태
men = titanic[titanic['sex']=='male'] #이거 자체가 df 형태

ax = sns.distplot(women[women['survived']==1]['age'], bins=20,  #women[women['survived']==1] : 여성 'survived'컬럼이 1인 df중에서 ['age'] 데이터만
                  label ='survived', ax = axes[0],kde=False)
ax = sns.distplot(women[women['survived']==0]['age'], bins=40,
                  label ='not_survived', ax = axes[0],kde=False)
ax.legend() ; ax. set_title('Female')

ax = sns.distplot(men[men['survived']==1]['age'], bins=18,
                  label ='survived', ax = axes[1],kde=False)
ax = sns.distplot(men[men['survived']==0]['age'], bins=40,
                  label ='not_survived', ax = axes[1],kde=False)
ax.legend() ; ax. set_title('male')

💡 이름으로 신분 확인하기

import re
for idx, dataset in titanic.iterrows():
    tmp = dataset['name']
    print(re.search('\,\s\w+(\s\w+)?\.',tmp).group())
    # '\,\s\w+(\s\w+)?\.' : \,: ,로 시작, 
    #                       \s: 한 칸을 비움, 
    #                       \w+ : 어떤 단어들이 여러개 나옴
    #                       (\s\w+)? : (공백 + 어떤 단어) 가 없을수도 있고, 있을수도 있고
    #                       \. : .로 끝남
    # 대상 : tmp

out>>
, Miss.
, Master.
, Miss.
, Mr.
, Mrs. ...

import re

title=[]
for idx, dataset in titanic.iterrows():
    tmp = dataset['name']
    condition = re.search('\,\s\w+(\s\w+)?\.',tmp).group()
    title.append(condition[2 : -1]) #, Miss.에서 ,부터 0, .전 : -1

title

out>>
['Miss',
 'Master',
 'Miss',
 'Mr', ...]

✏️ 머신러닝

✏️ 출처

"제로베이스 데이터 취업 스쿨" 강의

SQL 작성 순서

SELECT - FROM - WHERE - GROUP BY - HAVING - ORDER BY - LIMIT

SQL 실행 순서

FROM - WHERE - GROUP BY - HAVING - SELECT - ORDER BY - LIMIT

✏️ 열기

mysql -u 유저네임 -p [데이터베이스]

mysql -h "엔드포인트" -P 3306 -u 유저네임 -p비밀번호 데이터베이스

✏️ 기초 type

• CHAR 또는 CHARACTER: 고정 길이 문자열을 나타내는 데이터 타입( 지정된 길이만큼의 문자열을 저장)

• VARCHAR 또는 CHARACTER VARYING : 가변 길이 문자열을 나타내는 데이터 타입 (최대 길이가 정해져 있으나 실제 데이터의 길이에 따라 유동적으로 조정됨)

• TEXT : 긴 문자열을 나타내는 데이터 타입. 가변 길이의 문자열을 저장할 수 있음.

• INTEGER : 정수 값을 나타내는 데이터 타입 (일반적으로 32비트 혹은 64비트로 표현)

• REAL 또는 FLOAT : 실수 값

• DOUBLE : 보다 높은 정밀도 제공

• DECIMAL 또는 NUMERIC : 고정 소수점 숫자를 나타내는 데이터 타입, 정확한 소수 자리를 유지하기 위해 사용

• DATE : 날짜 값을 나타내는 데이터 타입

• TIME : 시간 값을 나타내는 데이터 타입

• TIMESTAMP : 날짜와 시간을 나타내는 데이터 타입

• BOOLEAN : 참(True) 또는 거짓(False) 값을 나타내는 데이터 타입

✏️ 테이블

💡 생성 (create)

create TABLE 테이블_이름 (열1_이름 type 그_외_옵션, 열2_이름 type 그_외_옵션)

# 예시 1
create table gas_brand (id int AUTO_INCREMENT,name varchar(16),primary key (id))

# 예시 2
create table gas_brand (id int AUTO_INCREMENT primary key,name varchar(16))

• ,으로 데이터간 구분
• 구성
  • id : 데이터 제목
  • int : type
  • AUTO_INCREMENT : 숫자 자동 생성
  • primary key (id) :

💡 자료(value) 입력 (insert into)

# 예시 1
insert into 테이블_이름 (열_이름1, 열_이름2) values ('데이터 내용1_string','데이터 내용2_string','데이터 내용3_string')
## (열_이름1, 열_이름2)은 전체 열 입력이 아닌 일부 열일 경우 작성하고, 전체 열 입력일 경우 안적어도 됨

# 예시 2
insert into gas_brand values (데이터 내용1_int, 데이터 내용2_int,데이터 내용3_int)

• 데이터 타입에 따라 따옴표 사용하기

💡 조회

• 테이블 타입 조회

  desc 테이블_이름

• 테이블 내용 조회

  select * from 테이블_이름

• * = 모든 value

💡 제약조건 (외래키)

✏️ Python

💡 시작하기

import mysql.connector

💡 커넥터 만들기

conn=mysql.connector.connect(
    host = "엔드포인트",
    port = 포트 넘버,
    user = '유저 이름',
    password = "비밀번호",
    database="데이터베이스 이름"
)

#즉, conn : 유저 정보가 담겨 있음

💡 커서 지정

cur=conn.cursor(buffered=True)

#conn에는 유저 정보

💡 명령&동작 시행

cur.execute("명령")

#명령이 길 경우 1,
sql = "insert into 테이블_이름 (데이터_제목) values ('데이터 내용1_string','데이터 내용2_string','데이터 내용3_string')"

cur.execute(sql)

#명령이 길 경우 2,(줄나눠도 인식시키는 방법)

sql = "INSERT INTO gas_station (a, b, c, d, e, f, g, h, i, j, k)" +\
"VALUES(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)"

cur.execute(sql,(A,B,C,D,E,F,G,H,I,J,K))

💡 conn.commit()

• 트랜잭션을 종료하고 다른 사용자에게 변경된 모든 사항을 보이도록 만드는 문
• 일반적으로 트랜잭션 종료시 해당 업데이트를 확정한다는 의미에서 "커밋"이라고 사용
• commit을 하면 바로바로 sql에 자료가 들어감
• 업데이트를 취소 처리를 "롤백 (ROLLBACK)"이라고 하며, 이러한 제어를 "약속 제어"라고 부름

  conn.commit()

  💡 cur.fetchone( ) & cur.fetchall( )

• . fetchone( )
  • fetchone을 호출할 때마다 로우 단위로 데이터를 얻을 수 있음
  • 아래 예시는 2개의 로우만 존재하므로 세번째부터 출력 X

    In [5]: cursor.fetchone()
    Out[5]: ('16.06.03', 97000, 98600, 96900, 98000, 321405)
    

In [6]: cursor.fetchone() Out[6]: ('16.06.02', 99000, 99300, 96300, 97500, 556790)

In [7]: cursor.fetchone()

In [8]:

* . fetchall( )
  * 한 번에 <span style="color:yellowgreen">모든</span> 로우를 읽기
```python
In [9]: cursor.fetchall()
Out[9]: 
[('16.06.03', 97000, 98600, 96900, 98000, 321405),
('16.06.02', 99000, 99300, 96300, 97500, 556790)]

✏️ 연습 사이트

SQL 개념 연습하기 좋은 사이트 (1)

✏️ 출처

📚SQL 문법 정리 3) 데이터베이스로부터 데이터 읽기 COMMIT (SQL) [SQL 24] 제약조건 - PK(Primary Key), FK(Foreign Key) SQL 외래 키에 대한 이해 [SQL]작성 및 실행 순서를 이해하면 좋은 점

💡 BI 솔루션

• BI 기업에서 데이터를 수집, 정리, 분석하고 활용하여 효율적인 의사 결정을 하도록 하는 애플리케이션과 기술의 집합(Business Intelligence)
• 행 혹은 열 둘 중 하나가 없어도 차트 생성 가능(예-파이 차트)
• 타부서와 소통에선 엑셀,막대 차트, 파이 차트같이 단순한 시각화가 효율적(이 대쉬보드를 누가 볼 것인지!!를 유념)

💡 테이블 구성

로지컬 테이블 / 피지컬 테이블

💡 유니온 & 조인

• 유니온 (결합)

  • 다중 결합 가능함
  • 주의점 : 유니온을 하려면 결합하려는 자료들의 구조가 같아야함 (필드 수, 유형 등)

• 조인 (병합)

  • 물리적으로 병합해서 하나의 데이터로 만드는 것
  • 피지컬 테이블에서 조인해야함
  • 아래 이미지는 각각 고유 상태의 자료 (관계)
  • 조인 유형 선택

💡 차원 & 측정값

태블로에서 데이터를 확인하여 자동으로 차원인지 측정값인지 분류함 (기준 : 실선)

• 차원
  • 정성적 값 (ex-이름, 날짜, 지리적 데이터 등)
  • 연속형 차원 : 데이터 유형이 문자열 혹은 bool 형식일 경우, 연속형 불가
• 측정값
  • 정량적 수치 값

💡 연속형 & 불연속성

각각 연속형(파란색)과 불연속성(초록색)으로 분류

• 연속형
  • 컬러 그라데이션 표기
• 불연속형
  • 컬러 구분 표기
  • 날짜
    • 기본적으로 불연속형이기 때문에 끊긴 그래프 나옴
    • 필요한 목적에 따라 연속형 가능

💡 필터링 & 드릴다운 & 값 단위 변경

• 필터링
• 드릴다운
• 값 단위 변경 : '레이블-서식-숫자'에서 수정
• 소수점 자리수 수정

✏️ 차트

💡 비중 차트 - 막대차트

• 옆으로 누운 그래프
• 막대 차트로 비중 표현하기

💡 비중 차트 - 파이 차트

💡 비중 차트 - 트리맵

• 항목이 많을 경우 파이차트보다 유용 (but 실무에선 잘 사용 X)

💡 테이블

• 응용 1 : 매출별 순위

  • '순위'탭 이름 변경하기

• 응용 2 : 100% 비율 변경하기

• 응용 3 : YTD vs 누계 누계를 누계를 오른쪽 마우스 - '다음을 사용하여 계산' - '패널(아래로)'로 설정하면 YTD와 동일

💡 콤비네이션 차트 (이중 축)

• 라인 + 원형 라인과 원형이 안 맞을 때 = 두 차트의 축 범위가 다를 때 => 축 동기화 해주기

• 라인 + 영역

• 도넛 차트

✏️ 출처

"제로베이스 데이터 취업 스쿨" 강의

✏️ 자주 사용하는 기본 코드

from selenium import webdriver
from selenium.webdriver.common.by import By
import time
from tqdm import tqdm_notebook
from tqdm import tqdm
from bs4 import BeautifulSoup
import numpy as np

#이건 종종
import warnings
warnings.simplefilter(action="ignore",category=FutureWarning)

💡 셀레니움

1. 기본

   driver = webdriver.Chrome()
   driver.get('https://주소') #연결할 페이지 링킹
   time.sleep(10) #버퍼링 고려해 time sleep 넣어주는게 안전
   driver.find_element(By.CSS_SELECTOR,'CSS 주소').click()

2. 표 읽기

   #표 찾아서 table 이라는 변수로 지정
   table = driver.find_element(By.CSS_SELECTOR,'표 CSS 주소')

💡 Beautiful Soup (파싱)

1. 기본

   req=driver.page_source
   soup = BeautifulSoup(req,'html.parser')
   print(soup.prettify)

2. select / find_all / find_element

   select_변수 = soup.select('beatifulsoup에서 내가 필요한 곳에 대한 주소') #html(soup)에서 전체만 추출
   select_변수

✏️ 출처

제로베이스 데이터취업스쿨 강의 [python] Selenium으로 웹 페이지 크롤링하기 2 / 표(table) 웹크롤링 - BeautifulSoup에서 find와 select 사용하기

✏️ 데이터프레임 만들기

💡 행(row) 기준

• 디렉토리 : 한 행 {'컬럼명' : '값'}
• 리스트로 묶기

  source =  
  [{'매장명': '용마로주유소',
  '주소': '서울 중랑구 용마산로 309 (면목동)',
  '브랜드': 'SK에너지',
  '휘발유 가격': '1,798',
  '경유 가격': '1,698',
  '셀프 여부': 'Y',
  '세차장 여부': 'Y',
  '충전소 여부': 'N',
  '경정비 여부': 'N',
  '편의점 여부': 'N',
  '24시간 운영 여부': 'N',
  '구': '중랑구'},
  {'매장명': '범아주유소',
  '주소': '서울 중랑구 동일로 881 (묵동)',
  '브랜드': 'S-OIL',
  '휘발유 가격': '1,859',
  '경유 가격': '1,739',
  '셀프 여부': 'N',
  '세차장 여부': 'Y',
  '충전소 여부': 'N',
  '경정비 여부': 'Y',
  '편의점 여부': 'N',
  '24시간 운영 여부': 'N',
  '구': '중랑구'}]
  

df=pd.DataFrame(source)

### 💡 Github에서 파일 불러오기
```python
git_address="http://~~~" #따옴표 중요
df=pd.read_excel(git_address)

• 번외 ) 리스트를 튜플로 만들기 (zip), 튜플을 딕셔너리로, 언팩킹

  # 리스트를 튜플로 만들기 (zip),
  list1=['a','b','c']
  list2=[1,2,3]
  pairs =[pair for pair in zip(list1,list2)]
  paris
  

out>> [('a',1),('b',2),('c',3)]

#튜플을 딕셔너리로 dict(pairs)

out>> {'a':1,'b':2,'c':3 }

#언팩킹 x,y =zip(*pairs) x

out>> ('a','b','c')

print(list(y))

out>> [1,2,3]

### 💡 열(column) 기준
```python
source={'country': ['a', 'b', 'c', 'e', 'e'],'person': [11, 22, 3, 23, 9],'zero': [0, 0, 0, 0, 0]}

df_temp=pd.DataFrame(source)
df_temp

'country': ['a', 'b', 'c', 'e', 'e']}

✏️ 파일 읽기

💡 csv

import pandas as pd

#파일 불러오기
data = pd.read_csv('주소/파일.csv', encoding='')

#파일 확인하기
data.head()

💡 html

import pandas as pd
pd.read_html(URL, match='.+', flavor=None, header=None, index_col=None, skiprows=None, attrs=None, parse_dates=False, tupleize_cols=None, thousands=', ', encoding=None, decimal='.', converters=None, na_values=None, keep_default_na=True, displayed_only=True)

✏️ 열(컬럼) 조회

💡 컬럼 1개

• df[‘ColumnName’]
• df.ColumnName

💡 컬럼 여러개

• df[[‘ColumnName’, 'ColumnName']] 리스트에 리스트 형식

💡 loc를 사용해서 불러오기

✏️ 행 조회

💡 인덱싱 활용 : loc, iloc

df.loc[행 인덱싱 값, 열 인덱싱 값 ]

• Location 약자

# 예시
df.loc[0] : 0번째 행변경 (딕셔너리)
df.loc[0,'Name'] : 0번째 행, Name 열
df.loc[:,'Name'] : 전체 행, Name 열
df.loc[:4,:'Name'] : 처음행부터 4까지, 처음열부터 Name 열
df.loc[[1,2,5],['Name','Address']] : 1,2,5행 + Name, Address 열

# 예시 : age 컬럼에서 3인 값들 추출하기
cond1=df['age'] == 1
df.loc[cond1]

# 예시 : age 컬럼에서 3인 값들 추출하기 + class가 30인 값 추출하기
df.loc[(df['age'] == 1) | (df['class가'] == 30)]

# 멀티 인덱스일 경우_아래 이미지
df_target.loc[('서울시', '합계', '발생건수'),열]

df.iloc[행 인덱싱값, 열 인덱싱 값]

• Integer Location 약자
• 맨 첫 행은 0부터 시작
• 명칭을 직접 적거나 특정 조건식을 사용하는 loc와 달리 컴퓨터가 읽기 좋은 '숫자'형식으로 위치에 접근함

# 예시 
df.iloc[2] #0부터 시작해서 0>1>2 번째 줄
df.iloc[3:7] #0>1>2>3 번째 ~ 6번째 줄
df.iloc[:7] #처음부터 ~ 6번째 줄
df.iloc[:-7] #마지막에서부터 ~ 6번째까지

💡 iterrows()

• 데이터의 행-열/데이터 정보를 튜플 형태의 generator 객체로 반환하는 메서드
• (행 이름, 내용의 Series객체) 형태로 반환하는데, Series객체는 열 - 값 형태로 반환

💡 조건 활용

• df[df['ColumnName']조건]

• df[df.ColumnName 조건] 데이터 프레임에 데이터 프레임

# 예시 : age 컬럼이 30 이상인 행을 가져오고 싶다면
df[df['age']>=30]
df[df.age>=30]

# 예시 : name이 ‘Clara Oswald’가 아닌 경우만 선택하고 싶다면
df[df['name'] != 'Clara Oswald']
df[df.name != 'Clara Oswald']

✏️ 데이터프레임 내용 수정

💡 .replace (수정 전, 수정 후)

💡 인덱스, 컬럼명_딕셔너리, 리스트

아래 코드에서 이 부분 로직 잘 확인하기 : df.loc[df.index == index, 'country'] == country

df={'country': ['a', 'b', 'c', 'e', 'e']},'person': [11, 22, 3, 23, 9]},'zero': [0, 0, 0, 0 0]}

#(인덱스,'country'컬럼 변경 내용)
df_change_list = [
    (1, 'A'),
    (3, 'C'),
    (4, 'E'),
]

for index, country in df_change_list:
    df.loc[df.index == index, 'country'] = country

💡 컬럼명_리스트

df.columns=[]

💡 컬럼명_딕셔너리

df.rename(columns={'기존 이름' : '바뀔 이름'})

💡 컬럼 순서_리스트

data={
    "name" : a,
    "age" : b,
    "height" : c,
    "sex" : d
}
혹은
df.columns = ['name', 'age', 'height', 'sex']
------------------------------------------------------------
#1
df[['name', 'sex', 'age', 'height']]

#2
df=pd.DataFrame(data, columns=["name","sex","age","height"])
df

# **3
new_order_column=['name', 'sex', 'age', 'height']
df[new_order_column]

💡 값 변경_딕셔너리

아래 코드에서 이 부분 로직 잘 확인하기 : items() / df.loc[df["Column"]==old_name, "Column"] : [행,열]

#컬럼명 주어짐
old_to_new_value = {
    'Old_1': 'New_1',
    'Old_2': 'New_2',
    'Old_3': 'New_3',}

for old_name, new_name in old_to_new_value.items():
    df.loc[df["Column"]==old_name, "Column"] = new_name

💡 데이터프레임 형 변환 : astype

1. 1개 열

   df1 = df.astype({'col1':'int32'})

2. 다수 열

   df1 = df.astype({'col1':'int32', 'col3':'int64'})
   print(df1.dtypes)

• 변경할 타입들이 동일 할 경우

  columns_to_convert = ['col1', 'col2', 'col3']
  df1[columns_to_convert] = df1[columns_to_convert].astype(float)

3. 모든 열

   df1= df.astype(dtype='int64',errors='ignore')
   #errors = int64로 변경할 수 없는건 무시
   print(df1.dtypes)

💡 특정 단어를 포함하고 있다면??

#특정 단어를 포함하고 있는 열을 제외한 데이터프레임으로 설정
df = df[~df['column'].str.contains('특정 단어')]

💡 split()

예시) df의 A 컬럼에서 str 타입을 공백으로 나눈다

df.컬럼명.str.split(' ')[0]

예시) df의 A 컬럼에서 str 타입을 공백으로 나눈 것에서 str타입 [0]번째 호출

df.['A'].str.split(' ').str[0]

# 같은 문법
for id, row in df.iterrows():
    df.loc[id, 'A'] = row['A'].split(' ')[0]

-----
df['A'] = df['A'].str.split(' ').str[0]

for i, row in df_practice.iterrows():
    df_practice['구분']=df_practice['구분'].str.split(' ')[i][0]

#위와 동일한 코드
df_practice['구분'] = df_practice['구분'].apply(lambda x: x.split(' ')[0])

💡 strip()

• 문자열에서 양쪽 끝에 있는 공백이나 지정한 다른 문자들을 제거

  s = "   Hello   "
  print(s.strip())  # 출력: "Hello"

  s = "----Hello----"
  print(s.strip('-'))  # 출력: "Hello"

• 데이터 프레임 value에서 공백 제거

  df['컬럼명']=df['컬럼명'].str.strip()

✏️ 데이터 프레임 삭제하기

💡 기본 코드 : drop()

'리스트' 사용 axis=1 : 열(coulumn)

drop_col = ['A','C','F']
df=df.drop(drop_col,axis=1)

💡 특정 조건에 맞는 행 삭제

source = {'country': ['a', 'b', 'c', 'e', 'e'],
'person': [11, 3, 3, 23, 5],
'zero': [0, 0, 0, 0, 0]}

# 'country'컬럼에서 'b'인 행 지우기
idx = source[source['country'] == "b"].index
source.drop(idx , inplace=True)

# 더 심플한 방법 : 'country'컬럼에서 'b'가 아닌 행 찾기
DF = source[source.country != 'b']

💡 중복 제거 : drop_duplicates()

df.drop_duplicates()

💡 멀티인덱스 제거 : droplevel(level=)

df_result = df_result.droplevel(level=2)

✏️ 데이터프레임 정렬

💡 sort_values()

1. 기본 원리 : A 컬럼을 내림차순으로

   df.sort_values(by='A', ascending=False)

2. A 컬럼을 오름차순으로 먼저 맞춘후 B 컬럼 오름차순 지정

   df.sort_values(by=['A', 'B'], ascending=[True, True])

3. 컬럼 ) 특정 리스트 순서대로

   type_list = ['합계', '차대사람', '차대차', '차량단독', '건널목']
   category_type = pd.CategoricalDtype(categories=type_list, ordered=True)

4. 멀티 인덱스 ) 특정 리스트 순서대로

   gu_list = ['서울시', '종로구', '중구', '용산구', '성동구]
   df=df.reindex(index=gu_list, level=1)
   # 두번째 인덱스 줄을 gu_list 순서대로 배열

💡 sort_index()

💡 groupby()

#예시 df.groupby('age').var()

* 다중 통계
```python
df.groupby('age').agg(['mean', 'var'])

💡 List순으로 정렬하기

• .map( ) 사용

city_list = ['서울', '부산', '대전', '광주']
cat_list = ['A', 'B', 'C', 'D', 'E', 'F', 'G']
type_list = ['가', '나', '다', '라', '마', '-']

# 리스트 항목별로 순서 매기기
sorterIndex_city = dict(zip(gu_list, range(len(gu_list))))
sorterIndex_type = dict(zip(type_list, range(len(type_list))))
sorterIndex_cat = dict(zip(cat_list, range(len(cat_list))))

# 순서를 위한 임시 컬럼 만들기
df['도시순서'] = df['도시'].map(sorterIndex_city)
df['유형순서'] = df['유형'].map(sorterIndex_type)
df['구분'] = df['구분'].map(sorterIndex_cat)

#'도시순서'가 같으면 '유형순서, '유형순서'가 같으면 '구분순서'순으로 배열
df.sort_values(['도시순서','유형순서','구분순서'],inplace=)

# 임시 컬럼 삭제하기
df.drop(['도시순서','유형순서','구분순서'],axis=1,inplace=True)

✏️ 데이터 프레임 합치기

💡 .merge() : 데이터프레임 병합하기

• 공통된 컬럼 (key) 를 기반으로 합쳐짐

import pandas as pd

# 기준열 이름이 같을 때
pd.merge(left, right, on = '기준열', how = '조인방식')

# 기준열 이름이 다를 때
pd.merge(left, right, left_on = '왼쪽 열', right_on = '오른쪽 열', how = '조인방식')

• on : (두 데이터프레임의 기준열 이름이 같을 때) 기준열 하지만 양쪽 데이터프레임에서 기준이 되는 열의 이름이 다르다면 각각 left_on = '왼쪽 열', right_on = '오른쪽 열'로 지정하면 된다.

  • left_on : 기준열 이름이 다를 때, 왼쪽 기준열
  • right_on : 기준열 이름이 다를 때, 오른쪽 기준열

• how : 조인 방식 {'left', 'right', 'inner', 'outer'} 기본값은 'inner'

  • left : right에 없으면 right 자리에 Nan
  • right : left에 없으면 left 자리에 Nan
  • inner : 교집합만
  • outer : 전체

💡 .concat() : 데이터 프레임 붙이기

• 합집합 형태로 데이터를 묶을 때 편리
• 기본 asix=0 : 행단위로 아래에 붙여넣기 asix=1 : 열단위로 옆에 붙여넣기

✏️ 결측치 확인

💡 결측치 행 확인 : isnull()

1. 기본 원리 데이터 프레임에 True/False 표시 : 결측치 O = True / 결측치 X = False

   df.isnull()

2. 특정 열에서 찾기 1 A열의 결측치

   df[df['A'].isnull()]

3. 특정 열에서 찾기 2 A와 C 결측치_참고 : &(and), |(or)

   df[(df['A'].isnull()) | (df['C'].isnull())]

4. 결측치 개수 확인 방법

   df.isnull().sum()
   

결과

A 2 B 1 C 3 dtype: int64

#특정 열에 있는지 여부 체크 df['A'].isnull().sum()

### 💡 결측치 아닌 행 확인 : notnull()
1. 기본 원리
데이터 프레임에 True/False 표시 : 결측치 O = False / 결측치 X = True
```python
df.notnull()

2. 특정 열에서 찾기 1 A열의 결측치가 아닌 것을 데이터 프레임으로

   df[df['A'].notnull()]

3. 특정 열에서 찾기 2 A와 C 결측치가 아닌 것을 데이터 프레임으로_참고 : &(and), |(or)

   df[(df['A'].notnull()) | (df['C'].notnull())]

4. 결측치가 아닌 값 개수 확인 방법

   df.    notnull().sum()
   

결과

A 4 B 5 C 3 dtype: int64

### 💡 결측값 채우기
```python
df.fillna(value=None, method=None, axis=None, inplace=False, limit=None, downcast=None)

✏️ 인덱스 셋 & 리셋

💡 set_index()

df.set_index('id')
df.set_index(['id', 'name'])

• 멀티 인덱스 추출하기

  df.index.get_level_values(0)

💡 reset_index()

DataFrame.reset_index(level=None, drop=False,
inplace=False, col_level=0, col_fill='')

✏️ 코드 간소화하기

df=df.groupby('Country').count()
df=df.sort_values(by='Year', ascending=False)
df=df.head(10) # 상위 10개
df=df.reset_index()
dropList=['Month','Day','Region','city','latitude','longitude','Type']
df=df.drop(dropList,axis=1)

dropList = ['Month', 'Day', 'Region', 'city', 'latitude', 'longitude', 'Type']

df = (
    df.groupby('Country').count()
    .sort_values(by='Year', ascending=False)
    .head(10)
    .reset_index()
    .drop(columns=dropList)
)

✏️ 출처

[pandas] 2-1. loc와 iloc 차이와 사용방법 [pandas] 열 또는 행 선택하기 [Pandas] 파이썬 결측치 확인 방법 : isnull, notnull [Python/파이썬] Pandas Dataframe 결합 : Merge [Pandas] 데이터프레임 정렬하기 : sort_values, sort_index 함수 [파이썬 pandas] 데이터프레임 컬럼 순서 변경, 추가, 이름 바꾸기 [파이썬] 7. 판다스 - 특정 조건 만족하는 행 삭제하기|작성자 러닝머신 [Python] 데이터프레임 합치기 :: pd.merge() 02. 데이터 프레임 결합하기 판다스(Pandas) .groupby()로 할 수 있는 거의 모든 것! (통계량, 전처리)

• 프로젝트에 대한 설명, 사용 방법, 라이센스, 설치법과 같은 부분에 대해 기술하는 파일 (포트폴리오 설명 용도로도 사용)

• 본인, 직장 동료, 프로그램 사용자를 위해 존재
• 벨로그 markdown 문법과 동일함

💡 Markdown

큰 제목 : =====

작은 제목 : -----

Hashtag 제목

• '#' 1개부터 ~ 6개 : #가 많아질 수록 타이틀은 작아짐

블럭인용문

• '>','>>','>>>' 등으로 사용

코드블럭 1

<code>코드입력</code>
<pre><code>코드입력</code></pre>

코드블럭 2

• ```

✏️ 출처

제로베이스 데이터취업스쿨 강의

💡 기초 코드

아래 코드는 git의 직접적인 명령코드는 아니나 알아두면 유용

* [local] 경로 이동하기

% cd 폴더명

* [local] 폴더 만들기

% mkdir 폴더명

* [local] 빈 파일 만들기

% touch 파일명.확장자

* CAT : 파일 내용 확인하기

% cat 파일명.확장자

* CAT : 파일 생성하고 내부 파일에 내용 입력하기 (파일이 있으면 덮어씀)

% cat > 파일명.확장자
명령어 #ex-파이썬이라면 print('hello,world')
control + D #for Mac / 위 내용 저장됨

* CAT : 기존 파일에 덧붙여쓰기

% cat >> 파일명.확장자
명령어 #ex-파이썬이라면 print('hello,world')
control + D #for Mac / 위 내용 저장됨

💡 Local & Remote Repository

* [local] 폴더 초기화

• 해당 폴더를 git이 관리하기 시작하는 초기화 명령
• 숨은 폴더로 git 폴더 생성됨
• 별도 브랜치를 생성하지 않는 이상 main 혹은 master 브랜치로 이름 지정됨

  % git init 

  * ⭐️ [local] 파일을 index(stage)에 추가

  % git add 파일명.확장자

  * ⭐️ [local] 파일을 index(stage)에 추가된 사항을 head에 반영(확정)

  cat등으로 파일 수정후 아래 코드 입력해서 업데이트 해주면 git graph에 history 업데이트 됨

  % git commit -m '메시지 입력' 파일명.확장자

github에서 repository 만들기

* [remote] remote repository 등록

% git remote add origin https://계정이름:토큰@github repository 주소

* [remote] remote repository 연결 확인

% git remote -v

* [remote] push (local 자료를 remote repository로)

% git push origin [main or master...]

* [remote] pull (remote repository를 local로)

% git pull origin [main or master...]

💡 Git Clone

• github에서 repository를 먼저 생성후 local pull까지 바로 진행
• git init 과정 불필요 -> 바로 git add 명령어부터 실행 가능
• github의 폴더명과 동일한 local 폴더 자동으로 생성
• github 사이트 상의 폴더중 폴더명 맨 앞에 .이 있는건 local에서 숨은 폴더

  % git clone https://계정이름:토큰@github repository 주소

💡 Branch

• 브랜치를 생성해도 local 상에선 보이진 않지만, 그 브랜치 안에서 파일 생성 등 가능 -> commit , push 등 가능 (그럼 main or master 브랜치가 아닌 그 브랜치로 히스토리가 누적됨)
• 동일한 파일이라도 브랜치마다 내용이 다를 수 있음 (하단 '💡 Git diff'로 상세 내용 확인)
  • main hello.py에는 print('hello, cat')이 등록
  • git checkout dev로 dev 브랜치 이동 -> cat > hello.py | print('hello, dog')으로 수정 -> cat hello.py로 확인하면 print('hello, dog') 나옴

    * branch 조회

    local branch조회

    % git branch

    remote branch 조회

    % git branch -r

    local & remote branch 조회

    % git branch -a

    * branch 생성

    생성시 동일한 브랜치명 사용 X (동일한 브랜치명으로 생성이 불가함)

    % git branch 브랜치명

    * branch 이동

    % git checkout 브랜치명

    * branch 생성 후 바로 이동

    생성시 동일한 브랜치명 사용 X (동일한 브랜치명으로 생성이 불가함)

    % git checkout -b 브랜치명

    * branch push (local 자료를 remote repository로)

    % git push origin 브랜치명

    * branch 삭제하기

    local 삭제 (해당 브랜치에 있을 땐 삭제 안됨, 다른 브랜치로 이동 후 삭제 / github remote repository에는 삭제 안됨)

    % git branch -d 브랜치명

    branch remote 삭제

    % git push origin -delete 브랜치명

💡 Git Log

• 현재 위치한 브랜치에서 변경 이력 확인 가능 (git graph의 텍스트 버전)
• 가장 상단에 최신 업데이트 내용 기록되어 있음

  % git log

💡 Git Diff

• 버전간의 차이를 조회할 수 있는 명령

  * branch간 비교

  vim으로 조회

  % git diff 브랜치명 브랜치명

  vscode로 조회 : 사전에 editor에 vscode로 설정 필요

  % git difftool 브랜치명 브랜치명
  

y 누르기

#### * Commit간 비교

% git diff commithash commithash or % git difftool commithash commithash

commithash 확인하는 방법 : % git log

#### * 마지막 commit과 이전 commit 비교

% git diff HEAD HEAD^ or % git difftool HEAD HEAD^

#### * 마지막 commit과 현재 수정사항

% git diff HEAD or % git difftool HEAD

#### * Local & remote 간 비교

% git diff 브랜치명 origin/브랜치명 or % git diff 브랜치명 origin/브랜치명

### 💡 Git Merge
[사전에 editor에 설정 필요](https://velog.io/@soo_oo/GIT#-editor)
모브랜치로 이동 후(% git checkout 브랜치명) 아래 코드 입력 : 모브랜치에 자브랜치를 merge 시킴 (자브랜치 내용으로 수정됨)
<span style="color:gray"> 모,자는 혼자 이해하기 쉽게 하기 위해서 붙힌 것</span>

% git merge 자브랜치명

### 💡 Git Merge (Merge Conflict)
![](https://velog.velcdn.com/images/soo_oo/post/ecdb4d15-42e6-4eec-bdd7-1b1ac1080814/image.png)
#### * git mergetool

(VS코드로 mergetool 셋팅이 되어 있다면) % git mergetool

VS코드가 연결됨 -> 오류 지점 찾기
#### * 오류 수정
* Diff 를 <<<<, ====, >>>> 로 표시
![](https://velog.velcdn.com/images/soo_oo/post/528df561-1291-48c4-9bc8-e84937db7319/image.png)
* 맞는 코드를 선택하여 수정하고 저장.(Diff 표시 부분도 삭제)
  * 협업자가 많을 경우, 협업자와 상의 후 진행하기
![](https://velog.velcdn.com/images/soo_oo/post/a4472743-d4fb-4a1a-8429-f32af751aac5/image.png)
#### * Conflict 해제
* 위 상태는 파일만 수정된 상태
* 아래의 해제 단계 필요

#인덱스(stage)추가 % git add 파일명.확장자

#head 연결 (메시지 적을 필요 없이 아래 코드만 입력해도 됨) % git commit

창이 새로 뜨면 command + s하고 닫기

* cat으로 확인하면 merge 된 것 확인 가능

### 💡 Git Tag
특정 버전 (commit)에 tag를 달아놓을 필요가 있을 때 사용 (ex-버전 릴리즈)
#### * 마지막 버전에 태깅

% git tag 태그이름

예시>> % git tag v0.3

#### * 특정 버전에 태깅
commithash 확인하는 방법 : % git log

% git tag 태그이름 commithash

예시>> % git tag v0.2 commithash_blahblah

#### * Tag를 Remote Repository로 Push

% git push origin 태그이름

#### * Tag 목록 확인

% git tag

#### * Tag 상세정보

% git show 태그이름

#### * Tag 삭제 (Local)

% git tag --delete 태그이름

#### * Tag 삭제 (Remote)

% git push --delete origin 태그이름

```

✏️ 출처

제로베이스 데이터취업스쿨 강의

💡 버전 관리란?

소프트웨어의 변경사항을 체계적으로 추적하고 통제하는 것

• Version Control Sytem (버전관리 시스템) (밑줄 : 현업에서 많이 사용하는 툴)

  • CVCS = CVS, SVN, etc…
  • DVCS = Mercurial, Git, etc…

• Configuration Management System (형상관리 시스템)

💡 장점

• 협업에 유용하다.
• 개발자 모두가 모두 분산처리 서버의 주인임으로 빠르게 일을 처리할 수 있다.
• history 추적이 가능하다.
• 로컬 서버로 오프라인 작업이 가능하다. (다른 개발자에 영향 없음 + 일시적인 서버 장애에도 개발 진행 가능)

✏️ GIT

💡 대표 서비스

• github

  • Git을 호스팅 해주는 웹 서비스, 협업을 위한 기능을 제공
  • 참고 - 소스코드 보안이 중요한 경우 사용을 기피함

• gitlab

  • 설치형 버전관리 시스템 - 소스코드 보안이 중요한 기업에서 주로 사용
  • 클라우드 버전관리 시스템 - 10명이하무료(Github와유사)
  • Issue tracker, Git Remote Repository, API, Team, Group 기능 제공

💡 GIT 설치하기 (For MAC M1)

1. 설치여부 확인 (at 터미널)

설치되어 있다면 pass 난 이미 설치되어 있어 이후 과정은 진행하지 않아 아래 과정 진행하지 않음

git  --version

2-1. Homebrew 설치

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

2-2. 터미널 이동 후 아래 입력

% /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

2-3-1. zsh: command not found 에러가 발생한다면

% /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
zsh: command not found

# 홈브루를 /opt 디렉토리에 설치하기 위해 이동
% cd /opt

# 루트 권한으로 homebrew 폴더를 만든다
% sudo mkdir homebrew

# homebrew 폴더의 루트 권한을 유저로 바꿔준다
% sudo chown -R $(whoami) /opt/homebrew
//sudo chown -R 유저명 경로 = 경로의 권한을 유저한테 준다는 뜻

# homebrew 다운로드
% curl -L https://github.com/Homebrew/brew/tarball/
master | tar xz --strip 1 -C homebrew

# homebrew bin 디렉토리를 PATH에 추가
% echo "export PATH=/opt/homebrew/bin:$PATH" >> ~/.zshrc

# homebrew 홈페이지에 있던 명령어를 이제 실행!
% /bin/bash -c "$(curl -fsSL https://gist.githubusercontent.com/nrubin29/
bea5aa83e8dfa91370fe83b62dad6dfa/raw/
48f48f7fef21abb308e129a80b3214c2538fc611/homebrew_m1.sh)"
Copyright zerobase Corp. All Rights Reserved

# 설치완료

2-3-2. Password (Mac) 입력 후 Enter

% /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/
install/HEAD/install.sh)"
==> Checking for `sudo` access (which may request your password).
Password:

2-4. 설치 중 enter 누르기

Press RETURN to continue or any other key to abort

2-5. Password (Mac) 입력후 Enter

...
Downloading Command Line Tools for Xcode
Downloaded Command Line Tools for Xcode Installing Command Line Tools for Xcode
Done with Command Line Tools for Xcode
Done.
==> /usr/bin/sudo /bin/rm -f /tmp/
.com.apple.dt.CommandLineTools.installondemand.in-progress
Password:

2-6. 설치 완료

...
==> Next steps:
- Run these two commands in your terminal to add Homebrew to your PATH:
%
echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> /Users/insang/.zprofile
eval "$(/opt/homebrew/bin/brew shellenv)"
- Run `brew help` to get started
- Further documentation:
https://docs.brew.sh
%

3-1. brew로 git 설치하기 (at 터미널)

% brew install git
.... 
Emacs Lisp files have been installed to:
/opt/homebrew/share/emacs/site-lisp/git
%

3-2. zsh: command not found: brew 에러가 발생한다면

% brew install git
zsh: command not found: brew
% eval "$(/opt/homebrew/bin/brew shellenv)"
% brew install git
....
Emacs Lisp files have been installed to:
/opt/homebrew/share/emacs/site-lisp/git
%

3-3. 설치여부 확인

git  --version

💡 GIThub 가입후 git configuration

1. 터미널에서 아래 개인 정보 입력

git config --global user.name <username>
git config --global user.email <email>

예시 >>
% git config --global user.name zerobasegit
% git config --global user.email zerobase.git@gmail.com

2. CRLF

for mac

% git config --global core.autocrlf input

for window : 가져올 때는 LF 를 CRLF 로 변경하고 보낼때는 CRLF 를 LF 로 변경 -LF가 기본 통용임으로 윈도우-맥 유저간 협업 작업을 위해 LF로 변경하고 보내는 설정 필수 -그렇지 않으면 CRLF 차이로 인해 commit 이 발생할 수 있음

% git config --global core.autocrlf true

3. editor

아래 "💡 Editor"에서 추가 설명

git config --global core.editor <editor>

>> 예시
% git config --global core.editor vim

4. 전체 설정 확인

% git config --list

>> 예시
% git config --list credential.helper=osxkeychain
user.name=<username>
user.email=zerobase.<email>
core.editor=vim
core.auticrlf=true

💡 Editor

git config --global core.editor <editor>

>> 예시
% git config --global core.editor vim

• --wait 옵션 : command line으로 VScode를 실행했을 경우, VScode를 닫을 때까지 command 대기 (터미널에 명령 입력 안됨)

  git config --global core.editor <editor> --wait

• 현재 config 확인하는 코드

  % git config --global core.editor

• VScode로 변경하기

  % git config --global core.editor "code --wait"

• 설정된 editor 상세 옵션 수정할수 있는 창
  • 위 명령으로 VS코드로 변경후 아래 코드 입력하면 VS코드가 열림
  • vim상태에서도 수정할 수 있으나 가독성이 떨어짐

    % git config --global -e

• 창에 들어간 후 아래 코드로 tool 설정하기
  • git diff

    [diff]
      tool = vscode
    [difftool "vscode"]
      cmd = "code --wait --diff $LOCAL $REMOTE"

    • git merge

      [merge]
      tool = vscode
      [mergetool "vscode"]
      cmd = "code --wait $MERGED"

      ✏️ 출처

      제로베이스 데이터취업스쿨 강의 형상관리에 대해서... SCM, VCS, SVN, git... 나무위키_git

• 참고자료 : [나름 중급 파이썬1] args와 *kwargs

💡 *args

이건 이미 알고 있는 내용이라 간단히 짚고 가자면, 함수 인자가 몇개 들어 올지 모를 때 "def 함수명 (*인자명)" 으로 지정해 사용한다.

다만, 내가 이 파트에서 주요하게 정리하고 싶은 부분은 바로 아래이다.

💡 **kwargs

• kwargs : keyword argument의 줄임말
• {'키워드 : '특정 값'}으로 함수 전달

아래 코드의 단점은 plotSineWave()함수에 인자를 넣을 때, 숫자 순서들이 충분히 헷갈릴 수 있다는 점이다. 코드가 길 때는 def 지정된 인자들을 확인하기 어려울 수도 있음!! 이럴 때 사용하는게 "**kwargs" 이다.

def plotSinWave(amp,freq,endTime,sampleTime,startTime,bias):
  """
  plot sin wave
  y= a sin(2 pi f t + t_o) + b
  """

  time = np.arange(startTime,endTime,sampleTime)
  result = amp+np.sin(2 *np.pi * freq *time + startTime)+bias

  plt.figure(figsize=(12,6))
  plt.plot(time,result)
  plt.grid(True)
  plt.xlabel("time")
  plt.ylabel("sin")
  plt.title(str(amp)+ "sine(2*pi" + str (freq) + "*t" + str(startTime) +")+" + str(bias))
  plt.show()

plotSinWave(2,1,10,0.01,0.5,0)

#**karges 사용시 각 번호 살피기

#1.
def plotSinWave(**kwargs):
  """
  plot sin wave
  y= a sin(2 pi f t + t_o) + b
  """

  #2. (기본값을 아래같이 설정했으나, 코드에 인자 입력하면 그에 맞춰서 인식함)
  amp = kwargs.get("amp",1)
  freq =kwargs.get("freq",1)
  endTime = kwargs.get("endTime",1)
  sampleTime = kwargs.get("sampleTime",0.01)
  startTime = kwargs.get("startTime",0)
  bias = kwargs.get("bias",0)
  figsize =kwargs.get("figsize",(12,6))

  time = np.arange(startTime,endTime,sampleTime)
  result = amp+np.sin(2 *np.pi * freq *time + startTime)+bias

  plt.figure(figsize=(12,6))
  plt.plot(time,result)
  plt.grid(True)
  plt.xlabel("time")
  plt.ylabel("sin")
  plt.title(str(amp)+ "sine(2*pi" + str (freq) + "*t" + str(startTime) +")+" + str(bias))
  plt.show()

# 3.
plotSinWave()

바로 위 코드와 다른 점은 크게 3가지로 각 번호 표기한 부분을 보면된다. 2번 부분에 임의로 값을 지정해줬기에 3번 부분엔 특별히 인자를 기입할 필요가 없다.

그렇다면 다른 값을 넣어보자.

plotSinWave(amp=2, freq =0.5, endTime=10)

"**kwargs"를 사용했기 때문에 3번 부분에 모든 인자를 다시 입력할 필요없이 필요한 특정 인자에만 값을 수정해주었다.

• 기본 구성요소 : index, columns, values, aggfunc

pd.pivot_table(df,              # 피벗할 데이터프레임
               index = '--',    # 행 위치에 들어갈 열
               columns = '--',  # 열 위치에 들어갈 열
               values = '--',   # 데이터로 사용할 열
               aggfunc = '--')  # 데이터 집계함수

💡 피벗 데이블의 인덱스 & 벨류 지정

pd.pivot_table(df, index="인덱스로 갈 컬럼 이름",
values=['컬럼 이름 1', '컬럼 이름 2']))

💡 멀티 인덱스

pd.pivot_table(df, index=["인덱스로 갈 컬럼 이름 1","인덱스 컬럼 2","인덱스 컬럼 3"],
values=['컬럼 이름 1', '컬럼 이름 2']))

💡 컬럼 설정

df.pivot_table(index=['Manager','Rep'], values='Price',columns='Product',aggfunc=np.sum)

💡 피벗 테이블의 연산

• 덧셈

  df.pivot_table(aggfunc=np.sum)

  • 2개 이상의 연산

    df.pivot_table(aggfunc=[np.sum,len])

• 맨 밑 총합 나오게

  margins=True

💡 응용

• 피벗테이블_멀티인덱스 + 'fill_value='

• 주피터(Jupyter)

• 오픈소스 웹 어플리케이션으로, 코드 작성, 시각화 및 문서 작성이 가능한 대화형 환경을 제공하는 도구
• 주피터 노트북은 프로그래밍 언어인 파이썬뿐 아니라 R, Julia 등다양한 언어를 지원
• 명령어 입력후 [shift + tap] 입력시 설명서 확인

• 판다스(Pandas)

• 여러가지 유용한 데이터 자료구조를 제공하는 파이썬 라이브러리
• 공식 홈페이지

• 참고 자료 : 따라하면서 쉽게 배우는 판다스 / Jupyter Notebook이란?

💡 intro

• import

  • numpy : 수치적 해석이 많을 때

    import numpy as np
    import pandas as pd
    import matplotlib.pyplot as plt
    %matplotlib inline

• 데이터 읽기

  • 파일 확장자 : csv / excel /
  • encoding = 'utf-8' : 한글 글자깨짐 방지
  • 데이터 주소 .. : 현재 폴더의 1단계 상위 폴더
  • 데이터 주소 . : 현재 폴더
    • thousands = ' , ' : 1000단위 이상 넘어가면 문자로 인식 할 수 있어서, 숫자로 인식 할수 있도록 지정

      pd.read_파일 확장자('데이터 주소'),encoding='utf-8'

💡 유용 메서드 (python)

유용 사이트 : https://data-make.tistory.com/125

• .info()
• .unique() : 칼럼에 중복되지 않은 유일한 value 출력
• .isnull() : 누락 데이터(NaN) 값 개수 구하기
• .notnull() : 누락 데이터가 아닌 값만 구하기
• .head(n) : n 지정 없을시 상위 5개, n값만큼 상위 출력
• .tail(n) : n 지정 없을시 하위 5개, n값만큼 하위 출력
• .columns.droplevel([n,m]) : 인덱스 n,m 컬럼 제거 del / drop 사용
• .iterrows ( ) : pandas용 반복문/받을 때, 인덱스와 내용으로 나누어 받는것 주의
• .split( ) : 띄어쓰기대로 나눠 하나의 리스트화

💡 유용 메서드

• (fill_value = 0) :Nan 같은 누락요소 반영 전 '=값'을 반영