Skip to content

Commit 96d58b5

Browse files
fcholletfchollet
committed
Add notebooks
1 parent 386a7c1 commit 96d58b5

19 files changed

+17210
-0
lines changed

‎2.1-a-first-look-at-a-neural-network.ipynb

+451
Large diffs are not rendered by default.

‎3.5-classifying-movie-reviews.ipynb

+1,051
Large diffs are not rendered by default.

‎3.6-classifying-newswires.ipynb

+984
Large diffs are not rendered by default.

‎3.7-predicting-house-prices.ipynb

+709
Large diffs are not rendered by default.

‎4.4-overfitting-and-underfitting.ipynb

+980
Large diffs are not rendered by default.

‎5.1-introduction-to-convnets.ipynb

+330
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,330 @@
1+
{
2+
"cells": [
3+
{
4+
"cell_type": "code",
5+
"execution_count": 1,
6+
"metadata": {},
7+
"outputs": [
8+
{
9+
"name": "stderr",
10+
"output_type": "stream",
11+
"text": [
12+
"Using TensorFlow backend.\n"
13+
]
14+
},
15+
{
16+
"data": {
17+
"text/plain": [
18+
"'2.0.8'"
19+
]
20+
},
21+
"execution_count": 1,
22+
"metadata": {},
23+
"output_type": "execute_result"
24+
}
25+
],
26+
"source": [
27+
"import keras\n",
28+
"keras.__version__"
29+
]
30+
},
31+
{
32+
"cell_type": "markdown",
33+
"metadata": {
34+
"collapsed": true
35+
},
36+
"source": [
37+
"# 5.1 - Introduction to convnets\n",
38+
"\n",
39+
"This notebook contains the code sample found in Chapter 5, Section 1 of [Deep Learning with Python](https://www.manning.com/books/deep-learning-with-python?a_aid=keras&a_bid=76564dff). Note that the original text features far more content, in particular further explanations and figures: in this notebook, you will only find source code and related comments.\n",
40+
"\n",
41+
"----\n",
42+
"\n",
43+
"First, let's take a practical look at a very simple convnet example. We will use our convnet to classify MNIST digits, a task that you've already been \n",
44+
"through in Chapter 2, using a densely-connected network (our test accuracy then was 97.8%). Even though our convnet will be very basic, its \n",
45+
"accuracy will still blow out of the water that of the densely-connected model from Chapter 2.\n",
46+
"\n",
47+
"The 6 lines of code below show you what a basic convnet looks like. It's a stack of `Conv2D` and `MaxPooling2D` layers. We'll see in a \n",
48+
"minute what they do concretely.\n",
49+
"Importantly, a convnet takes as input tensors of shape `(image_height, image_width, image_channels)` (not including the batch dimension). \n",
50+
"In our case, we will configure our convnet to process inputs of size `(28, 28, 1)`, which is the format of MNIST images. We do this via \n",
51+
"passing the argument `input_shape=(28, 28, 1)` to our first layer."
52+
]
53+
},
54+
{
55+
"cell_type": "code",
56+
"execution_count": 2,
57+
"metadata": {},
58+
"outputs": [],
59+
"source": [
60+
"from keras import layers\n",
61+
"from keras import models\n",
62+
"\n",
63+
"model = models.Sequential()\n",
64+
"model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))\n",
65+
"model.add(layers.MaxPooling2D((2, 2)))\n",
66+
"model.add(layers.Conv2D(64, (3, 3), activation='relu'))\n",
67+
"model.add(layers.MaxPooling2D((2, 2)))\n",
68+
"model.add(layers.Conv2D(64, (3, 3), activation='relu'))"
69+
]
70+
},
71+
{
72+
"cell_type": "markdown",
73+
"metadata": {},
74+
"source": [
75+
"Let's display the architecture of our convnet so far:"
76+
]
77+
},
78+
{
79+
"cell_type": "code",
80+
"execution_count": 3,
81+
"metadata": {},
82+
"outputs": [
83+
{
84+
"name": "stdout",
85+
"output_type": "stream",
86+
"text": [
87+
"_________________________________________________________________\n",
88+
"Layer (type) Output Shape Param # \n",
89+
"=================================================================\n",
90+
"conv2d_1 (Conv2D) (None, 26, 26, 32) 320 \n",
91+
"_________________________________________________________________\n",
92+
"max_pooling2d_1 (MaxPooling2 (None, 13, 13, 32) 0 \n",
93+
"_________________________________________________________________\n",
94+
"conv2d_2 (Conv2D) (None, 11, 11, 64) 18496 \n",
95+
"_________________________________________________________________\n",
96+
"max_pooling2d_2 (MaxPooling2 (None, 5, 5, 64) 0 \n",
97+
"_________________________________________________________________\n",
98+
"conv2d_3 (Conv2D) (None, 3, 3, 64) 36928 \n",
99+
"=================================================================\n",
100+
"Total params: 55,744\n",
101+
"Trainable params: 55,744\n",
102+
"Non-trainable params: 0\n",
103+
"_________________________________________________________________\n"
104+
]
105+
}
106+
],
107+
"source": [
108+
"model.summary()"
109+
]
110+
},
111+
{
112+
"cell_type": "markdown",
113+
"metadata": {
114+
"collapsed": true
115+
},
116+
"source": [
117+
"You can see above that the output of every `Conv2D` and `MaxPooling2D` layer is a 3D tensor of shape `(height, width, channels)`. The width \n",
118+
"and height dimensions tend to shrink as we go deeper in the network. The number of channels is controlled by the first argument passed to \n",
119+
"the `Conv2D` layers (e.g. 32 or 64).\n",
120+
"\n",
121+
"The next step would be to feed our last output tensor (of shape `(3, 3, 64)`) into a densely-connected classifier network like those you are \n",
122+
"already familiar with: a stack of `Dense` layers. These classifiers process vectors, which are 1D, whereas our current output is a 3D tensor. \n",
123+
"So first, we will have to flatten our 3D outputs to 1D, and then add a few `Dense` layers on top:"
124+
]
125+
},
126+
{
127+
"cell_type": "code",
128+
"execution_count": 4,
129+
"metadata": {
130+
"collapsed": true
131+
},
132+
"outputs": [],
133+
"source": [
134+
"model.add(layers.Flatten())\n",
135+
"model.add(layers.Dense(64, activation='relu'))\n",
136+
"model.add(layers.Dense(10, activation='softmax'))"
137+
]
138+
},
139+
{
140+
"cell_type": "markdown",
141+
"metadata": {},
142+
"source": [
143+
"We are going to do 10-way classification, so we use a final layer with 10 outputs and a softmax activation. Now here's what our network \n",
144+
"looks like:"
145+
]
146+
},
147+
{
148+
"cell_type": "code",
149+
"execution_count": 5,
150+
"metadata": {},
151+
"outputs": [
152+
{
153+
"name": "stdout",
154+
"output_type": "stream",
155+
"text": [
156+
"_________________________________________________________________\n",
157+
"Layer (type) Output Shape Param # \n",
158+
"=================================================================\n",
159+
"conv2d_1 (Conv2D) (None, 26, 26, 32) 320 \n",
160+
"_________________________________________________________________\n",
161+
"max_pooling2d_1 (MaxPooling2 (None, 13, 13, 32) 0 \n",
162+
"_________________________________________________________________\n",
163+
"conv2d_2 (Conv2D) (None, 11, 11, 64) 18496 \n",
164+
"_________________________________________________________________\n",
165+
"max_pooling2d_2 (MaxPooling2 (None, 5, 5, 64) 0 \n",
166+
"_________________________________________________________________\n",
167+
"conv2d_3 (Conv2D) (None, 3, 3, 64) 36928 \n",
168+
"_________________________________________________________________\n",
169+
"flatten_1 (Flatten) (None, 576) 0 \n",
170+
"_________________________________________________________________\n",
171+
"dense_1 (Dense) (None, 64) 36928 \n",
172+
"_________________________________________________________________\n",
173+
"dense_2 (Dense) (None, 10) 650 \n",
174+
"=================================================================\n",
175+
"Total params: 93,322\n",
176+
"Trainable params: 93,322\n",
177+
"Non-trainable params: 0\n",
178+
"_________________________________________________________________\n"
179+
]
180+
}
181+
],
182+
"source": [
183+
"model.summary()"
184+
]
185+
},
186+
{
187+
"cell_type": "markdown",
188+
"metadata": {},
189+
"source": [
190+
"As you can see, our `(3, 3, 64)` outputs were flattened into vectors of shape `(576,)`, before going through two `Dense` layers.\n",
191+
"\n",
192+
"Now, let's train our convnet on the MNIST digits. We will reuse a lot of the code we have already covered in the MNIST example from Chapter \n",
193+
"2."
194+
]
195+
},
196+
{
197+
"cell_type": "code",
198+
"execution_count": 6,
199+
"metadata": {},
200+
"outputs": [],
201+
"source": [
202+
"from keras.datasets import mnist\n",
203+
"from keras.utils import to_categorical\n",
204+
"\n",
205+
"(train_images, train_labels), (test_images, test_labels) = mnist.load_data()\n",
206+
"\n",
207+
"train_images = train_images.reshape((60000, 28, 28, 1))\n",
208+
"train_images = train_images.astype('float32') / 255\n",
209+
"\n",
210+
"test_images = test_images.reshape((10000, 28, 28, 1))\n",
211+
"test_images = test_images.astype('float32') / 255\n",
212+
"\n",
213+
"train_labels = to_categorical(train_labels)\n",
214+
"test_labels = to_categorical(test_labels)"
215+
]
216+
},
217+
{
218+
"cell_type": "code",
219+
"execution_count": 7,
220+
"metadata": {},
221+
"outputs": [
222+
{
223+
"name": "stdout",
224+
"output_type": "stream",
225+
"text": [
226+
"Epoch 1/5\n",
227+
"60000/60000 [==============================] - 8s - loss: 0.1766 - acc: 0.9440 \n",
228+
"Epoch 2/5\n",
229+
"60000/60000 [==============================] - 7s - loss: 0.0462 - acc: 0.9855 \n",
230+
"Epoch 3/5\n",
231+
"60000/60000 [==============================] - 7s - loss: 0.0322 - acc: 0.9902 \n",
232+
"Epoch 4/5\n",
233+
"60000/60000 [==============================] - 7s - loss: 0.0241 - acc: 0.9926 \n",
234+
"Epoch 5/5\n",
235+
"60000/60000 [==============================] - 7s - loss: 0.0187 - acc: 0.9943 \n"
236+
]
237+
},
238+
{
239+
"data": {
240+
"text/plain": [
241+
"<keras.callbacks.History at 0x7fbd9c4cd828>"
242+
]
243+
},
244+
"execution_count": 7,
245+
"metadata": {},
246+
"output_type": "execute_result"
247+
}
248+
],
249+
"source": [
250+
"model.compile(optimizer='rmsprop',\n",
251+
" loss='categorical_crossentropy',\n",
252+
" metrics=['accuracy'])\n",
253+
"model.fit(train_images, train_labels, epochs=5, batch_size=64)"
254+
]
255+
},
256+
{
257+
"cell_type": "markdown",
258+
"metadata": {},
259+
"source": [
260+
"Let's evaluate the model on the test data:"
261+
]
262+
},
263+
{
264+
"cell_type": "code",
265+
"execution_count": 8,
266+
"metadata": {},
267+
"outputs": [
268+
{
269+
"name": "stdout",
270+
"output_type": "stream",
271+
"text": [
272+
" 9536/10000 [===========================>..] - ETA: 0s"
273+
]
274+
}
275+
],
276+
"source": [
277+
"test_loss, test_acc = model.evaluate(test_images, test_labels)"
278+
]
279+
},
280+
{
281+
"cell_type": "code",
282+
"execution_count": 9,
283+
"metadata": {},
284+
"outputs": [
285+
{
286+
"data": {
287+
"text/plain": [
288+
"0.99129999999999996"
289+
]
290+
},
291+
"execution_count": 9,
292+
"metadata": {},
293+
"output_type": "execute_result"
294+
}
295+
],
296+
"source": [
297+
"test_acc"
298+
]
299+
},
300+
{
301+
"cell_type": "markdown",
302+
"metadata": {},
303+
"source": [
304+
"While our densely-connected network from Chapter 2 had a test accuracy of 97.8%, our basic convnet has a test accuracy of 99.3%: we \n",
305+
"decreased our error rate by 68% (relative). Not bad! "
306+
]
307+
}
308+
],
309+
"metadata": {
310+
"kernelspec": {
311+
"display_name": "Python 3",
312+
"language": "python",
313+
"name": "python3"
314+
},
315+
"language_info": {
316+
"codemirror_mode": {
317+
"name": "ipython",
318+
"version": 3
319+
},
320+
"file_extension": ".py",
321+
"mimetype": "text/x-python",
322+
"name": "python",
323+
"nbconvert_exporter": "python",
324+
"pygments_lexer": "ipython3",
325+
"version": "3.5.2"
326+
}
327+
},
328+
"nbformat": 4,
329+
"nbformat_minor": 2
330+
}

0 commit comments

Comments
 (0)