봉자씨의 즐퇴놀이

  ## 1. 라이브러리 임포트

# import numpy as np
# import pandas as pd

import numpy as np
import pandas as pd


## 2. 파일 읽어오기

# AI-HUB 감성 대화 말뭉치 활용하여 만든 데이터 읽어오기
# final_data = pd. [칸 채우기] ('https://github.com/ohgzone/file1/raw/main/aihub_coupus.csv' )

final_data = pd.read_csv('https://github.com/ohgzone/file1/raw/main/aihub_coupus.csv' )



# 데이터 확인하기
final_data.head()

# 총 51,630건
final_data.info()

## 3. 영문, 숫자, 특수문자 제거

# '문장' 컬럼의 내용중에 영문, 특수문자 있는지 확인 : 영문과 특수문자 존재 확인
# final_data[final_data['문장'].str.contains('[^가-힣 ]')].values[:10]


final_data[final_data['문장'].str.contains('[^가-힣 ]')].values[:10]

# '문장' 컬럼의 내용에서 숫자, 영문자, 특수문자등의 글자는 삭제처리
# final_data['문장'].replace('[^가-힣 ]','', regex=True) : 이렇게도 가능

# final_data['문장'] = final_data['문장'].str.replace('[^가-힣 ]','', regex=True)


final_data['문장'] = final_data['문장'].str.replace('[^가-힣 ]', '', regex= True)

# '문장' 컬럼의 내용에서 영문, 특수문자 없음 확인
# final_data['문장'][final_data['문장'].str.contains('[^가-힣 ]')].sum()

final_data['문장'][final_data['문장'].str.contains('[^가-힣 ]')].sum()

# 숫자, 영문자, 특수문자 등 제거후 데이터 확인하기.
final_data.head()

## 4. 전처리 : Null, 중복 제거

# final_data 어떤 컬럼과 내용으로 되어 있는지 다시 확인
final_data.tail()

# '문장' 컬럼의 내용을 양끝의 빈공간 삭제
# final_data['문장'] = final_data['문장'].str.strip()
final_data['문장'] =final_data['문장'].str.strip()


# 데이터 다시 확인
final_data.tail()

# Null 있는지 확인 : 없음
final_data.isnull().sum()

# 중복 데이터 있는지 확인 : 56건 중복 존재 확인

final_data['문장'].duplicated().sum()

# 중복 데이터 제거

final_data.drop_duplicates(subset=['문장'], inplace =True)



# 기존 51,630건 --> 이후 51,574건 : 56건 중복 삭제 확인
final_data.info()

## 5. Label 분포 확인

# label '감정' 분포 확인 : 총 6개이며, 고루게 분포 확인. 단 기쁨이 약간 부족해 보임
# final_data['감정']. [칸 채우기] ()
final_data['감정'].value_counts()

# plot Bar차트 그리기
final_data['감정'].value_counts().plot(kind='bar')

## 6. label 숫자로 인코딩

# 라벨와 클래스을 매핑 작업

from sklearn.preprocessing import LabelEncoder
encoder = LabelEncoder()
final_data['감정'] = encoder.fit_transform(final_data['감정'])
encoder.classes_


final_data.tail()

## 7. X, Y 분리

# X, Y 분리
features = final_data['문장'].values
labels = final_data['감정'].values

features.shape, labels.shape

# features 내용 3개 출력
features[:3]

# print('이벤트 문자열 최대 길이 :{}'.format(max(len(l) for l in features)))
# print('이벤트 문자열 평균 길이 :{}'.format(sum(map(len, features))/len(features)))

print('even word max :{}'.format(max(len(l) for l in features)))
print ('event word  avg :{}'.format(sum(map(len, features))/len(features)))

# 히스토그램을 보면 30~40 부근에 많이 몰려 있음 알수 있다.

plt.hist([len(l) for l in features], bins=50)
plt.xlabel('length of samples')
plt.ylabel('number of samples')
plt.show()


## 8. train set와 test set 분리

from sklearn.model_selection import train_test_split

x_train, x_test, y_train, y_test = train_test_split(features, labels, test_size =0.2, stratify=labels , random_state= 41)
x_train.shape, x_test.shape, y_train.shape, y_test.shape


# 샘플확인 , 라벨 확인
# {0: '불안', 1: '분노', 2: '상처', 3: '슬픔', 4: '당황', 5: '기쁨'}

x_train[:2], y_train[:2]

# 말뭉치를 TF-IDF로 변환하기
from sklearn.feature_extraction.text import TfidfVectorizer

tfidf = TfidfVectorizer()
x_train_v = tfidf.fit_transform(x_train)
x_test_v = tfidf.transform(x_test)



# 각 라인의 각 단어에 대한 TF-IDF 값 표현
print(x_train_v)

# 학습데이터셋의 TF-IDF 매트릭스 확인하기 : 41259 라인, 47366 단어
x_train_v.shape

## 9. 머신러닝 모델링

# 학습하는데 Colab에서 4분 소요
from sklearn.ensemble import RandomForestClassifier

rfc = RandomForestClassifier()
rfc.fit(x_train_v, y_train)
rfc.score(x_test_v, y_test)


### 10. 예측해 보기

# 출력 결과 해석 : (0, 44327) 0.241660101642553
# 0 : 첫라인, 44327 : 단어에 맵핑된 번호, 0.241660101642553 : tf-idf 계산 값
print('검증 데이터 셋의 첫번째 TF-IDF: {}'.format(x_test_v[0]))

print(f'검증데이터셋의 첫번째 TF-IDF 역변환 : {tfidf.inverse_transform(x_test_v[:1])}')

# RandomForest 모델로 예측하기
predict = rfc.predict(x_test_v[:1])
predict, encoder.inverse_transform(predict)

<br>
<br>
<br>
<br>

# 배운 내용 정리
1. AI-HUB 감정말뭉치 데이터 읽어오고
2. 데이터 전처리 : 한글, 공백외의 영어, 숫자, 특수문자등 제거
3. TF-IDF 토큰나이져 활용하여 토큰화하고 문장을 숫자로 나열
4. 머신러닝 RandomForest 모델을 활용하여 감성분류 수행


<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>

# B. LTSM 모델 이용하여 Classification하기
+ AI-HUB 감정말뭉치 데이터를 가지고
+ LSTM 모델학습하여 감정 뷴류 보겠습니다.

<br>
<br>

## 1. 라이브러리 임포트

import numpy as np
import pandas as pd

## 2. 파일 읽어오기

# AI-HUB 감성 대화 말뭉치 활용하여 만든 데이터 읽어오기
final_data = pd.read_csv('https://github.com/ohgzone/file1/raw/main/aihub_coupus.csv' )

# 데이터 확인하기
final_data.head()

# 총 51,630건
final_data.info()

## 3. 영문, 숫자 특수문자 제거

# '문장' 컬럼의 내용중에 영문, 특수문자 있는지 확인 : 영문과 특수문자 존재 확인
final_data[final_data['문장'].str.contains('[^가-힣 ]')].values[:10]

# '문장' 컬럼의 내용에서 숫자, 영문자, 특수문자등의 글자는 삭제처리
final_data['문장'] = final_data['문장'].str.replace('[^가-힣 ]','', regex=True)

# '문장' 컬럼의 내용에서 영문, 특수문자 없음 확인
final_data['문장'][final_data['문장'].str.contains('[^가-힣 ]')].sum()

# 숫자, 영문자, 특수문자 등 제거후 데이터 확인하기.
final_data.head()

## 4. 전처리 : Null, 중복 제거

# final_data 어떤 컬럼과 내용으로 되어 있는지 다시 확인
final_data.tail()

# '문장' 컬럼의 내용을 양끝의 빈공간 삭제
final_data['문장'] = final_data['문장'].str.strip()

# 데이터 다시 확인
final_data.tail()

# Null 있는지 확인 : 없음
final_data.isnull().sum()

# 중복 데이터 있는지 확인 : 56건 중복 존재 확인
final_data['문장'].duplicated().sum()

# 중복 데이터 제거
final_data.drop_duplicates(subset=['문장'], inplace=True)

# 기존 51,630건 --> 이후 51,574건 : 56건 중복 삭제 확인
final_data.info()

## 5. Label 분포 확인

# label '감정' 분포 확인 : 총 6개이며, 고루게 분포 확인. 단 기쁨이 약간 부족해 보임
final_data['감정'].value_counts()

# plot Bar차트 그리기
final_data['감정'].value_counts().plot(kind='bar')

## 6. label 숫자로 인코딩

# 감정 리스트 만듬
list1 = final_data['감정'].value_counts().index.values
list1

# 라벨와 클래스을 매핑 작업
label2class = {}
class2label = {}
for cl, la in enumerate(list1):
  # print(i, j)
  label2class[la] = cl
  class2label[cl] = la

print(label2class)
print(class2label)

# '감정' 라벨링 수행
final_data['label'] = final_data['감정'].map(label2class)

final_data.tail()

## 7. X, Y 분리

# X, Y 분리
features = final_data['문장'].values
labels = final_data['label'].values


features.shape, labels.shape

# features 내용 3개 출력
features[:3]

print('이벤트 문자열 최대 길이 :{}'.format(max(len(l) for l in features)))
print('이벤트 문자열 평균 길이 :{}'.format(sum(map(len, features))/len(features)))

# 히스토그램을 보면 30~40 부근에 많이 몰려 있음 알수 있다.
plt.hist([len(s) for s in features], bins=50)
plt.xlabel('length of samples')
plt.ylabel('number of samples')
plt.show()

## 8. train set와 test set 분리

from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(features, labels , test_size=0.2, stratify=labels, random_state=41)
x_train.shape, x_test.shape, y_train.shape, y_test.shape

# 샘플확인 , 라벨 확인
# {0: '불안', 1: '분노', 2: '상처', 3: '슬픔', 4: '당황', 5: '기쁨'}

x_train[:2], y_train[:2]

## 9. 전체 문장에 대해 Tokenizing
+ 컴퓨터가 이해하기 위해 모든 단어를 숫자로 변환해야 함.
+ 단어 빈도수 따지지 않고 무조건 모든 단어 수용해서 진행

import tensorflow as tf
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences

# Tokenizer 구현 : 단어 사전 만들기(fit_on_texts)

tokenizer = Tokenizer()
tokenizer.fit_on_texts(x_train)


# 단어에 대한 숫자 매핑
print(tokenizer.word_index)

# 반대로 숫자로 단어 매핑
print(tokenizer.index_word)

# 단어별 빈도수 확인
print(tokenizer.word_counts)

# 총 단어 갯수 : 47,646
max_words = len(tokenizer.index_word)
print(max_words)

## 10. texts_to_sequences : 문장을 숫자로 나열
- 빈도수 적은 단어 제외하는것 없이 모든 단어 포함해서 진행
- 그리고, 예를 들어 1번 등장하는 단어는 삭제하는 작업은 필요시 수행!!

# 문장을 숫자로 나열

x_train_seq= tokenizer.texts_to_sequences(x_train)
x_test_seq = tokenizer.texts_to_sequences(x_test)


# 문장을 숫자로 변경후 갯수 확인
# x_train.shape, x_test.shape, y_train.shape, y_test.shape : ((41259,), (10315,), (41259,), (10315,))
print(len(x_train_seq), len(x_test_seq))

print(x_train[1:3])
print(x_train_seq[1:3])

## 11. Padding Sequence

# 문장의 최대 길이 파악 : 제일 긴 문장 seq 길이는 38개로 구성됨.
max(len(l) for l in x_train_seq)

# 모든 문장을 최대 문장 Seq 길이 38에 맞춘다.

x_train_pad = pad_sequences(x_train_seq, maxlen=38)
x_test_pad = pad_sequences(x_test_seq, maxlen=38)

# 문장 Seq 내용을 보니 잘 패딩되어 있음 확인
x_train_pad[:1]

# 문장 Seq 패딩의 shape 확인
x_train_pad.shape, x_test_pad.shape

## 12. LSTM 모델링

from tensorflow.keras.layers import Dense, Flatten, Conv2D, MaxPool2D
from tensorflow.keras.layers import Embedding, Bidirectional, LSTM, SimpleRNN, GRU
from tensorflow.keras.models import Sequential
from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint

# 하이퍼 파라미터

max_words = 47646 + 1    # 총 단어 갯수 + padding 0 번호
max_len = 38             # 최대 문장 길이
embedding_dim = 32      # embedding 차원

# 모델 선언
model = Sequential()

# 단어를 의미있는 32 차원으로 Vector 변경(Embedding)
model.add(Embedding(max_words, embedding_dim, input_length=max_len))

# LSTM 모델

model.add(LSTM(16, return_sequences=True))
model.add(LSTM(16, return_sequences=True))
model.add(Flatten())
model.add(Dense(128, activation='swish'))
model.add(Dense(32, activation='swish'))
model.add(Dense(6, activation='softmax'))

# 모델 compile
model.compile(loss = 'sparse_categorical_crossentropy',
              optimizer = 'adam',
              metrics = ['accuracy'])
model.summary()

# 조기종료 콜백함수 정의(EarlyStopping)
es =  EarlyStopping(monitor='val_loss', patience=10, verbose=1)

# 체크포인트 저장(ModelCheckpoint)
checkpoint_path = 'tmp_checkpoint.keras'
cp = ModelCheckpoint(checkpoint_path, monitor='val_loss', verbose=1, save_best_only=True)

# 모델 학습(fit)
history = model.fit(x_train_pad, y_train, epochs=50, batch_size=512,
                      validation_split=0.2, verbose =1, callbacks=[es, cp])

epochs = range(1, len(history.history['accuracy']) + 1)
plt.plot(epochs, history.history['accuracy'])
plt.plot(epochs, history.history['val_accuracy'])
plt.title('model accuracy')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['train', 'valid'], )
plt.show()

model.evaluate(x_test_pad, y_test)

### 13. 예측해 보기

print(f'문자열 : {x_test[0]}')
print(f'Sequence : {x_test_pad[0]}')

# 모델 예측하기(predict)
predict = model.predict (x_test_pad[:1])

print(f'True : {class2label[y_test[0]]}')
print(f'Predict : {class2label[np.argmax(predict)]}')

### 1.필요한 라이브러리 임포트

import os
from glob import glob
from PIL import Image

import numpy as np
import tensorflow as tf

import matplotlib.pyplot as plt


### 2.이미지 파일 가져오기

# 약 3,700장의 꽃 사진 데이터세트를 사용합니다.
# 아래 데이터 가져오기 그냥 사용합니다.

import pathlib
dataset_url = "https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz"
data_dir = tf.keras.utils.get_file('flower_photos', origin=dataset_url, untar=True)
data_dir = pathlib.Path(data_dir)


# 이미지 패스 확인
data_dir

# 이미지 폴더 밑의 폴더 확인

!ls -l /root/.keras/datasets/flower_photos/

# daisy 폴더 안의 이지미 갯수
!ls -l /root/.keras/datasets/flower_photos/daisy | grep jpg | wc -l

# dandelion 폴더 안의 이지미 갯수
!ls -l /root/.keras/datasets/flower_photos/dandelion | grep jpg | wc -l

# roses 폴더 안의 이지미 갯수
!ls -l /root/.keras/datasets/flower_photos/roses | grep jpg | wc -l

# sunflowers 폴더 안의 이지미 갯수
!ls -l /root/.keras/datasets/flower_photos/sunflowers | grep jpg | wc -l

# tulips 폴더 안의 이지미 갯수iiiiiiiiiii
!ls -l /root/.keras/datasets/flower_photos/tulips | grep jpg | wc -l

### 3. os.listdir과 PIL.Image 이용하여 이미지 읽기

# 이미지 패스 지정
daisy_path = '/root/.keras/datasets/flower_photos/daisy/'
dandelion_path = '/root/.keras/datasets/flower_photos/dandelion/'
roses_path = '/root/.keras/datasets/flower_photos/roses/'
sunflowers_path = '/root/.keras/datasets/flower_photos/sunflowers/'
tulips_path = '/root/.keras/datasets/flower_photos/tulips/'

# 이미지 패스의 파말 리스트 만들기
daisy_file = os.listdir(daisy_path)
dandelion_file = os.listdir(dandelion_path)
roses_file = os.listdir(roses_path)
sunflowers_file = os.listdir(sunflowers_path)
tulips_file = os.listdir(tulips_path)

# 이미지 파일 리스트 읽어보기
daisy_file[:2], roses_file[:2]

# 위의 파일 리스트에서 2개씩 읽고 이미지 출력하기
for img_file in daisy_file[:2] :
    img = Image.open(daisy_path + img_file).resize((224,224))
    plt.title(img_file + ' : daisy')
    plt.imshow(img)
    plt.show()

for img_file in roses_file[:2] :
    img = Image.open(roses_path + img_file).resize((224,224))
    plt.title(img_file + ' : roses')
    plt.imshow(img)
    plt.show()

### 4. 이미지 라벨링 포함해서 Class별 이미지 리스트 만들기

# Class 라벨 정의

class2idx = {'daisy' :  0, 'dandelion' : 1,  'roses' : 2, 'sunflowers' : 3, 'tulips' : 4}
idx2class = {0 : 'daisy', 1 : 'dandelion', 2 : 'roses', 3 : 'sunflowers', 4 : 'tulips'}




# 수작업으로 이미지 리스트와 라벨 리스트 만들기

img_list = []
label_list = []

daisy_file = os.listdir(daisy_path)
for img_file in daisy_file :
  img = Image.open(daisy_path + img_file).resize((128,128))
  img = np.array(img)/255.  # 이미지 스케일링
  img_list.append(img)
  label_list.append(0) # daisy : 0

dandelion_file = os.listdir(dandelion_path)
for img_file in dandelion_file :
  img = Image.open(dandelion_path + img_file).resize((128,128))
  img = np.array(img)/255.  # 이미지 스케일링
  img_list.append(img)
  label_list.append(1) # dandelion : 1

roses_file = os.listdir(roses_path)
for img_file in roses_file :
  img = Image.open(roses_path + img_file).resize((128,128))
  img = np.array(img)/255.  # 이미지 스케일링
  img_list.append(img)
  label_list.append(2) # roses : 2

sunflowers_file = os.listdir(sunflowers_path)
for img_file in sunflowers_file :
  img = Image.open(sunflowers_path + img_file).resize((128,128))
  img = np.array(img)/255.  # 이미지 스케일링
  img_list.append(img)
  label_list.append(3) # sunflowers : 2

tulips_file = os.listdir(tulips_path)
for img_file in tulips_file :
  img = Image.open(tulips_path + img_file).resize((128,128))
  img = np.array(img)/255.  # 이미지 스케일링
  img_list.append(img)
  label_list.append(4) # tulips : 2

# 이미지 리스트, 라벨 리스트루 numpy array 변경
img_list_arr = np.array (img_list)
label_list_arr = np.array(label_list)

# 이미지 리스트, 라벨 리스트 shape 확인
img_list_arr.shape, label_list_arr.shape

### 5. Train/Test 데이터셋 만들기

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(img_list_arr, label_list_arr, test_size =0.3, stratify=label_list_arr, random_state=41)
X_train.shape, X_test.shape , y_train.shape, y_test.shape

## B. Build Model

### 1. Build Model

# Hyperparameter Tunning

num_epochs = 10
batch_size = 32

learning_rate = 0.001
dropout_rate = 0.5

input_shape = (128, 128, 3)  # 사이즈 확인

# Sequential 모델 정의
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPooling2D

model =Sequential()
model.add( Conv2D(32, kernel_size=(5,5), strides=(1,1), padding='same', activation='relu', input_shape=input_shape))
model.add(MaxPooling2D (pool_size=(2,2), strides=(2,2)))
model.add(Conv2D(64,(2,2), activation='relu', padding='same'))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Dropout(0.2))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.3))
model.add(Dense(5, activation='softmax'))


# 모델 컴파일
model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate),
              loss = 'sparse_categorical_crossentropy',
              metrics =['accuracy'])


model.summary()

### 2. Callback

# callback : EarlyStopping, ModelCheckpoint

from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint

# EarlyStopping
es = EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=5)

# ModelCheckpoint
checkpoint_path = "my_checkpoint.keras"
cp = ModelCheckpoint(filepath=checkpoint_path,
                     save_best_only =True,
                     monitor = 'val_loss',
                     verbose = 1)


### 3. 모델 학습

# num_epochs = 10
# batch_size = 32

# 모델 학습(fit)
history = model.fit (
    X_train, y_train ,
    validation_data=(X_test, y_test),
    epochs=num_epochs,
    batch_size=batch_size,
    callbacks=[es, cp]
)

### 4. 성능 그래프

history.history.keys()

plt.plot(history.history['accuracy'], label='Accuracy')
plt.plot(history.history['val_accuracy'], label='Val Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()
plt.title('Model Accuracy')
plt.show()

### 5. Predict

# Test 데이터로 성능 예측하기

i =1
plt.figure(figsize=(16, 8))
for img, label in zip(X_test[:8], y_test[:8]) :
    pred = model.predict(img.reshape(-1, 128, 128, 3))
    pred_t = np.argmax(pred)
    plt.subplot(2, 4, i)
    plt.title('True Value :{}, Pred Value : {}'.format(label, pred_t))
    plt.imshow(img)
    plt.axis('off')
    i = i+1

## 배운 내용 정리
1. os.listdir과 PIL.Image 활용해서 이미지 Dataset 만들어 보았습니다.
2. os.listdir과 PIL.Image 함수를 이용하여 필요한 데이터를 읽어오고
3. 리스트에 하나씩 넣어주면서 같이 라벨링도 라벨링에 넣어 주었습니다.
4. 이미지 리스트와 라벨 리스트를 numpy array로 변경후 학습 테이더셋과 검증 테이터 셋으로 나눠어 주었습니다.
5. 이후 , CNN 모델을 만들고 학습하고 평가해 보았습니다.
8. 약간의 수작업이 있었는데, 이런식으로 데이터셋 구성 및 모델을 만들수 있었습니다.

<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>

## C.image_dataset_from_directory 이용하여 데이터셋 만들기

### 1.필요한 라이브러리 임포트

from glob import glob
import os
import numpy as np
import tensorflow as tf

import matplotlib.pyplot as plt

### 2.이미지 파일 가져오기

# 약 3,700장의 꽃 사진 데이터세트를 사용합니다.
# 아래 데이터 가져오기 그냥 사용합니다.

import pathlib
dataset_url = "https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz"
data_dir = tf.keras.utils.get_file('flower_photos', origin=dataset_url, untar=True)
data_dir = pathlib.Path(data_dir)



# 이미지 패스 확인
data_dir

# 이미지 폴더 밑의 폴더 확인

!ls -l /root/.keras/datasets/flower_photos/

# daisy 폴더 안의 이지미 갯수
!ls -l /root/.keras/datasets/flower_photos/daisy | grep jpg | wc -l

# dandelion 폴더 안의 이지미 갯수
!ls -l /root/.keras/datasets/flower_photos/dandelion | grep jpg | wc -l

# roses 폴더 안의 이지미 갯수
!ls -l /root/.keras/datasets/flower_photos/roses | grep jpg | wc -l

# sunflowers 폴더 안의 이지미 갯수
!ls -l /root/.keras/datasets/flower_photos/sunflowers | grep jpg | wc -l

# tulips 폴더 안의 이지미 갯수
!ls -l /root/.keras/datasets/flower_photos/tulips | grep jpg | wc -l

###  3. 이미지 파일 하나 읽어 이미지 보기

# 이미지 패스 지정
daisy_path = '/root/.keras/datasets/flower_photos/daisy/'

# 이미지 패스의 파말 리스트 만들기
daisy_file = os.listdir(daisy_path)

# 이미지 파일 리스트 읽어보기
daisy_file[:2]

# 위의 파일 리스트에서 2개씩 읽고 이미지 출력하기
for img_file in daisy_file[:2] :
    img = Image.open(daisy_path + img_file).resize((224,224))
    plt.title(img_file + ' : daisy')
    plt.imshow(img)
    plt.show()


### 4. Data Preprocess

### image_dataset_from_directory 이용하여 자동으로 이미지 데이터셋 생성, 라벨링 한꺼번에 처리 할수 있다.

# 하이터 파라미터 정의
input_shape =(224, 224, 3)
batch_size = 32
num_calsses= 5


# 이미지 패스 지정
img_path ='/root/.keras/datasets/flower_photos/'

# image_dataset_from_directory 함수 활용하여
# 이미지 폴더 밑의 이미지들에 대해 원핫인코딩된 labeling수행, 이미지 배치, 셔플 수행
train_ds = tf.keras.preprocessing.image_dataset_from_directory(
    directory= img_path,
    label_mode = 'categorical',
    batch_size = batch_size,
    image_size = (224,224),
    seed = 42,
    shuffle= True,
    validation_split=0.2,
    subset='training'
)

test_ds = tf.keras.preprocessing.image_dataset_from_directory(
    directory=img_path,
    label_mode = 'categorical',
    image_size = (224,224),
    batch_size = batch_size,
    seed = 42,
    shuffle= True,
    validation_split=0.2,
    subset='validation'
)


# Class 이름 확인
train_ds.class_names

# 40,000건 중에서 32,000건 Train 사용. test용으로 8,000건 사용
len(train_ds) * 32 , len(test_ds) * 32

batch_img, batch_label = next(iter(train_ds))
batch_img.shape, batch_label.shape

# 샘플 이미지 확인

i = 0
for batch_img, batch_label in train_ds.take(1):
  if i == 0 :
    print(batch_img[i].shape)
    plt.imshow(batch_img[i]/225)
  i = i + 1


## B. 모델링

### 1. Build Model

# Hyperparameter Tunning

num_epochs = 10
batch_size = 32

learning_rate = 0.001
dropout_rate = 0.5

input_shape = (224, 224, 3)  # 사이즈 확인
num_classes = 5

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPooling2D, Rescaling

model = Sequential()
model.add(Rescaling(1. / 255))  # 이미지 Rescaling. 없이 하면 성능이 안나옴.
model.add( Conv2D(32, kernel_size=(5,5), strides=(1,1), padding='same', activation='relu', input_shape=input_shape))
model.add( MaxPooling2D (pool_size=(2,2), strides=(2,2)))
model.add(Conv2D(64,(2,2), activation='relu', padding='same'))
model.add(MaxPooling2D(pool_size=(2,2)))
model.add(Dropout(0.2))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.3))
model.add(Dense(5, activation='softmax'))

# Model compile
model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate),
              loss= 'categorical_crossentropy',
              metrics =['accuracy'])

### 2. Callback

from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint
es = EarlyStopping(monitor ='val_loss', mode='min', verbose = 1, patience = 3)
chk_path = 'my_checkpoint.keras'
cp = ModelCheckpoint(filepath = chk_path,
                     save_best_only = True,
                     monitor = 'val_loss',
                     verbose = 1)

### 3. 모델 학습

# image_dataset_from_directory 이용하여 데이터 만들었을때 아래와 같이 학습 진행
# num_epochs = 10

# 모델 학습(fit)
history = model.fit(
    train_ds,
    validation_data=(test_ds),
    epochs=10,
    callbacks=[es, cp]
)

### 4. 성능 그래프

history.history.keys()

plt.plot(history.history['accuracy'], label='Accuracy')
plt.plot(history.history['val_accuracy'], label='Val Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()
plt.title('Model Accuracy')
plt.show()

### 5. Predict

len(test_ds) * 32

# 배치사이즈 이미지/라벨 가져오기
batch_img , batch_label = next(iter(test_ds))
type(batch_img), batch_img.shape

# Test 데이터로 성능 예측하기

i = 1
plt.figure(figsize = (16, 30))
for img, label in list(zip(batch_img, batch_label)):
  pred = model.predict(img.numpy().reshape(-1, 224, 224, 3), verbose = 0)
  pred_t = np.argmax(pred)
  plt.subplot(8, 4, i)
  plt.title(f'True Value:{np.argmax(label)}, Pred Value: {pred_t}')
  plt.axis('off')
  plt.imshow(img/255)  # 이미지 픽셀값들이 실수형이므로 0~1 사이로 변경해야 에러 안남
  i = i + 1


## 배운 내용 정리
1. DataSet을 만들기 위해 많은 수작업(파일 읽어오기, Pipeline(map, cache, batch, shuffle, prefetch), 라벨 코딩등) 필요
2. 이런 수작업을 케라스 image_dataset_from_directory 이용하여 한번에 처리할수 있습니다.
3. 여러분은 image_dataset_from_directory 와 같은 필요한 함수들을 필요에 따라 잘 사용하시면 되겠습니다.

<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>

## E. MobileNet Transfer Learning & Fine-tuning 모델링

### 1. Build Model

# 케라스 applicatioins에 어떤 종류의 모델 있는지 확인
dir(tf.keras.applications)

# 사전 훈련된 모델 MobileNetV2에서 기본 모델을 생성합니다.
# 아래와 같은 형식을 MobileNetV2 Transfer Learning 사용하며 됩니다.
base_model = tf.keras.applications.MobileNetV2(input_shape = (224, 224, 3), weights='imagenet', include_top= False)

base_model.summary()

# tf.keras.applications.MobileNetV2 모델은 [-1, 1]의 픽셀 값을 예상하지만 이 시점에서 이미지의 픽셀 값은 [0, 255]입니다.
# MobileNetV2 모델에서 제대로 수행하기 위해 크기를 [-1, 1]로 재조정해야 합니다.(안하고 수행해도 성능 잘 나옴)
# 방법 2가지 있음
# 첫번째 방법 : preprocess_input = tf.keras.applications.mobilenet_v2.preprocess_input
# 두번째 방법 : rescale = tf.keras.layers.Rescaling(1./127.5, offset=-1)

# MobileNet V2 베이스 모델 고정하기
base_model.trainable = False


# 모델 구축 : 이미지 픽셀값 조정 수행하기(Rescaling) --> 성능 더 잘 나옴.
inputs = tf.keras.Input(shape=(224,224,3))
x = tf.keras.layers.Rescaling(1./127.5, offset=-1)(inputs)
x = base_model(x, training=False)
x = tf.keras.layers.GlobalAveragePooling2D()(x)
output = tf.keras.layers.Dense(5, activation='softmax')(x)

model = tf.keras.Model(inputs=inputs, outputs=output)
model.summary()




# 모델 compile

model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate),  # Optimization
              loss='categorical_crossentropy',  # Loss Function
              metrics=['accuracy'])             # Metrics / Accuracy

### 2. Callback

from tensorflow.keras.callbacks import EarlyStopping, ModelCheckpoint

# EarlyStopping
es =EarlyStopping(monitor='val_loss', mode='min', verbose=1, patience=3)

# ModelCheckpoint
checkpoint_path = "my_checkpoint.keras"
checkpoint = ModelCheckpoint(filepath=checkpoint_path,
                             save_best_only=True,
                             monitor='val_loss',
                             verbose=1)

### 3. 모델 학습

# image_dataset_from_directory 이용하여 DataSet을 만들었으며
# num_epochs = 10
# batch_size = 32

history = model.fit(
    train_ds,
    validation_data = test_ds,
    epochs=2,
    callbacks=[es, checkpoint]
)

### 4. 성능 그래프

history.history.keys()

plt.plot(history.history['accuracy'], label='Accuracy')
plt.plot(history.history['val_accuracy'], label='Val Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()
plt.title('Model Accuracy')
plt.show()

### 5. Predict

# test_generator 샘플 데이터 가져오기
# 배치 사이즈 32 확인

batch_img, batch_label = next(iter(test_ds))
print(batch_img.shape)
print(batch_label.shape)

# 이미지 rescale 되어 있는 상태
batch_img[0][0][:10]

# 100% 성능 보여줌

i = 1
plt.figure(figsize=(16, 30))
for img, label in list(zip(batch_img, batch_label)):
    pred = model.predict(img.numpy().reshape(-1, 224,224,3), verbose=0)
    pred_t = np.argmax(pred)
    plt.subplot(8, 4, i)
    plt.title(f'True Value:{np.argmax(label)}, Pred Value: {pred_t}')
    plt.imshow(img/255)  # 이미지 픽셀값들이 실수형이므로 0~1 사이로 변경해야 에러 안남
    i = i + 1

안녕하세요 봉자씨입니다.

업무를 진행하다보면 이미지로 되어 있는 텍스트를 문서화 하기 위해서 텍스트로 입력을 해야하는 경우가 있습니다.

이 경우가 아니더라도 보관되어 있는 이미지의 문서화가 필요 한 경우가 종종 있죠.

이런 경우에 이미지의 텍스트를 보고 입력하는 방법으로 기존에는 진행 했습니다.

하지만 이제 그렇게 진행하지 않고 새로운 방법으로 좀 시간을 단축 가능한 방법 찾아보겠습니다.

이미지화된 텍스트를 문서화 텍스트로 바꾸기!

먼저 텍스트를 포함한 이미지가 존재하겠죠.

해당 이미지를 아래와 같이 차근 차근 따라해 보겠습니다.

1. 구글 드라이브를 입력하여 구글 드라이브에 접속합니다.(없다면 간단하게 가입을...)

2 .텍스트 파일로 변환하고자 하는 이미지 파일을 아무곳이나 업로드 합니다. 

저는 imgTmp라는 파일명으로 업로드 해보도록 하겠습니다. 그리고 아래의 파일은 샘플 파일입니다.

3. 업로드 된 파일을 오른 쪽 마우스 클릭을 해봅니다.

    그럼 아래의 초록색 박스 처럼 Google문서가 보이는 것을 확인 할수 있습니다.

    해당 부분을 마우스로 클릭합니다.

4. 조금의 시간이 지난 후에 아래와 같은 결과를 확인 할 수 있습니다.

    이미지가 정말 텍스트로 변환 된 것을 확인이 가능하죠.

    단, 혹시 모르니 그래도 비교는 꼭 해보세요.

간단하죠. 그렇게 어렵지 않게 이미지를 텍스트 파일로 변환 했습니다.

위와 같은 방법을 사용하신다면 시간을 조금 단축 할 수 있지 않을까요.

감사합니다.

안녕하세요 봉자씨입니다.

파이썬에서 숫자를  많이 다룹니다. 

그래서 오늘은 많이 사용하는 그 숫자에 대해서 사용시에 알아야 할 것들을 한번 같이 정리해 보겠습니다.

1. 연산시에 알아 야 하는 것들

기본적인 +, -는 더하기와 빼기를 의미합니다.

그리고 * 는 곱하기를 /는 나는기를 의미하죠.

아래의 것들은 사용하다 보면 햇갈리는 연산자 입니다.

9 / 2  # 결과 4.5 (부동소수점 나누기)
9 //2  # 결과 4 (정수 나누기(소수점 이하 버림)를 의미)
9 %2 # 결과 1 (나머지를 구함)
9 **2  # 결과 81 (9의 2승을 의미)

파이썬 콘솔로 아래와 같이 확인을 해보세요.

2. 진수에 대해서 알아야 하는 것들

파이썬에 진수에 대해서 알야아 하는 것을 정리해 봅니다. 

파이썬에도 역시나 다른 언어와 같이 2진수 8진수 16진수가 존재합니다.

2진수는 0과 1로만 이루어진 수를, 

8진수는 0~7로만 이루어진 수를,

16진수는 0~9, A, B, C, D, E 로 이루어진 수죠.

그리고 이를 파이썬에서도 다른 언어와 같이 아래와 같이 표현을 하게 됩니다.

2진수를 표현 할땐 앞에 0b or OB 붙여 줍니다. # 0b101010 (2진수) # 42  
8진수를 표현 할땐 앞에 0o or OO  붙여 줍니다.# 0o52 (8진수)
16진수를 표현 할땐 앞에 0x or 0X 붙여 줍니다.# 0x2a (16진수)

그럼 이것도 역시 한번 파이썬 콘솔로 테스트 해보겠습니다.

아래의 테스트는 42가 맞냐고 비교를 해서 보여줬습니다. 그냥 입력을 하게 되면("0b101010") 42가 출력이 되니 그것도 해보세요.

3. 형변환에 대해서 알아야 하는 것들

파이썬에서의 숫자로 형 변환을 했을 경우에 대해서 알아 보겠습니다.

즉, 다른 형태의 데이터를 숫자로 변환 했을 때에 알아야 하는 것에 대해서 알아보겠습니다.

먼저 파이썬3를 기준으로 했을 경우 정수형(integer)과 실수형(floating point number)이 존재합니다.

정수형과 실수형의 구분은 파이썬에서는 변수 선언시 타입을 별도로 선언하지 않기에 값에 소숫점이 없다면 정수형, 있다면 실수형입니다.

다른 형태의 데이터를 정수형으로 형변환 할때는 int()라는 것을 사용합니다.

그렇게 되면 아래와 같이 형이 변환이 됩니다.

int(True)   => 1  (Boolean형의 데이터를 정수로 형변환 했을 경우 True는 1 False는 0이 됩니다.)
int(9.8)     => 9 (실수형을 정수형으로 형변환 시키게 되면 소수점을 잃게 됩니다.)
int(1.0e4)  =>10000(지수 형식의 표현법도 정수형으로 형변환 할 수 있습니다.)
int(‘10’)     =>10(문자열을 정수형으로 형변환 가능합니다.)
int(‘9.8’)    =>error(소수점 혹은 지수 포함 문자열 처리 불가합니다.)

추가적으로 아래의 형변환 형태는 기억해주세요

1.0+5       =>6.0(정수형과 실수형을 더하게 되면 결과는 실수형이 됩니다. 5가 실수형으로 형변환이 자동으로 이루어 집니다.)
False+6.0    =>6.0(False랑 6을 더하게 되면 False가 자동으로 실수 형변환이 이루어 지며, 0으로 바뀌어 더하면 6이 됩니다.)

콘솔에서 테스트 하면 아래와 같습니다.

4. long이 사라진 python3에서 int 크기는?(python3에서는 long은 없다!)

파이썬 2에서는 정수형 데이터 타입이 int와 long 두 가지가 있었는데, Int크기는 32bit,  long 64bit 데이터형입니다.

int 타입 변수의 값이 표현 범위를 넘어서게 되면 자동으로 long으로 타입으로 변경되었습니다.

그런데!

파이썬 3에서는 long 타입이 없어지고 int 타입만 남게 되었습니다.

그래서 아무리 큰 수를 넣어도 Inteager overflow가 발생하지 않습니다. 

Python3에서는 Googol도 닮을 수 있을 정도로 큰 수를 넣을수 있습니다.

구골? 구골이란 10에 100승을 의미합니다.

10**100 = 구골!

테스트를 해보면, googol이란 변수에 10**100을 넣었습니다.

잘 표현이 되는 것을 확인할 수 있습니다. 그리고 이를 출력해 봐도 잘 나오는 것을 확인 할 수 있습니다.googol*googol

파이썬에 type이라는 함수가 있는 해당 함수로 변수의 타입을 확인 할 수 있습니다. 타입을 확인해 보니 int형 임을 확인 할 수 있습니다.

위의 테스트를 파이썬2에서 테스트를 해보면 아래와 같이 

long형으로 나오는 것을 확인 할 수 있습니다.

파이썬에서의 숫자를 다루면서 이 정도 알고 계시면 됩니다.

감사합니다. 

안녕하세요 봉자씨입니다.

파이썬에서 데이터의 종류가 무엇이 있는지 그리고 각 데이터들은 어떻게 다른지에 대해서 한번 알아 보도록 하겠습니다.

데이터의 종류와 이를 다루기 위해서는 아래와 같은 단어에 대해서 꼭 알고 넘어가야 합니다.

파이썬을 공부하다 보면 자주 등장하는 3가지에 대해서 이야기 해보겠습니다.

1. 변수

2. 이름

3. 객체

먼저 변수에 대해서 알아 보겠습니다.

변수는 변하는 수 입니다. 그래서 다른 값을 가질 수 있습니다. 이와 다른 반대의 개념으로 상수가 있습니다. 상수의 경우는 변하지 않는 수를 이야기 합니다. ex) 1, 2, 3,111 등 쉽게 숫자를 생각하시면됩니다.

그런 변수는 할당이라고 하는 단어를 자주 보게 됩니다. 즉 "a라는 변수에 77을 할당한다"라고 하면  "a=77" 로 프로그래밍하면 됩니다.

여기서 할당이라는 이야기는 복사의 의미가 아니라 해당 수에 이름표를 붙인다라고 생각하심 됩니다.

이름? 이름에 대해서 알아보겠습니다.

파이썬에서 변수를 선언하고 변수를 사용할 수 있습니다 .그런데 이런 변수를 아무것이나 사용할 수 있는건 아닙니다. 사용할 수 없는 이름이 있습니다. 그럼 그런 이름이 무엇일가요.

아래와 같은 이름을 예약어(또는 파이썬의 키워드)라고 해서 사용 할 수 없는 이름입니다 .왜? 파이썬에서 이거 써요~

추가적으로 아래의 규칙을 지켜 줘야 합니다.

문자부터 시작해야 하며 숫자부터 시작하면 안 됩니다.

특수 문자(+, -, *, /, $, @, &, % 등)는 사용할 수 없습니다.

영문 문자와 숫자를 사용할 수 있지만 대소문자는 구분합니다.

객체에 대해서 알아보겠습니다.

객체라는 말은 파이썬을 하게 되면 자주 듣게 됩니다. 

객체에서 꼭 알아야 할 말은 파이썬의 모든 것은 객체로 구현되어 있다.

객체는 어떤 것이라도 변수에 담을 수있다.

결국 모든 것이 객체이니 어떤 것도 변수에 담을 수 있다.

위와 같이 파이썬의 데이터를 다루기 전, 꼭 알아야 하는 개념 3가지 변수, 이름, 객체에 대해서 알아보았습니다.

조금 어려울 수도 있습니다. 하지만 나중에 다시 와서 해당 글을 읽어보시면 아....라고 생각할 수 있을 것입니다.

그럼 다음 강의에서는 이제 진짜 데이터에 대해서 알아볼게요.

감사합니다.

안녕하세요 봉자씨입니다.

설치가 다 완료 되셨나요.

그럼 모든 언어의 시작이라고 불리우는 "Hello world" 대신 파이썬이니까.. "Hello Python"을 한번 출력해 보겠습니다.

헬로우 파이썬을 3가지 방법으로 한번 해보겠습니다.

1. Command 창의 환경에서 출력해 보기

간단하게 Command창을 열고 python3를 입력합니다.

그럼 아래와 같이  >>> 요런 표시가 보이게 됩니다.

그 곳에 print("Hello Pytoh")을 입력하면 아래와 같이 처음 짠 파이썬 프로그램이 됩니다. 

2. 파이참에서 프로젝트 생성후 해당 프로젝트에 Python파일 생성 후 출력해보기!(.py파일 생성 후 파일로 실행하기)

new project를 생성하여 진행하시면 됩니다.

저는 StartPython이라는 프로젝트를 만들어서 한번 작업을 해보도록 하겠습니다.

위와 같이 만들면 아래와 같이 왼쪽에 프로젝트 생성이 되는 것을 확인 할 수 있습니다.

프로젝트가 생성된 것을 확인 할 수 있습니다.

프로젝트를 클릭하고 마우스 오른쪽을 클릭합니다. 그럼 아래와 같이 창이 열리고 창에서 New를 선택해서 새로운 파이썬 파일을 만들어 봅니다. 파일 명은 Hello로 하도록하겠습니다.

그럼 아래와 같이 파일이 생기는 것을 확인 할수 있습니다.

Hello.py(파이썬을 만들면 .py라는 확장자로 파일이 생기게 됩니다. 그리고 이 파일에 프로그램을 하고 해당 파일을 실행 할 수 있게됩니다.)을 열고 나서 이제 해당 파일에 print("Hello Python")를 입력합니다. 그럼 아래와 같이 입력이 되죠.

그런데 이렇게 프로그램만 했다고 실행이 되는 것이 아닙니다.

이제 이 프로그램을 한번 실행해 보겠습니다.

상단 메뉴에 가서 Run에서 Run을 찾아서 클릭해 보세요 

결과가 출력이 되게 됩니다.

아래 부분에 Hello Python 출력되는 것을 볼 수 있습니다. 이것은 나중에 .py를 만들고 실행하는 행위를 대신해 주는 것입니다.

Command창에서 Hello.py파일이 있는 위치에 가서 아래와 같이 실행하는 것과 같습니다.

python3 Hello.py

3. 파이참에서 1번과 같이 command창에서 출력해 보기

파이참에서는 기본적으로 Python Console를 제공해 줍니다.

하단 부분의 탭을 클릭하여 아래와 같이 입력 하면 결과를 확인 할 수 있습니다.

이제 파이썬의 시작을 위한 첫 발을 내딪었습니다.

그럼 다음 강의에서 뵐게요.

감사합니다.

안녕하세요 봉자씨입니다.

파이썬을 이제 파이썬에 대해서 이런 저런 이야기를 그만하고

파이썬을 설치해 보도록 하겠습니다.

파이썬을 설치하기 위해서는 아래의 사이트 방문을 합니다.

www.python.org/downloads/

사이트에 방문하여 노란 박스의 부분에 다운로드를 클릭해서 다운로드 받으시고 설치하시면 됩니다. 

이렇게 되면 파이썬 최신 버전을 설치하시게 됩니다.

(다운로드 받은 파일을 실행하여 설치하시면 되요!)

이제 설치가 잘 되었나 확인을 한번 해보겠습니다.

설치가 완료되었다면 command창을 열어서 한번 확인을 해보겠습니다.

아래와 같이 창을 열고 아래와 같이 입력하세요

python --version

만약 버전이 2.7로 나온다면 python3라고 하고 --version을 확인해 보세요

그럼 우리가 설치한 버전을 확인 할 수 있습니다.

최신 버전인 3.9.1이 나오면 설치가 제대로 된 것입니다.

그리고 나서 이제 python3 라고 입력해보세요.

이제 python3를 개발 할 수가 있습니다.

그러나.....

위와 같은 환경에서 파이썬을 개발하기란 정말 어렵습니다.

개발 할때 디버깅도 해야하고 이런 저런 코드의 양도 늘어나게 되면 정말 개발하기 힘이 듭니다.

그래서 이런 개발을 좀 더 좋은 환경에서 할 수 있도록 제공해 주는 툴이 있습니다.

이름하여 IDE 있습니다.

통합 개발 환경(統合開発環境, Integrated Development Environment, IDE)은 코딩, 디버그, 컴파일, 배포 등 프로그램 개발에 관련된 모든 작업을 하나의 프로그램 안에서 처리하는 환경을 제공하는 소프트웨어

그런 IDE에는 여러가지가 있습니다. 파이썬 개발을 지원하는 IDE는 아래와 같이 많습니다.

그럼 우리는 어떤 것을 설치하고 공부를 해야 할 가요.

솔직히 아무것이나 선택하셔서 하시면 됩니다. 호불호가 있을 뿐입니다.

하지만 파이참을 추천드립니다. 파이참의 경우 파이썬 코딩을 위한 여러가지 기능을 참 편리하게 제공합니다.

아래의 주소로 접속하시어 다운로드 받으시면 됩니다.

커뮤니티 버전(Free) 버전을 받아서 설치하시며 됩니다.

PyCharm설치(Community #개발용)

Window https://www.jetbrains.com/ko-kr/pycharm/download/#section=windows

Mac https://www.jetbrains.com/ko-kr/pycharm/download/#section=mac

여기까지 하시면 파이썬 학습을 위한 학습 도구들은 모두 설치하신 겁니다.

그럼 다음 강의에서 뵙겠습니다. 

아래의 글은 파이참을 선택하는 이유이니 참고해 주세요

https://bongjacy.tistory.com/entry/파이썬3-시작하기python-버전-선택과-디버깅-툴의-선택?category=1128906

안녕하세요 봉자씨입니다.

이 전에 파이썬을 왜 공부해야하고 파이썬으로 무엇을 해야 하는지에 대해서 알아 보았습니다.

그럼 이제 파이썬을 진짜로 공부해 보도록 하겠습니다.

파이썬은 인터프린터 언어라는 말이 있던데 무슨 말이죠?

파이썬이 인터프린터 언어다라는 말을 듣게 되고 이게 무슨 말인가 싶습니다.

프로그래밍 언어는 꼭 그렇진 않지만 두가지 부류로 나뉜다고 생각하시면 됩니다.

(아래의 내용은 초보용 해석이니 참고)

한방에 프로그램한 소스 코드를 읽어서 기계어로 변환하여 이를 실행하는 컴파일 언어와

프로그램한 소스 코드를 한줄 한줄 실시간으로 읽어서 실행하는 인터 프린터 언어가 있습니다.

이 중에 파이썬 언어는 인터프린터 언어에 해당합니다. 

원시 코드 (프로그래머가 작성한 소스코드)를 기계어로 변환하는 과정 없습니다.

한줄 한줄 해석하여 바로 명령어를 실행 R, Python, Ruby와 같은 언어들이 대표적입니다.

Runtime 상황에서는 한 줄씩 실시간으로 읽어서 실행하기 때문에 컴파일 언어에 비해 속도가 느립니다.
실행속도는 느리지만 코드 변경시 빌드 과정없이 바로 실행이 가능하다는 장점이 있습니다.

파이썬 하다 보면 이런 이야기가 나옵니다. 

Cpython? pypy? 대체 무슨 말이죠?

현재의 파이썬에서는 표준 파이썬 구현체인 CPython의 인터프리터를 사용하고 안정적으로 지원하고 있습니다.

PyPy의 경우 JIT 컴파일 및 메모리 사용량 감소와 같은 것이 코드의 속도를 크게 향상 시켰습니다.

근데 지금 Cpython 사용해요? why 안써? PyPy?

 - 파이썬 3 호환성 부족

 - 확장 지원 부족

 - 접착제 코드로 적합하지 않음

 - 속도가 전부는 아니다

음 파이썬 3???

이 전 글을 처음부터 보신 분은 이해하시 겠지만 처음 이 글을 보신 분은

대체 파이썬이면 파이썬이지 파이썬3가 무엇인지에 대해서 이해가 안가시는 분이 대다수라고 생각이 듭니다.

간단히 파이썬을 이야기하면 버전에 따라서 파이썬2와 파이썬3로 나눌 수 있습니다.

이를 한마디로 다시 정리하면

Python2는 과거이고, Python3는 미래이다.

귀도 반 로섬과 관계자는 고치기 힘든 것들을 함께 개선 하기로 결정. 이를 Python3라고 부르기로 하였습니다.

현재 파이썬 2.7의 버전은 2.7.17입니다. 2020년 1월에 2.7.18 버전의 코드 프리징(더이상 지원 안함)이 진행되고,

4월에는 2.x의 최종 버전인 2.7.18이 출시됩니다. 이후로는 더이상 업데이트가 이뤄지지 않습니다.

또한 중요한 것은 파이썬2와 파이썬3는 호환이 되지 않으니 꼭 알고 계세요.

그럼 파이썬2와 파이썬3의 차이가 무엇인가요?

그럼 왜 파이썬2와 파이썬3의 차이를 알아야 하나요?

우리는 이제 최신 버전의 파이썬3로 학습을 할 것입니다.

그런데 굳이 파이썬2에 대한 차이점을 알아야 하는 이유가 무엇일가요?

이유는 딱 한가지 입니다.

우리가 인터넷 상에서 파이썬 소스 코드도 찾아보고 참고도 하는 경우가 많을 것이고

그렇게 해야 파이썬의 실력이 무럭무럭 자라납니다. 

그런데 이 과정에서 내가 보는 코드가 파이썬2 인데도 불구하고

파이썬3 환경에서 실행을 하고 안돌아 가고 문제가 되는 경우가 발생 할 수 있습니다.

이런 경우를 위해서 우리는 굳이 파이썬2와 파이썬3의 차이점을 알아야 하고

이를 통해서 파이썬2 소스와 파이썬3의 소스를 구별 할 수 있어야 합니다.

안녕하세요 봉자씨입니다.

파이썬을 당장 공부하려고 하는데 왜 파이썬을 배워야 하는지에 대해서 필요성을 잘 모르는 경우가 많습니다.

java, c, javasript, vuejs 등 수많은 언어가 있습니다.

이런 많은 언어 중에 왜 파이썬인가에 대해서 간단하게 알아보도록 하겠습니다.

그래서 파이썬을 왜 배워야 하나요?

첫번째, 다른 프로그래밍 언어에 비해서 문법이 쉽기 때문에 배우기 쉬움

이것이 다른 언어에 비해서 큰 장점으로 그만큼 누구나 배울 수 있다는 뜻이고,

컴퓨터의 활용도가 그만큼 높아진다는 의미

컴퓨터 언어를 배워 보지 못한 사람들도 쉽게 배울 수 있는 언어가 파이썬이라고 보면 됨.

두번째, 파이썬은 인간다운 프로그래밍 언어

다른 어셈블리어(기계에 프로그래밍하는 가장 기계에 가까운 언어라고 보시면 됩니다.) 나 C언어, C++, JAVA 등등은 언어의 발전을 통해서

컴퓨터에 사람이 접근이 쉽도록 만들어지기는 했지만, 여전히 컴퓨터에 더 가까운 형태에 언어(그래서 사람이 보기 힘들죠)

그러나 파이썬은 인간이 이해하기 쉬운 형태의 문법을 지니기 때문에 가독성이 좋음

세번째, 파이썬은 간결하여, 개발속도가 빠름

문법이 대체로 간결하여 읽기 쉽고, 쓰기도 쉬움

따라서 프로그램 개발속도도 다른 언어에 비해 빠름

네번째, 파이썬은 다양한 분야에서 활용이 가능

웹 개발 뿐만 아니라 데이터 분석, 머신러닝, 그래픽, 학술 연구등 여러분야에서 활용도가 높고,생산성이 높음

데이터 수집 및 분석 면으로 보면 대부분 사람들이 파이썬을 배울 필요가 있는 이유이기도 합니다.

요즘은 데이터 분석이나 머신러닝 그리고 웹 개발을 위해서 파이썬을 많이 배운답니다.

그럼 이렇게 쉽고 편하고 빠르고 다양하게 쓴다는 언어 파이썬으로 무엇을 할 수 있을 가요?

우리가 당장 파이썬을 배우는 이유를 차치하더라도 이 것을 배워두게 되면

아래와 같은 것들을 할 수 있어요

그래서 파이썬으로 무엇이 가능한데요? 

시스템 유틸리티 제작

파이썬은 운영체제(윈도우, 리눅스 등)의 시스템 명령어를 사용할 수 있는 각종 도구를 갖추고 있기 때문에

이를 바탕으로 갖가지 시스템 유틸리티를 만드는 데 유리합니다.

예를 들어서 파이썬 프로그램으로 피씨도 끄고 피씨에 있는 여러가지 기능들을 조작 할 수 있답니다.

GUI 프로그래밍

Tkinter를 사용하면 단 5줄의 소스 코드만으로 윈도우 창을 띄울 수 있습니다.

예를 들어서 화면을 만들어 무엇인가를 입력 받는 프로그램을 만들 수 있습니다. 쉽게!

C/C++와의 결합

C나 C++로 만든 프로그램을 파이썬에서 사용할 수 있으며, 파이썬으로 만든 프로그램 역시 C나 C++에서 사용할 수 있습니다.

컴퓨터를 옛날에 처음 배우면 C언어를 배우고 이는 컴퓨터 언어의 기초를 다지기 좋은 언어이기도 합니다. 

이 언어는 조금 어려운 느낌이 있는 언어이기도 합니다. 이 언어는 컴퓨터에 가까운 언어라 하여 여러가지 강력한 코딩이 가능한데요.

이런 언어와의 결합도가 파이썬은 뛰어 납니다! 서로 호환 가능!

웹 프로그래밍

파이썬은 웹 프로그램을 만들기에 매우 적합한 도구이며, 실제로 파이썬으로 제작한 웹 사이트는 셀 수 없을 정도로 많습니다.

파이썬 단 3줄로 웹 서버를 만들 수 있습니다. (웹 프로그램을 돌리기 위해서는 웹 서버라는 것이 필요합니다.)

수치 연산 프로그래밍

파이썬은 수치 연산 프로그래밍에 적합한 언어는 아니지만 C로 작성된 NumPy라는 수치 연산 모듈을 통해서

수치 연산을 빠르게 할 수 있다. 나중에 파이썬을 데이터 분석용으로 사용하신다면 NumPy의 강력함을 이해 하실수 있습니다.

데이터베이스 프로그래밍

Oracle, MySQL, PostgreSQL 등의 데이터베이스에 접근하기 위한 도구를 제공한다.

응용 프로그램을 만들 경우 항상 DB는 동반이 되는데 이때 이를 컨트롤 할때 파이썬으로 쉽게 접근 하도록 도구를 제공해 줍니다.

다른 언어 사용없이 파이썬 만으로도 쉽게 접속이 가능하니 참 편합니다.

데이터 분석, 사물 인터넷

데이터 분석에 특화된 ‘R’이라는 언어를 아직 많이 사용하고 있지만, Pandas 등장이후로 파이썬 사용이 늘고 있습니다.

사물 인터넷 분야에서도 파이썬은 활용도가 높습니다. Raspberry Pi는 리눅스 기반의 아주 작은 컴퓨터인데 홈시어터나

아주 작은 게임기를 만들수 있는데 파이썬은 이 라즈베리파이를 제어하는 도구로 사용됩니다.

그럼 파이썬은 다돼? 아니요 좀 어렵 거나 굳이 파이썬을 선택하지 말아야 하는 경우도 있습니다.

아래의 경우를 보시면 됩니다.

파이썬으로 쪼매 힘든 것들

시스템과 밀접한 프로그래밍 영역

파이썬으로 리눅스 같은 운영체제, 엄청난 횟수의 반복과 연산이 필요한 프로그램

또는 데이터 압축 알고리즘 개발 프로그램 등을 만드는 것은 어려움

즉 대단히 빠른 속도를 요구하거나 하드웨어를 직접 건드려야 하는 프로그램에는 어울리지 않다고 보면 됩니다.

그런 경우는 아래의 언어를 사용하는 것이 일반적입니다.

=>C언어 또는 C++로 개발

모바일 프로그래밍

파이썬은 구글이 가장 많이 애용하는 언어이지만 파이썬으로 안드로이드 앱 개발은 아직 어렵습니다.

안드로이드에서 파이썬으로 만든 프로그램이 실행 지원하나 이것만으로 앱을 만들기에는 아직 역부족이죠.

아이폰 앱을 개발하는 것 역시 파이썬으로 할 수 없는 것은 마찬가지라고 보시면 됩니다.

=>안드로이드 #자바 #코틀린

=>아이폰 #Object C #Swift

생각나는 대로 적어 보았습니다.

하지만 파이썬은 이런 장단점은 있지만 언급 드린 것 이외에도 수 많은 것들을 할 수 있습니다

이 것을 반증하듯 파이썬의 언어 순위(프로그램 언어 인기도 순위)는 쑥쑥 급성장 하고 있습니다.

그만큼 믿고 공부하기에 참 좋은 언어입니다.

그럼 다음 강의에서 뵙겠습니다.

참고로 아래의 표는 언어 순위니 참고하세요(무려 2위!!!!!)

안녕하세요 봉자씨입니다.

파이썬을 공부하기 전에 파이썬이 어떻게 만들어 졌는지 한번 알아 보겠습니다.

(굳이? 네 이런 스토리를 알고 있으면 언어에 대한 애정이 생깁니다. 뇌피셜이지만..)

누가 만들었지?

파이썬은 아래의 아저씨가 만들었습니다. 

구글에서 일하고 드롭박스에서 일한 귀도 반 로섬 아저씨가 만들었습니다.

어쩌다가 이 아저씨가 파이썬을 만들 걸가요?

1989년 크리스마스가 있던 주에 자신이 출근하던 연구실의 문이 닫혀 있어서 취미삼아 파이썬을 만들었다고 합니다.

파이썬이라는 이름은 귀도가 즐겨 봤던 코미디 프로그램인 몬티 파이썬의 날아다니는 써커스 <Monty Python's Flying Circus>에서

이름을 지었다고 합니다.

파이썬의 로고 및 아이콘이 뱀 모양인 이유는 python의 원래 뜻이 비단뱀이었기 때문이라고 합니다.

파이썬 수업 전에 파이썬의 탄생에 대해서 간단하게 재미 삼아 알아 봤습니다.

그럼 다음 강의에서 뵙겠습니다.

파이썬 언어엔 철학이 있다?'

파이썬은 아래와 같은 철학을 가졌습니다. 나중에 여러 분이 파이썬을 설치하게 되면

그때에 import this라는 명령어를 한번 쳐보세요.

그럼 아래와 같은 파이썬의 철학을 이야기해주는 시와 같은 문구를 보실 수 있습니다.

아름다운게 추한 것보다 낫다.

Beautiful is better than ugly

명시적인 것이 암시적인 것 보다 낫다.

Explicit is better than implicit

단순함이 복잡함보다 낫다.

Simple is better than complex

복잡함이 난해한 것보다 낫다.

Complex is better than complicated

가독성은 중요하다.

Readability counts

...

실제 캡쳐 화면입니다.