digits.keys()
# 출력 결과
dict_keys(['data', 'target', 'frame', 'feature_names', 'target_names', 'images', 'DESCR'])
# DESCR 키는 데이터셋에 대한 설명
print(digits['DESCR'])
# 출력 결과
.. _digits_dataset:
Optical recognition of handwritten digits dataset
--------------------------------------------------
**Data Set Characteristics:**
:Number of Instances: 1797
:Number of Attributes: 64
:Attribute Information: 8x8 image of integer pixels in the range 0..16.
:Missing Attribute Values: None
:Creator: E. Alpaydin (alpaydin '@' boun.edu.tr)
:Date: July; 1998
This is a copy of the test set of the UCI ML hand-written digits datasets
https://archive.ics.uci.edu/ml/datasets/Optical+Recognition+of+Handwritten+Digits
The data set contains images of hand-written digits: 10 classes where
each class refers to a digit.
Preprocessing programs made available by NIST were used to extract
normalized bitmaps of handwritten digits from a preprinted form. From a
total of 43 people, 30 contributed to the training set and different 13
to the test set. 32x32 bitmaps are divided into nonoverlapping blocks of
4x4 and the number of on pixels are counted in each block. This generates
...
2005.
- Claudio Gentile. A New Approximate Maximal Margin Classification
Algorithm. NIPS. 2000.
load_데이터셋의 유일한 매개변수인 return_X_y를 True로 하면 특성 X와 타깃 y배열을 반환
import numpy as np
# digits 함수는 특별히 n_class 매개변수를 사용하여 필요한 숫자 개수 지정가능
# 0~4까지 5개의 숫자만 y값에 넣도록 매개변수 설정
X, y = datasets.load_digits(n_class = 5, return_X_y = True)
np.unique(y)
# 출력 결과
array([0, 1, 2, 3, 4])
2. 모의 데이터셋 만들기
선형 회귀 알고리즘에 사용하려면 make_regression 추천
make_regression은 실수 특성 행렬과 실수 타깃 벡터 반환
from sklearn.datasets import make_regression
# n_features는 전체 특성
# n_informative는 타깃 벡터 생성에 사용할 특성
features, target, coefiicients = make_regression(n_samples = 100,
n_features = 3,
n_informative = 3,
n_targets = 1,
noise = 0.0,
coef = True,
random_state = 1)
from sklearn.datasets import make_regression
features, target, coefiicients = make_regression(n_samples = 100,
n_features = 3,
n_informative = 3,
n_targets = 1,
noise = 0.0,
coef = True,
random_state = 1)
print('특성 행렬\n', features[:3])
print('타깃 벡터\n', target[:3])
# 출력 결과
특성 행렬
[[ 1.29322588 -0.61736206 -0.11044703]
[-2.793085 0.36633201 1.93752881]
[ 0.80186103 -0.18656977 0.0465673 ]]
타깃 벡터
[-10.37865986 25.5124503 19.67705609]
분류 알고리즘에 사용하려면 make_classification 추천
make_classification은 실수 특성 행렬과 정수 타깃 벡터 반환
from sklearn.datasets import make_classification
# n_redundant는 필요없는 특성의 수, n_informative 특성의 랜덤 선형 결합으로 생성됨
# weights는 차례대로 각각 첫번째 ,두번째 클래스의 비율
features, target = make_classification(n_samples = 100,
n_features = 3,
n_informative = 3,
n_redundant = 0,
n_classes = 2,
weights = [.25, .75],
random_state = 1)
print('특성 행렬\n', features[:3])
print('타깃 벡터\n', target[:3])
# 출력 결과
특성 행렬
[[ 1.06354768 -1.42632219 1.02163151]
[ 0.23156977 1.49535261 0.33251578]
[ 0.15972951 0.83533515 -0.40869554]]
타깃 벡터
[1 0 0]
군집 알고리즘에 사용하려면 make_blobs 추천
make_blobs은 실수 특성 행렬과 정수 타깃 벡터 반환
from sklearn.datasets import make_blobs
features, target = make_blobs(n_samples = 100,
n_features = 2,
centers = 3,
cluster_std = 0.5,
shuffle = True,
random_state = 1)
print('특성 행렬\n', features[:3])
print('타깃 벡터\n', target[:3])
# 출력 결과
특성 행렬
[[ -1.22685609 3.25572052]
[ -9.57463218 -4.38310652]
[-10.71976941 -4.20558148]]
타깃 벡터
[0 1 1]
# 만들어진 군집 데이터 시각화
# pip install matplotlib
import matplotlib.pyplot as plt
plt.scatter(features[:, 0], features[:, 1], c = target)
plt.show()
3. CSV 파일 적재하기
pandas 라이브러리의 read_csv() 사용
매개변수
sep = ',': 파일이 사용하는 구분자를 ','로 지정
skiprows = range(1, 11): 1행부터 12행까지 건너뛴 후 출력
nrows = 1: 한 행 출력
import pandas as pd
dataframe = pd.read_csv('csv 경로')
4. 엑셀 파일 적재하기
pandas 라이브러리의 read_excel() 사용
read_excel()을 사용하려면 xlrd 패키지 설치 필요
매개변수
sheet_name: 시트 이름 문자열 또는 시트의 위치를 나타내는 정수(0부터 시작되는 인덱스)
na_filter: 결측값 탐지, 결측값이 없는 데이터라면 해당 옵션을 제외하는 것이 성능 향상에 도움
먼저, SQLite 데이터베이스 엔진으로 연결하기 위해 create_engine 함수 사용
이후, read_sql_query 함수로 SQL을 사용하여 데이터베이스에 질의, 그 결과를 데이터프레임으로 가져옴
# pip install sqlalchemy
import pandas as pd
from sqlalchemy import create_engine
# sample.db라는 데이터베이스에 연결
database_connection = create_engine('sqlite:///sample.db')
# sample.db에서 data라는 이름의 테이블의 모든 열을 반환하라고 요청
dataframe = pd.read_sql_query('SELECT * FROM data', database_connection)
# 모든 행을 가져올 때는 질의문 없이 read_sql_table() 함수도 사용 가능
dataframe = pd.read_sql_table('data', database_connection)
데이터 분석을 공부하며 코딩 자체에도 재미를 느꼈습니다. 그래서 자바로 웹개발을 공부하고, 다른 여러 프로그래밍 언어도 공부하였습니다. 그러면서 데이터 분석의 결과를 직접 만든 웹에 대시보드 형태로 띄워보고 싶다는 목표를 가지게 되었습니다. 또, 요즘 휴대폰 하나로 모든 것을 해결할 수 있는 시대인 만큼 휴대폰 앱으로도 확인할 수 있으면 좋을 것이라고 생각하였고, 앱 개발도 공부해보고 싶었습니다. 웹과 앱 모두에서 개발이 가능한 사람이 되고 싶었고 그렇게 선택한 언어가 Dart 기반의 Flutter 였습니다. 그리고 Flutter를 공부하기 위해 선택한 책은 '풀스택 개발이 쉬워지는 다트&플러터'입니다.
서평 이벤트를 통해 해당 책을 제공받았습니다.
IT 관련 분야의 도서를 많이 출판하는 영진닷텀에서 나온 책으로 전문성은 물론, 책의 구성도 언어를 공부하기에 최적화된 순서로 되어 있습니다. 책에는 다음과 같은 내용이 포함되어 있었습니다.
Dart 언어 문법과 구조 이해
Dart로 서버와 클라이언트 개발하기
Flutter 래퍼런스 프로그램 개발하기
Flutter로 데스트톱, 웹서비스 개발하기
지속 가능한 개발자로 첫 걸음 내딛기
책의 두께도 어마어마 하지만 그만큼 한권으로 많은 양을 공부할 수 있고, 이후에 Flutter를 전문적으로 응용하고 싶을 때도 기본서로 사용할 수 있을 것 같습니다.
장마다 마지막에 연습문제를 넣어두어서 공부했던 개념을 직접 실습해보고 모르는 부분은 더 확실히하며 넘어갈 수 있었습니다.
언어를 사용하며 접할 수 있는 Error에 대한 설명도 나와있고, 코드에 대한 설명도 한줄 한줄 꼼꼼하고 친절하게 설명되어 있어 혼자 공부하는 데에도 적은 시간에 많은 양을 정확하게 공부하는데 도움이 되었습니다.
책의 가장 좋았던 점은 책을 따라가다보면 프로젝트를 직접 구현할 수 있다는 것이었습니다. 언어의 문법이나 개념을 정확히 공부했더라도 실제 프로젝트에 응용할 수 없다면 무용지물이 됩니다. 그만큼 실제 프로젝트에 응용하는 것이 중요하고 어려운 일이지만 '풀스택 개발이 쉬워지는 다트&플러터'와 함께하면 프로젝트에 언어를 적용하는 것도 문제 없어 보입니다.
'풀스택 개발이 쉬워지는 다트&플러터'로 웹, 앱의 풀스택 개발을 제대로 공부할 수 있는 기회를 얻어 정말 좋은 시간이었습니다. 데이터 분석과 접목한 웹, 앱 개발이라는 저의 목표를 달성하는데 큰 도움이 된 책입니다.
from tensorflow.keras.datasets import imdb
(x_train, y_train), (x_test, y_test) = imdb.load_data()
단어 번호와 단어의 관계를 사전으로 만듦
1번은 문장의 시작, 2번은 사전에 없는 단어(OOV)로 미리 지정
word_index = imdb.get_word_index()
index_word = {idx + 3 : word for word, idx in word_index.items()}
index_word[1] = '<START>'
index_word[2] = '<UNKNOWN>'
' '.join(index_word[i] for i in x_train[0])
# 출력 결과
"<START> this film was just brilliant casting location scenery story direction everyone's really
suited the part they played and you could just imagine being there robert redford's is an
amazing actor and now the same being director norman's father came from the same scottish
island as myself so i loved the fact there was a real connection with this film the witty
remarks throughout the film were great it was just brilliant so much that i bought the film
as soon as it was released for retail and would recommend it to everyone to watch and the fly
fishing was amazing really cried at the end it was so sad and you know what they say if you
cry at a film it must have been good and this definitely was also congratulations to the two
little boy's that played the part's of norman and paul they were just brilliant children are
often left out of the praising list i think because the stars that play them all grown up are
such a big profile for the whole film but these children are amazing and should be praised for
what they have done don't you think the whole story was so lovely because it was true and was
someone's life after all that was shared with us all"
num_words = max(index_word) + 1
- 텍스트를 단어 번호로 바꾸기
texts = []
for data in x_train:
text = ' '.join(index_word[i] for i in data)
texts.append(text)
len(texts) # 25000
Tokenizer를 사용해 텍스트를 단어로 바꿈
from keras.preprocessing.text import Tokenizer
tok = Tokenizer()
tok.fit_on_texts(texts)
new_data = tok.texts_to_sequences(texts)
new_data[0][:10]
# 출력 결과
[28, 11, 19, 13, 41, 526, 968, 1618, 1381, 63]
# 모든 데이터 문장을 토큰화하고 위의 문장을 그 토큰으로 바꾼뒤 10개만 출력
import wget
import os
import zipfile
wget.download("http://mng.bz/0tIo")
local_zip = '0tIo'
zip_ref = zipfile.ZipFile(local_zip, 'r')
zip_ref.extractall()
zip_ref.close()
imdb_dir = "aclImdb"
train_dir = os.path.join(imdb_dir, 'train')
labels = []
texts = []
for label_type in ['neg', 'pos']:
dir_name = os.path.join(train_dir, label_type)
for fname in os.listdir(dir_name):
if fname[-4:] == '.txt':
f = open(os.path.join(dir_name, fname), encoding = 'utf-8')
texts.append(f.read())
f.close()
if label_type == 'neg':
labels.append(0)
else:
labels.append(1)
texts[0]
# 출력 결과
"Story of a man who has unnatural feelings for a pig. Starts out with a opening scene that is
a terrific example of absurd comedy. A formal orchestra audience is turned into an insane,
violent mob by the crazy chantings of it's singers. Unfortunately it stays absurd the WHOLE
time with no general narrative eventually making it just too off putting. Even those from the
era should be turned off. The cryptic dialogue would make Shakespeare seem easy to a third grader.
On a technical level it's better than you might think with some good cinematography by future
great Vilmos Zsigmond. Future stars Sally Kirkland and Frederic Forrest can be seen briefly."
labels[0] # 0(부정적인 리뷰)
import numpy as np
samples = ['The cat sat on the mat.',
'The dog ate my homeworks.']
token_index = {}
for sample in samples:
for word in sample.split():
if word not in token_index:
token_index[word] = len(token_index) + 1
max_len = 10
results = np.zeros(shape = (len(samples), max_len,
max(token_index.values()) + 1))
# 원-핫 인코딩
for i, sample in enumerate(samples):
for j, word in list(enumerate(sample.split()))[:max_len]:
index = token_index.get(word)
results[i, j, index] = 1.
results
# 출력 결과
array([[[0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.], # The
[0., 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.], # cat
[0., 0., 0., 1., 0., 0., 0., 0., 0., 0., 0.], # sat
[0., 0., 0., 0., 1., 0., 0., 0., 0., 0., 0.], # on
[0., 0., 0., 0., 0., 1., 0., 0., 0., 0., 0.], # the
[0., 0., 0., 0., 0., 0., 1., 0., 0., 0., 0.], # mat
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]],
[[0., 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.], # The
[0., 0., 0., 0., 0., 0., 0., 1., 0., 0., 0.], # dog
[0., 0., 0., 0., 0., 0., 0., 0., 1., 0., 0.], # ate
[0., 0., 0., 0., 0., 0., 0., 0., 0., 1., 0.], # my
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 1.], # homeworks
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]]])
3. 케라스를 사용한 단어 수준 원-핫 인코딩
fit_on_texts()
texts_to_sequences()
texts_to_matrix()
from tensorflow.keras.preprocessing.text import Tokenizer
samples = ['The cat sat on the mat.',
'The dog ate my homeworks.']
tokenizer = Tokenizer(num_words = 1000)
tokenizer.fit_on_texts(samples)
sequences = tokenizer.texts_to_sequences(samples)
ohe_results = tokenizer.texts_to_matrix(samples, mode = 'binary')
word_index = tokenizer.word_index
print(len(word_index))
# 출력 결과
9
# 9개의 토큰을 가지고 있음
# 단어의 순서
sequences
# 출력 결과
[[1, 2, 3, 4, 1, 5], [1, 6, 7, 8, 9]]
# 원-핫 인코딩 결과
print(ohe_results.shape)
print(ohe_results)
# 출력 결과
(2, 1000)
[[0. 1. 1. ... 0. 0. 0.]
[0. 1. 0. ... 0. 0. 0.]]
word_index
# 출력 결과
{'the': 1,
'cat': 2,
'sat': 3,
'on': 4,
'mat': 5,
'dog': 6,
'ate': 7,
'my': 8,
'homeworks': 9}
# 단어 인덱스에 따라 sequences의 값이 정해짐
- 토큰화 예제
OOV: Out Of Vocabulary
새로운 문장에서 기존에 토큰화한 문장에 존재하지 않으면 OOV로 대체됨
from tensorflow.keras.preprocessing.text import Tokenizer
samples = ["I'm the smartest student.",
"I'm the best student."]
tokenizer = Tokenizer(num_words = 10, oov_token = '<OOV>')
tokenizer.fit_on_texts(samples)
sequences = tokenizer.texts_to_sequences(samples)
binary_results = tokenizer.texts_to_matrix(samples, mode = 'binary')
print(tokenizer.word_index)
# 출력 결과
# 현재 tokenizer에 대한 word_index
{'<OOV>': 1, "i'm": 2, 'the': 3, 'student': 4, 'smartest': 5, 'best': 6}
특정 단어를 나타내는 정수 인덱스를 밀집 벡터(dense vector)로 매핑하는 딕셔너리 레이어
입력: (samples, sqquence_length)
출력: (samples, sequences_length, dim)
from tensorflow.keras.layers import Embedding
embedding_layer = Embedding(1000, 64)
embedding_layer
# 출력 결과
<keras.layers.core.embedding.Embedding at 0x265f5b12fa0>
# embedding 객체가 출력됨
6. 예제: IMDB 데이터
인터넷 영화 데이터베이스(Internet Movie Database)
양극단의 리뷰 5만개로 이루어진 데이터셋
훈련 데이터: 25,000개
테스트 데이터: 25,000개
- modules import
from tensorflow.keras.datasets import imdb
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, Dense, Flatten
word_index = {}
for key, val in imdb.get_word_index().items():
word_index[val] = key
for i in range(1, 6):
print(word_index[i])
# 출력 결과
the
and
a
of
to
- 데이터 전처리
모든 데이터를 같은 길이로 맞추기
pad_sequence()
데이터가 maxlen보다 길면 데이터를 자름
데이터가 길면 padding 설정
pre: 데이터 앞에 0으로 채움
post: 데이터 뒤에 0으로 채움
모든 데이터(문장 하나하나)가 같은 길이로 맞춰져야 Embedding 레이어 사용가능
from tensorflow.keras.preprocessing.sequence import pad_sequences
pad_x_train = pad_sequences(x_train, maxlen = max_len, padding = 'pre')
pad_x_test = pad_sequences(x_test, maxlen = max_len, padding = 'pre')
print(len(x_train[0]))
print(len(pad_x_train[0]))
# 출력 결과
218
20
# 최대 길이만큼 줄어듬
res = requests.get('https://www.gutenberg.org/files/2591/2591-0.txt')
res
# 출력 결과
<Response [200]>
# 200이면 잘 응답한 것
# 404면 오류 발생한 것
- 데이터 전처리
grimm = res.text[2801:530661]
grimm = re.sub(r'[^a-zA-Z\. ]', ' ', grimm)
sentences = grimm.split('. ')
data = [s.split() for s in sentences]
len(data) # 3468
data[0]
# 출력 결과
['SECOND',
'STORY',
'THE',
'SALAD',
'THE',
'STORY',
'OF',
'THE',
'YOUTH',
'WHO',
'WENT',
'FORTH',
'TO',
'LEARN',
'WHAT',
'FEAR',
'WAS',
'KING',
'GRISLY',
'BEARD',
'IRON',
'HANS',
'CAT',
'SKIN',
'SNOW',
...
'tree',
'which',
'bore',
'golden',
'apples']
# gensim 패키지로부터 Word2Vec을 불러오기
from gensim.models.word2vec import Word2Vec
# sg인자에 0을 넘겨주면 CBOW, 1을 넘겨주면 Skip-gram
# 최소 3번은 등장한 단어, 동시 처리의 수는 4개
model = Word2Vec(data, sg = 1, vector_size = 100, window = 3, min_count = 3, workers = 4)
- 모델 저장 및 로드
# 저장
model.save('word2vec.model')
# 로드
pretrained_model = Word2Vec.load('word2vec.model')
wv.most_similar()에 positive와 negetive라는 옵션을 넘길 수 있음
# 'man + princess - woman'을 벡터 계산을 한 값을 출력
# man이고 princess인데 woman이 아닌 단어
pretrained_model.wv.most_similar(positive = ['man', 'princess'], negative = ['woman'])
# 출력 결과
[('bird', 0.9595717787742615),
('prince', 0.9491060376167297),
('cook', 0.9410891532897949),
('bride', 0.9401964545249939),
('huntsman', 0.9375050067901611),
('mouse', 0.9356588125228882),
('cat', 0.9344455003738403),
('giant', 0.9341970682144165),
('gardener', 0.9327394366264343),
('maid', 0.9326624870300293)]
- gensim으로 학습된 단어 임베딩을 Keras에서 불러오기
from keras.models import Sequential
from keras.layers import Embedding
num_words, emb_dim = pretrained_model.wv.vectors.shape
print(num_words)
print(emb_dim)
# 출력 결과
2446
100
import tensorflow as tf
from tensorflow.keras.preprocessing.image import array_to_img, img_to_array, load_img, ImageDataGenerator
from tensorflow.keras.layers import Conv2D, Flatten, MaxPool2D, Input, Dropout, Dense
from tensorflow.keras import Model
from tensorflow.keras.optimizers import Adam
import os
import zipfile
import matplotlib.image as mpimg
import matplotlib.pyplot as plt
- 데이터 로드
# 외부에서 데이터 가져오기
import wget
wget.download("https://storage.googleapis.com/mledu-datasets/cats_and_dogs_filtered.zip")
# 압축 해제
local_zip = 'cats_and_dogs_filtered.zip'
zip_ref = zipfile.ZipFile(local_zip, 'r')
# 현재 폴더에 압축해제
zip_ref.extractall()
zip_ref.close()
# 압축해제된 폴더를 기본 경로로 지정, 폴더 내의 train과 validation 폴더에 각각 접근
base_dir = 'cats_and_dogs_filtered'
train_dir = os.path.join(base_dir, 'train')
validation_dir = os.path.join(base_dir, 'validation')
# 압축해제된 폴더 내의 train cat, validation cat, train dog, validation dog 폴더에 각각 접근
train_cats_dir = os.path.join(train_dir, 'cats')
train_dogs_dir = os.path.join(train_dir, 'dogs')
validation_cats_dir = os.path.join(validation_dir, 'cats')
validation_dogs_dir = os.path.join(validation_dir, 'dogs')
train_cat_frames = os.listdir(train_cats_dir)
train_dog_frames = os.listdir(train_dogs_dir)
- 이미지 보강된 데이터 확인
# ImageDataGenerator 정의
datagen = ImageDataGenerator(
rotation_range = 40,
width_shift_range = 0.2,
height_shift_range = 0.2,
shear_range = 0.2,
zoom_range = 0.2,
horizontal_flip = True,
fill_mode = 'nearest'
)
# 이미지 로드
img_path = os.path.join(train_cats_dir, train_cat_frames[2])
img = load_img(img_path, target_size = (150, 150))
x = img_to_array(img)
x = x.reshape((1, ) + x.shape)
i = 0
for batch in datagen.flow(x, batch_size = 1):
plt.figure(i)
imgplot = plt.imshow(array_to_img(batch[0]))
i += 1
if i % 5 == 0:
break
import tensorflow as tf
from tensorflow.keras.datasets import cifar10
from tensorflow.keras.layers import Conv2D, MaxPool2D, Dense, Flatten, Input, Dropout, BatchNormalization
from tensorflow.keras.models import Sequential, Model
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.utils import to_categorical
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
import numpy as np
2. 데이터 로드 및 전처리
(x_train_full, y_train_full), (x_test, y_test) = cifar10.load_data()
print(x_train_full.shape, y_train_full.shape)
print(x_test.shape, y_test.shape)
# 출력 결과
(50000, 32, 32, 3) (50000, 1)
(10000, 32, 32, 3) (10000, 1)
# 정답 데이터의 값은 레이블로 되어있음
print(y_test[0])
# 출력 결과
[3]
# 예시 데이터
np.random.seed(777)
class_names = ['airplane', 'automobile', 'bird', 'cat', 'deer',
'dog', 'frog', 'horse', 'sheep', 'truck']
sample_size = 9
random_idx = np.random.randint(60000, size = sample_size)
plt.figure(figsize = (5, 5))
for i, idx in enumerate(random_idx):
plt.subplot(3, 3, i + 1)
plt.xticks([])
plt.yticks([])
plt.imshow(x_train_full[i])
plt.xlabel(class_names[int(y_train_full[i])])
plt.show()
32 * 32 이미지라 화질이 낮음
# x 데이터 정규화
x_mean = np.mean(x_train_full, axis = (0, 1, 2))
x_std = np.std(x_train_full, axis = (0, 1, 2))
x_train_full = (x_train_full - x_mean) / x_std
x_test = (x_test - x_mean) / x_std
# 학습데이터와 검증데이터 분리
x_train, x_val, y_train, y_val = train_test_split(x_train_full, y_train_full, test_size = 0.3)
# 전처리한 데이터 형태 출력
print(x_train.shape)
print(y_train.shape)
print(x_val.shape)
print(y_val.shape)
print(x_test.shape)
print(y_test.shape)
# 출력 결과
(35000, 32, 32, 3)
(35000, 1)
(15000, 32, 32, 3)
(15000, 1)
(10000, 32, 32, 3)
(10000, 1)
%load_ext tensorboard
import datetime
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
from tensorflow.keras import Model
from tensorflow.keras.models import Sequential
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.datasets.fashion_mnist import load_data
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.layers import Dense, Conv2D, MaxPool2D, Dropout, Input, Flatten
