GIỚI THIỆU SCIKIT-LEARN

VÀ TENSOR FLOWS

Khoa Công nghệ thông ,n

TS. Phạm Công Thắng
 Tài liệu tham khảo
• “Machine Learning cơ bản”, Vũ Hữu Tiệp, 2018
• “Hands-On Machine Learning with Scikit-Learn and TensorFlow”, Aurélien
Géron, 2017
• https://scikit-learn.org/stable/getting_started.html
• https://www.tensorflow.org/
• https://www.tensorflow.org/guide
• https://www.tensorflow.org/tutorials

2
 Học máy (machine learning – ML) là gì

Ví dụ 1: Dự đoán sự sống/chết của hành khách trên tàu Titanic

dựa trên độ tuổi và giá vé
Ví dụ 2: Ước lượng một căn nhà rộng x m2, có y phòng ngủ và
cách trung tâm thành phố z km sẽ có giá khoảng bao nhiêu

3
4
 Tổng quan về học máy
• Mỗi mô hình ML được mô tả bởi các tham số mô hình (model
parameters)
• Công việc của một thuật toán ML là đi tìm các tham số mô hình phù
hợp với mỗi bài toán
• Việc đi tìm các tham số mô hình có liên quan mật thiết đến các phép
đánh giá
• Mục đích của chúng ta là đi tìm các tham số mô hình sao cho các
phép đánh giá cho kết quả tốt nhất (gọi là huấn luyện mô hình)
o Trong bài toán classification, kết quả tốt có thể được hiểu là ít điểm dữ
liệu bị phân lớp sai nhất
o Trong bài toán regression, kết quả tốt là khi sự sai lệch giữa đầu ra dự
đoán và đầu ra thực sự là ít nhất
5
 Tổng quan về học máy (tt)

• Quan hệ giữa một phép đánh giá và các tham số mô hình

thường được mô tả thông qua một hàm số được gọi là hàm mất
mát (loss function)
• Hàm mất mát này thường có giá trị nhỏ khi phép đánh giá cho
kết quả tốt
• Xây dựng một mô hình ML là việc đi giải một bài toán tối ưu:

! Cần quan tâm 2 vấn đề: xây dựng hàm mất mát và thuật toán tối ưu hoá
6
 Mô hình chung cho các bài toán học máy

7
 Scikit-learn

• Scikit-learn là một thư viện học máy mã nguồn mở hỗ trợ học có

giám sát và không giám sát (supervised and unsupervised
learning).
• Cung cấp các công cụ khác nhau để tiền xử lý dữ liệu, huấn
luyện mô hình (model fitting hay model training), lựa chọn và
đánh giá mô hình, và nhiều tiện ích khác.
• Scikit-learn chứa rất nhiều thuật toán và mô hình học máy được
tích hợp sẵn, được gọi là bộ ước lượng (estimators).

8
 Scikit-learn (tt)

• Quy trình của BT học máy (có giám sát) điển hình thường gồm
2 bước: trích xuất đặc trưng và mô hình/thuật toán để dự đoán
các giá trị đích
• Trong scikit-learn:
• Trích xuất đặc trưng được thực hiện bằng các bộ tiền xử lý
(pre-processors)
• Mô hình/thuật toán được thực hiện bằng các bộ ước lượng
(estimators)
• Chúng được cài đặt bằng các hàm thư viện với API tương tự
nhau

9
 Bộ tiền xử lý (pre-processors)

• Một bộ tiền xử lý áp dụng phương pháp biến đổi dữ liệu nào đó

để tạo ra ma trận dữ liệu mẫu mới
• Ma trận dữ liệu mẫu X: kích thước của X thường là
(n_samples, n_features), có nghĩa là các mẫu được biểu thị
dưới dạng hàng và các thuộc tính dưới dạng cột

from sklearn.preprocessing import StandardScaler

X = [[0, 15], # 2 samples, 2 features
[1, -10]]
# scale data according to computed scaling values
X_scaled = StandardScaler().fit(X).transform(X)

10
 Bộ ước lượng: huấn luyện và dự báo

• Mỗi bộ ước lượng có thể được tính toán bộ tham số (hay được
huấn luyện) đối với từng tập dữ liệu
• Ví dụ: huấn luyện bộ phân lớp RandomForestClassifier bằng
một tập dữ liệu đơn giản:

from sklearn.ensemble import RandomForestClassifier

clf = RandomForestClassifier(random_state=0)
X = [[ 1, 2, 3], # 2 samples, 3 features
[11, 12, 13]]
y = [0, 1] # class labels of each sample
clf.fit(X, y) # model fiGng

11
 Bộ ước lượng: huấn luyện và dự báo (tt)

• Phương thức fit() thường nhận 2 đầu vào:

• Ma trận dữ liệu mẫu X: kích thước của X thường là
(n_samples, n_features)
• Các giá trị đích/nhãn y: là số thực đ/v bài toán hồi quy, hoặc
là số nguyên (hoặc một tập giá trị rời rạc nào) đ/v bài toán
phân loại.
oy thường là mảng 1d trong đó thành phần thứ i tương
ứng với giá trị đích/nhãn của mẫu (ở hàng) thứ i của X.
oĐối với các bài toán học không giám sát, y không cần
được đặc tả.

12
 Bộ ước lượng: huấn luyện và dự báo (tt)

• Cả X và y là các mảng hoặc các kiểu dữ liệu giống với mảng

(array-like data types)
• Sau khi bộ ước lượng được “khớp” (hay huấn luyện) với tập dữ
liệu, nó có thể được sử dụng để dự đoán các giá trị đích/nhãn
của dữ liệu bất kỳ

clf.predict(X) # predict classe labels of the training data

clf.predict([[4, 5, 6], [14, 15, 16]]) # predict classe labels of

the new data

13
 Pipelines: chaining pre-processors and estimators

• Bộ tiền xử lý và bộ ước lượng có thể được kết hợp với nhau

thành một đối tượng duy nhất: đường ống (pipeline)
• Đường ống có API giống như bộ ước lượng: có thể được huấn
luyện bộ tham số và sử dụng để dự đoán
• Hàm train_test_split() chia tập dữ liệu thành tập huấn luyện và
tập kiểm thử theo tỉ lệ cho trước

14
 Pipelines: chaining pre-processors and estimators
• Ví dụ: chia tập dữ liệu Iris thành tập huấn luyện và kiểm thử, huấn luyện một
đường ống và tính độ chính xác của nó trên dữ liệu kiểm thử:
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import Logis6cRegression
from sklearn.pipeline import make_pipeline
from sklearn.datasets import load_iris
from sklearn.model_selec6on import train_test_split
from sklearn.metrics import accuracy_score
# create a pipeline object
pipe = make_pipeline(
StandardScaler(),
Logis6cRegression()
)
# load the iris dataset and split it into train and test sets
X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
# fit the whole pipeline
pipe.fit(X_train, y_train)
# we can now use it like any other es6mator
accuracy_score(y_test, pipe.predict(X_test))
15
 Đánh giá và lựa chọn mô hình

16
 Đánh giá mô hình (Model evaluation)
• Các phương pháp đánh giá
• Các tiêu chí đánh giá
(Xem Slide “Đánh giá và lựa chọn mô hình học máy_TQKhoat”)

17
 Đánh giá mô hình bằng cross-validation

(5-fold cross-validation)

18
 Đánh giá mô hình bằng cross-validation
• Ví dụ thực hiện quy trình xác thực chéo 5 lần (5-fold cross-
validation procedure), sử dụng hàm cross_validate().
• Có thể lặp lại theo cách thủ công qua các folds, sử dụng các chiến
lược tách dữ liệu khác nhau và sử dụng các chức năng tính điểm
(scoring) tùy chỉnh.

from sklearn.datasets import make_regression

from sklearn.linear_model import LinearRegression
from sklearn.model_selec6on import cross_validate

X, y = make_regression(n_samples=1000, random_state=0)
lr = LinearRegression()

result = cross_validate(lr, X, y) # defaults to 5-fold CV

result['test_score'] # r_squared score is high because dataset is easy

19
 Lựa chọn tham số mô hình (model selection)

• Nhiều PP học máy thường có (tập) siêu tham số

(hyperparameters) buộc người dùng phải đưa giá trị vào
• In scikit-learn they are passed as arguments to the constructor of
the estimator classes
• Typical examples include C, kernel and gamma for Support
Vector Classifier, alpha for Lasso, etc.

20
 Lựa chọn tham số mô hình (model selection)

• Việc tinh chỉnh mô hình cho khớp với một số dữ liệu có sẵn
không dẫn đến việc nó sẽ dự đoán tốt trên dữ liệu mới
• Các trường hợp thường xảy ra đ/v một mô hình đã huấn luyện:
oTốt (Good fit): nếu cả training error và test error đều thấp
oDưới khớp (Underfitting): nếu training error cao và test error
cao
oQuá khớp (Overfitting): nếu training error thấp nhưng test
error cao (khả năng tổng quát hoá của mô hình thấp)
" Overfitting đặc biệt xảy ra khi lượng dữ liệu huấn luyện quá nhỏ hoặc
độ phức tạp của mô hình quá cao

21
 Lựa chọn mô hình

22
 Lựa chọn mô hình bằng cross-validation

https://scikit-learn.org/stable/modules/cross_validation.html
23
 Model selection - Automatic parameter searches

• Tất cả các bộ ước lượng đều có các tham số (thường được gọi là
siêu tham số) có thể được điều chỉnh.
• Hiệu suất tổng quát của một bộ ước lượng thường phụ thuộc rất
nhiều vào một (vài) siêu tham số.
• Ví dụ: RandomForestRegressor có tham số n_estimators
xác định số lượng cây trong rừng và tham số max_depth xác
định độ sâu tối đa của mỗi cây.
• Thông thường, không rõ giá trị chính xác của các tham số này
phải là bao nhiêu vì chúng phụ thuộc vào dữ liệu hiện có.
• Scikit-learning cung cấp các công cụ để tự động tìm các kết hợp tham
số tốt nhất (thông qua xác nhận chéo cross-validation).

24
 Model selection - Automatic parameter searches
• Ví dụ: tìm kiếm ngẫu nhiên trên không gian tham số của một rừng ngẫu nhiên với một đối tượng
RandomizedSearchCV. Khi quá trình tìm kiếm kết thúc, RandomizedSearchCV hoạt động như một
RandomForestRegressor đã được trang bị bộ thông số tốt nhất.
from sklearn.datasets import fetch_california_housing
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selec9on import RandomizedSearchCV
from sklearn.model_selec9on import train_test_split
from scipy.stats import randint

X, y = fetch_california_housing(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)
# define the parameter space that will be searched over
param_distribu9ons = {'n_es9mators': randint(1, 5),
'max_depth': randint(5, 10)}
# now create a searchCV object and fit it to the data
search = RandomizedSearchCV(es9mator=RandomForestRegressor(random_state=0),
param_distribu9ons=param_distribu9ons,
n_iter=5,
random_state=0)
search.fit(X_train, y_train)
search.best_params_ # Parameter seSng that gave the best results on the hold out data

# the search object now acts like a normal random forest es9mator
# with max_depth=9 and n_es9mators=4
search.score(X_test, y_test)
25
 Các phương pháp học máy và ví dụ
• Mã nguồn thực hiện
(https://scikit-learn.org/stable/user_guide.html#user-guide )
• Supervised learning
• Unsupervised learning
• Model selection and evaluation
• Inspection
• Visualizations
• Computing with scikit-learn
• …..
• https://scikit-learn.org/stable/auto_examples/index.html

26
 TensorFlow
• TensorFlow là một nền tảng mã nguồn mở end-to-end dành cho học máy.
• Một hệ sinh thái toàn diện, linh hoạt gồm các công cụ, thư viện và
tài nguyên cộng đồng cho phép các nhà nghiên cứu thúc đẩy tính
năng tiên tiến trong ML và các nhà phát triển dễ dàng xây dựng và
triển khai các ứng dụng hỗ trợ ML
• https://www.tensorflow.org/

27
 TensorFlow
• Easy model building
• Dễ dàng xây dựng và huấn luyện một cách dễ dàng các mô hình ML
bằng cách sử dụng các API cấp cao trực quan như Keras với khả năng
thực thi nhanh chóng, giúp lặp lại mô hình ngay lập tức và gỡ lỗi dễ dàng
• Robust ML production anywhere
• Dễ dàng huấn luyện và triển khai các mô hình trên đám mây (in the
cloud), tại chỗ, trong trình duyệt hoặc trên thiết bị bất kể sử dụng ngôn
ngữ nào
• Powerful experimentation for research
• Một kiến trúc đơn giản và linh hoạt để đưa các ý tưởng mới từ khái niệm
đến mã code, đến các mô hình hiện đại và công bố nhanh hơn

28
 Install TensorFlow with pip
• Install TensorFlow with pip
• TensorFlow 2 packages are available
• tensorflow —Latest stable release with CPU and GPU support
(Ubuntu and Windows)
• tf-nightly —Preview build (unstable) . Ubuntu and Windows
include GPU support .
• Older versions of TensorFlow
• For TensorFlow 1.x, CPU and GPU packages are separate:
• tensorflow==1.15 —Release for CPU-only
• tensorflow-gpu==1.15 —Release with GPU support
(Ubuntu and Windows)

29
 Install TensorFlow with pip
• System requirements
• Python 3.6–3.8
• Python 3.8 support requires TensorFlow 2.2 or later.
• pip 19.0 or later (requires manylinux2010 support)
• Ubuntu 16.04 or later (64-bit)
• macOS 10.12.6 (Sierra) or later (64-bit) (no GPU support)
• macOS requires pip 20.3 or later
• Windows 7 or later (64-bit)
• Microsoft Visual C++ Redistributable for Visual Studio 2015, 2017 and
2019
• Raspbian 9.0 or later
• GPU support requires a CUDA®-enabled card (Ubuntu and Windows)

30
 Google Colab: An easy way to learn and use TensorFlow

• Không cần cài đặt - chạy hướng dẫn TensorFlow trực tiếp trong trình duyệt
với Colaboratory

31
 Setup and basic usage

import os

import tensorflow as tf

import cProfile

x = [[2.]]
m = tf.matmul(x, x)
print("hello, {}".format(m))

hello, [[4.]]

32
 Setup and basic usage
a = tf.constant([[1, 2],[3, 4]]) # Use NumPy values
print(a) import numpy as np
tf.Tensor( [[1 2] [3 4]],
c = np.multiply(a, b)
shape=(2, 2), dtype=int32)
print(c)
# Broadcasting support
b = tf.add(a, 1) [[ 2 6]
print(b) [12 20]]

tf.Tensor( [[2 3] [4 5]], # Obtain numpy value from a

shape=(2, 2), dtype=int32) tensor:
print(a.numpy())
# Operator overloading is suppor # => [[1 2]
ted # [3 4]]
print(a * b)
[[1 2]
tf.Tensor( [[ 2 6] [12 20]], [3 4]]
shape=(2, 2), dtype=int32)

33
 Dynamic control flow
def fizzbuzz(max_num):
counter = tf.constant(0)
max_num = tf.convert_to_tensor(max_num) fizzbuzz(15)
for num in range(1, max_num.numpy()+1):
num = tf.constant(num)
if int(num % 3) == 0 and int(num % 5) == 0:
print('FizzBuzz') 1
elif int(num % 3) == 0: 2
print('Fizz')
elif int(num % 5) == 0: Fizz
print('Buzz') 4
else:
print(num.numpy()) Buzz
counter += 1 Fizz
7
8
Fizz Buzz
11
Fizz
13
14
FizzBuz

34
 Dynamic models
• tf.GradientTape được sử dụng trong các mô hình động.
• Ví dụ này cho thuật toán tìm kiếm theo đường backtracking trông
giống như mã NumPy bình thường, ngoại trừ có các gradients và
có thể phân biệt được, mặc dù quy trình điều khiển phức tạp:

def line_search_step(fn, init_x, rate=1.0):

with tf.GradientTape() as tape:
# Variables are automatically tracked.
# But to calculate a gradient from a tensor, you must `watch`
it.
tape.watch(init_x)
value = fn(init_x)
grad = tape.gradient(value, init_x)
grad_norm = tf.reduce_sum(grad * grad)
init_value = value
while value > init_value - rate * grad_norm:
x = init_x - rate * grad
value = fn(x)
rate /= 2.0
return x, value

35
 Custom gradients
def log1pexp(x):
return tf.math.log(1 + tf.exp(x))

def grad_log1pexp(x):
with tf.GradientTape() as tape:
tape.watch(x)
value = log1pexp(x)
return tape.gradient(value, x)

# The gradient computation works fine at x = 0.

grad_log1pexp(tf.constant(0.)).numpy()

0.5
# However, x = 100 fails because of numerical i
nstability.
grad_log1pexp(tf.constant(100.)).numpy()

nan

36
 Performance
• Tính toán tự động được tải xuống GPU trong quá trình thực thi nhanh chóng: kiểm soát nơi chạy, có thể đặt
nó trong một khối tf.device ('/ gpu: 0') (hoặc khối CPU tương đương):
import time
def measure(x, steps):
# TensorFlow initializes a GPU the first time it's used, exclude from timing.
tf.matmul(x, x)
start = time.time()
for i in range(steps):
x = tf.matmul(x, x)
# tf.matmul can return before completing the matrix multiplication
# (e.g., can return after enqueing the operation on a CUDA stream).
# The x.numpy() call below will ensure that all enqueued operations
# have completed (and will also copy the result to host memory,
# so we're including a little more than just the matmul operation
# time).
_ = x.numpy()
end = time.time()
return end - start

shape = (1000, 1000)

steps = 200
print("Time to multiply a {} matrix by itself {} times:".format(shape, steps))
# Run on CPU:
with tf.device("/cpu:0"):
print("CPU: {} secs".format(measure(tf.random.normal(shape), steps)))
# Run on GPU, if available:
if tf.config.list_physical_devices("GPU"):
with tf.device("/gpu:0"):
print("GPU: {} secs".format(measure(tf.random.normal(shape), steps)))
else:
print("GPU: not found")

Time to multiply a (1000, 1000) matrix by itself 200 times:

CPU: 5.081462860107422 secs
GPU: 0.1586625576019287 secs
37
 # tf.data: Build TensorFlow input pipelines
• API tf.data cho phép xây dựng các đường ống đầu vào (input pipeline) phức
tạp từ các mảnh đơn giản, có thể tái sử dụng.
• API tf.data giúp có thể xử lý lượng lớn dữ liệu, đọc từ các định
dạng dữ liệu khác nhau và thực hiện các phép biến đổi phức tạp
• API tf.data giới thiệu một trừu tượng tf.data.Dataset đại diện cho
một chuỗi các phần tử, trong đó mỗi phần tử bao gồm một hoặc
nhiều thành phần.
• Có hai cách riêng biệt để tạo tập dữ liệu:
• Nguồn dữ liệu xây dựng Dataset từ dữ liệu được lưu trữ trong
bộ nhớ hoặc trong một hoặc nhiều tệp.
• Một phép chuyển đổi dữ liệu xây dựng một Dataset từ một
hoặc nhiều đối tượng tf.data.Dataset

38
 # tf.data: Build TensorFlow input pipelines
• Để tạo một input pipeline, phải bắt đầu với một nguồn dữ liệu.
• Xây dựng Dataset từ dữ liệu trong bộ nhớ, có thể sử dụng
tf.data.Dataset.from_tensors() hoặc tf.data.Dataset.from_tensor_slices ()
• Nếu dữ liệu đầu vào được lưu trữ trong một tệp ở định dạng TFRecord, có thể
sử dụng tf.data.TFRecordDataset ().
• Khi có một đối tượng Dataset, có thể biến đổi nó thành một Dataset mới bằng
cách chuỗi các cuộc gọi phương thức trên đối tượng tf.data.Dataset.
• Có thể áp dụng các phép biến đổi cho mỗi phần tử như Dataset.map () và
các phép biến đổi nhiều phần tử như Dataset.batch ()
• Đối tượng Dataset là có thể lặp lại. Điều này làm cho nó có thể sử dụng các
phần tử của nó bằng cách sử dụng vòng lặp for, hoặc bằng cách tạo một
trình lặp một cách rõ ràng bằng cách sử dụng next

39
 # tf.data: Build TensorFlow input pipelines
import tensorflow as tf

import pathlib
import os
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

np.set_printoptions(precision=4)

dataset = tf.data.Dataset.from_tensor_slices([8, 3, 0, 8, 2, 1])

dataset

<TensorSliceDataset shapes: (), types: tf.int32> it = iter(dataset)

print(next(it).numpy())
for elem in dataset:
print(elem.numpy())

8
8
3
0
8
2
1
40
 Dataset structure
• Tập dữ liệu tạo ra một chuỗi các phần tử, trong đó mỗi phần tử là cấu trúc giống
nhau
• Các thành phần riêng lẻ của cấu trúc có thể thuộc bất kỳ kiểu nào mà
tf.TypeSpec có thể đại diện
• tf.Tensor
• tf.sparse.SparseTensor
• tf.RaggedTensor
• tf.TensorArray
• tf.data.Dataset.
• Thuộc tính Dataset.element_spec cho phép kiểm tra kiểu của từng thành
phần.
• Trả về một cấu trúc lồng nhau (nested structure) của các đối tượng
tf.TypeSpec, khớp với cấu trúc của phần tử, có thể là một thành phần
đơn lẻ, một bộ thành phần hoặc một bộ thành phần lồng nhau.

41
 Dataset structure
dataset1 = tf.data.Dataset.from_tensor_slices(tf.random.uniform([4, 10]))

dataset1.element_spec

TensorSpec(shape=(10,), dtype=tf.float32, name=None)

dataset2 = tf.data.Dataset.from_tensor_slices(
(tf.random.uniform([4]),
tf.random.uniform([4, 100], maxval=100, dtype=tf.int32)))

dataset2.element_spec

(TensorSpec(shape=(), dtype=tf.float32, name=None), TensorSpec(shape=(100,),

dtype=tf.int32, name=None))

dataset3 = tf.data.Dataset.zip((dataset1, dataset2))

dataset3.element_spec
(TensorSpec(shape=(10,), dtype=tf.float32, name=None),
(TensorSpec(shape=(), dtype=tf.float32, name=None),
TensorSpec(shape=(100,), dtype=tf.int32, name=None)))

# Dataset containing a sparse tensor.

dataset4 = tf.data.Dataset.from_tensors(tf.SparseTensor(indices=[[0, 0], [1, 2]], values
=[1, 2], dense_shape=[3, 4]))

dataset4.element_spec

SparseTensorSpec(TensorShape([3, 4]), tf.int32)

42
 Using tf.data with tf.keras
• API `tf.keras’ đơn giản hóa nhiều khía cạnh của việc tạo và thực thi các mô
hình học máy.
• Các API `.fit ()’ và `.evaluate ()’ và ‘.predict()’ hỗ trợ các tập dữ liệu làm
đầu vào

43
 Using tf.data with tf.keras
train, test = tf.keras.datasets.fashion_mnist.load_data()
images, labels = train
images = images/255.0
labels = labels.astype(np.int32)

fmnist_train_ds = tf.data.Dataset.from_tensor_slices((images, labels))

fmnist_train_ds = fmnist_train_ds.shuffle(5000).batch(32)

model = tf.keras.Sequential([
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(10)
])

model.compile(optimizer='adam',
loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=['accuracy'])

model.fit(fmnist_train_ds, epochs=5)

Epoch 1/5
1875/1875 [==============================] - 3s 1ms/step - loss: 0.4137 - accuracy: 0.8564
Epoch 2/5
1875/1875 [==============================] - 3s 1ms/step - loss: 0.4055 - accuracy: 0.8594
Epoch 3/5
1875/1875 [==============================] - 3s 1ms/step - loss: 0.4034 - accuracy: 0.8601
Epoch 4/5
1875/1875 [==============================] - 3s 1ms/step - loss: 0.3971 - accuracy: 0.8619
Epoch 5/5
1875/1875 [==============================] - 3s 1ms/step - loss: 0.3951 - accuracy: 0.8631
<tensorflow.python.keras.callbacks.History at 0x7fd5041c1450>

44
 Using tf.data with tf.keras

model.fit(fmnist_train_ds.repeat(), epochs=5, steps_per_epoch=20)

Epoch 1/5
20/20 [==============================] - 0s 2ms/step - loss: 0.4024 - accuracy: 0.8703
Epoch 2/5
20/20 [==============================] - 0s 2ms/step - loss: 0.3819 - accuracy: 0.8500
Epoch 3/5
20/20 [==============================] - 0s 2ms/step - loss: 0.3997 - accuracy: 0.8781
Epoch 4/5
20/20 [==============================] - 0s 2ms/step - loss: 0.3674 - accuracy: 0.8625
Epoch 5/5
20/20 [==============================] - 0s 2ms/step - loss: 0.4204 - accuracy: 0.8562
<tensorflow.python.keras.callbacks.History at 0x7fd5041be490>

loss, accuracy = model.evaluate(fmnist_train_ds

)
print("Loss :", loss)
print("Accuracy :", accuracy)

1875/1875 [==============================] - 3s 1ms/step - loss: 0.3915 - accuracy:

0.8624
Loss : 0.3915383219718933
Accuracy : 0.862416684627533

45
 Using tf.data with tf.keras
loss, accuracy = model.evaluate(fmnist_train_ds.repeat(), steps=10)
print("Loss :", loss)
print("Accuracy :", accuracy)

10/10 [==============================] - 0s 2ms/step - loss: 0.4046 - accuracy:

0.8438 Loss : 0.40462103486061096 Accuracy : 0.84375

predict_ds = tf.data.Dataset.from_tensor_slices(images).batch(32)
result = model.predict(predict_ds, steps = 10)
print(result.shape)

(320, 10)

result = model.predict(fmnist_train_ds, steps = 10)

print(result.shape)

(320, 10)

46
 Bài tập
1. Tính độ chính xác trung bình của pipeline gồm các kỹ thuật xử lý đặc trưng
đã chọn trong BT trước & thuật toán hồi quy logistic dùng kỹ thuật 5-fold cross
validation (dùng hàm cross_validate()).
2. Thử nghiệm quá trình xây dựng và đánh giá mô hình hồi quy logistic theo
các bước sau:
- Chia bộ dữ liệu thành Training set và Test set dùng kỹ thuật Hold-out with
Stratified sampling (chỉ thực hiện 1 lần với tỉ lệ Train:Test = 7:3)
- Lựa chọn mô hình hồi quy logistic có bộ siêu tham số tối ưu (với 2 siêu tham
số sử dụng trong kỹ thuật regularization: penalty=L1/L2/none & C=1/lambda)
dùng kỹ thuật 5-fold cross-validation trên Training set
- Huấn luyện mô hình với bộ siêu tham số tối ưu dùng Training set
- Tính độ chính xác dự đoán của mô hình đã xây dựng trên Test set

47