Hướng dẫn máy ảnh
Evelyn Clarke
Keras là gì?
Máy ảnh là một thư viện Mạng thần kinh nguồn mở được viết bằng Python chạy trên Theano hoặc Tensorflow. Nó được thiết kế theo mô-đun, nhanh chóng và dễ sử dụng. Nó được phát triển bởi François Chollet, một kỹ sư của Google. Keras không xử lý tính toán cấp thấp. Thay vào đó, nó sử dụng một thư viện khác để thực hiện việc đó, được gọi là “Backend.
Keras là trình bao bọc API cấp cao dành cho API cấp thấp, có khả năng chạy trên TensorFlow, CNTK hoặc Theano. API cấp cao của Keras xử lý cách chúng tôi tạo mô hình, xác định lớp hoặc thiết lập nhiều mô hình đầu vào-đầu ra. Ở cấp độ này, Keras cũng biên dịch mô hình của chúng tôi với các hàm mất mát và tối ưu hóa, quy trình đào tạo với hàm phù hợp. Máy ảnh trong Python không xử lý API cấp thấp như tạo biểu đồ tính toán, tạo tensor hoặc các biến khác vì nó đã được xử lý bởi công cụ “phụ trợ”.
Phần cuối là gì?
Phần cuối là một thuật ngữ trong Keras thực hiện tất cả các tính toán cấp thấp như tích tensor, tích chập và nhiều thứ khác với sự trợ giúp của các thư viện khác như Tensorflow hoặc Theano. Vì vậy, “công cụ phụ trợ” sẽ thực hiện việc tính toán và phát triển các mô hình. Tensorflow là “công cụ phụ trợ” mặc định nhưng chúng ta có thể thay đổi nó trong cấu hình.
Phần cuối của Theano, Tensorflow và CNTK
Theano là một dự án nguồn mở được phát triển bởi nhóm MILA tại Đại học Montreal, Quebec, Canada. Đây là Framework được sử dụng rộng rãi đầu tiên. Đó là một Python thư viện hỗ trợ mảng đa chiều cho các phép toán sử dụng Numpy hoặc Scipy. Theano có thể sử dụng GPU để tính toán nhanh hơn, nó cũng có thể tự động xây dựng đồ thị ký hiệu để tính toán gradient. Trên trang web của mình, Theano tuyên bố rằng nó có thể nhận dạng các biểu thức không ổn định về mặt số và tính toán chúng bằng các thuật toán ổn định hơn, điều này rất hữu ích cho các biểu thức không ổn định của chúng ta.
Mặt khác, Tensorflow là ngôi sao đang lên trong khuôn khổ deep learning. Được phát triển bởi nhóm Brain của Google, đây là công cụ học sâu phổ biến nhất. Với rất nhiều tính năng và các nhà nghiên cứu góp phần giúp phát triển framework này cho mục đích deep learning.
Một công cụ phụ trợ khác cho Keras là The Microsoft Bộ công cụ nhận thức hoặc CNTK. Nó là một framework deep learning mã nguồn mở được phát triển bởi Microsoft Đội. Nó có thể chạy trên nhiều GPU hoặc nhiều máy để đào tạo mô hình deep learning trên quy mô lớn. Trong một số trường hợp, CNTK được báo cáo nhanh hơn các framework khác như Tensorflow hoặc Theano. Tiếp theo trong hướng dẫn Keras CNN này, chúng ta sẽ so sánh các phần phụ trợ của Theano, TensorFlow và CNTK.
So sánh các phần phụ trợ
Chúng ta cần làm một điểm chuẩn để biết sự so sánh giữa hai phần phụ trợ này. Như bạn có thể thấy trong Điểm chuẩn của Jeong-Yoon Lee, hiệu suất của 3 chương trình phụ trợ khác nhau trên phần cứng khác nhau sẽ được so sánh. Và kết quả là Theano chậm hơn so với phần phụ trợ khác, theo báo cáo 50 lần chậm hơn, nhưng độ chính xác gần nhau.
Một kiểm tra điểm chuẩn được thực hiện bởi Jasmeet Bhatia. Anh ấy báo cáo rằng Theano chậm hơn Tensorflow trong một số bài kiểm tra. Nhưng độ chính xác tổng thể gần như giống nhau đối với mọi mạng được thử nghiệm.
Vì vậy, giữa Theano, Tensorflow và CTK thì rõ ràng TensorFlow tốt hơn Theano. Với TensorFlow, thời gian tính toán ngắn hơn nhiều và CNN tốt hơn các loại khác.
Tiếp theo trong Keras này Python hướng dẫn, chúng ta sẽ tìm hiểu về sự khác biệt giữa Keras và TensorFlow (Keras vs Tensorflow).
Keras vs Tensorflow
| Thông số Kỹ thuật | Máy ảnh | Dòng chảy |
|---|---|---|
| Kiểu | Trình bao bọc API cấp cao | API cấp thấp |
| phức tạp | Dễ dàng sử dụng nếu bạn Python Ngôn ngữ | Bạn cần tìm hiểu cú pháp sử dụng một số hàm Tensorflow |
| Mục đích | Triển khai nhanh chóng để tạo mô hình với các lớp tiêu chuẩn | Cho phép bạn tạo một biểu đồ tính toán hoặc các lớp mô hình tùy ý |
| CÔNG CỤ | Sử dụng công cụ gỡ lỗi API khác như TFDBG | Bạn có thể sử dụng các công cụ trực quan hóa Tensorboard |
| Cộng đồng | Cộng đồng tích cực lớn | Cộng đồng tích cực lớn và tài nguyên được chia sẻ rộng rãi |
Ưu điểm của Keras
Triển khai nhanh chóng và dễ hiểu
Keras rất nhanh chóng tạo ra một mô hình mạng. Nếu bạn muốn tạo một mô hình mạng đơn giản với một vài dòng, Python Keras có thể giúp bạn điều đó. Hãy xem ví dụ về Keras bên dưới:
from keras.models import Sequential from keras.layers import Dense, Activation model = Sequential() model.add(Dense(64, activation='relu', input_dim=50)) #input shape of 50 model.add(Dense(28, activation='relu')) #input shape of 50 model.add(Dense(10, activation='softmax'))
Vì API thân thiện nên chúng ta có thể dễ dàng hiểu được quy trình. Viết mã với hàm đơn giản và không cần đặt nhiều tham số.
Hỗ trợ cộng đồng lớn
Có rất nhiều cộng đồng AI sử dụng Keras cho khung Deep Learning của họ. Nhiều người trong số họ xuất bản mã của họ cũng như các hướng dẫn cho công chúng.
Có nhiều phụ trợ
Bạn có thể chọn Tensorflow, CNTK và Theano làm chương trình phụ trợ cho Keras. Bạn có thể chọn một chương trình phụ trợ khác cho các dự án khác nhau tùy theo nhu cầu của bạn. Mỗi phụ trợ đều có lợi thế riêng.
Triển khai mô hình đa nền tảng và dễ dàng
Với nhiều thiết bị và nền tảng được hỗ trợ, bạn có thể triển khai Keras trên mọi thiết bị như
- iOS với CoreML
- Android với Tensorflow Android,
- Trình duyệt web có hỗ trợ .js
- Công cụ đám mây
- Raspberry Pi
Hỗ trợ nhiều GPU
Bạn có thể đào tạo Keras trên một GPU hoặc sử dụng nhiều GPU cùng một lúc. Bởi vì Keras có hỗ trợ tích hợp cho tính năng song song dữ liệu nên nó có thể xử lý khối lượng dữ liệu lớn và tăng tốc thời gian cần thiết để đào tạo nó.
Nhược điểm của Keras
Không thể xử lý API cấp thấp
Keras chỉ xử lý API cấp cao chạy trên framework hoặc công cụ phụ trợ hàng đầu khác như Tensorflow, Theano hoặc CNTK. Vì vậy, sẽ không hữu ích lắm nếu bạn muốn tạo lớp trừu tượng của riêng mình cho mục đích nghiên cứu vì Keras đã có các lớp được cấu hình sẵn.
Cài đặt Keras
Trong phần này, chúng ta sẽ xem xét các phương pháp khác nhau có sẵn để cài đặt Keras
Cài đặt trực tiếp hoặc Môi trường ảo
Cái nào tốt hơn? Cài đặt trực tiếp vào python hiện tại hoặc sử dụng môi trường ảo? Tôi khuyên bạn nên sử dụng môi trường ảo nếu bạn có nhiều dự án. Bạn muốn biết tại sao? Điều này là do các dự án khác nhau có thể sử dụng phiên bản khác nhau của thư viện máy ảnh.
Ví dụ: tôi có một dự án cần Python 3.5 bằng OpenCV 3.3 với phần phụ trợ Keras-Theano cũ hơn nhưng trong dự án khác, tôi phải sử dụng Keras với phiên bản mới nhất và Tensorflow vì nó phụ trợ với Python Hỗ trợ 3.6.6
Chúng ta không muốn thư viện Keras xung đột với nhau phải không? Vì vậy, chúng tôi sử dụng Môi trường ảo để bản địa hóa dự án với một loại thư viện cụ thể hoặc chúng tôi có thể sử dụng một nền tảng khác như Dịch vụ đám mây để thực hiện tính toán cho chúng tôi như Amazon Dịch vụ Web.
Cài đặt Keras trên Amazon Dịch vụ web (AWS)
Amazon Dịch vụ web là một nền tảng cung cấp dịch vụ và sản phẩm Điện toán đám mây cho các nhà nghiên cứu hoặc bất kỳ mục đích nào khác. AWS thuê phần cứng, mạng, Cơ sở dữ liệu, v.v. của họ để chúng tôi có thể sử dụng trực tiếp từ internet. Một trong những dịch vụ AWS phổ biến dành cho mục đích deep learning là Amazon Dịch vụ học sâu hình ảnh máy hoặc DL
Để biết hướng dẫn chi tiết về cách sử dụng AWS, hãy tham khảo phần này hướng dẫn
Lưu ý về AMI: Bạn sẽ có AMI sau đây
AWS Deep Learning AMI là môi trường ảo trong Dịch vụ AWS EC2 giúp các nhà nghiên cứu hoặc người thực hành làm việc với Deep Learning. DLAMI cung cấp từ công cụ CPU nhỏ cho đến công cụ nhiều GPU công suất cao với CUDA, cuDNN được cấu hình sẵn và đi kèm với nhiều khung học sâu khác nhau.
Nếu muốn sử dụng ngay thì bạn nên chọn Deep Learning AMI vì nó được cài đặt sẵn các framework deep learning phổ biến.
Nhưng nếu muốn dùng thử framework deep learning tùy chỉnh cho nghiên cứu, bạn nên cài đặt AMI Deep Learning Base vì nó đi kèm với các thư viện cơ bản như CUDA, cuDNN, trình điều khiển GPU và các thư viện cần thiết khác để chạy với môi trường deep learning của bạn.
Cách cài đặt Keras trên Amazon SageMaker
Amazon SageMaker là một nền tảng deep learning giúp bạn đào tạo và triển khai mạng deep learning với thuật toán tốt nhất.
Là người mới bắt đầu, đây là phương pháp dễ sử dụng Keras nhất. Dưới đây là quy trình cài đặt Keras trên Amazon SageMaker:
Bước 1) Mở Amazon SageMaker
Ở bước đầu tiên, hãy mở Amazon người làm hiền triết console và nhấp vào Tạo phiên bản sổ ghi chép.
Bước 2) Nhập thông tin chi tiết
- Nhập tên sổ ghi chép của bạn.
- Tạo vai trò IAM. Nó sẽ tạo ra một vai trò AMI Amazon Vai trò IAM ở định dạng AmazonSageMaker-Executionrole-YYYYMMDD|HHmmSS.
- Cuối cùng, chọn Tạo phiên bản sổ ghi chép. Sau một lúc, Amazon Sagemaker khởi chạy phiên bản máy tính xách tay.
Chú thích: Nếu bạn muốn truy cập tài nguyên từ VPC của mình, hãy đặt quyền truy cập internet trực tiếp thành được bật. Nếu không, phiên bản máy tính xách tay này sẽ không có quyền truy cập internet, do đó không thể đào tạo hoặc lưu trữ các mô hình
Bước 3) Khởi chạy phiên bản
Bấm vào Mở để khởi chạy phiên bản
Bước 4) Bắt đầu mã hóa
In Jupyter, Nhấp vào Mới> conda_tensorflow_p36 và bạn đã sẵn sàng viết mã
Cài đặt Keras trong Linux
Để kích hoạt Keras với Tensorflow làm công cụ phụ trợ, trước tiên chúng ta cần cài đặt Tensorflow. Chạy lệnh này để cài đặt tensorflow với CPU (không có GPU)
pip install --upgrade tensorflow
nếu bạn muốn kích hoạt hỗ trợ GPU cho tensorflow, bạn có thể sử dụng lệnh này
pip install --upgrade tensorflow-gpu
hãy đăng ký Python để xem cài đặt của chúng tôi có thành công hay không bằng cách gõ
user@user:~$ python Python 3.6.4 (default, Mar 20 2018, 11:10:20) [GCC 5.4.0 20160609] on linux Type "help", "copyright", "credits" or "license" for more information. >>> import tensorflow >>>
nếu không có thông báo lỗi thì quá trình cài đặt thành công
Cài đặt Keras
Sau khi cài đặt Tensorflow, hãy bắt đầu cài đặt máy ảnh. Nhập lệnh này trong terminal
pip install keras
nó sẽ bắt đầu cài đặt Keras và tất cả các phần phụ thuộc của nó. Bạn sẽ thấy một cái gì đó như thế này:
Bây giờ chúng tôi đã cài đặt Keras trong hệ thống của mình!
Đang xác minh
Trước khi bắt đầu sử dụng Keras, chúng ta nên kiểm tra xem Keras của chúng ta có sử dụng Tensorflow khi nó phụ trợ hay không bằng cách mở tệp cấu hình:
gedit ~/.keras/keras.json
bạn sẽ thấy một cái gì đó như thế này
{
"floatx": "float32",
"epsilon": 1e-07,
"backend": "tensorflow",
"image_data_format": "channels_last"
}
như bạn có thể thấy, phần “phụ trợ” sử dụng tensorflow. Điều đó có nghĩa là máy ảnh đang sử dụng Tensorflow làm chương trình phụ trợ như chúng tôi mong đợi
và bây giờ chạy nó trên terminal bằng cách gõ
user@user:~$ python3 Python 3.6.4 (default, Mar 20 2018, 11:10:20) [GCC 5.4.0 20160609] on linux Type "help", "copyright", "credits" or "license" for more information. >>> import keras Using TensorFlow backend. >>>
Cách cài đặt Keras trên Windows
Trước khi chúng tôi cài đặt Dòng chảy và Keras, chúng ta nên cài đặt Python, pip và virtualenv. Nếu bạn đã cài đặt các thư viện này, bạn nên tiếp tục bước tiếp theo, nếu không, hãy thực hiện như sau:
đặt Python 3 bằng cách tải xuống từ đây liên kết này
Cài đặt pip bằng cách chạy điều này
Cài đặt virtualenv bằng lệnh này
pip3 install –U pip virtualenv
đặt Microsoft Hình ảnh C++ Bản cập nhật có thể phân phối lại 2015 3
- Truy cập trang tải xuống Visual Studio https://www.microsoft.com/en-us/download/details.aspx?id=53587
- Chọn Công cụ phân phối lại và Xây dựng
- Tải về và cài đặt Microsoft Hình ảnh C++ Bản cập nhật có thể phân phối lại 2015 3
Sau đó chạy tập lệnh này
pip3 install virtualenv
Thiết lập môi trường ảo
Điều này được sử dụng để cách ly hệ thống làm việc với hệ thống chính.
virtualenv –-system-site-packages –p python3 ./venv
Kích hoạt môi trường
.\venv\Scripts\activate
Sau khi chuẩn bị môi trường, việc cài đặt Tensorflow và Keras vẫn giống như Linux. Tiếp theo trong hướng dẫn Học sâu với Keras này, chúng ta sẽ tìm hiểu về các nguyên tắc cơ bản của Keras cho Học sâu.
Nguyên tắc cơ bản của Keras về học sâu
Cấu trúc chính trong Keras là Mô hình xác định biểu đồ hoàn chỉnh của mạng. Bạn có thể thêm nhiều lớp hơn vào mô hình hiện có để xây dựng mô hình tùy chỉnh mà bạn cần cho dự án của mình.
Dưới đây là cách tạo Mô hình tuần tự và một số lớp thường được sử dụng trong học sâu
1. Mô hình tuần tự
from keras.models import Sequential from keras.layers import Dense, Activation,Conv2D,MaxPooling2D,Flatten,Dropout model = Sequential()
2. Lớp chập
Đây là Keras Python ví dụ về lớp chập là lớp đầu vào có hình dạng đầu vào là 320x320x3, với 48 bộ lọc có kích thước 3×3 và sử dụng ReLU làm hàm kích hoạt.
input_shape=(320,320,3) #this is the input shape of an image 320x320x3 model.add(Conv2D(48, (3, 3), activation='relu', input_shape= input_shape))
một loại khác là
model.add(Conv2D(48, (3, 3), activation='relu'))
3. Tối đaPooling Lớp
Để lấy mẫu biểu diễn đầu vào, hãy sử dụng MaxPool2d và chỉ định kích thước hạt nhân
model.add(MaxPooling2D(pool_size=(2, 2)))
4. Lớp dày đặc
thêm Lớp được kết nối đầy đủ chỉ bằng cách chỉ định Kích thước đầu ra
model.add(Dense(256, activation='relu'))
5. Lớp bỏ học
Thêm lớp bỏ học với xác suất 50%
model.add(Dropout(0.5))
Biên soạn, đào tạo và đánh giá
Sau khi xác định mô hình của mình, hãy bắt đầu huấn luyện chúng. Trước tiên, cần phải biên dịch mạng với chức năng mất và chức năng tối ưu hóa. Điều này sẽ cho phép mạng thay đổi trọng số và giảm thiểu tổn thất.
model.compile(loss='mean_squared_error', optimizer='adam')
Bây giờ để bắt đầu đào tạo, hãy sử dụng tính năng fit để cung cấp dữ liệu đào tạo và xác thực cho mô hình. Điều này sẽ cho phép bạn huấn luyện mạng theo đợt và đặt các kỷ nguyên.
model.fit(X_train, X_train, batch_size=32, epochs=10, validation_data=(x_val, y_val))
Bước cuối cùng của chúng tôi là đánh giá mô hình với dữ liệu thử nghiệm.
score = model.evaluate(x_test, y_test, batch_size=32)
Hãy thử sử dụng hồi quy tuyến tính đơn giản
import keras
from keras.models import Sequential
from keras.layers import Dense, Activation
import numpy as np
import matplotlib.pyplot as plt
x = data = np.linspace(1,2,200)
y = x*4 + np.random.randn(*x.shape) * 0.3
model = Sequential()
model.add(Dense(1, input_dim=1, activation='linear'))
model.compile(optimizer='sgd', loss='mse', metrics=['mse'])
weights = model.layers[0].get_weights()
w_init = weights[0][0][0]
b_init = weights[1][0]
print('Linear regression model is initialized with weights w: %.2f, b: %.2f' % (w_init, b_init))
model.fit(x,y, batch_size=1, epochs=30, shuffle=False)
weights = model.layers[0].get_weights()
w_final = weights[0][0][0]
b_final = weights[1][0]
print('Linear regression model is trained to have weight w: %.2f, b: %.2f' % (w_final, b_final))
predict = model.predict(data)
plt.plot(data, predict, 'b', data , y, 'k.')
plt.show()
Sau khi huấn luyện dữ liệu, kết quả đầu ra sẽ như thế này
với trọng lượng ban đầu
Linear regression model is initialized with weights w: 0.37, b: 0.00
và trọng lượng cuối cùng
Linear regression model is trained to have weight w: 3.70, b: 0.61
Tinh chỉnh các mô hình được đào tạo trước trong Keras và cách sử dụng chúng
Tại sao chúng tôi sử dụng Mô hình tinh chỉnh và khi nào chúng tôi sử dụng nó
Tinh chỉnh là nhiệm vụ điều chỉnh một mô hình được đào tạo trước sao cho các tham số có thể thích ứng với mô hình mới. Khi muốn huấn luyện từ đầu trên một mô hình mới, chúng ta cần một lượng lớn dữ liệu để mạng có thể tìm thấy tất cả các tham số. Nhưng trong trường hợp này, chúng tôi sẽ sử dụng mô hình được đào tạo trước để các tham số đã được học và có trọng số.
Ví dụ: nếu chúng ta muốn huấn luyện mô hình Keras của riêng mình để giải quyết vấn đề phân loại nhưng chúng ta chỉ có một lượng nhỏ dữ liệu thì chúng ta có thể giải quyết vấn đề này bằng cách sử dụng một Chuyển giao học tập + Phương pháp tinh chỉnh.
Sử dụng mạng và trọng lượng được đào tạo trước, chúng tôi không cần đào tạo toàn bộ mạng. Chúng ta chỉ cần huấn luyện lớp cuối cùng được sử dụng để giải quyết nhiệm vụ của mình vì chúng ta gọi nó là phương pháp Tinh chỉnh.
Chuẩn bị mô hình mạng
Đối với mô hình được đào tạo trước, chúng ta có thể tải nhiều mô hình khác nhau mà Keras đã có trong thư viện của nó như:
- VGG16
- Khởi đầuV3
- ResNet
- Mạng di động
- Sự khởi đầu
- Khởi đầuResNetV2
Nhưng trong quá trình này, chúng tôi sẽ sử dụng mô hình mạng VGG16 và imageNet làm trọng số cho mô hình. Chúng tôi sẽ tinh chỉnh mạng để phân loại 8 loại lớp khác nhau bằng cách sử dụng Hình ảnh từ Bộ dữ liệu hình ảnh tự nhiên Kaggle
Kiến trúc mô hình VGG16
Tải dữ liệu của chúng tôi lên nhóm AWS S3
Đối với quá trình đào tạo của chúng tôi, chúng tôi sẽ sử dụng hình ảnh thiên nhiên từ 8 lớp khác nhau như máy bay, ô tô, mèo, chó, hoa, trái cây, xe máy và con người. Đầu tiên, chúng ta cần tải dữ liệu của mình lên Amazon Xô S3.
Amazon Nhóm S3
Bước 1) Sau khi đăng nhập vào tài khoản S3 của bạn, hãy tạo một nhóm bằng cách bấm giờ Tạo nhóm
Bước 2) Bây giờ hãy chọn Tên nhóm và Khu vực tùy theo tài khoản của bạn. Đảm bảo rằng tên nhóm có sẵn. Sau cú nhấp chuột đó Tạo.
Bước 3) Như bạn có thể thấy, Buck của bạn đã sẵn sàng để sử dụng. Nhưng như bạn có thể thấy, Quyền truy cập không được công khai, sẽ tốt cho bạn nếu bạn muốn giữ nó ở chế độ riêng tư cho riêng mình. Bạn có thể thay đổi nhóm này thành Quyền truy cập công cộng trong Thuộc tính nhóm
Bước 4) Bây giờ bạn bắt đầu tải dữ liệu đào tạo của mình lên Nhóm. Ở đây tôi sẽ tải lên tệp tar.gz bao gồm các hình ảnh cho quá trình đào tạo và kiểm tra.
Bước 5) Bây giờ bấm vào tập tin của bạn và sao chép liên kết để chúng tôi có thể tải nó xuống.
Chuẩn bị dữ liệu
Chúng tôi cần tạo dữ liệu đào tạo của mình bằng Keras ImageDataGenerator.
Trước tiên, bạn phải tải xuống bằng wget với liên kết tới tệp của bạn từ S3 Bucket.
!wget https://s3.us-east-2.amazonaws.com/naturalimages02/images.tar.gz !tar -xzf images.tar.gz
Sau khi bạn tải xuống dữ liệu, hãy bắt đầu Quá trình đào tạo.
from keras.preprocessing.image import ImageDataGenerator
import numpy as np
import matplotlib.pyplot as plt
train_path = 'images/train/'
test_path = 'images/test/'
batch_size = 16
image_size = 224
num_class = 8
train_datagen = ImageDataGenerator(validation_split=0.3,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
train_generator = train_datagen.flow_from_directory(
directory=train_path,
target_size=(image_size,image_size),
batch_size=batch_size,
class_mode='categorical',
color_mode='rgb',
shuffle=True)
Dữ liệu hình ảnhGenerator sẽ tạo dữ liệu X_training từ một thư mục. Thư mục con trong thư mục đó sẽ được sử dụng làm lớp cho từng đối tượng. Hình ảnh sẽ được tải với chế độ màu RGB, với chế độ lớp phân loại cho dữ liệu Y_training, với kích thước lô là 16. Cuối cùng, xáo trộn dữ liệu.
Hãy xem hình ảnh của chúng tôi một cách ngẫu nhiên bằng cách vẽ chúng bằng matplotlib
x_batch, y_batch = train_generator.next()
fig=plt.figure()
columns = 4
rows = 4
for i in range(1, columns*rows):
num = np.random.randint(batch_size)
image = x_batch[num].astype(np.int)
fig.add_subplot(rows, columns, i)
plt.imshow(image)
plt.show()
Sau đó, hãy tạo mô hình mạng của chúng tôi từ VGG16 với trọng số được huấn luyện trước imageNet. Chúng tôi sẽ đóng băng các lớp này để các lớp không thể huấn luyện được nhằm giúp chúng tôi giảm thời gian tính toán.
Tạo mô hình của chúng tôi từ VGG16
import keras
from keras.models import Model, load_model
from keras.layers import Activation, Dropout, Flatten, Dense
from keras.preprocessing.image import ImageDataGenerator
from keras.applications.vgg16 import VGG16
#Load the VGG model
base_model = VGG16(weights='imagenet', include_top=False, input_shape=(image_size, image_size, 3))
print(base_model.summary())
# Freeze the layers
for layer in base_model.layers:
layer.trainable = False
# # Create the model
model = keras.models.Sequential()
# # Add the vgg convolutional base model
model.add(base_model)
# # Add new layers
model.add(Flatten())
model.add(Dense(1024, activation='relu'))
model.add(Dense(1024, activation='relu'))
model.add(Dense(num_class, activation='softmax'))
# # Show a summary of the model. Check the number of trainable parameters
print(model.summary())
Như bạn có thể thấy bên dưới, bản tóm tắt về mô hình mạng của chúng tôi. Từ đầu vào từ Lớp VGG16, sau đó chúng tôi thêm 2 Lớp được kết nối đầy đủ sẽ trích xuất 1024 tính năng và một lớp đầu ra sẽ tính toán 8 lớp bằng kích hoạt softmax.
Layer (type) Output Shape Param # ================================================================= vgg16 (Model) (None, 7, 7, 512) 14714688 _________________________________________________________________ flatten_1 (Flatten) (None, 25088) 0 _________________________________________________________________ dense_1 (Dense) (None, 1024) 25691136 _________________________________________________________________ dense_2 (Dense) (None, 1024) 1049600 _________________________________________________________________ dense_3 (Dense) (None, 8) 8200 ================================================================= Total params: 41,463,624 Trainable params: 26,748,936 Non-trainable params: 14,714,688
Hội thảo
# # Compile the model
from keras.optimizers import SGD
model.compile(loss='categorical_crossentropy',
optimizer=SGD(lr=1e-3),
metrics=['accuracy'])
# # Start the training process
# model.fit(x_train, y_train, validation_split=0.30, batch_size=32, epochs=50, verbose=2)
# # #save the model
# model.save('catdog.h5')
history = model.fit_generator(
train_generator,
steps_per_epoch=train_generator.n/batch_size,
epochs=10)
model.save('fine_tune.h5')
# summarize history for accuracy
import matplotlib.pyplot as plt
plt.plot(history.history['loss'])
plt.title('loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['loss'], loc='upper left')
plt.show()
Kết quả
Epoch 1/10 432/431 [==============================] - 53s 123ms/step - loss: 0.5524 - acc: 0.9474 Epoch 2/10 432/431 [==============================] - 52s 119ms/step - loss: 0.1571 - acc: 0.9831 Epoch 3/10 432/431 [==============================] - 51s 119ms/step - loss: 0.1087 - acc: 0.9871 Epoch 4/10 432/431 [==============================] - 51s 119ms/step - loss: 0.0624 - acc: 0.9926 Epoch 5/10 432/431 [==============================] - 51s 119ms/step - loss: 0.0591 - acc: 0.9938 Epoch 6/10 432/431 [==============================] - 51s 119ms/step - loss: 0.0498 - acc: 0.9936 Epoch 7/10 432/431 [==============================] - 51s 119ms/step - loss: 0.0403 - acc: 0.9958 Epoch 8/10 432/431 [==============================] - 51s 119ms/step - loss: 0.0248 - acc: 0.9959 Epoch 9/10 432/431 [==============================] - 51s 119ms/step - loss: 0.0466 - acc: 0.9942 Epoch 10/10 432/431 [==============================] - 52s 120ms/step - loss: 0.0338 - acc: 0.9947
Như bạn có thể thấy, tổn thất của chúng tôi giảm đáng kể và độ chính xác gần như 100%. Để thử nghiệm mô hình của mình, chúng tôi đã chọn ngẫu nhiên các hình ảnh trên internet và đưa nó vào thư mục thử nghiệm với một lớp khác để kiểm tra
Thử nghiệm mô hình của chúng tôi
model = load_model('fine_tune.h5')
test_datagen = ImageDataGenerator()
train_generator = train_datagen.flow_from_directory(
directory=train_path,
target_size=(image_size,image_size),
batch_size=batch_size,
class_mode='categorical',
color_mode='rgb',
shuffle=True)
test_generator = test_datagen.flow_from_directory(
directory=test_path,
target_size=(image_size, image_size),
color_mode='rgb',
shuffle=False,
class_mode='categorical',
batch_size=1)
filenames = test_generator.filenames
nb_samples = len(filenames)
fig=plt.figure()
columns = 4
rows = 4
for i in range(1, columns*rows -1):
x_batch, y_batch = test_generator.next()
name = model.predict(x_batch)
name = np.argmax(name, axis=-1)
true_name = y_batch
true_name = np.argmax(true_name, axis=-1)
label_map = (test_generator.class_indices)
label_map = dict((v,k) for k,v in label_map.items()) #flip k,v
predictions = [label_map[k] for k in name]
true_value = [label_map[k] for k in true_name]
image = x_batch[0].astype(np.int)
fig.add_subplot(rows, columns, i)
plt.title(str(predictions[0]) + ':' + str(true_value[0]))
plt.imshow(image)
plt.show()
Và bài kiểm tra của chúng tôi như được đưa ra dưới đây! Chỉ có 1 hình ảnh được dự đoán sai trong quá trình kiểm tra 14 hình ảnh!
Mạng thần kinh nhận dạng khuôn mặt với Keras
Tại sao chúng ta cần sự công nhận
Chúng tôi cần Nhận dạng để giúp chúng tôi dễ dàng nhận dạng hoặc xác định khuôn mặt của một người, loại đối tượng, tuổi ước tính của một người từ khuôn mặt của người đó hoặc thậm chí biết nét mặt của người đó.
Có thể bạn nhận ra rằng mỗi khi bạn cố gắng đánh dấu khuôn mặt của bạn mình trong một bức ảnh, tính năng trên Facebook đã làm điều đó cho bạn, đó là đánh dấu khuôn mặt của người bạn mà bạn không cần phải đánh dấu trước. Đây là tính năng Nhận diện khuôn mặt được Facebook áp dụng để giúp chúng ta tag bạn bè dễ dàng hơn.
Vì vậy, làm thế nào nó hoạt động? Mỗi khi chúng ta đánh dấu khuôn mặt của bạn mình, AI của Facebook sẽ học hỏi khuôn mặt đó và sẽ cố gắng dự đoán cho đến khi nhận được kết quả đúng. Hệ thống tương tự mà chúng tôi sẽ sử dụng để thực hiện Nhận dạng khuôn mặt của riêng mình. Hãy bắt đầu thực hiện Nhận dạng khuôn mặt của riêng chúng ta bằng Deep Learning
Mô hình mạng
Chúng tôi sẽ sử dụng Mô hình mạng VGG16 nhưng có trọng lượng VGGFace.
Kiến trúc mô hình VGG16
VGGFace là gì? đó là triển khai Keras của Nhận dạng khuôn mặt sâu được giới thiệu bởi Parkhi, Omkar M. et al. “Nhận dạng khuôn mặt sâu.” BMVC (2015). Khung sử dụng VGG16 làm kiến trúc mạng.
Bạn có thể tải xuống VGGFace từ github
from keras.applications.vgg16 import VGG16
from keras_vggface.vggface import VGGFace
face_model = VGGFace(model='vgg16',
weights='vggface',
input_shape=(224,224,3))
face_model.summary()
Như bạn có thể thấy bản tóm tắt mạng
_________________________________________________________________ Layer (type) Output Shape Param # ================================================================= input_1 (InputLayer) (None, 224, 224, 3) 0 _________________________________________________________________ conv1_1 (Conv2D) (None, 224, 224, 64) 1792 _________________________________________________________________ conv1_2 (Conv2D) (None, 224, 224, 64) 36928 _________________________________________________________________ pool1 (MaxPooling2D) (None, 112, 112, 64) 0 _________________________________________________________________ conv2_1 (Conv2D) (None, 112, 112, 128) 73856 _________________________________________________________________ conv2_2 (Conv2D) (None, 112, 112, 128) 147584 _________________________________________________________________ pool2 (MaxPooling2D) (None, 56, 56, 128) 0 _________________________________________________________________ conv3_1 (Conv2D) (None, 56, 56, 256) 295168 _________________________________________________________________ conv3_2 (Conv2D) (None, 56, 56, 256) 590080 _________________________________________________________________ conv3_3 (Conv2D) (None, 56, 56, 256) 590080 _________________________________________________________________ pool3 (MaxPooling2D) (None, 28, 28, 256) 0 _________________________________________________________________ conv4_1 (Conv2D) (None, 28, 28, 512) 1180160 _________________________________________________________________ conv4_2 (Conv2D) (None, 28, 28, 512) 2359808 _________________________________________________________________ conv4_3 (Conv2D) (None, 28, 28, 512) 2359808 _________________________________________________________________ pool4 (MaxPooling2D) (None, 14, 14, 512) 0 _________________________________________________________________ conv5_1 (Conv2D) (None, 14, 14, 512) 2359808 _________________________________________________________________ conv5_2 (Conv2D) (None, 14, 14, 512) 2359808 _________________________________________________________________ conv5_3 (Conv2D) (None, 14, 14, 512) 2359808 _________________________________________________________________ pool5 (MaxPooling2D) (None, 7, 7, 512) 0 _________________________________________________________________ flatten (Flatten) (None, 25088) 0 _________________________________________________________________ fc6 (Dense) (None, 4096) 102764544 _________________________________________________________________ fc6/relu (Activation) (None, 4096) 0 _________________________________________________________________ fc7 (Dense) (None, 4096) 16781312 _________________________________________________________________ fc7/relu (Activation) (None, 4096) 0 _________________________________________________________________ fc8 (Dense) (None, 2622) 10742334 _________________________________________________________________ fc8/softmax (Activation) (None, 2622) 0 ================================================================= Total params: 145,002,878 Trainable params: 145,002,878 Non-trainable params: 0 _________________________________________________________________ Traceback (most recent call last):
chúng tôi sẽ làm một Chuyển giao học tập + Tinh chỉnh để đào tạo nhanh hơn với các tập dữ liệu nhỏ. Đầu tiên, chúng ta sẽ đóng băng các lớp cơ sở để các lớp không thể huấn luyện được.
for layer in face_model.layers:
layer.trainable = False
sau đó chúng tôi thêm lớp của riêng mình để nhận dạng các khuôn mặt thử nghiệm của mình. Chúng tôi sẽ thêm 2 lớp được kết nối đầy đủ và một lớp đầu ra có 5 người để phát hiện.
from keras.models import Model, Sequential
from keras.layers import Input, Convolution2D, ZeroPadding2D, MaxPooling2D, Flatten, Dense, Dropout, Activation
person_count = 5
last_layer = face_model.get_layer('pool5').output
x = Flatten(name='flatten')(last_layer)
x = Dense(1024, activation='relu', name='fc6')(x)
x = Dense(1024, activation='relu', name='fc7')(x)
out = Dense(person_count, activation='softmax', name='fc8')(x)
custom_face = Model(face_model.input, out)
Hãy xem tóm tắt mạng của chúng tôi
Layer (type) Output Shape Param # ================================================================= input_1 (InputLayer) (None, 224, 224, 3) 0 _________________________________________________________________ conv1_1 (Conv2D) (None, 224, 224, 64) 1792 _________________________________________________________________ conv1_2 (Conv2D) (None, 224, 224, 64) 36928 _________________________________________________________________ pool1 (MaxPooling2D) (None, 112, 112, 64) 0 _________________________________________________________________ conv2_1 (Conv2D) (None, 112, 112, 128) 73856 _________________________________________________________________ conv2_2 (Conv2D) (None, 112, 112, 128) 147584 _________________________________________________________________ pool2 (MaxPooling2D) (None, 56, 56, 128) 0 _________________________________________________________________ conv3_1 (Conv2D) (None, 56, 56, 256) 295168 _________________________________________________________________ conv3_2 (Conv2D) (None, 56, 56, 256) 590080 _________________________________________________________________ conv3_3 (Conv2D) (None, 56, 56, 256) 590080 _________________________________________________________________ pool3 (MaxPooling2D) (None, 28, 28, 256) 0 _________________________________________________________________ conv4_1 (Conv2D) (None, 28, 28, 512) 1180160 _________________________________________________________________ conv4_2 (Conv2D) (None, 28, 28, 512) 2359808 _________________________________________________________________ conv4_3 (Conv2D) (None, 28, 28, 512) 2359808 _________________________________________________________________ pool4 (MaxPooling2D) (None, 14, 14, 512) 0 _________________________________________________________________ conv5_1 (Conv2D) (None, 14, 14, 512) 2359808 _________________________________________________________________ conv5_2 (Conv2D) (None, 14, 14, 512) 2359808 _________________________________________________________________ conv5_3 (Conv2D) (None, 14, 14, 512) 2359808 _________________________________________________________________ pool5 (MaxPooling2D) (None, 7, 7, 512) 0 _________________________________________________________________ flatten (Flatten) (None, 25088) 0 _________________________________________________________________ fc6 (Dense) (None, 1024) 25691136 _________________________________________________________________ fc7 (Dense) (None, 1024) 1049600 _________________________________________________________________ fc8 (Dense) (None, 5) 5125 ================================================================= Total params: 41,460,549 Trainable params: 26,745,861 Non-trainable params: 14,714,688
Như bạn có thể thấy ở trên, sau lớp pool5, nó sẽ được làm phẳng thành một vectơ đặc trưng duy nhất sẽ được lớp dày đặc sử dụng để nhận dạng cuối cùng.
Chuẩn bị khuôn mặt của chúng tôi
Bây giờ chúng ta hãy chuẩn bị khuôn mặt của chúng ta. Tôi đã tạo một thư mục gồm 5 người nổi tiếng
- Jack Ma
- Jason Statham
- Johnny Depp
- Robert Downey
- Rowan Atkinson
Mỗi thư mục chứa 10 hình ảnh cho mỗi quá trình đào tạo và đánh giá. Đó là một lượng dữ liệu rất nhỏ nhưng đó chính là thách thức, phải không?
Chúng tôi sẽ sử dụng sự trợ giúp của công cụ Keras để giúp chúng tôi chuẩn bị dữ liệu. Hàm này sẽ lặp lại trong thư mục tập dữ liệu và sau đó chuẩn bị để có thể sử dụng trong quá trình đào tạo.
from keras.preprocessing.image import ImageDataGenerator
batch_size = 5
train_path = 'data/'
eval_path = 'eval/'
train_datagen = ImageDataGenerator(rescale=1./255,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
valid_datagen = ImageDataGenerator(rescale=1./255,
shear_range=0.2,
zoom_range=0.2,
horizontal_flip=True)
train_generator = train_datagen.flow_from_directory(
train_path,
target_size=(image_size,image_size),
batch_size=batch_size,
class_mode='sparse',
color_mode='rgb')
valid_generator = valid_datagen.flow_from_directory(
directory=eval_path,
target_size=(224, 224),
color_mode='rgb',
batch_size=batch_size,
class_mode='sparse',
shuffle=True,
)
Đào tạo mô hình của chúng tôi
Hãy bắt đầu quá trình đào tạo của chúng tôi bằng cách biên dịch mạng của chúng tôi với chức năng mất dữ liệu và trình tối ưu hóa. Ở đây, chúng tôi sử dụngsparse_categorical_crossentropy làm hàm mất mát, với sự trợ giúp của SGD làm công cụ tối ưu hóa học tập của chúng tôi.
from keras.optimizers import SGD
custom_face.compile(loss='sparse_categorical_crossentropy',
optimizer=SGD(lr=1e-4, momentum=0.9),
metrics=['accuracy'])
history = custom_face.fit_generator(
train_generator,
validation_data=valid_generator,
steps_per_epoch=49/batch_size,
validation_steps=valid_generator.n,
epochs=50)
custom_face.evaluate_generator(generator=valid_generator)
custom_face.save('vgg_face.h5')
Epoch 25/50
10/9 [==============================] - 60s 6s/step - loss: 1.4882 - acc: 0.8998 - val_loss: 1.5659 - val_acc: 0.5851
Epoch 26/50
10/9 [==============================] - 59s 6s/step - loss: 1.4882 - acc: 0.8998 - val_loss: 1.5638 - val_acc: 0.5809
Epoch 27/50
10/9 [==============================] - 60s 6s/step - loss: 1.4779 - acc: 0.8597 - val_loss: 1.5613 - val_acc: 0.5477
Epoch 28/50
10/9 [==============================] - 60s 6s/step - loss: 1.4755 - acc: 0.9199 - val_loss: 1.5576 - val_acc: 0.5809
Epoch 29/50
10/9 [==============================] - 60s 6s/step - loss: 1.4794 - acc: 0.9153 - val_loss: 1.5531 - val_acc: 0.5892
Epoch 30/50
10/9 [==============================] - 60s 6s/step - loss: 1.4714 - acc: 0.8953 - val_loss: 1.5510 - val_acc: 0.6017
Epoch 31/50
10/9 [==============================] - 60s 6s/step - loss: 1.4552 - acc: 0.9199 - val_loss: 1.5509 - val_acc: 0.5809
Epoch 32/50
10/9 [==============================] - 60s 6s/step - loss: 1.4504 - acc: 0.9199 - val_loss: 1.5492 - val_acc: 0.5975
Epoch 33/50
10/9 [==============================] - 60s 6s/step - loss: 1.4497 - acc: 0.8998 - val_loss: 1.5490 - val_acc: 0.5851
Epoch 34/50
10/9 [==============================] - 60s 6s/step - loss: 1.4453 - acc: 0.9399 - val_loss: 1.5529 - val_acc: 0.5643
Epoch 35/50
10/9 [==============================] - 60s 6s/step - loss: 1.4399 - acc: 0.9599 - val_loss: 1.5451 - val_acc: 0.5768
Epoch 36/50
10/9 [==============================] - 60s 6s/step - loss: 1.4373 - acc: 0.8998 - val_loss: 1.5424 - val_acc: 0.5768
Epoch 37/50
10/9 [==============================] - 60s 6s/step - loss: 1.4231 - acc: 0.9199 - val_loss: 1.5389 - val_acc: 0.6183
Epoch 38/50
10/9 [==============================] - 59s 6s/step - loss: 1.4247 - acc: 0.9199 - val_loss: 1.5372 - val_acc: 0.5934
Epoch 39/50
10/9 [==============================] - 60s 6s/step - loss: 1.4153 - acc: 0.9399 - val_loss: 1.5406 - val_acc: 0.5560
Epoch 40/50
10/9 [==============================] - 60s 6s/step - loss: 1.4074 - acc: 0.9800 - val_loss: 1.5327 - val_acc: 0.6224
Epoch 41/50
10/9 [==============================] - 60s 6s/step - loss: 1.4023 - acc: 0.9800 - val_loss: 1.5305 - val_acc: 0.6100
Epoch 42/50
10/9 [==============================] - 59s 6s/step - loss: 1.3938 - acc: 0.9800 - val_loss: 1.5269 - val_acc: 0.5975
Epoch 43/50
10/9 [==============================] - 60s 6s/step - loss: 1.3897 - acc: 0.9599 - val_loss: 1.5234 - val_acc: 0.6432
Epoch 44/50
10/9 [==============================] - 60s 6s/step - loss: 1.3828 - acc: 0.9800 - val_loss: 1.5210 - val_acc: 0.6556
Epoch 45/50
10/9 [==============================] - 59s 6s/step - loss: 1.3848 - acc: 0.9599 - val_loss: 1.5234 - val_acc: 0.5975
Epoch 46/50
10/9 [==============================] - 60s 6s/step - loss: 1.3716 - acc: 0.9800 - val_loss: 1.5216 - val_acc: 0.6432
Epoch 47/50
10/9 [==============================] - 60s 6s/step - loss: 1.3721 - acc: 0.9800 - val_loss: 1.5195 - val_acc: 0.6266
Epoch 48/50
10/9 [==============================] - 60s 6s/step - loss: 1.3622 - acc: 0.9599 - val_loss: 1.5108 - val_acc: 0.6141
Epoch 49/50
10/9 [==============================] - 60s 6s/step - loss: 1.3452 - acc: 0.9399 - val_loss: 1.5140 - val_acc: 0.6432
Epoch 50/50
10/9 [==============================] - 60s 6s/step - loss: 1.3387 - acc: 0.9599 - val_loss: 1.5100 - val_acc: 0.6266
Như bạn có thể thấy, độ chính xác xác thực của chúng tôi lên tới 64%, đây là kết quả tốt đối với một lượng nhỏ dữ liệu đào tạo. Chúng tôi có thể cải thiện điều này bằng cách thêm nhiều lớp hơn hoặc thêm nhiều hình ảnh đào tạo hơn để mô hình của chúng tôi có thể tìm hiểu thêm về khuôn mặt và đạt được độ chính xác cao hơn.
Hãy kiểm tra mô hình của chúng tôi bằng một hình ảnh thử nghiệm
from keras.models import load_model
from keras.preprocessing.image import load_img, save_img, img_to_array
from keras_vggface.utils import preprocess_input
test_img = image.load_img('test.jpg', target_size=(224, 224))
img_test = image.img_to_array(test_img)
img_test = np.expand_dims(img_test, axis=0)
img_test = utils.preprocess_input(img_test)
predictions = model.predict(img_test)
predicted_class=np.argmax(predictions,axis=1)
labels = (train_generator.class_indices)
labels = dict((v,k) for k,v in labels.items())
predictions = [labels[k] for k in predicted_class]
print(predictions)
['RobertDJr']
sử dụng hình ảnh của Robert Downey Jr. làm hình ảnh thử nghiệm của chúng tôi, nó cho thấy khuôn mặt được dự đoán là đúng!
Dự đoán bằng Live Cam!
Sẽ thế nào nếu chúng ta kiểm tra kỹ năng của mình bằng cách triển khai nó bằng đầu vào từ webcam? Sử dụng OpenCV với tầng Haar Face để tìm khuôn mặt của chúng tôi và với sự trợ giúp của mô hình mạng, chúng tôi có thể nhận ra người đó.
Bước đầu tiên là chuẩn bị khuôn mặt của bạn và bạn bè của bạn. Chúng ta càng có nhiều dữ liệu thì kết quả càng tốt!
Chuẩn bị và huấn luyện mạng của bạn như bước trước, sau khi huấn luyện xong, hãy thêm dòng này để lấy hình ảnh đầu vào từ cam
#Load trained model
from keras.models import load_model
from keras_vggface import utils
import cv2
image_size = 224
device_id = 0 #camera_device id
model = load_model('my faces.h5')
#make labels according to your dataset folder
labels = dict(fisrtname=0,secondname=1) #and so on
print(labels)
cascade_classifier = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')
camera = cv2.VideoCapture(device_id)
while camera.isOpened():
ok, cam_frame = camera.read()
if not ok:
break
gray_img=cv2.cvtColor(cam_frame, cv2.COLOR_BGR2GRAY)
faces= cascade_classifier.detectMultiScale(gray_img, minNeighbors=5)
for (x,y,w,h) in faces:
cv2.rectangle(cam_frame,(x,y),(x+w,y+h),(255,255,0),2)
roi_color = cam_frame [y:y+h, x:x+w]
roi color = cv2.cvtColor(roi_color, cv2.COLOR_BGR2RGB)
roi_color = cv2.resize(roi_color, (image_size, image_size))
image = roi_color.astype(np.float32, copy=False)
image = np.expand_dims(image, axis=0)
image = preprocess_input(image, version=1) # or version=2
preds = model.predict(image)
predicted_class=np.argmax(preds,axis=1)
labels = dict((v,k) for k,v in labels.items())
name = [labels[k] for k in predicted_class]
cv2.putText(cam_frame,str(name),
(x + 10, y + 10), cv2.FONT_HERSHEY_SIMPLEX, 1, (255,0,255), 2)
cv2.imshow('video image', cam_frame)
key = cv2.waitKey(30)
if key == 27: # press 'ESC' to quit
break
camera.release()
cv2.destroyAllWindows()
Cái nào tốt hơn? Keras hoặc Tensorflow
Keras mang lại sự đơn giản khi viết kịch bản. Chúng ta có thể bắt đầu viết và hiểu trực tiếp với Keras vì nó không quá khó hiểu. Nó thân thiện với người dùng hơn và dễ thực hiện hơn, không cần tạo nhiều biến để chạy mô hình. Vì vậy, chúng ta không cần phải hiểu mọi chi tiết trong quy trình phụ trợ.
Mặt khác, Tensorflow là các hoạt động cấp thấp mang lại sự linh hoạt và các hoạt động nâng cao nếu bạn muốn tạo một biểu đồ hoặc mô hình tính toán tùy ý. Tensorflow cũng có thể hình dung quá trình với sự trợ giúp của TenorBoard và một công cụ gỡ lỗi chuyên dụng.
Vì vậy, nếu bạn muốn bắt đầu làm việc với deep learning mà không quá phức tạp, hãy sử dụng Keras. Bởi vì Keras cung cấp sự đơn giản và thân thiện với người dùng, dễ triển khai hơn Tensorflow. Nhưng nếu bạn muốn viết thuật toán của riêng mình trong dự án hoặc nghiên cứu deep learning, bạn nên sử dụng Tensorflow.
Tổng kết
Vì vậy, hãy tóm tắt mọi thứ chúng ta đã thảo luận và thực hiện trong hướng dẫn này.
- Keras trong API cấp cao được sử dụng để làm cho mạng học sâu trở nên dễ dàng hơn với sự trợ giúp của công cụ phụ trợ.
- Keras rất dễ sử dụng và dễ hiểu với sự hỗ trợ của python nên cảm giác sử dụng trở nên tự nhiên hơn bao giờ hết. Nó tốt cho những người mới bắt đầu muốn tìm hiểu về deep learning và cho những nhà nghiên cứu muốn sử dụng API dễ dàng.
- Quá trình cài đặt rất dễ dàng và bạn có thể sử dụng môi trường ảo hoặc sử dụng nền tảng bên ngoài như AWS.
- Keras cũng đi kèm với nhiều loại mô hình mạng khác nhau để giúp chúng tôi dễ dàng sử dụng mô hình có sẵn hơn để đào tạo trước và tinh chỉnh mô hình mạng của riêng mình.
- Ngoài ra, có rất nhiều hướng dẫn và bài viết về cách sử dụng Keras từ các cộng đồng mã trên toàn thế giới cho mục đích học sâu.
