Keras - Hướng dẫn nhanh

Keras - Giới thiệu

Học sâu là một trong những lĩnh vực chính của khuôn khổ học máy. Học máy là nghiên cứu thiết kế các thuật toán, lấy cảm hứng từ mô hình não người. Học sâu đang trở nên phổ biến hơn trong các lĩnh vực khoa học dữ liệu như robot, trí tuệ nhân tạo (AI), nhận dạng âm thanh và video và nhận dạng hình ảnh. Mạng nơ-ron nhân tạo là cốt lõi của phương pháp học sâu. Học sâu được hỗ trợ bởi nhiều thư viện khác nhau như Theano, TensorFlow, Caffe, Mxnet, v.v., Keras là một trong những thư viện python mạnh mẽ và dễ sử dụng nhất, được xây dựng trên các thư viện học sâu phổ biến như TensorFlow, Theano, v.v. , để tạo ra các mô hình học sâu.

Tổng quan về Keras

Keras chạy trên các thư viện máy mã nguồn mở như TensorFlow, Theano hoặc Bộ công cụ nhận thức (CNTK). Theano là một thư viện python được sử dụng cho các tác vụ tính toán số nhanh. TensorFlow là thư viện toán học biểu tượng nổi tiếng nhất được sử dụng để tạo mạng nơ-ron và mô hình học sâu. TensorFlow rất linh hoạt và lợi ích chính là tính toán phân tán. CNTK là khung học sâu được phát triển bởi Microsoft. Nó sử dụng các thư viện như Python, C #, C ++ hoặc các bộ công cụ học máy độc lập. Theano và TensorFlow là những thư viện rất mạnh nhưng khó hiểu để tạo mạng nơ-ron.

Keras dựa trên cấu trúc tối thiểu, cung cấp một cách dễ dàng và dễ dàng để tạo các mô hình học sâu dựa trên TensorFlow hoặc Theano. Keras được thiết kế để nhanh chóng xác định các mô hình học sâu. Chà, Keras là một lựa chọn tối ưu cho các ứng dụng học sâu.

Đặc trưng

Keras tận dụng các kỹ thuật tối ưu hóa khác nhau để làm cho API mạng thần kinh cấp cao dễ dàng hơn và hoạt động hiệu quả hơn. Nó hỗ trợ các tính năng sau:

  • API nhất quán, đơn giản và có thể mở rộng.

  • Cấu trúc tối thiểu - dễ dàng đạt được kết quả mà không cần bất kỳ kiểu cách nào.

  • Nó hỗ trợ nhiều nền tảng và phụ trợ.

  • Đây là khuôn khổ thân thiện với người dùng chạy trên cả CPU và GPU.

  • Khả năng mở rộng tính toán cao.

Những lợi ích

Keras là một khung công tác năng động và mạnh mẽ và có những ưu điểm sau:

  • Hỗ trợ cộng đồng lớn hơn.

  • Dễ dàng kiểm tra.

  • Mạng nơron Keras được viết bằng Python giúp mọi thứ đơn giản hơn.

  • Keras hỗ trợ cả mạng chập và mạng lặp lại.

  • Mô hình học sâu là các thành phần rời rạc, do đó, bạn có thể kết hợp thành nhiều cách.

Keras - Cài đặt

Chương này giải thích về cách cài đặt Keras trên máy tính của bạn. Trước khi chuyển sang cài đặt, chúng ta hãy xem qua các yêu cầu cơ bản của Keras.

Điều kiện tiên quyết

Bạn phải đáp ứng các yêu cầu sau:

  • Bất kỳ loại hệ điều hành nào (Windows, Linux hoặc Mac)
  • Phiên bản Python 3.5 trở lên.

Python

Keras là thư viện mạng thần kinh dựa trên python nên python phải được cài đặt trên máy của bạn. Nếu python được cài đặt đúng cách trên máy của bạn, sau đó mở thiết bị đầu cuối của bạn và nhập python, bạn có thể thấy phản hồi tương tự như được chỉ định bên dưới,

Python 3.6.5 (v3.6.5:f59c0932b4, Mar 28 2018, 17:00:18) 
[MSC v.1900 64 bit (AMD64)] on win32 
Type "help", "copyright", "credits" or "license" for more information. 
>>>

Hiện tại, phiên bản mới nhất là '3.7.2'. Nếu Python chưa được cài đặt, hãy truy cập liên kết python chính thức - www.python.org và tải xuống phiên bản mới nhất dựa trên hệ điều hành của bạn và cài đặt nó ngay lập tức trên hệ thống của bạn.

Các bước cài đặt Keras

Cài đặt Keras khá dễ dàng. Làm theo các bước dưới đây để cài đặt Keras đúng cách trên hệ thống của bạn.

Bước 1: Tạo môi trường ảo

Virtualenvđược sử dụng để quản lý các gói Python cho các dự án khác nhau. Điều này sẽ hữu ích để tránh phá vỡ các gói được cài đặt trong các môi trường khác. Vì vậy, bạn nên sử dụng môi trường ảo trong khi phát triển các ứng dụng Python.

Linux/Mac OS

Người dùng Linux hoặc mac OS, hãy chuyển đến thư mục gốc của dự án và nhập lệnh dưới đây để tạo môi trường ảo,

python3 -m venv kerasenv

Sau khi thực hiện lệnh trên, thư mục “kerasenv” được tạo với bin,lib and include folders ở vị trí cài đặt của bạn.

Windows

Người dùng Windows có thể sử dụng lệnh dưới đây,

py -m venv keras

Bước 2: Kích hoạt môi trường

Bước này sẽ cấu hình các tệp thực thi python và pip trong đường dẫn shell của bạn.

Linux/Mac OS

Bây giờ chúng tôi đã tạo ra một môi trường ảo có tên là “kerasvenv”. Di chuyển đến thư mục và gõ lệnh dưới đây,

$ cd kerasvenv kerasvenv $ source bin/activate

Windows

Người dùng Windows di chuyển bên trong thư mục “kerasenv” và nhập lệnh dưới đây,

.\env\Scripts\activate

Bước 3: Thư viện Python

Keras phụ thuộc vào các thư viện python sau.

  • Numpy
  • Pandas
  • Scikit-learn
  • Matplotlib
  • Scipy
  • Seaborn

Hy vọng rằng bạn đã cài đặt tất cả các thư viện trên vào hệ thống của mình. Nếu các thư viện này chưa được cài đặt, hãy sử dụng lệnh dưới đây để cài đặt từng thư viện một.

numpy

pip install numpy

bạn có thể thấy phản hồi sau đây,

Collecting numpy 
   Downloading 
https://files.pythonhosted.org/packages/cf/a4/d5387a74204542a60ad1baa84cd2d3353c330e59be8cf2d47c0b11d3cde8/ 
   numpy-3.1.1-cp36-cp36m-macosx_10_6_intel.
macosx_10_9_intel.macosx_10_9_x86_64. 
   macosx_10_10_intel.macosx_10_10_x86_64.whl (14.4MB) 
      |████████████████████████████████| 14.4MB 2.8MB/s

pandas

pip install pandas

Chúng tôi có thể thấy phản hồi sau đây,

Collecting pandas 
   Downloading 
https://files.pythonhosted.org/packages/cf/a4/d5387a74204542a60ad1baa84cd2d3353c330e59be8cf2d47c0b11d3cde8/ 
pandas-3.1.1-cp36-cp36m-macosx_10_6_intel.
macosx_10_9_intel.macosx_10_9_x86_64. 
   macosx_10_10_intel.macosx_10_10_x86_64.whl (14.4MB) 
      |████████████████████████████████| 14.4MB 2.8MB/s

matplotlib

pip install matplotlib

Chúng tôi có thể thấy phản hồi sau đây,

Collecting matplotlib 
   Downloading 
https://files.pythonhosted.org/packages/cf/a4/d5387a74204542a60ad1baa84cd2d3353c330e59be8cf2d47c0b11d3cde8/ 
matplotlib-3.1.1-cp36-cp36m-macosx_10_6_intel.
macosx_10_9_intel.macosx_10_9_x86_64. 
   macosx_10_10_intel.macosx_10_10_x86_64.whl (14.4MB) 
      |████████████████████████████████| 14.4MB 2.8MB/s

scipy

pip install scipy

Chúng tôi có thể thấy phản hồi sau đây,

Collecting scipy 
   Downloading 
https://files.pythonhosted.org/packages/cf/a4/d5387a74204542a60ad1baa84cd2d3353c330e59be8cf2d47c0b11d3cde8 
/scipy-3.1.1-cp36-cp36m-macosx_10_6_intel.
macosx_10_9_intel.macosx_10_9_x86_64. 
   macosx_10_10_intel.macosx_10_10_x86_64.whl (14.4MB) 
      |████████████████████████████████| 14.4MB 2.8MB/s

scikit-learn

Nó là một thư viện máy học mã nguồn mở. Nó được sử dụng cho các thuật toán phân loại, hồi quy và phân cụm. Trước khi chuyển sang cài đặt, nó yêu cầu những điều sau:

  • Phiên bản Python 3.5 trở lên
  • NumPy phiên bản 1.11.0 trở lên
  • Phiên bản SciPy 0.17.0 trở lên
  • joblib 0,11 hoặc cao hơn.

Bây giờ, chúng ta cài đặt scikit-learning bằng lệnh dưới đây:

pip install -U scikit-learn

Seaborn

Seaborn là một thư viện tuyệt vời cho phép bạn dễ dàng hình dung dữ liệu của mình. Sử dụng lệnh dưới đây để cài đặt -

pip pip install seaborninstall -U scikit-learn

Bạn có thể thấy thông báo tương tự như được chỉ định bên dưới -

Collecting seaborn 
   Downloading 
https://files.pythonhosted.org/packages/a8/76/220ba4420459d9c4c9c9587c6ce607bf56c25b3d3d2de62056efe482dadc 
/seaborn-0.9.0-py3-none-any.whl (208kB) 100% 
   |████████████████████████████████| 215kB 4.0MB/s 
Requirement already satisfied: numpy> = 1.9.3 in 
./lib/python3.7/site-packages (from seaborn) (1.17.0) 
Collecting pandas> = 0.15.2 (from seaborn) 
   Downloading 
https://files.pythonhosted.org/packages/39/b7/441375a152f3f9929ff8bc2915218ff1a063a59d7137ae0546db616749f9/ 
pandas-0.25.0-cp37-cp37m-macosx_10_9_x86_64.
macosx_10_10_x86_64.whl (10.1MB) 100% 
   |████████████████████████████████| 10.1MB 1.8MB/s 
Requirement already satisfied: scipy>=0.14.0 in 
./lib/python3.7/site-packages (from seaborn) (1.3.0) 
Collecting matplotlib> = 1.4.3 (from seaborn) 
   Downloading 
https://files.pythonhosted.org/packages/c3/8b/af9e0984f
5c0df06d3fab0bf396eb09cbf05f8452de4e9502b182f59c33b/ 
matplotlib-3.1.1-cp37-cp37m-macosx_10_6_intel.
macosx_10_9_intel.macosx_10_9_x86_64 
.macosx_10_10_intel.macosx_10_10_x86_64.whl (14.4MB) 100% 
   |████████████████████████████████| 14.4MB 1.4MB/s 
...................................... 
...................................... 
Successfully installed cycler-0.10.0 kiwisolver-1.1.0 
matplotlib-3.1.1 pandas-0.25.0 pyparsing-2.4.2 
python-dateutil-2.8.0 pytz-2019.2 seaborn-0.9.0

Cài đặt Keras bằng Python

Hiện tại, chúng tôi đã hoàn thành các yêu cầu cơ bản để cài đặt Kera. Bây giờ, cài đặt Keras bằng quy trình tương tự như được chỉ định bên dưới:

pip install keras

Thoát khỏi môi trường ảo

Sau khi hoàn thành tất cả các thay đổi trong dự án của bạn, sau đó chỉ cần chạy lệnh dưới đây để thoát khỏi môi trường -

deactivate

Đám mây Anaconda

Chúng tôi tin rằng bạn đã cài đặt đám mây anaconda trên máy của mình. Nếu anaconda chưa được cài đặt, hãy truy cập liên kết chính thức, www.anaconda.com/distribution và chọn tải xuống dựa trên hệ điều hành của bạn.

Tạo một môi trường chung cư mới

Khởi chạy lời nhắc anaconda, điều này sẽ mở môi trường Anaconda cơ sở. Hãy để chúng tôi tạo ra một môi trường chung cư mới. Quá trình này tương tự như virtualenv. Nhập lệnh dưới đây vào thiết bị đầu cuối chung cư của bạn -

conda create --name PythonCPU

Nếu muốn, bạn cũng có thể tạo và cài đặt các mô-đun bằng GPU. Trong hướng dẫn này, chúng tôi làm theo hướng dẫn của CPU.

Kích hoạt môi trường chung cư

Để kích hoạt môi trường, hãy sử dụng lệnh dưới đây:

activate PythonCPU

Cài đặt spyder

Spyder là một IDE để thực thi các ứng dụng python. Hãy để chúng tôi cài đặt IDE này trong môi trường chung cư của chúng tôi bằng cách sử dụng lệnh dưới đây:

conda install spyder

Cài đặt thư viện python

Chúng ta đã biết các thư viện python numpy, pandas, v.v., cần thiết cho keras. Bạn có thể cài đặt tất cả các mô-đun bằng cách sử dụng cú pháp dưới đây:

Syntax

conda install -c anaconda <module-name>

Ví dụ: bạn muốn cài đặt gấu trúc -

conda install -c anaconda pandas

Giống như phương pháp tương tự, hãy thử tự mình cài đặt các mô-đun còn lại.

Cài đặt Keras

Bây giờ, mọi thứ đã ổn nên bạn có thể bắt đầu cài đặt keras bằng lệnh dưới đây:

conda install -c anaconda keras

Khởi chạy spyder

Cuối cùng, khởi chạy spyder trong thiết bị đầu cuối chung cư của bạn bằng lệnh dưới đây:

spyder

Để đảm bảo mọi thứ đã được cài đặt chính xác, hãy nhập tất cả các mô-đun, nó sẽ thêm mọi thứ và nếu có gì sai, bạn sẽ nhận được module not found thông báo lỗi.

Keras - Cấu hình phụ trợ

Chương này giải thích chi tiết việc triển khai chương trình phụ trợ Keras TensorFlow và Theano. Hãy để chúng tôi đi qua từng triển khai một.

TensorFlow

TensorFlow là một thư viện máy học mã nguồn mở được sử dụng cho các tác vụ tính toán số do Google phát triển. Keras là một API cấp cao được xây dựng trên TensorFlow hoặc Theano. Chúng tôi đã biết cách cài đặt TensorFlow bằng pip.

Nếu nó chưa được cài đặt, bạn có thể cài đặt bằng lệnh dưới đây:

pip install TensorFlow

Khi chúng tôi thực thi keras, chúng tôi có thể thấy tệp cấu hình nằm trong thư mục chính của bạn bên trong và truy cập .keras / keras.json.

keras.json

{ 
   "image_data_format": "channels_last", 
   "epsilon": 1e-07, "floatx": "float32", "backend": "tensorflow" 
}

Đây,

  • image_data_format đại diện cho định dạng dữ liệu.

  • epsilonđại diện cho hằng số. Nó được sử dụng để tránhDivideByZero lỗi.

  • floatx đại diện cho kiểu dữ liệu mặc định float32. Bạn cũng có thể thay đổi nó thànhfloat16 hoặc là float64 sử dụng set_floatx() phương pháp.

  • image_data_format đại diện cho định dạng dữ liệu.

Giả sử, nếu tệp không được tạo thì hãy di chuyển đến vị trí và tạo bằng các bước dưới đây:

> cd home 
> mkdir .keras 
> vi keras.json

Hãy nhớ rằng, bạn nên chỉ định .keras làm tên thư mục của nó và thêm cấu hình ở trên vào bên trong tệp keras.json. Chúng ta có thể thực hiện một số thao tác được xác định trước để biết các chức năng phụ trợ.

Theano

Theano là một thư viện học sâu mã nguồn mở cho phép bạn đánh giá các mảng đa chiều một cách hiệu quả. Chúng ta có thể dễ dàng cài đặt bằng lệnh dưới đây:

pip install theano

Theo mặc định, keras sử dụng phần phụ trợ TensorFlow. Nếu bạn muốn thay đổi cấu hình backend từ TensorFlow thành Theano, chỉ cần thay đổi backend = theano trong tệp keras.json. Nó được mô tả dưới đây -

keras.json

{ 
   "image_data_format": "channels_last", 
   "epsilon": 1e-07, 
   "floatx": "float32", 
   "backend": "theano" 
}

Bây giờ hãy lưu tệp của bạn, khởi động lại thiết bị đầu cuối của bạn và bắt đầu keras, phần phụ trợ của bạn sẽ được thay đổi.

>>> import keras as k 
using theano backend.

Keras - Tổng quan về Học sâu

Học sâu là một lĩnh vực con đang phát triển của học máy. Học sâu liên quan đến việc phân tích đầu vào theo cách từng lớp, trong đó mỗi lớp dần dần trích xuất thông tin cấp cao hơn về đầu vào.

Chúng ta hãy xem một kịch bản đơn giản về phân tích một hình ảnh. Giả sử rằng hình ảnh đầu vào của bạn được chia thành một lưới pixel hình chữ nhật. Bây giờ, lớp đầu tiên tóm tắt các pixel. Lớp thứ hai hiểu các cạnh trong hình ảnh. Lớp Tiếp theo xây dựng các nút từ các cạnh. Sau đó, tiếp theo sẽ tìm các nhánh từ các nút. Cuối cùng, lớp đầu ra sẽ phát hiện đối tượng đầy đủ. Ở đây, quá trình trích xuất đặc trưng đi từ đầu ra của một lớp thành đầu vào của lớp tiếp theo tiếp theo.

Bằng cách sử dụng phương pháp này, chúng tôi có thể xử lý một lượng lớn các tính năng, điều này làm cho học sâu trở thành một công cụ rất mạnh mẽ. Các thuật toán học sâu cũng hữu ích cho việc phân tích dữ liệu phi cấu trúc. Chúng ta hãy cùng tìm hiểu những kiến ​​thức cơ bản về học sâu trong chương này.

Mạng lưới thần kinh nhân tạo

Cách tiếp cận chính và phổ biến nhất của học sâu là sử dụng “Mạng nơ-ron nhân tạo” (ANN). Chúng được lấy cảm hứng từ mô hình não người, là cơ quan phức tạp nhất của cơ thể chúng ta. Bộ não con người được tạo thành từ hơn 90 tỷ tế bào nhỏ gọi là “Tế bào thần kinh”. Các tế bào thần kinh được kết nối với nhau thông qua sợi thần kinh được gọi là "sợi trục" và "đuôi gai". Vai trò chính của sợi trục là truyền thông tin từ tế bào thần kinh này sang tế bào thần kinh khác mà nó được kết nối.

Tương tự, vai trò chính của đuôi gai là nhận thông tin được truyền bởi các sợi trục của một tế bào thần kinh khác mà nó được kết nối. Mỗi nơ-ron xử lý một thông tin nhỏ sau đó chuyển kết quả cho một nơ-ron khác và quá trình này tiếp tục. Đây là phương pháp cơ bản được bộ não con người sử dụng để xử lý lượng lớn thông tin như giọng nói, hình ảnh, v.v. và trích xuất thông tin hữu ích từ đó.

Dựa trên mô hình này, Mạng thần kinh nhân tạo (ANN) đầu tiên được phát minh bởi nhà tâm lý học Frank Rosenblatt, vào năm 1958. ANN được tạo thành từ nhiều nút tương tự như tế bào thần kinh. Các nút liên kết chặt chẽ với nhau và được tổ chức thành các lớp ẩn khác nhau. Lớp đầu vào nhận dữ liệu đầu vào và dữ liệu đi qua một hoặc nhiều lớp ẩn tuần tự và cuối cùng là lớp đầu ra dự đoán điều gì đó hữu ích về dữ liệu đầu vào. Ví dụ: đầu vào có thể là một hình ảnh và đầu ra có thể là thứ được xác định trong hình ảnh, chẳng hạn như “Cat”.

Một nơron đơn lẻ (được gọi là perceptron trong ANN) có thể được biểu diễn như sau:

Đây,

  • Nhiều đầu vào cùng với trọng lượng đại diện cho đuôi gai.

  • Tổng đầu vào cùng với chức năng kích hoạt đại diện cho các nơ-ron. Sum thực sự có nghĩa là giá trị được tính toán của tất cả các đầu vào và hàm kích hoạt đại diện cho một hàm, nó sửa đổi Sum giá trị thành 0, 1 hoặc 0 thành 1.

  • Đầu ra thực tế đại diện cho sợi trục và đầu ra sẽ được nhận bởi nơron ở lớp tiếp theo.

Hãy để chúng tôi hiểu các loại mạng nơ-ron nhân tạo khác nhau trong phần này.

Perceptron nhiều lớp

Perceptron nhiều lớp là dạng ANN đơn giản nhất. Nó bao gồm một lớp đầu vào duy nhất, một hoặc nhiều lớp ẩn và cuối cùng là lớp đầu ra. Một lớp bao gồm một tập hợp các perceptron. Lớp đầu vào về cơ bản là một hoặc nhiều tính năng của dữ liệu đầu vào. Mỗi lớp ẩn bao gồm một hoặc nhiều nơ-ron và xử lý một số khía cạnh nhất định của tính năng và gửi thông tin đã xử lý vào lớp ẩn tiếp theo. Quá trình lớp đầu ra nhận dữ liệu từ lớp ẩn cuối cùng và cuối cùng xuất ra kết quả.

Mạng thần kinh hợp hiến (CNN)

Mạng nơron chuyển đổi là một trong những ANN phổ biến nhất. Nó được sử dụng rộng rãi trong các lĩnh vực nhận dạng hình ảnh và video. Nó dựa trên khái niệm tích chập, một khái niệm toán học. Nó gần giống với perceptron nhiều lớp ngoại trừ nó chứa một loạt lớp chập và lớp gộp trước lớp nơron ẩn được kết nối đầy đủ. Nó có ba lớp quan trọng -

  • Convolution layer - Nó là khối xây dựng chính và thực hiện các tác vụ tính toán dựa trên hàm tích chập.

  • Pooling layer - Nó được sắp xếp bên cạnh lớp tích chập và được sử dụng để giảm kích thước đầu vào bằng cách loại bỏ thông tin không cần thiết để việc tính toán có thể được thực hiện nhanh hơn.

  • Fully connected layer - Nó được sắp xếp bên cạnh lớp chập và lớp gộp và phân loại đầu vào thành nhiều loại khác nhau.

Một CNN đơn giản có thể được trình bày như sau:

Đây,

  • 2 dãy Convolution và lớp gộp được sử dụng và nó nhận và xử lý đầu vào (ví dụ hình ảnh).

  • Một lớp được kết nối đầy đủ duy nhất được sử dụng và nó được dùng để xuất dữ liệu (ví dụ: phân loại hình ảnh)

Mạng thần kinh tái diễn (RNN)

Mạng thần kinh tái diễn (RNN) rất hữu ích để giải quyết lỗ hổng trong các mô hình ANN khác. Hầu hết ANN không nhớ các bước từ các tình huống trước đó và học cách đưa ra quyết định dựa trên ngữ cảnh trong quá trình đào tạo. Trong khi đó, RNN lưu trữ thông tin quá khứ và tất cả các quyết định của nó được thực hiện từ những gì nó đã học được từ quá khứ.

Cách tiếp cận này chủ yếu hữu ích trong phân loại ảnh. Đôi khi, chúng ta có thể cần nhìn vào tương lai để sửa chữa quá khứ. Trong trường hợp này, RNN hai chiều rất hữu ích để học hỏi từ quá khứ và dự đoán tương lai. Ví dụ: chúng tôi có các mẫu viết tay trong nhiều đầu vào. Giả sử, chúng ta có sự nhầm lẫn trong một đầu vào thì chúng ta cần kiểm tra lại các đầu vào khác để nhận ra bối cảnh chính xác đưa ra quyết định từ quá khứ.

Quy trình làm việc của ANN

Trước tiên, chúng ta hãy hiểu các giai đoạn khác nhau của học sâu và sau đó, tìm hiểu cách Keras giúp đỡ trong quá trình học sâu.

Thu thập dữ liệu cần thiết

Học sâu đòi hỏi nhiều dữ liệu đầu vào để học thành công và dự đoán kết quả. Vì vậy, trước tiên hãy thu thập càng nhiều dữ liệu càng tốt.

Phân tích dữ liệu

Phân tích dữ liệu và hiểu rõ về dữ liệu. Cần hiểu rõ hơn về dữ liệu để chọn thuật toán ANN chính xác.

Chọn một thuật toán (mô hình)

Chọn một thuật toán phù hợp nhất với loại quy trình học tập (ví dụ: phân loại hình ảnh, xử lý văn bản, v.v.) và dữ liệu đầu vào có sẵn. Thuật toán được đại diện bởiModelở Keras. Thuật toán bao gồm một hoặc nhiều lớp. Mỗi lớp trong ANN có thể được biểu diễn bằngKeras Layer ở Keras.

  • Prepare data - Xử lý, lọc và chỉ chọn thông tin cần thiết từ dữ liệu.

  • Split data- Tách dữ liệu thành tập dữ liệu huấn luyện và kiểm tra. Dữ liệu kiểm tra sẽ được sử dụng để đánh giá dự đoán của thuật toán / Mô hình (khi máy học) và kiểm tra chéo hiệu quả của quá trình học.

  • Compile the model- Biên dịch thuật toán / mô hình để có thể sử dụng nó để học thêm bằng cách đào tạo và cuối cùng là dự đoán. Bước này yêu cầu chúng ta chọn chức năng mất mát và Trình tối ưu hóa. Chức năng mất mát và Trình tối ưu hóa được sử dụng trong giai đoạn học để tìm ra lỗi (độ lệch so với kết quả thực tế) và thực hiện tối ưu hóa để lỗi sẽ được giảm thiểu.

  • Fit the model - Quá trình học tập thực tế sẽ được thực hiện trong giai đoạn này bằng cách sử dụng tập dữ liệu đào tạo.

  • Predict result for unknown value - Dự đoán đầu ra cho dữ liệu đầu vào chưa biết (ngoài dữ liệu đào tạo và kiểm tra hiện có)

  • Evaluate model - Đánh giá mô hình bằng cách dự đoán kết quả đầu ra cho dữ liệu thử nghiệm và so sánh chéo dự đoán với kết quả thực tế của dữ liệu thử nghiệm.

  • Freeze, Modify or choose new algorithm- Kiểm tra việc đánh giá mô hình có thành công hay không. Nếu có, hãy lưu thuật toán cho mục đích dự đoán trong tương lai. Nếu không, sau đó sửa đổi hoặc chọn thuật toán / mô hình mới và cuối cùng, một lần nữa đào tạo, dự đoán và đánh giá mô hình. Lặp lại quy trình cho đến khi tìm được thuật toán (mô hình) tốt nhất.

Các bước trên có thể được trình bày bằng cách sử dụng biểu đồ bên dưới:

Keras - Học sâu

Keras cung cấp một khung hoàn chỉnh để tạo bất kỳ loại mạng nơron nào. Keras rất sáng tạo cũng như rất dễ học. Nó hỗ trợ mô hình mạng nơ ron đơn giản đến mô hình mạng nơ ron rất lớn và phức tạp. Hãy để chúng tôi hiểu kiến ​​trúc của khung Keras và cách Keras giúp học sâu trong chương này.

Kiến trúc của Keras

API Keras có thể được chia thành ba loại chính:

  • Model
  • Layer
  • Mô-đun cốt lõi

Trong Keras, mọi ANN được đại diện bởi Keras Models. Đổi lại, mọi Mô hình Keras đều là thành phần củaKeras Layers và đại diện cho các lớp ANN như đầu vào, lớp ẩn, lớp đầu ra, lớp tích chập, lớp tổng hợp, v.v., mô hình Keras và quyền truy cập lớp Keras modules cho chức năng kích hoạt, chức năng mất, chức năng điều chỉnh, v.v., Sử dụng mô hình Keras, Lớp Keras và mô-đun Keras, bất kỳ thuật toán ANN nào (CNN, RNN, v.v.) đều có thể được biểu diễn một cách đơn giản và hiệu quả.

Sơ đồ sau mô tả mối quan hệ giữa mô hình, lớp và mô-đun lõi:

Chúng ta hãy xem tổng quan về mô hình Keras, lớp Keras và mô-đun Keras.

Mô hình

Mô hình Keras có hai loại như được đề cập bên dưới -

Sequential Model- Mô hình tuần tự về cơ bản là một thành phần tuyến tính của các Lớp Keras. Mô hình tuần tự rất dễ dàng, tối thiểu cũng như có khả năng biểu diễn gần như tất cả các mạng nơ-ron có sẵn.

Một mô hình tuần tự đơn giản như sau:

from keras.models import Sequential 
from keras.layers import Dense, Activation 
model = Sequential()  
model.add(Dense(512, activation = 'relu', input_shape = (784,)))

Ở đâu,

  • Line 1 nhập khẩu Sequential mô hình từ các mô hình Keras

  • Line 2 nhập khẩu Dense lớp và Activation mô-đun

  • Line 4 tạo một mô hình tuần tự mới bằng cách sử dụng Sequential API

  • Line 5 thêm một lớp dày đặc (API dày đặc) với relu chức năng kích hoạt (sử dụng mô-đun Kích hoạt).

Sequential mô hình lộ ra Modellớp để tạo ra các mô hình tùy chỉnh. Chúng ta có thể sử dụng khái niệm phân loại con để tạo mô hình phức tạp của riêng mình.

Functional API - Hàm API về cơ bản được sử dụng để tạo các mô hình phức tạp.

Lớp

Mỗi lớp Keras trong mô hình Keras đại diện cho lớp tương ứng (lớp đầu vào, lớp ẩn và lớp đầu ra) trong mô hình mạng nơ ron được đề xuất thực tế. Keras cung cấp rất nhiều lớp tiền xây dựng để có thể dễ dàng tạo ra bất kỳ mạng nơ-ron phức tạp nào. Một số lớp Keras quan trọng được chỉ định bên dưới,

  • Lớp lõi
  • Lớp chuyển đổi
  • Nhóm các lớp
  • Lớp lặp lại

Một mã python đơn giản để đại diện cho mô hình mạng thần kinh bằng cách sử dụng sequential mô hình như sau -

from keras.models import Sequential 
from keras.layers import Dense, Activation, Dropout model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,))) 
model.add(Dropout(0.2)) 
model.add(Dense(512, activation = 'relu')) model.add(Dropout(0.2)) 
model.add(Dense(num_classes, activation = 'softmax'))

Ở đâu,

  • Line 1 nhập khẩu Sequential mô hình từ các mô hình Keras

  • Line 2 nhập khẩu Dense lớp và Activation mô-đun

  • Line 4 tạo một mô hình tuần tự mới bằng cách sử dụng Sequential API

  • Line 5 thêm một lớp dày đặc (API dày đặc) với relu chức năng kích hoạt (sử dụng mô-đun Kích hoạt).

  • Line 6 thêm một lớp bỏ qua (API Dropout) để xử lý quá phù hợp.

  • Line 7 thêm một lớp dày đặc khác (API dày đặc) với relu chức năng kích hoạt (sử dụng mô-đun Kích hoạt).

  • Line 8 thêm một lớp bỏ qua khác (API Dropout) để xử lý việc lắp quá mức.

  • Line 9 thêm lớp dày đặc cuối cùng (API dày đặc) với softmax chức năng kích hoạt (sử dụng mô-đun Kích hoạt).

Keras cũng cung cấp các tùy chọn để tạo các lớp tùy chỉnh của riêng chúng tôi. Lớp tùy chỉnh có thể được tạo bằng cách phân lớp phụKeras.Layer và nó tương tự như các mô hình Keras phân lớp phụ.

Mô-đun cốt lõi

Keras cũng cung cấp rất nhiều chức năng liên quan đến mạng nơ-ron tích hợp sẵn để tạo đúng mô hình Keras và các lớp Keras. Một số chức năng như sau:

  • Activations module - Chức năng kích hoạt là một khái niệm quan trọng trong ANN và các mô-đun kích hoạt cung cấp nhiều chức năng kích hoạt như softmax, relu, v.v.

  • Loss module - Mô-đun tổn thất cung cấp các chức năng tổn thất như mean_squared_error, mean_absolute_error, poisson, v.v.,

  • Optimizer module - Mô-đun trình tối ưu hóa cung cấp chức năng trình tối ưu hóa như adam, sgd, v.v.,

  • Regularizers - Mô-đun bộ điều chỉnh cung cấp các chức năng như bộ điều chỉnh L1, bộ điều chỉnh L2, v.v.,

Hãy cùng chúng tôi tìm hiểu chi tiết các mô-đun Keras trong chương sắp tới.

Keras - Mô-đun

Như chúng ta đã học trước đó, mô-đun Keras chứa các lớp, hàm và biến được xác định trước rất hữu ích cho thuật toán học sâu. Chúng ta hãy tìm hiểu các mô-đun do Keras cung cấp trong chương này.

Các mô-đun có sẵn

Đầu tiên chúng ta hãy xem danh sách các mô-đun có sẵn trong Keras.

  • Initializers- Cung cấp danh sách các chức năng khởi tạo. Chúng ta có thể tìm hiểu nó một cách chi tiết trong chương lớp Keras . trong giai đoạn tạo mô hình của học máy.

  • Regularizers- Cung cấp một danh sách các chức năng điều tiết. Chúng ta có thể tìm hiểu chi tiết trong chương Keras Layers .

  • Constraints- Cung cấp danh sách các ràng buộc chức năng. Chúng ta có thể tìm hiểu chi tiết trong chương Keras Layers .

  • Activations- Cung cấp danh sách các chức năng kích hoạt. Chúng ta có thể tìm hiểu chi tiết trong chương Keras Layers .

  • Losses- Cung cấp danh sách các chức năng mất mát. Chúng ta có thể tìm hiểu chi tiết trong chương Huấn luyện mô hình .

  • Metrics- Cung cấp danh sách chức năng đo lường. Chúng ta có thể tìm hiểu chi tiết trong chương Huấn luyện mô hình .

  • Optimizers- Cung cấp danh sách các chức năng tối ưu hóa. Chúng ta có thể tìm hiểu chi tiết trong chương Huấn luyện mô hình .

  • Callback- Cung cấp danh sách các chức năng gọi lại. Chúng tôi có thể sử dụng nó trong quá trình đào tạo để in dữ liệu trung gian cũng như để dừng đào tạo chính nó (EarlyStopping phương pháp) dựa trên một số điều kiện.

  • Text processing- Cung cấp các chức năng chuyển đổi văn bản thành mảng NumPy phù hợp với học máy. Chúng ta có thể sử dụng nó trong giai đoạn chuẩn bị dữ liệu của máy học.

  • Image processing- Cung cấp các chức năng chuyển đổi hình ảnh thành mảng NumPy phù hợp với học máy. Chúng ta có thể sử dụng nó trong giai đoạn chuẩn bị dữ liệu của máy học.

  • Sequence processing- Cung cấp các chức năng tạo dữ liệu theo thời gian từ dữ liệu đầu vào đã cho. Chúng ta có thể sử dụng nó trong giai đoạn chuẩn bị dữ liệu của máy học.

  • Backend- Cung cấp chức năng của thư viện phụ trợ như TensorFlowTheano .

  • Utilities - Cung cấp nhiều chức năng tiện ích hữu ích trong học sâu.

Để xem nào backend mô-đun và utils mô hình trong chương này.

mô-đun phụ trợ

backend moduleđược sử dụng cho các hoạt động phụ trợ keras. Theo mặc định, keras chạy trên phần phụ trợ TensorFlow. Nếu muốn, bạn có thể chuyển sang các chương trình phụ trợ khác như Theano hoặc CNTK. Cấu hình phụ trợ Defualt được xác định bên trong thư mục gốc của bạn dưới tệp .keras / keras.json.

Mô-đun phụ trợ Keras có thể được nhập bằng mã bên dưới

>>> from keras import backend as k

Nếu chúng ta đang sử dụng TensorFlow phụ trợ mặc định , thì hàm dưới đây trả về thông tin dựa trên TensorFlow như được chỉ định bên dưới:

>>> k.backend() 
'tensorflow'
>>> k.epsilon() 
1e-07
>>> k.image_data_format() 
'channels_last'
>>> k.floatx() 
'float32'

Hãy cho chúng tôi hiểu ngắn gọn một số hàm phụ trợ quan trọng được sử dụng để phân tích dữ liệu -

get_uid ()

Nó là định danh cho đồ thị mặc định. Nó được định nghĩa dưới đây -

>>> k.get_uid(prefix='') 
1 
>>> k.get_uid(prefix='') 2

reset_uids

Nó được sử dụng để đặt lại giá trị uid.

>>> k.reset_uids()

Bây giờ, một lần nữa thực thi get_uid () . Điều này sẽ được đặt lại và thay đổi lại thành 1.

>>> k.get_uid(prefix='') 
1

giữ chỗ

Nó được sử dụng để khởi tạo một tensor trình giữ chỗ. Trình giữ chỗ đơn giản để giữ hình dạng 3-D được hiển thị bên dưới -

>>> data = k.placeholder(shape = (1,3,3)) 
>>> data 
<tf.Tensor 'Placeholder_9:0' shape = (1, 3, 3) dtype = float32> 
If you use int_shape(), it will show the shape. 
>>> k.int_shape(data) (1, 3, 3)

dấu chấm

Nó được sử dụng để nhân hai tenxơ. Coi a và b là hai chục và c sẽ là kết quả của phép nhân của ab. Giả sử hình dạng là (4,2) và hình dạng b là (2,3). Nó được định nghĩa dưới đây,

>>> a = k.placeholder(shape = (4,2)) 
>>> b = k.placeholder(shape = (2,3)) 
>>> c = k.dot(a,b) 
>>> c 
<tf.Tensor 'MatMul_3:0' shape = (4, 3) dtype = float32> 
>>>

những cái

Nó được sử dụng để khởi tạo tất cả dưới dạng one giá trị.

>>> res = k.ones(shape = (2,2)) 
#print the value 
>>> k.eval(res) 
array([[1., 1.], [1., 1.]], dtype = float32)

batch_dot

Nó được sử dụng để thực hiện tích của hai dữ liệu theo lô. Kích thước đầu vào phải từ 2 trở lên. Nó được hiển thị bên dưới -

>>> a_batch = k.ones(shape = (2,3)) 
>>> b_batch = k.ones(shape = (3,2)) 
>>> c_batch = k.batch_dot(a_batch,b_batch) 
>>> c_batch 
<tf.Tensor 'ExpandDims:0' shape = (2, 1) dtype = float32>

Biến đổi

Nó được sử dụng để khởi tạo một biến. Hãy để chúng tôi thực hiện thao tác chuyển vị đơn giản trong biến này.

>>> data = k.variable([[10,20,30,40],[50,60,70,80]]) 
#variable initialized here 
>>> result = k.transpose(data) 
>>> print(result) 
Tensor("transpose_6:0", shape = (4, 2), dtype = float32) 
>>> print(k.eval(result)) 
   [[10. 50.] 
   [20. 60.] 
   [30. 70.] 
   [40. 80.]]

Nếu bạn muốn truy cập từ numpy -

>>> data = np.array([[10,20,30,40],[50,60,70,80]]) 
>>> print(np.transpose(data)) 
   [[10 50] 
   [20 60] 
   [30 70] 
   [40 80]] 
>>> res = k.variable(value = data) 
>>> print(res) 
<tf.Variable 'Variable_7:0' shape = (2, 4) dtype = float32_ref>

is_sparse (tensor)

Nó được sử dụng để kiểm tra xem tensor có bị thưa hay không.

>>> a = k.placeholder((2, 2), sparse=True) 
>>> print(a) SparseTensor(indices =       
   Tensor("Placeholder_8:0", 
   shape = (?, 2), dtype = int64), 
values = Tensor("Placeholder_7:0", shape = (?,), 
dtype = float32), dense_shape = Tensor("Const:0", shape = (2,), dtype = int64)) 
>>> print(k.is_sparse(a)) True

to_dense ()

Nó được sử dụng để chuyển thưa thớt thành dày đặc.

>>> b = k.to_dense(a) 
>>> print(b) Tensor("SparseToDense:0", shape = (2, 2), dtype = float32) 
>>> print(k.is_sparse(b)) False

random_uniform_variable

Nó được sử dụng để khởi tạo bằng cách sử dụng uniform distribution Ý tưởng.

k.random_uniform_variable(shape, mean, scale)

Đây,

  • shape - biểu thị các hàng và cột ở định dạng bộ giá trị.

  • mean - trung bình của phân phối đồng đều.

  • scale - độ lệch chuẩn của phân bố đồng đều.

Hãy để chúng tôi xem xét cách sử dụng ví dụ dưới đây -

>>> a = k.random_uniform_variable(shape = (2, 3), low=0, high = 1) 
>>> b = k. random_uniform_variable(shape = (3,2), low = 0, high = 1) 
>>> c = k.dot(a, b) 
>>> k.int_shape(c) 
(2, 2)

mô-đun utils

utilscung cấp chức năng tiện ích hữu ích cho học sâu. Một số phương pháp được cung cấp bởiutils mô-đun như sau:

HDF5Matrix

Nó được sử dụng để biểu diễn dữ liệu đầu vào ở định dạng HDF5.

from keras.utils import HDF5Matrix data = HDF5Matrix('data.hdf5', 'data')

to_categorical

Nó được sử dụng để chuyển đổi vector lớp thành ma trận lớp nhị phân.

>>> from keras.utils import to_categorical 
>>> labels = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
>>> to_categorical(labels) 
array([[1., 0., 0., 0., 0., 0., 0., 0., 0., 0.], 
   [0., 1., 0., 0., 0., 0., 0., 0., 0., 0.], 
   [0., 0., 1., 0., 0., 0., 0., 0., 0., 0.], 
   [0., 0., 0., 1., 0., 0., 0., 0., 0., 0.], 
   [0., 0., 0., 0., 1., 0., 0., 0., 0., 0.], 
   [0., 0., 0., 0., 0., 1., 0., 0., 0., 0.], 
   [0., 0., 0., 0., 0., 0., 1., 0., 0., 0.], 
   [0., 0., 0., 0., 0., 0., 0., 1., 0., 0.], 
   [0., 0., 0., 0., 0., 0., 0., 0., 1., 0.], 
   [0., 0., 0., 0., 0., 0., 0., 0., 0., 1.]], dtype = float32)
>>> from keras.utils import normalize 
>>> normalize([1, 2, 3, 4, 5]) 
array([[0.13483997, 0.26967994, 0.40451992, 0.53935989, 0.67419986]])

print_summary

Nó được sử dụng để in tóm tắt của mô hình.

from keras.utils import print_summary print_summary(model)

plot_model

Nó được sử dụng để tạo biểu diễn mô hình ở định dạng dấu chấm và lưu vào tệp.

from keras.utils import plot_model 
plot_model(model,to_file = 'image.png')

Điều này plot_model sẽ tạo ra một hình ảnh để hiểu hiệu suất của mô hình.

Keras - Lớp

Như đã học trước đó, các lớp Keras là khối xây dựng chính của các mô hình Keras. Mỗi lớp nhận thông tin đầu vào, thực hiện một số tính toán và cuối cùng xuất ra thông tin đã được biến đổi. Đầu ra của một lớp sẽ chảy vào lớp tiếp theo làm đầu vào của nó. Hãy để chúng tôi tìm hiểu chi tiết đầy đủ về các lớp trong chương này.

Giới thiệu

Một lớp Keras yêu cầu shape of the input (input_shape) để hiểu cấu trúc của dữ liệu đầu vào, initializerđể thiết lập trọng số cho mỗi đầu vào và cuối cùng là các chất kích hoạt để biến đổi đầu ra thành phi tuyến tính. Ở giữa, các ràng buộc hạn chế và chỉ định phạm vi mà trọng số của dữ liệu đầu vào sẽ được tạo ra và bộ điều chỉnh sẽ cố gắng tối ưu hóa lớp (và mô hình) bằng cách áp dụng động các hình phạt đối với các trọng số trong quá trình tối ưu hóa.

Tóm lại, lớp Keras yêu cầu các chi tiết tối thiểu dưới đây để tạo một lớp hoàn chỉnh.

  • Hình dạng của dữ liệu đầu vào
  • Số lượng tế bào thần kinh / đơn vị trong lớp
  • Initializers
  • Regularizers
  • Constraints
  • Activations

Hãy để chúng tôi hiểu khái niệm cơ bản trong chương tiếp theo. Trước khi hiểu khái niệm cơ bản, chúng ta hãy tạo một lớp Keras đơn giản bằng cách sử dụng API mô hình tuần tự để có ý tưởng về cách hoạt động của mô hình và lớp Keras.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
from keras import regularizers 
from keras import constraints 
model = Sequential() 
model.add(Dense(32, input_shape=(16,), kernel_initializer = 'he_uniform', 
   kernel_regularizer = None, kernel_constraint = 'MaxNorm', activation = 'relu')) 
model.add(Dense(16, activation = 'relu')) 
model.add(Dense(8))

Ở đâu,

  • Line 1-5 nhập các mô-đun cần thiết.

  • Line 7 tạo một mô hình mới bằng cách sử dụng API tuần tự.

  • Line 9 tạo ra một cái mới Dense lớp và thêm nó vào mô hình. Denselà một lớp mức đầu vào do Keras cung cấp, lớp này chấp nhận số lượng nơ-ron hoặc đơn vị (32) làm tham số bắt buộc của nó. Nếu lớp là lớp đầu tiên, thì chúng ta cần cung cấpInput Shape, (16,)cũng. Nếu không, đầu ra của lớp trước sẽ được sử dụng làm đầu vào của lớp tiếp theo. Tất cả các thông số khác là tùy chọn.

    • Tham số đầu tiên đại diện cho số lượng đơn vị (nơ-ron).

    • input_shape biểu diễn hình dạng của dữ liệu đầu vào.

    • kernel_initializer đại diện cho bộ khởi tạo được sử dụng. he_uniform hàm được đặt dưới dạng giá trị.

    • kernel_regularizer đại diện regularizerđược sử dụng. Không có giá trị nào được đặt làm giá trị.

    • kernel_constraint đại diện cho ràng buộc được sử dụng. MaxNorm hàm được đặt dưới dạng giá trị.

    • activationđại diện cho kích hoạt được sử dụng. hàm relu được đặt thành giá trị.

  • Line 10 tạo thứ hai Dense lớp với 16 đơn vị và thiết lập relu như chức năng kích hoạt.

  • Line 11 tạo lớp Dày cuối cùng với 8 đơn vị.

Khái niệm cơ bản về lớp

Hãy để chúng tôi hiểu khái niệm cơ bản về lớp cũng như cách Keras hỗ trợ từng khái niệm.

Hình dạng đầu vào

Trong học máy, tất cả các loại dữ liệu đầu vào như văn bản, hình ảnh hoặc video sẽ được chuyển đổi đầu tiên thành mảng số và sau đó đưa vào thuật toán. Số đầu vào có thể là mảng một chiều, mảng hai chiều (ma trận) hoặc mảng nhiều chiều. Chúng tôi có thể chỉ định thông tin chiều bằng cách sử dụngshape, một bộ số nguyên. Ví dụ,(4,2) biểu diễn ma trận với bốn hàng và hai cột.

>>> import numpy as np 
>>> shape = (4, 2) 
>>> input = np.zeros(shape) 
>>> print(input) 
[
   [0. 0.] 
   [0. 0.] 
   [0. 0.] 
   [0. 0.]
] 
>>>

Tương tự, (3,4,2) ma trận ba chiều có ba tập hợp ma trận 4x2 (hai hàng và bốn cột).

>>> import numpy as np 
>>> shape = (3, 4, 2) 
>>> input = np.zeros(shape) 
>>> print(input)
[
   [[0. 0.] [0. 0.] [0. 0.] [0. 0.]] 
   [[0. 0.] [0. 0.] [0. 0.] [0. 0.]] 
   [[0. 0.] [0. 0.] [0. 0.] [0. 0.]]
]
>>>

Để tạo lớp đầu tiên của mô hình (hoặc lớp đầu vào của mô hình), hình dạng của dữ liệu đầu vào phải được chỉ định.

Khởi tạo

Trong Học máy, trọng số sẽ được gán cho tất cả dữ liệu đầu vào. Initializersmô-đun cung cấp các chức năng khác nhau để thiết lập các trọng lượng ban đầu này. Một sốKeras Initializer chức năng như sau:

Zeros

Tạo ra 0 cho tất cả dữ liệu đầu vào.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
my_init = initializers.Zeros() 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

Ở đâu, kernel_initializer đại diện cho bộ khởi tạo cho nhân của mô hình.

Ones

Tạo ra 1 cho tất cả dữ liệu đầu vào.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
my_init = initializers.Ones() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

Không thay đổi

Tạo ra một giá trị không đổi (giả sử, 5) do người dùng chỉ định cho tất cả dữ liệu đầu vào.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
my_init = initializers.Constant(value = 0) model.add(
   Dense(512, activation = 'relu', input_shape = (784,), kernel_initializer = my_init)
)

Ở đâu, value đại diện cho giá trị không đổi

Ngẫu nhiên

Tạo ra giá trị bằng cách sử dụng phân phối chuẩn của dữ liệu đầu vào.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
my_init = initializers.RandomNormal(mean=0.0, 
stddev = 0.05, seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

Ở đâu,

  • mean đại diện cho giá trị trung bình của các giá trị ngẫu nhiên để tạo

  • stddev đại diện cho độ lệch chuẩn của các giá trị ngẫu nhiên để tạo ra

  • seed đại diện cho các giá trị để tạo số ngẫu nhiên

RandomUniform

Tạo ra giá trị bằng cách sử dụng phân phối dữ liệu đầu vào đồng nhất.

from keras import initializers 
my_init = initializers.RandomUniform(minval = -0.05, maxval = 0.05, seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

Ở đâu,

  • minval đại diện cho giới hạn dưới của các giá trị ngẫu nhiên để tạo

  • maxval đại diện cho giới hạn trên của các giá trị ngẫu nhiên để tạo

Đã cắt ngắn

Tạo giá trị bằng cách sử dụng phân phối chuẩn bị cắt ngắn của dữ liệu đầu vào.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
my_init = initializers.TruncatedNormal(mean = 0.0, stddev = 0.05, seed = None
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

VarianceScaling

Tạo ra giá trị dựa trên hình dạng đầu vào và hình dạng đầu ra của lớp cùng với tỷ lệ được chỉ định.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
my_init = initializers.VarianceScaling(
   scale = 1.0, mode = 'fan_in', distribution = 'normal', seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   skernel_initializer = my_init))

Ở đâu,

  • scale đại diện cho hệ số tỷ lệ

  • mode đại diện cho bất kỳ một trong số fan_in, fan_outfan_avg giá trị

  • distribution đại diện cho một trong hai normal hoặc là uniform

VarianceScaling

Nó tìm thấy stddev giá trị cho phân phối chuẩn bằng cách sử dụng công thức dưới đây và sau đó tìm trọng số bằng cách sử dụng phân phối chuẩn,

stddev = sqrt(scale / n)

Ở đâu n đại diện,

  • số lượng đơn vị đầu vào cho mode = fan_in

  • số đơn vị ra cho mode = fan_out

  • số lượng đơn vị đầu vào và đầu ra trung bình cho mode = fan_avg

Tương tự, nó tìm giới hạn cho phân phối đồng đều bằng cách sử dụng công thức dưới đây và sau đó tìm trọng số bằng cách sử dụng phân phối đồng đều,

limit = sqrt(3 * scale / n)

lecun_normal

Tạo ra giá trị bằng cách sử dụng phân phối chuẩn lecun của dữ liệu đầu vào.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
my_init = initializers.RandomUniform(minval = -0.05, maxval = 0.05, seed = None)
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

Nó tìm thấy stddev sử dụng công thức dưới đây và sau đó áp dụng phân phối chuẩn

stddev = sqrt(1 / fan_in)

Ở đâu, fan_in đại diện cho số lượng đơn vị đầu vào.

lecun_uniform

Tạo ra giá trị bằng cách sử dụng phân phối dữ liệu đầu vào thống nhất lecun.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
my_init = initializers.lecun_uniform(seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

Nó tìm thấy limit sử dụng công thức dưới đây và sau đó áp dụng phân phối đồng đều

limit = sqrt(3 / fan_in)

Ở đâu,

  • fan_in đại diện cho số lượng đơn vị đầu vào

  • fan_out đại diện cho số lượng đơn vị đầu ra

glorot_normal

Tạo ra giá trị bằng cách sử dụng phân phối chuẩn glorot của dữ liệu đầu vào.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
my_init = initializers.glorot_normal(seed=None) model.add(
   Dense(512, activation = 'relu', input_shape = (784,), kernel_initializer = my_init)
)

Nó tìm thấy stddev sử dụng công thức dưới đây và sau đó áp dụng phân phối chuẩn

stddev = sqrt(2 / (fan_in + fan_out))

Ở đâu,

  • fan_in đại diện cho số lượng đơn vị đầu vào

  • fan_out đại diện cho số lượng đơn vị đầu ra

glorot_uniform

Tạo ra giá trị bằng cách sử dụng phân phối dữ liệu đầu vào đồng nhất glorot.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
my_init = initializers.glorot_uniform(seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

Nó tìm thấy limit sử dụng công thức dưới đây và sau đó áp dụng phân phối đồng đều

limit = sqrt(6 / (fan_in + fan_out))

Ở đâu,

  • fan_in đại diện cho số lượng đơn vị đầu vào.

  • fan_out đại diện cho số lượng đơn vị đầu ra

he_normal

Tạo ra giá trị bằng cách sử dụng phân phối chuẩn của dữ liệu đầu vào.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
my_init = initializers.RandomUniform(minval = -0.05, maxval = 0.05, seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

Nó tìm stddev bằng cách sử dụng công thức dưới đây và sau đó áp dụng phân phối chuẩn.

stddev = sqrt(2 / fan_in)

Ở đâu, fan_in đại diện cho số lượng đơn vị đầu vào.

he_uniform

Tạo ra giá trị bằng cách sử dụng phân phối dữ liệu đầu vào đồng nhất.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
my_init = initializers.he_normal(seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

Nó tìm thấy limit sử dụng công thức dưới đây và sau đó áp dụng phân phối đồng đều.

limit = sqrt(6 / fan_in)

Ở đâu, fan_in đại diện cho số lượng đơn vị đầu vào.

Trực giao

Tạo một ma trận trực giao ngẫu nhiên.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
my_init = initializers.Orthogonal(gain = 1.0, seed = None) 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init))

Ở đâu, gain biểu diễn hệ số nhân của ma trận.

Danh tính

Tạo ma trận nhận dạng.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
my_init = initializers.Identity(gain = 1.0) model.add(
   Dense(512, activation = 'relu', input_shape = (784,), kernel_initializer = my_init)
)

Ràng buộc

Trong học máy, một ràng buộc sẽ được đặt trên tham số (trọng số) trong giai đoạn tối ưu hóa. <> Mô-đun ràng buộc cung cấp các chức năng khác nhau để thiết lập ràng buộc trên lớp. Một số chức năng ràng buộc như sau.

NonNeg

Ràng buộc trọng số là giá trị không âm.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import initializers 
my_init = initializers.Identity(gain = 1.0) model.add(
   Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_initializer = my_init)
)

Ở đâu, kernel_constraint đại diện cho ràng buộc được sử dụng trong lớp.

UnitNorm

Giới hạn trọng lượng là đơn vị định mức.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import constraints 
my_constrain = constraints.UnitNorm(axis = 0) 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_constraint = my_constrain))

MaxNorm

Giới hạn trọng lượng để định mức nhỏ hơn hoặc bằng giá trị đã cho.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import constraints 
my_constrain = constraints.MaxNorm(max_value = 2, axis = 0) 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_constraint = my_constrain))

Ở đâu,

  • max_value đại diện cho giới hạn trên

  • trục đại diện cho kích thước mà ràng buộc được áp dụng. ví dụ: trong Hình dạng (2,3,4) trục 0 biểu thị kích thước thứ nhất, 1 biểu thị kích thước thứ hai và 2 biểu thị kích thước thứ ba

MinMaxNorm

Ràng buộc trọng lượng là chuẩn giữa các giá trị tối thiểu và tối đa được chỉ định.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import constraints 
my_constrain = constraints.MinMaxNorm(min_value = 0.0, max_value = 1.0, rate = 1.0, axis = 0) 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_constraint = my_constrain))

Ở đâu, rate đại diện cho tốc độ mà giới hạn trọng lượng được áp dụng.

Bộ điều chỉnh

Trong học máy, bộ điều chỉnh được sử dụng trong giai đoạn tối ưu hóa. Nó áp dụng một số hình phạt trên tham số lớp trong quá trình tối ưu hóa. Mô-đun chính quy Keras cung cấp các chức năng bên dưới để thiết lập các hình phạt trên lớp. Quy định chỉ áp dụng trên cơ sở từng lớp.

Bộ điều chỉnh L1

Nó cung cấp chính quy dựa trên L1.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import regularizers 
my_regularizer = regularizers.l1(0.) 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_regularizer = my_regularizer))

Ở đâu, kernel_regularizer đại diện cho tốc độ mà giới hạn trọng lượng được áp dụng.

Bộ điều chỉnh L2

Nó cung cấp chính quy dựa trên L2.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import regularizers 
my_regularizer = regularizers.l2(0.) 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,), 
   kernel_regularizer = my_regularizer))

Bộ điều chỉnh L1 và L2

Nó cung cấp cả quy định hóa dựa trên L1 và L2.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
from keras import regularizers 
my_regularizer = regularizers.l2(0.) 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,),
   kernel_regularizer = my_regularizer))

Kích hoạt

Trong học máy, chức năng kích hoạt là một chức năng đặc biệt được sử dụng để tìm xem một tế bào thần kinh cụ thể có được kích hoạt hay không. Về cơ bản, hàm kích hoạt thực hiện biến đổi phi tuyến của dữ liệu đầu vào và do đó cho phép các tế bào thần kinh học tốt hơn. Đầu ra của một tế bào thần kinh phụ thuộc vào chức năng kích hoạt.

Như bạn nhớ lại khái niệm nhận thức đơn lẻ, đầu ra của một tế bào cảm thụ (neuron) chỉ đơn giản là kết quả của hàm kích hoạt, hàm này chấp nhận tổng của tất cả đầu vào nhân với trọng số tương ứng của nó cộng với độ lệch tổng thể, nếu có.

result = Activation(SUMOF(input * weight) + bias)

Vì vậy, chức năng kích hoạt đóng một vai trò quan trọng trong việc học thành công mô hình. Keras cung cấp rất nhiều chức năng kích hoạt trong mô-đun kích hoạt. Hãy để chúng tôi tìm hiểu tất cả các kích hoạt có sẵn trong mô-đun.

tuyến tính

Áp dụng chức năng tuyến tính. Không lam gi cả.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
model = Sequential() 
model.add(Dense(512, activation = 'linear', input_shape = (784,)))

Ở đâu, activationđề cập đến chức năng kích hoạt của lớp. Nó có thể được chỉ định đơn giản bằng tên của hàm và lớp sẽ sử dụng các trình kích hoạt tương ứng.

elu

Áp dụng đơn vị tuyến tính hàm mũ.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
model = Sequential() 
model.add(Dense(512, activation = 'elu', input_shape = (784,)))

selu

Áp dụng đơn vị tuyến tính theo cấp số nhân được chia tỷ lệ.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
model = Sequential() 
model.add(Dense(512, activation = 'selu', input_shape = (784,)))

relu

Áp dụng Đơn vị tuyến tính đã chỉnh lưu.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,)))

softmax

Áp dụng chức năng Softmax.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
model = Sequential() 
model.add(Dense(512, activation = 'softmax', input_shape = (784,)))

softplus

Áp dụng chức năng Softplus.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
model = Sequential() 
model.add(Dense(512, activation = 'softplus', input_shape = (784,)))

softsign

Áp dụng chức năng Softsign.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
model = Sequential() 
model.add(Dense(512, activation = 'softsign', input_shape = (784,)))

tanh

Áp dụng hàm tiếp tuyến Hyperbolic.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
model = Sequential() 
model.add(Dense(512, activation = 'tanh', input_shape = (784,)))

sigmoid

Áp dụng chức năng Sigmoid.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
model = Sequential() 
model.add(Dense(512, activation = 'sigmoid', input_shape = (784,)))

hard_sigmoid

Áp dụng chức năng Hard Sigmoid.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
model = Sequential() 
model.add(Dense(512, activation = 'hard_sigmoid', input_shape = (784,)))

số mũ

Áp dụng hàm số mũ.

from keras.models import Sequential 
from keras.layers import Activation, Dense 
model = Sequential() 
model.add(Dense(512, activation = 'exponential', input_shape = (784,)))
Sr.No Lớp & Mô tả
1

Lớp dày đặc

Dense layer là lớp mạng nơ-ron được kết nối sâu thường xuyên.

2

Lớp bỏ học

Dropout là một trong những khái niệm quan trọng trong học máy.

3

Làm phẳng các lớp

Flatten được sử dụng để làm phẳng đầu vào.

4

Định hình lại các lớp

Reshape được sử dụng để thay đổi hình dạng của đầu vào.

5

Permute lớp

Permute cũng được sử dụng để thay đổi hình dạng của đầu vào bằng cách sử dụng mẫu.

6

Lớp lặp lại

RepeatVector được sử dụng để lặp lại đầu vào cho số lần đặt, n lần.

7

Lớp Lambda

Lambda được sử dụng để biến đổi dữ liệu đầu vào bằng biểu thức hoặc hàm.

số 8

Lớp chuyển đổi

Keras chứa rất nhiều lớp để tạo ANN dựa trên Convolution, thường được gọi là Mạng thần kinh Convolution (CNN) .

9

Lớp gộp

Nó được sử dụng để thực hiện các hoạt động tổng hợp tối đa trên dữ liệu tạm thời.

10

Lớp kết nối cục bộ

Các lớp được kết nối cục bộ tương tự như lớp Conv1D nhưng sự khác biệt là trọng số lớp Conv1D được chia sẻ nhưng ở đây trọng số không được chia sẻ.

11

Hợp nhất lớp

Nó được sử dụng để hợp nhất một danh sách các đầu vào.

12

Lớp nhúng

Nó thực hiện các thao tác nhúng trong lớp đầu vào.

Keras - Lớp tùy chỉnh

Keras cho phép tạo lớp tùy chỉnh của riêng chúng tôi. Khi một lớp mới được tạo, nó có thể được sử dụng trong bất kỳ mô hình nào mà không bị hạn chế. Hãy để chúng tôi tìm hiểu cách tạo lớp mới trong chương này.

Keras cung cấp một cơ sở layerlớp, Lớp có thể phân lớp để tạo lớp tùy chỉnh của riêng chúng ta. Chúng ta hãy tạo một lớp đơn giản sẽ tìm trọng lượng dựa trên phân phối chuẩn và sau đó thực hiện phép tính cơ bản để tìm tổng của tích đầu vào và trọng lượng của nó trong quá trình luyện tập.

Bước 1: Nhập mô-đun cần thiết

Trước tiên, hãy để chúng tôi nhập các mô-đun cần thiết -

from keras import backend as K 
from keras.layers import Layer

Đây,

  • backend được sử dụng để truy cập dot chức năng.

  • Layer là lớp cơ sở và chúng tôi sẽ phân lớp nó để tạo lớp của chúng tôi

Bước 2: Xác định một lớp lớp

Hãy để chúng tôi tạo một lớp học mới, MyCustomLayer bằng cách phân loại phụ Layer class -

class MyCustomLayer(Layer): 
   ...

Bước 3: Khởi tạo lớp lớp

Hãy để chúng tôi khởi tạo lớp mới của chúng tôi như được chỉ định bên dưới:

def __init__(self, output_dim, **kwargs):    
   self.output_dim = output_dim 
   super(MyCustomLayer, self).__init__(**kwargs)

Đây,

  • Line 2 đặt thứ nguyên đầu ra.

  • Line 3 gọi cơ sở hoặc siêu lớp của init chức năng.

Bước 4: Thực hiện phương pháp xây dựng

buildlà phương thức chính và mục đích duy nhất của nó là xây dựng lớp đúng cách. Nó có thể làm bất cứ điều gì liên quan đến hoạt động bên trong của lớp. Khi chức năng tùy chỉnh được thực hiện xong, chúng ta có thể gọi lớp cơ sởbuildchức năng. Tùy chỉnh của chúng tôibuild chức năng như sau:

def build(self, input_shape): 
   self.kernel = self.add_weight(name = 'kernel', 
      shape = (input_shape[1], self.output_dim), 
      initializer = 'normal', trainable = True) 
   super(MyCustomLayer, self).build(input_shape)

Đây,

  • Line 1 xác định build phương pháp với một đối số, input_shape. Hình dạng của dữ liệu đầu vào được tham chiếu bởi input_shape.

  • Line 2tạo trọng số tương ứng với hình dạng đầu vào và đặt nó trong nhân. Đây là chức năng tùy chỉnh của chúng tôi về lớp. Nó tạo ra trọng số bằng cách sử dụng bộ khởi tạo 'bình thường'.

  • Line 6 gọi lớp cơ sở, build phương pháp.

Bước 5: Triển khai phương thức gọi

call phương pháp làm việc chính xác của lớp trong quá trình đào tạo.

Tùy chỉnh của chúng tôi call phương pháp như sau

def call(self, input_data): 
   return K.dot(input_data, self.kernel)

Đây,

  • Line 1 xác định call phương pháp với một đối số, input_data. input_data là dữ liệu đầu vào cho lớp của chúng ta.

  • Line 2 trả về sản phẩm dấu chấm của dữ liệu đầu vào, input_data và hạt nhân của lớp của chúng tôi, self.kernel

Bước 6: Triển khai phương thức compute_output_shape

def compute_output_shape(self, input_shape): return (input_shape[0], self.output_dim)

Đây,

  • Line 1 xác định compute_output_shape phương pháp với một đối số input_shape

  • Line 2 tính toán hình dạng đầu ra bằng cách sử dụng hình dạng của dữ liệu đầu vào và kích thước đầu ra được đặt trong khi khởi tạo lớp.

Thực hiện build, callcompute_output_shapehoàn thành việc tạo một lớp tùy chỉnh. Mã cuối cùng và hoàn chỉnh như sau

from keras import backend as K from keras.layers import Layer
class MyCustomLayer(Layer): 
   def __init__(self, output_dim, **kwargs): 
      self.output_dim = output_dim 
      super(MyCustomLayer, self).__init__(**kwargs) 
   def build(self, input_shape): self.kernel = 
      self.add_weight(name = 'kernel', 
      shape = (input_shape[1], self.output_dim), 
      initializer = 'normal', trainable = True) 
      super(MyCustomLayer, self).build(input_shape) # 
      Be sure to call this at the end 
   def call(self, input_data): return K.dot(input_data, self.kernel) 
   def compute_output_shape(self, input_shape): return (input_shape[0], self.output_dim)

Sử dụng lớp tùy chỉnh của chúng tôi

Hãy để chúng tôi tạo một mô hình đơn giản bằng cách sử dụng lớp tùy chỉnh của chúng tôi như được chỉ định bên dưới -

from keras.models import Sequential 
from keras.layers import Dense 
model = Sequential() 
model.add(MyCustomLayer(32, input_shape = (16,))) 
model.add(Dense(8, activation = 'softmax')) model.summary()

Đây,

  • Của chúng tôi MyCustomLayer được thêm vào mô hình bằng cách sử dụng 32 đơn vị và (16,) như hình dạng đầu vào

Chạy ứng dụng sẽ in tóm tắt mô hình như dưới đây:

Model: "sequential_1" 
_________________________________________________________________ 
Layer (type) Output Shape Param 
#================================================================ 
my_custom_layer_1 (MyCustomL (None, 32) 512 
_________________________________________________________________
dense_1 (Dense) (None, 8) 264 
================================================================= 
Total params: 776 
Trainable params: 776 
Non-trainable params: 0 
_________________________________________________________________

Keras - Người mẫu

Như đã học trước đó, mô hình Keras đại diện cho mô hình mạng nơron thực tế. Keras cung cấp hai chế độ để tạo mô hình, API tuần tự đơn giản và dễ sử dụng cũng như API chức năng linh hoạt và nâng cao hơn . Bây giờ chúng ta hãy học cách tạo mô hình bằng cách sử dụng cả API tuần tựhàm trong chương này.

Tuần tự

Ý tưởng cốt lõi của Sequential APIchỉ đơn giản là sắp xếp các lớp Keras theo thứ tự tuần tự và do đó, nó được gọi là API tuần tự . Hầu hết ANN cũng có các lớp theo thứ tự tuần tự và dữ liệu chảy từ lớp này sang lớp khác theo thứ tự nhất định cho đến khi dữ liệu cuối cùng đến lớp đầu ra.

Mô hình ANN có thể được tạo bằng cách đơn giản gọi Sequential() API như được chỉ định bên dưới -

from keras.models import Sequential 
model = Sequential()

Thêm lớp

Để thêm một lớp, chỉ cần tạo một lớp bằng API lớp Keras và sau đó chuyển lớp thông qua hàm add () như được chỉ định bên dưới:

from keras.models import Sequential 
model = Sequential() 
input_layer = Dense(32, input_shape=(8,)) model.add(input_layer) 
hidden_layer = Dense(64, activation='relu'); model.add(hidden_layer) 
output_layer = Dense(8) 
model.add(output_layer)

Ở đây, chúng ta đã tạo một lớp đầu vào, một lớp ẩn và một lớp đầu ra.

Truy cập mô hình

Keras cung cấp một số phương pháp để lấy thông tin mô hình như các lớp, dữ liệu đầu vào và dữ liệu đầu ra. Chúng như sau:

  • model.layers - Trả về tất cả các lớp của mô hình dưới dạng danh sách.

>>> layers = model.layers 
>>> layers 
[
   <keras.layers.core.Dense object at 0x000002C8C888B8D0>, 
   <keras.layers.core.Dense object at 0x000002C8C888B7B8>
   <keras.layers.core.Dense object at 0x 000002C8C888B898>
]
  • model.inputs - Trả về tất cả các tensors đầu vào của mô hình dưới dạng danh sách.

>>> inputs = model.inputs 
>>> inputs 
[<tf.Tensor 'dense_13_input:0' shape=(?, 8) dtype=float32>]
  • model.outputs - Trả về tất cả các tenxơ đầu ra của mô hình dưới dạng danh sách.

>>> outputs = model.outputs 
>>> outputs 
<tf.Tensor 'dense_15/BiasAdd:0' shape=(?, 8) dtype=float32>]
  • model.get_weights - Trả về tất cả các trọng số dưới dạng mảng NumPy.

  • model.set_weights(weight_numpy_array) - Đặt các trọng lượng của mô hình.

Nối tiếp mô hình

Keras cung cấp các phương thức để tuần tự hóa mô hình thành đối tượng cũng như json và tải lại sau. Chúng như sau:

  • get_config() - Trả về mô hình như một đối tượng.

config = model.get_config()
  • from_config() - Nó chấp nhận đối tượng cấu hình mô hình làm đối số và tạo mô hình cho phù hợp.

new_model = Sequential.from_config(config)
  • to_json() - Trả về mô hình dưới dạng một đối tượng json.

>>> json_string = model.to_json() 
>>> json_string '{"class_name": "Sequential", "config": 
{"name": "sequential_10", "layers": 
[{"class_name": "Dense", "config": 
{"name": "dense_13", "trainable": true, "batch_input_shape": 
[null, 8], "dtype": "float32", "units": 32, "activation": "linear", 
"use_bias": true, "kernel_initializer": 
{"class_name": "Vari anceScaling", "config": 
{"scale": 1.0, "mode": "fan_avg", "distribution": "uniform", "seed": null}},
"bias_initializer": {"class_name": "Zeros", "conf 
ig": {}}, "kernel_regularizer": null, "bias_regularizer": null, 
"activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}}, 
{" class_name": "Dense", "config": {"name": "dense_14", "trainable": true, 
"dtype": "float32", "units": 64, "activation": "relu", "use_bias": true, 
"kern el_initializer": {"class_name": "VarianceScaling", "config": 
{"scale": 1.0, "mode": "fan_avg", "distribution": "uniform", "seed": null}}, 
"bias_initia lizer": {"class_name": "Zeros", 
"config": {}}, "kernel_regularizer": null, "bias_regularizer": null, 
"activity_regularizer": null, "kernel_constraint" : null, "bias_constraint": null}}, 
{"class_name": "Dense", "config": {"name": "dense_15", "trainable": true, 
"dtype": "float32", "units": 8, "activation": "linear", "use_bias": true, 
"kernel_initializer": {"class_name": "VarianceScaling", "config": 
{"scale": 1.0, "mode": "fan_avg", "distribution": " uniform", "seed": null}}, 
"bias_initializer": {"class_name": "Zeros", "config": {}}, 
"kernel_regularizer": null, "bias_regularizer": null, "activity_r egularizer": 
null, "kernel_constraint": null, "bias_constraint": 
null}}]}, "keras_version": "2.2.5", "backend": "tensorflow"}' 
>>>
  • model_from_json() - Chấp nhận biểu diễn json của mô hình và tạo ra một mô hình mới.

from keras.models import model_from_json 
new_model = model_from_json(json_string)
  • to_yaml() - Trả về mô hình dưới dạng một chuỗi yaml.

>>> yaml_string = model.to_yaml() 
>>> yaml_string 'backend: tensorflow\nclass_name: 
Sequential\nconfig:\n layers:\n - class_name: Dense\n config:\n 
activation: linear\n activity_regular izer: null\n batch_input_shape: 
!!python/tuple\n - null\n - 8\n bias_constraint: null\n bias_initializer:\n 
class_name : Zeros\n config: {}\n bias_regularizer: null\n dtype: 
float32\n kernel_constraint: null\n 
kernel_initializer:\n cla ss_name: VarianceScaling\n config:\n 
distribution: uniform\n mode: fan_avg\n 
scale: 1.0\n seed: null\n kernel_regularizer: null\n name: dense_13\n 
trainable: true\n units: 32\n 
use_bias: true\n - class_name: Dense\n config:\n activation: relu\n activity_regularizer: null\n 
bias_constraint: null\n bias_initializer:\n class_name: Zeros\n 
config : {}\n bias_regularizer: null\n dtype: float32\n 
kernel_constraint: null\n kernel_initializer:\n class_name: VarianceScalin g\n 
config:\n distribution: uniform\n mode: fan_avg\n scale: 1.0\n 
seed: null\n kernel_regularizer: nu ll\n name: dense_14\n trainable: true\n 
units: 64\n use_bias: true\n - class_name: Dense\n config:\n 
activation: linear\n activity_regularizer: null\n 
bias_constraint: null\n bias_initializer:\n 
class_name: Zeros\n config: {}\n bias_regu larizer: null\n 
dtype: float32\n kernel_constraint: null\n 
kernel_initializer:\n class_name: VarianceScaling\n config:\n 
distribution: uniform\n mode: fan_avg\n 
scale: 1.0\n seed: null\n kernel_regularizer: null\n name: dense _15\n 
trainable: true\n units: 8\n 
use_bias: true\n name: sequential_10\nkeras_version: 2.2.5\n' 
>>>
  • model_from_yaml() - Chấp nhận đại diện yaml của mô hình và tạo ra một mô hình mới.

from keras.models import model_from_yaml 
new_model = model_from_yaml(yaml_string)

Tóm tắt mô hình

Hiểu được mô hình là giai đoạn rất quan trọng để sử dụng nó đúng cách cho các mục đích đào tạo và dự đoán. Keras cung cấp một phương pháp đơn giản, tóm tắt để có được thông tin đầy đủ về mô hình và các lớp của nó.

Tóm tắt về mô hình được tạo trong phần trước như sau:

>>> model.summary() Model: "sequential_10" 
_________________________________________________________________ 
Layer (type) Output Shape Param 
#================================================================ 
dense_13 (Dense) (None, 32) 288 
_________________________________________________________________ 
dense_14 (Dense) (None, 64) 2112 
_________________________________________________________________ 
dense_15 (Dense) (None, 8) 520 
================================================================= 
Total params: 2,920 
Trainable params: 2,920 
Non-trainable params: 0 
_________________________________________________________________ 
>>>

Huấn luyện và dự đoán mô hình

Mô hình cung cấp chức năng cho quá trình đào tạo, đánh giá và dự đoán. Chúng như sau:

  • compile - Cấu hình quá trình học tập của mô hình

  • fit - Đào tạo mô hình bằng cách sử dụng dữ liệu đào tạo

  • evaluate - Đánh giá mô hình bằng cách sử dụng dữ liệu thử nghiệm

  • predict - Dự đoán kết quả cho đầu vào mới.

API chức năng

API tuần tự được sử dụng để tạo mô hình theo từng lớp. API chức năng là một cách tiếp cận thay thế để tạo các mô hình phức tạp hơn. Mô hình chức năng, bạn có thể xác định nhiều đầu vào hoặc đầu ra chia sẻ các lớp. Đầu tiên, chúng ta tạo một thể hiện cho mô hình và kết nối với các lớp để truy cập đầu vào và đầu ra của mô hình. Phần này giải thích ngắn gọn về mô hình chức năng.

Tạo một mô hình

Nhập một lớp đầu vào bằng mô-đun bên dưới -

>>> from keras.layers import Input

Bây giờ, hãy tạo một lớp đầu vào chỉ định hình dạng kích thước đầu vào cho mô hình bằng cách sử dụng mã bên dưới:

>>> data = Input(shape=(2,3))

Xác định lớp cho đầu vào bằng mô-đun bên dưới -

>>> from keras.layers import Dense

Thêm lớp dày đặc cho đầu vào bằng cách sử dụng dòng mã bên dưới -

>>> layer = Dense(2)(data) 
>>> print(layer) 
Tensor("dense_1/add:0", shape =(?, 2, 2), dtype = float32)

Xác định mô hình bằng cách sử dụng mô-đun dưới đây -

from keras.models import Model

Tạo một mô hình theo cách chức năng bằng cách chỉ định cả lớp đầu vào và đầu ra -

model = Model(inputs = data, outputs = layer)

Mã hoàn chỉnh để tạo một mô hình đơn giản được hiển thị bên dưới:

from keras.layers import Input 
from keras.models import Model 
from keras.layers import Dense 
data = Input(shape=(2,3)) 
layer = Dense(2)(data) model = 
Model(inputs=data,outputs=layer) model.summary() 
_________________________________________________________________ 
Layer (type)               Output Shape               Param # 
================================================================= 
input_2 (InputLayer)       (None, 2, 3)               0 
_________________________________________________________________ 
dense_2 (Dense)            (None, 2, 2)               8 
================================================================= 
Total params: 8 
Trainable params: 8 
Non-trainable params: 0 
_________________________________________________________________

Keras - Tổng hợp mô hình

Trước đây, chúng ta đã nghiên cứu những kiến ​​thức cơ bản về cách tạo mô hình bằng cách sử dụng API tuần tự và hàm. Chương này giải thích về cách biên dịch mô hình. Biên dịch là bước cuối cùng trong việc tạo một mô hình. Sau khi biên dịch xong, chúng ta có thể chuyển sang giai đoạn đào tạo.

Chúng ta hãy tìm hiểu một số khái niệm cần thiết để hiểu rõ hơn về quá trình biên dịch.

Thua

Trong học máy, Losshàm được sử dụng để tìm lỗi hoặc sai lệch trong quá trình học. Keras yêu cầu hàm mất trong quá trình biên dịch mô hình.

Keras cung cấp khá nhiều hàm mất mát trong losses mô-đun và chúng như sau:

  • mean_squared_error
  • mean_absolute_error
  • mean_absolute_percentage_error
  • mean_squared_logarithmic_error
  • squared_hinge
  • hinge
  • categorical_hinge
  • logcosh
  • huber_loss
  • categorical_crossentropy
  • sparse_categorical_crossentropy
  • binary_crossentropy
  • kullback_leibler_divergence
  • poisson
  • cosine_proximity
  • is_categorical_crossentropy

Tất cả hàm mất mát ở trên chấp nhận hai đối số:

  • y_true - nhãn thực như tenxơ

  • y_pred - dự đoán với hình dạng giống như y_true

Nhập mô-đun tổn thất trước khi sử dụng chức năng tổn thất như được chỉ định bên dưới -

from keras import losses

Trình tối ưu hóa

Trong học máy, Optimizationlà một quá trình quan trọng để tối ưu hóa trọng số đầu vào bằng cách so sánh dự đoán và hàm mất mát. Keras cung cấp khá nhiều trình tối ưu hóa dưới dạng mô-đun, các trình tối ưu hóa và chúng như sau:

SGD - Trình tối ưu hóa dốc xuống dốc ngẫu nhiên.

keras.optimizers.SGD(learning_rate = 0.01, momentum = 0.0, nesterov = False)

RMSprop - Trình tối ưu hóa RMSProp.

keras.optimizers.RMSprop(learning_rate = 0.001, rho = 0.9)

Adagrad - Trình tối ưu hóa Adagrad.

keras.optimizers.Adagrad(learning_rate = 0.01)

Adadelta - Trình tối ưu hóa Adadelta.

keras.optimizers.Adadelta(learning_rate = 1.0, rho = 0.95)

Adam - Trình tối ưu hóa Adam.

keras.optimizers.Adam(
   learning_rate = 0.001, beta_1 = 0.9, beta_2 = 0.999, amsgrad = False
)

Adamax - Trình tối ưu hóa Adamax từ Adam.

keras.optimizers.Adamax(learning_rate = 0.002, beta_1 = 0.9, beta_2 = 0.999)

Nadam - Trình tối ưu hóa Nesterov Adam.

keras.optimizers.Nadam(learning_rate = 0.002, beta_1 = 0.9, beta_2 = 0.999)

Nhập mô-đun trình tối ưu hóa trước khi sử dụng trình tối ưu hóa như được chỉ định bên dưới -

from keras import optimizers

Số liệu

Trong học máy, Metricsđược sử dụng để đánh giá hiệu suất của mô hình của bạn. Nó tương tự như hàm mất mát, nhưng không được sử dụng trong quá trình đào tạo. Keras cung cấp khá nhiều chỉ số dưới dạng mô-đun,metrics và chúng như sau

  • accuracy
  • binary_accuracy
  • categorical_accuracy
  • sparse_categorical_accuracy
  • top_k_categorical_accuracy
  • sparse_top_k_categorical_accuracy
  • cosine_proximity
  • clone_metric

Tương tự như hàm mất mát, các số liệu cũng chấp nhận hai đối số dưới đây:

  • y_true - nhãn thực như tenxơ

  • y_pred - dự đoán với hình dạng giống như y_true

Nhập mô-đun số liệu trước khi sử dụng các số liệu như được chỉ định bên dưới -

from keras import metrics

Biên dịch mô hình

Mô hình Keras cung cấp một phương pháp, compile()để biên dịch mô hình. Đối số và giá trị mặc định củacompile() phương pháp như sau

compile(
   optimizer, 
   loss = None, 
   metrics = None, 
   loss_weights = None, 
   sample_weight_mode = None, 
   weighted_metrics = None, 
   target_tensors = None
)

Các đối số quan trọng như sau:

  • thiếu chức năng
  • Optimizer
  • metrics

Một mã mẫu để biên dịch chế độ như sau:

from keras import losses 
from keras import optimizers 
from keras import metrics 
model.compile(loss = 'mean_squared_error',  
   optimizer = 'sgd', metrics = [metrics.categorical_accuracy])

where,

  • loss function is set as mean_squared_error

  • optimizer is set as sgd

  • metrics is set as metrics.categorical_accuracy

Model Training

Models are trained by NumPy arrays using fit(). The main purpose of this fit function is used to evaluate your model on training. This can be also used for graphing model performance. It has the following syntax −

model.fit(X, y, epochs = , batch_size = )

Here,

  • X, y − It is a tuple to evaluate your data.

  • epochs − no of times the model is needed to be evaluated during training.

  • batch_size − training instances.

Let us take a simple example of numpy random data to use this concept.

Create data

Let us create a random data using numpy for x and y with the help of below mentioned command −

import numpy as np 
x_train = np.random.random((100,4,8)) 
y_train = np.random.random((100,10))

Now, create random validation data,

x_val = np.random.random((100,4,8)) 
y_val = np.random.random((100,10))

Create model

Let us create simple sequential model −

from keras.models import Sequential model = Sequential()

Add layers

Create layers to add model −

from keras.layers import LSTM, Dense 
# add a sequence of vectors of dimension 16 
model.add(LSTM(16, return_sequences = True)) 
model.add(Dense(10, activation = 'softmax'))

compile model

Now model is defined. You can compile using the below command −

model.compile(
   loss = 'categorical_crossentropy', optimizer = 'sgd', metrics = ['accuracy']
)

Apply fit()

Now we apply fit() function to train our data −

model.fit(x_train, y_train, batch_size = 32, epochs = 5, validation_data = (x_val, y_val))

Create a Multi-Layer Perceptron ANN

We have learned to create, compile and train the Keras models.

Let us apply our learning and create a simple MPL based ANN.

Dataset module

Before creating a model, we need to choose a problem, need to collect the required data and convert the data to NumPy array. Once data is collected, we can prepare the model and train it by using the collected data. Data collection is one of the most difficult phase of machine learning. Keras provides a special module, datasets to download the online machine learning data for training purposes. It fetches the data from online server, process the data and return the data as training and test set. Let us check the data provided by Keras dataset module. The data available in the module are as follows,

  • CIFAR10 small image classification
  • CIFAR100 small image classification
  • IMDB Movie reviews sentiment classification
  • Reuters newswire topics classification
  • MNIST database of handwritten digits
  • Fashion-MNIST database of fashion articles
  • Boston housing price regression dataset

Let us use the MNIST database of handwritten digits (or minst) as our input. minst is a collection of 60,000, 28x28 grayscale images. It contains 10 digits. It also contains 10,000 test images.

Below code can be used to load the dataset −

from keras.datasets import mnist 
(x_train, y_train), (x_test, y_test) = mnist.load_data()

where

  • Line 1 imports minst from the keras dataset module.

  • Line 3 calls the load_data function, which will fetch the data from online server and return the data as 2 tuples, First tuple, (x_train, y_train) represent the training data with shape, (number_sample, 28, 28) and its digit label with shape, (number_samples, ). Second tuple, (x_test, y_test) represent test data with same shape.

Other dataset can also be fetched using similar API and every API returns similar data as well except the shape of the data. The shape of the data depends on the type of data.

Create a model

Let us choose a simple multi-layer perceptron (MLP) as represented below and try to create the model using Keras.

The core features of the model are as follows −

  • Input layer consists of 784 values (28 x 28 = 784).

  • First hidden layer, Dense consists of 512 neurons and ‘relu’ activation function.

  • Second hidden layer, Dropout has 0.2 as its value.

  • Third hidden layer, again Dense consists of 512 neurons and ‘relu’ activation function.

  • Fourth hidden layer, Dropout has 0.2 as its value.

  • Fifth and final layer consists of 10 neurons and ‘softmax’ activation function.

  • Use categorical_crossentropy as loss function.

  • Use RMSprop() as Optimizer.

  • Use accuracy as metrics.

  • Use 128 as batch size.

  • Use 20 as epochs.

Step 1 − Import the modules

Let us import the necessary modules.

import keras 
from keras.datasets import mnist 
from keras.models import Sequential 
from keras.layers import Dense, Dropout 
from keras.optimizers import RMSprop 
import numpy as np

Step 2 − Load data

Let us import the mnist dataset.

(x_train, y_train), (x_test, y_test) = mnist.load_data()

Step 3 − Process the data

Let us change the dataset according to our model, so that it can be feed into our model.

x_train = x_train.reshape(60000, 784) 
x_test = x_test.reshape(10000, 784) 
x_train = x_train.astype('float32') 
x_test = x_test.astype('float32') 
x_train /= 255 
x_test /= 255 
y_train = keras.utils.to_categorical(y_train, 10) 
y_test = keras.utils.to_categorical(y_test, 10)

Where

  • reshape is used to reshape the input from (28, 28) tuple to (784, )

  • to_categorical is used to convert vector to binary matrix

Step 4 − Create the model

Let us create the actual model.

model = Sequential() 
model.add(Dense(512, activation = 'relu', input_shape = (784,))) 
model.add(Dropout(0.2)) 
model.add(Dense(512, activation = 'relu'))
model.add(Dropout(0.2)) 
model.add(Dense(10, activation = 'softmax'))

Step 5 − Compile the model

Let us compile the model using selected loss function, optimizer and metrics.

model.compile(loss = 'categorical_crossentropy',     
   optimizer = RMSprop(), 
   metrics = ['accuracy'])

Step 6 − Train the model

Let us train the model using fit() method.

history = model.fit(
   x_train, y_train, 
   batch_size = 128, 
   epochs = 20, 
   verbose = 1, 
   validation_data = (x_test, y_test)
)

Final thoughts

We have created the model, loaded the data and also trained the data to the model. We still need to evaluate the model and predict output for unknown input, which we learn in upcoming chapter.

import keras 
from keras.datasets import mnist 
from keras.models import Sequential 
from keras.layers import Dense, Dropout 
from keras.optimizers import RMSprop 
import numpy as np 
(x_train, y_train), (x_test, y_test) = mnist.load_data() 
x_train = x_train.reshape(60000, 784) 
x_test = x_test.reshape(10000, 784) 
x_train = x_train.astype('float32') 
x_test = x_test.astype('float32') 
x_train /= 255 
x_test /= 255 
y_train = keras.utils.to_categorical(y_train, 10) 
y_test = keras.utils.to_categorical(y_test, 10) 
model = Sequential() 
model.add(Dense(512, activation='relu', input_shape = (784,))) 
model.add(Dropout(0.2)) 
model.add(Dense(512, activation = 'relu')) model.add(Dropout(0.2)) 
model.add(Dense(10, activation = 'softmax'))
model.compile(loss = 'categorical_crossentropy', 
   optimizer = RMSprop(), 
   metrics = ['accuracy']) 
history = model.fit(x_train, y_train, 
   batch_size = 128, epochs = 20, verbose = 1, validation_data = (x_test, y_test))

Executing the application will give the below content as output −

Train on 60000 samples, validate on 10000 samples Epoch 1/20 
60000/60000 [==============================] - 7s 118us/step - loss: 0.2453 
- acc: 0.9236 - val_loss: 0.1004 - val_acc: 0.9675 Epoch 2/20 
60000/60000 [==============================] - 7s 110us/step - loss: 0.1023 
- acc: 0.9693 - val_loss: 0.0797 - val_acc: 0.9761 Epoch 3/20 
60000/60000 [==============================] - 7s 110us/step - loss: 0.0744 
- acc: 0.9770 - val_loss: 0.0727 - val_acc: 0.9791 Epoch 4/20 
60000/60000 [==============================] - 7s 110us/step - loss: 0.0599 
- acc: 0.9823 - val_loss: 0.0704 - val_acc: 0.9801 Epoch 5/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0504 
- acc: 0.9853 - val_loss: 0.0714 - val_acc: 0.9817 Epoch 6/20 
60000/60000 [==============================] - 7s 111us/step - loss: 0.0438 
- acc: 0.9868 - val_loss: 0.0845 - val_acc: 0.9809 Epoch 7/20 
60000/60000 [==============================] - 7s 114us/step - loss: 0.0391 
- acc: 0.9887 - val_loss: 0.0823 - val_acc: 0.9802 Epoch 8/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0364 
- acc: 0.9892 - val_loss: 0.0818 - val_acc: 0.9830 Epoch 9/20 
60000/60000 [==============================] - 7s 113us/step - loss: 0.0308 
- acc: 0.9905 - val_loss: 0.0833 - val_acc: 0.9829 Epoch 10/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0289 
- acc: 0.9917 - val_loss: 0.0947 - val_acc: 0.9815 Epoch 11/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0279 
- acc: 0.9921 - val_loss: 0.0818 - val_acc: 0.9831 Epoch 12/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0260 
- acc: 0.9927 - val_loss: 0.0945 - val_acc: 0.9819 Epoch 13/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0257 
- acc: 0.9931 - val_loss: 0.0952 - val_acc: 0.9836 Epoch 14/20
60000/60000 [==============================] - 7s 112us/step - loss: 0.0229 
- acc: 0.9937 - val_loss: 0.0924 - val_acc: 0.9832 Epoch 15/20 
60000/60000 [==============================] - 7s 115us/step - loss: 0.0235 
- acc: 0.9937 - val_loss: 0.1004 - val_acc: 0.9823 Epoch 16/20 
60000/60000 [==============================] - 7s 113us/step - loss: 0.0214 
- acc: 0.9941 - val_loss: 0.0991 - val_acc: 0.9847 Epoch 17/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0219 
- acc: 0.9943 - val_loss: 0.1044 - val_acc: 0.9837 Epoch 18/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0190 
- acc: 0.9952 - val_loss: 0.1129 - val_acc: 0.9836 Epoch 19/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0197 
- acc: 0.9953 - val_loss: 0.0981 - val_acc: 0.9841 Epoch 20/20 
60000/60000 [==============================] - 7s 112us/step - loss: 0.0198 
- acc: 0.9950 - val_loss: 0.1215 - val_acc: 0.9828

Keras - Model Evaluation and Model Prediction

This chapter deals with the model evaluation and model prediction in Keras.

Let us begin by understanding the model evaluation.

Model Evaluation

Evaluation is a process during development of the model to check whether the model is best fit for the given problem and corresponding data. Keras model provides a function, evaluate which does the evaluation of the model. It has three main arguments,

  • Test data
  • Test data label
  • verbose - true or false

Let us evaluate the model, which we created in the previous chapter using test data.

score = model.evaluate(x_test, y_test, verbose = 0) 
print('Test loss:', score[0]) 
print('Test accuracy:', score[1])

Executing the above code will output the below information.

0

The test accuracy is 98.28%. We have created a best model to identify the handwriting digits. On the positive side, we can still scope to improve our model.

Model Prediction

Prediction is the final step and our expected outcome of the model generation. Keras provides a method, predict to get the prediction of the trained model. The signature of the predict method is as follows,

predict(
   x, 
   batch_size = None, 
   verbose = 0, 
   steps = None, 
   callbacks = None, 
   max_queue_size = 10, 
   workers = 1, 
   use_multiprocessing = False
)

Here, all arguments are optional except the first argument, which refers the unknown input data. The shape should be maintained to get the proper prediction.

Let us do prediction for our MPL model created in previous chapter using below code −

pred = model.predict(x_test) 
pred = np.argmax(pred, axis = 1)[:5] 
label = np.argmax(y_test,axis = 1)[:5] 
print(pred) 
print(label)

Here,

  • Line 1 call the predict function using test data.

  • Line 2 gets the first five prediction

  • Line 3 gets the first five labels of the test data.

  • Line 5 - 6 prints the prediction and actual label.

The output of the above application is as follows −

[7 2 1 0 4] 
[7 2 1 0 4]

The output of both array is identical and it indicate that our model predicts correctly the first five images.

Keras - Convolution Neural Network

Let us modify the model from MPL to Convolution Neural Network (CNN) for our earlier digit identification problem.

CNN can be represented as below −

The core features of the model are as follows −

  • Input layer consists of (1, 8, 28) values.

  • First layer, Conv2D consists of 32 filters and ‘relu’ activation function with kernel size, (3,3).

  • Second layer, Conv2D consists of 64 filters and ‘relu’ activation function with kernel size, (3,3).

  • Thrid layer, MaxPooling has pool size of (2, 2).

  • Fifth layer, Flatten is used to flatten all its input into single dimension.

  • Sixth layer, Dense consists of 128 neurons and ‘relu’ activation function.

  • Seventh layer, Dropout has 0.5 as its value.

  • Eighth and final layer consists of 10 neurons and ‘softmax’ activation function.

  • Use categorical_crossentropy as loss function.

  • Use Adadelta() as Optimizer.

  • Use accuracy as metrics.

  • Use 128 as batch size.

  • Use 20 as epochs.

Step 1 − Import the modules

Let us import the necessary modules.

import keras 
from keras.datasets import mnist 
from keras.models import Sequential 
from keras.layers import Dense, Dropout, Flatten 
from keras.layers import Conv2D, MaxPooling2D 
from keras import backend as K 
import numpy as np

Step 2 − Load data

Let us import the mnist dataset.

(x_train, y_train), (x_test, y_test) = mnist.load_data()

Step 3 − Process the data

Let us change the dataset according to our model, so that it can be feed into our model.

img_rows, img_cols = 28, 28 
if K.image_data_format() == 'channels_first': 
   x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols) 
   x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols) 
   input_shape = (1, img_rows, img_cols) 
else: 
   x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1) 
   x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1) 
   input_shape = (img_rows, img_cols, 1) 
   
x_train = x_train.astype('float32') 
x_test = x_test.astype('float32') 
x_train /= 255 
x_test /= 255 
y_train = keras.utils.to_categorical(y_train, 10) 
y_test = keras.utils.to_categorical(y_test, 10)

The data processing is similar to MPL model except the shape of the input data and image format configuration.

Step 4 − Create the model

Let us create tha actual model.

model = Sequential() 
model.add(Conv2D(32, kernel_size = (3, 3),  
   activation = 'relu', input_shape = input_shape)) 
model.add(Conv2D(64, (3, 3), activation = 'relu')) 
model.add(MaxPooling2D(pool_size = (2, 2))) 
model.add(Dropout(0.25)) model.add(Flatten()) 
model.add(Dense(128, activation = 'relu')) 
model.add(Dropout(0.5)) 
model.add(Dense(10, activation = 'softmax'))

Step 5 − Compile the model

Let us compile the model using selected loss function, optimizer and metrics.

model.compile(loss = keras.losses.categorical_crossentropy, 
   optimizer = keras.optimizers.Adadelta(), metrics = ['accuracy'])

Step 6 − Train the model

Let us train the model using fit() method.

model.fit(
   x_train, y_train, 
   batch_size = 128, 
   epochs = 12, 
   verbose = 1, 
   validation_data = (x_test, y_test)
)

Executing the application will output the below information −

Train on 60000 samples, validate on 10000 samples Epoch 1/12 
60000/60000 [==============================] - 84s 1ms/step - loss: 0.2687 
- acc: 0.9173 - val_loss: 0.0549 - val_acc: 0.9827 Epoch 2/12 
60000/60000 [==============================] - 86s 1ms/step - loss: 0.0899 
- acc: 0.9737 - val_loss: 0.0452 - val_acc: 0.9845 Epoch 3/12 
60000/60000 [==============================] - 83s 1ms/step - loss: 0.0666 
- acc: 0.9804 - val_loss: 0.0362 - val_acc: 0.9879 Epoch 4/12 
60000/60000 [==============================] - 81s 1ms/step - loss: 0.0564 
- acc: 0.9830 - val_loss: 0.0336 - val_acc: 0.9890 Epoch 5/12 
60000/60000 [==============================] - 86s 1ms/step - loss: 0.0472 
- acc: 0.9861 - val_loss: 0.0312 - val_acc: 0.9901 Epoch 6/12 
60000/60000 [==============================] - 83s 1ms/step - loss: 0.0414 
- acc: 0.9877 - val_loss: 0.0306 - val_acc: 0.9902 Epoch 7/12 
60000/60000 [==============================] - 89s 1ms/step - loss: 0.0375 
-acc: 0.9883 - val_loss: 0.0281 - val_acc: 0.9906 Epoch 8/12 
60000/60000 [==============================] - 91s 2ms/step - loss: 0.0339 
- acc: 0.9893 - val_loss: 0.0280 - val_acc: 0.9912 Epoch 9/12 
60000/60000 [==============================] - 89s 1ms/step - loss: 0.0325 
- acc: 0.9901 - val_loss: 0.0260 - val_acc: 0.9909 Epoch 10/12 
60000/60000 [==============================] - 89s 1ms/step - loss: 0.0284 
- acc: 0.9910 - val_loss: 0.0250 - val_acc: 0.9919 Epoch 11/12 
60000/60000 [==============================] - 86s 1ms/step - loss: 0.0287 
- acc: 0.9907 - val_loss: 0.0264 - val_acc: 0.9916 Epoch 12/12 
60000/60000 [==============================] - 86s 1ms/step - loss: 0.0265 
- acc: 0.9920 - val_loss: 0.0249 - val_acc: 0.9922

Step 7 − Evaluate the model

Let us evaluate the model using test data.

score = model.evaluate(x_test, y_test, verbose = 0) 
print('Test loss:', score[0]) 
print('Test accuracy:', score[1])

Executing the above code will output the below information −

Test loss: 0.024936060590433316 
Test accuracy: 0.9922

The test accuracy is 99.22%. We have created a best model to identify the handwriting digits.

Step 8 − Predict

Finally, predict the digit from images as below −

pred = model.predict(x_test) 
pred = np.argmax(pred, axis = 1)[:5] 
label = np.argmax(y_test,axis = 1)[:5] 
print(pred) 
print(label)

The output of the above application is as follows −

[7 2 1 0 4] 
[7 2 1 0 4]

The output of both array is identical and it indicate our model correctly predicts the first five images.

Keras - Regression Prediction using MPL

In this chapter, let us write a simple MPL based ANN to do regression prediction. Till now, we have only done the classification based prediction. Now, we will try to predict the next possible value by analyzing the previous (continuous) values and its influencing factors.

The Regression MPL can be represented as below −

The core features of the model are as follows −

  • Input layer consists of (13,) values.

  • First layer, Dense consists of 64 units and ‘relu’ activation function with ‘normal’ kernel initializer.

  • Second layer, Dense consists of 64 units and ‘relu’ activation function.

  • Output layer, Dense consists of 1 unit.

  • Use mse as loss function.

  • Use RMSprop as Optimizer.

  • Use accuracy as metrics.

  • Use 128 as batch size.

  • Use 500 as epochs.

Step 1 − Import the modules

Let us import the necessary modules.

import keras 
from keras.datasets import boston_housing 
from keras.models import Sequential 
from keras.layers import Dense 
from keras.optimizers import RMSprop 
from keras.callbacks import EarlyStopping 
from sklearn import preprocessing 
from sklearn.preprocessing import scale

Step 2 − Load data

Let us import the Boston housing dataset.

(x_train, y_train), (x_test, y_test) = boston_housing.load_data()

Here,

boston_housing is a dataset provided by Keras. It represents a collection of housing information in Boston area, each having 13 features.

Step 3 − Process the data

Let us change the dataset according to our model, so that, we can feed into our model. The data can be changed using below code −

x_train_scaled = preprocessing.scale(x_train) 
scaler = preprocessing.StandardScaler().fit(x_train) 
x_test_scaled = scaler.transform(x_test)

Here, we have normalized the training data using sklearn.preprocessing.scale function. preprocessing.StandardScaler().fit function returns a scalar with the normalized mean and standard deviation of the training data, which we can apply to the test data using scalar.transform function. This will normalize the test data as well with the same setting as that of training data.

Step 4 − Create the model

Let us create the actual model.

model = Sequential() 
model.add(Dense(64, kernel_initializer = 'normal', activation = 'relu',
input_shape = (13,))) 
model.add(Dense(64, activation = 'relu')) model.add(Dense(1))

Step 5 − Compile the model

Let us compile the model using selected loss function, optimizer and metrics.

model.compile(
   loss = 'mse', 
   optimizer = RMSprop(), 
   metrics = ['mean_absolute_error']
)

Step 6 − Train the model

Let us train the model using fit() method.

history = model.fit(
   x_train_scaled, y_train,    
   batch_size=128, 
   epochs = 500, 
   verbose = 1, 
   validation_split = 0.2, 
   callbacks = [EarlyStopping(monitor = 'val_loss', patience = 20)]
)

Here, we have used callback function, EarlyStopping. The purpose of this callback is to monitor the loss value during each epoch and compare it with previous epoch loss value to find the improvement in the training. If there is no improvement for the patience times, then the whole process will be stopped.

Executing the application will give the below information as output −

Train on 323 samples, validate on 81 samples Epoch 1/500 2019-09-24 01:07:03.889046: I 
tensorflow/core/platform/cpu_feature_guard.cc:142] 
Your CPU supports instructions that this 
TensorFlow binary was not co mpiled to use: AVX2 323/323 
[==============================] - 0s 515us/step - loss: 562.3129 
- mean_absolute_error: 21.8575 - val_loss: 621.6523 - val_mean_absolute_erro 
r: 23.1730 Epoch 2/500 
323/323 [==============================] - 0s 11us/step - loss: 545.1666 
- mean_absolute_error: 21.4887 - val_loss: 605.1341 - val_mean_absolute_error 
: 22.8293 Epoch 3/500 
323/323 [==============================] - 0s 12us/step - loss: 528.9944 
- mean_absolute_error: 21.1328 - val_loss: 588.6594 - val_mean_absolute_error 
: 22.4799 Epoch 4/500 
323/323 [==============================] - 0s 12us/step - loss: 512.2739 
- mean_absolute_error: 20.7658 - val_loss: 570.3772 - val_mean_absolute_error 
: 22.0853 Epoch 5/500
323/323 [==============================] - 0s 9us/step - loss: 493.9775 
- mean_absolute_error: 20.3506 - val_loss: 550.9548 - val_mean_absolute_error: 21.6547 
.......... 
.......... 
.......... 
Epoch 143/500 
323/323 [==============================] - 0s 15us/step - loss: 8.1004 
- mean_absolute_error: 2.0002 - val_loss: 14.6286 - val_mean_absolute_error: 
2. 5904 Epoch 144/500 
323/323 [==============================] - 0s 19us/step - loss: 8.0300 
- mean_absolute_error: 1.9683 - val_loss: 14.5949 - val_mean_absolute_error: 
2. 5843 Epoch 145/500 
323/323 [==============================] - 0s 12us/step - loss: 7.8704 
- mean_absolute_error: 1.9313 - val_loss: 14.3770 - val_mean_absolute_error: 2. 4996

Step 7 − Evaluate the model

Let us evaluate the model using test data.

score = model.evaluate(x_test_scaled, y_test, verbose = 0) 
print('Test loss:', score[0]) 
print('Test accuracy:', score[1])

Executing the above code will output the below information −

Test loss: 21.928471583946077 Test accuracy: 2.9599233234629914

Step 8 − Predict

Finally, predict using test data as below −

prediction = model.predict(x_test_scaled) 
print(prediction.flatten()) 
print(y_test)

The output of the above application is as follows −

[ 7.5612316 17.583357 21.09344 31.859276 25.055613 18.673872 26.600405 22.403967 19.060272 22.264952 
17.4191 17.00466 15.58924 41.624374 20.220217 18.985565 26.419338 19.837091 19.946192 36.43445 
12.278508 16.330965 20.701359 14.345301 21.741161 25.050423 31.046402 27.738455 9.959419 20.93039 
20.069063 14.518344 33.20235 24.735163 18.7274 9.148898 15.781284 18.556862 18.692865 26.045074 
27.954073 28.106823 15.272034 40.879818 29.33896 23.714525 26.427515 16.483374 22.518442 22.425386 
33.94826 18.831465 13.2501955 15.537227 34.639984 27.468002 13.474407 48.134598 34.39617 
22.8503124.042334 17.747198 14.7837715 18.187277 23.655672 22.364983 13.858193 22.710032 14.371148 
7.1272087 35.960033 28.247292 25.3014 14.477208 25.306196 17.891165 20.193708 23.585173 34.690193 
12.200583 20.102983 38.45882 14.741723 14.408362 17.67158 18.418497 21.151712 21.157492 22.693687 
29.809034 19.366991 20.072294 25.880817 40.814568 34.64087 19.43741 36.2591 50.73806 26.968863 43.91787 
32.54908 20.248306 ] [ 7.2 18.8 19. 27. 22.2 24.5 31.2 22.9 20.5 23.2 18.6 14.5 17.8 50. 20.8 24.3 24.2 
19.8 19.1 22.7 12. 10.2 20. 18.5 20.9 23. 27.5 30.1 9.5 22. 21.2 14.1 33.1 23.4 20.1 7.4 15.4 23.8 20.1 
24.5 33. 28.4 14.1 46.7 32.5 29.6 28.4 19.8 20.2 25. 35.4 20.3 9.7 14.5 34.9 26.6 7.2 50. 32.4 21.6 29.8 
13.1 27.5 21.2 23.1 21.9 13. 23.2 8.1 5.6 21.7 29.6 19.6 7. 26.4 18.9 20.9 28.1 35.4 10.2 24.3 43.1 17.6 
15.4 16.2 27.1 21.4 21.5 22.4 25. 16.6 18.6 22. 42.8 35.1 21.5 36. 21.9 24.1 50. 26.7 25. ]

The output of both array have around 10-30% difference and it indicate our model predicts with reasonable range.

Keras - Time Series Prediction using LSTM RNN

In this chapter, let us write a simple Long Short Term Memory (LSTM) based RNN to do sequence analysis. A sequence is a set of values where each value corresponds to a particular instance of time. Let us consider a simple example of reading a sentence. Reading and understanding a sentence involves reading the word in the given order and trying to understand each word and its meaning in the given context and finally understanding the sentence in a positive or negative sentiment.

Here, the words are considered as values, and first value corresponds to first word, second value corresponds to second word, etc., and the order will be strictly maintained. Sequence Analysis is used frequently in natural language processing to find the sentiment analysis of the given text.

Let us create a LSTM model to analyze the IMDB movie reviews and find its positive/negative sentiment.

The model for the sequence analysis can be represented as below −

The core features of the model are as follows −

  • Input layer using Embedding layer with 128 features.

  • First layer, Dense consists of 128 units with normal dropout and recurrent dropout set to 0.2.

  • Output layer, Dense consists of 1 unit and ‘sigmoid’ activation function.

  • Use binary_crossentropy as loss function.

  • Use adam as Optimizer.

  • Use accuracy as metrics.

  • Use 32 as batch size.

  • Use 15 as epochs.

  • Use 80 as the maximum length of the word.

  • Use 2000 as the maximum number of word in a given sentence.

Step 1: Import the modules

Let us import the necessary modules.

from keras.preprocessing import sequence 
from keras.models import Sequential 
from keras.layers import Dense, Embedding 
from keras.layers import LSTM 
from keras.datasets import imdb

Step 2: Load data

Let us import the imdb dataset.

(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words = 2000)

Here,

  • imdb is a dataset provided by Keras. It represents a collection of movies and its reviews.

  • num_words represent the maximum number of words in the review.

Step 3: Process the data

Let us change the dataset according to our model, so that it can be fed into our model. The data can be changed using the below code −

x_train = sequence.pad_sequences(x_train, maxlen=80) 
x_test = sequence.pad_sequences(x_test, maxlen=80)

Here,

sequence.pad_sequences convert the list of input data with shape, (data) into 2D NumPy array of shape (data, timesteps). Basically, it adds timesteps concept into the given data. It generates the timesteps of length, maxlen.

Step 4: Create the model

Let us create the actual model.

model = Sequential() 
model.add(Embedding(2000, 128)) 
model.add(LSTM(128, dropout = 0.2, recurrent_dropout = 0.2)) 
model.add(Dense(1, activation = 'sigmoid'))

Here,

We have used Embedding layer as input layer and then added the LSTM layer. Finally, a Dense layer is used as output layer.

Step 5: Compile the model

Let us compile the model using selected loss function, optimizer and metrics.

model.compile(loss = 'binary_crossentropy', 
   optimizer = 'adam', metrics = ['accuracy'])

Step 6: Train the model

LLet us train the model using fit() method.

model.fit(
   x_train, y_train, 
   batch_size = 32, 
   epochs = 15, 
   validation_data = (x_test, y_test)
)

Executing the application will output the below information −

Epoch 1/15 2019-09-24 01:19:01.151247: I 
tensorflow/core/platform/cpu_feature_guard.cc:142] 
Your CPU supports instructions that this 
TensorFlow binary was not co mpiled to use: AVX2 
25000/25000 [==============================] - 101s 4ms/step - loss: 0.4707 
- acc: 0.7716 - val_loss: 0.3769 - val_acc: 0.8349 Epoch 2/15 
25000/25000 [==============================] - 95s 4ms/step - loss: 0.3058 
- acc: 0.8756 - val_loss: 0.3763 - val_acc: 0.8350 Epoch 3/15 
25000/25000 [==============================] - 91s 4ms/step - loss: 0.2100 
- acc: 0.9178 - val_loss: 0.5065 - val_acc: 0.8110 Epoch 4/15 
25000/25000 [==============================] - 90s 4ms/step - loss: 0.1394 
- acc: 0.9495 - val_loss: 0.6046 - val_acc: 0.8146 Epoch 5/15 
25000/25000 [==============================] - 90s 4ms/step - loss: 0.0973 
- acc: 0.9652 - val_loss: 0.5969 - val_acc: 0.8147 Epoch 6/15 
25000/25000 [==============================] - 98s 4ms/step - loss: 0.0759 
- acc: 0.9730 - val_loss: 0.6368 - val_acc: 0.8208 Epoch 7/15 
25000/25000 [==============================] - 95s 4ms/step - loss: 0.0578 
- acc: 0.9811 - val_loss: 0.6657 - val_acc: 0.8184 Epoch 8/15 
25000/25000 [==============================] - 97s 4ms/step - loss: 0.0448 
- acc: 0.9850 - val_loss: 0.7452 - val_acc: 0.8136 Epoch 9/15 
25000/25000 [==============================] - 95s 4ms/step - loss: 0.0324 
- acc: 0.9894 - val_loss: 0.7616 - val_acc: 0.8162Epoch 10/15 
25000/25000 [==============================] - 100s 4ms/step - loss: 0.0247 
- acc: 0.9922 - val_loss: 0.9654 - val_acc: 0.8148 Epoch 11/15 
25000/25000 [==============================] - 99s 4ms/step - loss: 0.0169 
- acc: 0.9946 - val_loss: 1.0013 - val_acc: 0.8104 Epoch 12/15 
25000/25000 [==============================] - 90s 4ms/step - loss: 0.0154 
- acc: 0.9948 - val_loss: 1.0316 - val_acc: 0.8100 Epoch 13/15 
25000/25000 [==============================] - 89s 4ms/step - loss: 0.0113 
- acc: 0.9963 - val_loss: 1.1138 - val_acc: 0.8108 Epoch 14/15 
25000/25000 [==============================] - 89s 4ms/step - loss: 0.0106 
- acc: 0.9971 - val_loss: 1.0538 - val_acc: 0.8102 Epoch 15/15 
25000/25000 [==============================] - 89s 4ms/step - loss: 0.0090 
- acc: 0.9972 - val_loss: 1.1453 - val_acc: 0.8129 
25000/25000 [==============================] - 10s 390us/step

Step 7 − Evaluate the model

Let us evaluate the model using test data.

score, acc = model.evaluate(x_test, y_test, batch_size = 32) 
   
print('Test score:', score) 
print('Test accuracy:', acc)

Executing the above code will output the below information −

Test score: 1.145306069601178 
Test accuracy: 0.81292

Keras - Applications

Keras applications module is used to provide pre-trained model for deep neural networks. Keras models are used for prediction, feature extraction and fine tuning. This chapter explains about Keras applications in detail.

Pre-trained models

Trained model consists of two parts model Architecture and model Weights. Model weights are large file so we have to download and extract the feature from ImageNet database. Some of the popular pre-trained models are listed below,

  • ResNet
  • VGG16
  • MobileNet
  • InceptionResNetV2
  • InceptionV3

Loading a model

Keras pre-trained models can be easily loaded as specified below −

import keras 
import numpy as np 
from keras.applications import vgg16, inception_v3, resnet50, mobilenet 
#Load the VGG model 
vgg_model = vgg16.VGG16(weights = 'imagenet') 
#Load the Inception_V3 model 
inception_model = inception_v3.InceptionV3(weights = 'imagenet') 
#Load the ResNet50 model 
resnet_model = resnet50.ResNet50(weights = 'imagenet') 
#Load the MobileNet model mobilenet_model = mobilenet.MobileNet(weights = 'imagenet')

Once the model is loaded, we can immediately use it for prediction purpose. Let us check each pre-trained model in the upcoming chapters.

Real Time Prediction using ResNet Model

ResNet is a pre-trained model. It is trained using ImageNet. ResNet model weights pre-trained on ImageNet. It has the following syntax −

keras.applications.resnet.ResNet50 (
   include_top = True, 
   weights = 'imagenet', 
   input_tensor = None, 
   input_shape = None, 
   pooling = None, 
   classes = 1000
)

Here,

  • include_top refers the fully-connected layer at the top of the network.

  • weights refer pre-training on ImageNet.

  • input_tensor refers optional Keras tensor to use as image input for the model.

  • input_shape refers optional shape tuple. The default input size for this model is 224x224.

  • classes refer optional number of classes to classify images.

Let us understand the model by writing a simple example −

Step 1: import the modules

Let us load the necessary modules as specified below −

>>> import PIL 
>>> from keras.preprocessing.image import load_img 
>>> from keras.preprocessing.image import img_to_array 
>>> from keras.applications.imagenet_utils import decode_predictions 
>>> import matplotlib.pyplot as plt 
>>> import numpy as np 
>>> from keras.applications.resnet50 import ResNet50 
>>> from keras.applications import resnet50

Step 2: Select an input

Let us choose an input image, Lotus as specified below −

>>> filename = 'banana.jpg' 
>>> ## load an image in PIL format 
>>> original = load_img(filename, target_size = (224, 224)) 
>>> print('PIL image size',original.size)
PIL image size (224, 224) 
>>> plt.imshow(original) 
<matplotlib.image.AxesImage object at 0x1304756d8> 
>>> plt.show()

Here, we have loaded an image (banana.jpg) and displayed it.

Step 3: Convert images into NumPy array

Let us convert our input, Banana into NumPy array, so that it can be passed into the model for the purpose of prediction.

>>> #convert the PIL image to a numpy array 
>>> numpy_image = img_to_array(original) 
>>> plt.imshow(np.uint8(numpy_image)) 
<matplotlib.image.AxesImage object at 0x130475ac8> 
>>> print('numpy array size',numpy_image.shape) 
numpy array size (224, 224, 3) 
>>> # Convert the image / images into batch format 
>>> image_batch = np.expand_dims(numpy_image, axis = 0) 
>>> print('image batch size', image_batch.shape) 
image batch size (1, 224, 224, 3)
>>>

Step 4: Model prediction

Let us feed our input into the model to get the predictions

>>> prepare the image for the resnet50 model >>> 
>>> processed_image = resnet50.preprocess_input(image_batch.copy()) 
>>> # create resnet model 
>>>resnet_model = resnet50.ResNet50(weights = 'imagenet') 
>>> Downloavding data from https://github.com/fchollet/deep-learning-models/releas
es/download/v0.2/resnet50_weights_tf_dim_ordering_tf_kernels.h5 
102858752/102853048 [==============================] - 33s 0us/step 
>>> # get the predicted probabilities for each class 
>>> predictions = resnet_model.predict(processed_image) 
>>> # convert the probabilities to class labels 
>>> label = decode_predictions(predictions) 
Downloading data from https://storage.googleapis.com/download.tensorflow.org/
data/imagenet_class_index.json 
40960/35363 [==================================] - 0s 0us/step 
>>> print(label)

Output

[
   [
      ('n07753592', 'banana', 0.99229723), 
      ('n03532672', 'hook', 0.0014551596), 
      ('n03970156', 'plunger', 0.0010738898), 
      ('n07753113', 'fig', 0.0009359837) , 
      ('n03109150', 'corkscrew', 0.00028538404)
   ]
]

Here, the model predicted the images as banana correctly.

Keras - Pre-Trained Models

In this chapter, we will learn about the pre-trained models in Keras. Let us begin with VGG16.

VGG16

VGG16 is another pre-trained model. It is also trained using ImageNet. The syntax to load the model is as follows −

keras.applications.vgg16.VGG16(
   include_top = True, 
   weights = 'imagenet', 
   input_tensor = None, 
   input_shape = None, 
   pooling = None, 
   classes = 1000
)

The default input size for this model is 224x224.

MobileNetV2

MobileNetV2 is another pre-trained model. It is also trained uing ImageNet.

The syntax to load the model is as follows −

keras.applications.mobilenet_v2.MobileNetV2 (
   input_shape = None, 
   alpha = 1.0, 
   include_top = True, 
   weights = 'imagenet', 
   input_tensor = None, 
   pooling = None, 
   classes = 1000
)

Here,

alpha controls the width of the network. If the value is below 1, decreases the number of filters in each layer. If the value is above 1, increases the number of filters in each layer. If alpha = 1, default number of filters from the paper are used at each layer.

The default input size for this model is 224x224.

InceptionResNetV2

InceptionResNetV2 is another pre-trained model. It is also trained using ImageNet. The syntax to load the model is as follows −

keras.applications.inception_resnet_v2.InceptionResNetV2 (
   include_top = True, 
   weights = 'imagenet',
   input_tensor = None, 
   input_shape = None, 
   pooling = None, 
   classes = 1000)

This model and can be built both with ‘channels_first’ data format (channels, height, width) or ‘channels_last’ data format (height, width, channels).

The default input size for this model is 299x299.

InceptionV3

InceptionV3 is another pre-trained model. It is also trained uing ImageNet. The syntax to load the model is as follows −

keras.applications.inception_v3.InceptionV3 (
   include_top = True, 
   weights = 'imagenet', 
   input_tensor = None, 
   input_shape = None, 
   pooling = None, 
   classes = 1000
)

Here,

The default input size for this model is 299x299.

Conclusion

Keras is very simple, extensible and easy to implement neural network API, which can be used to build deep learning applications with high level abstraction. Keras is an optimal choice for deep leaning models.