Python深度学习实战指南：初学者入门教程

2星需积分: 50 79 浏览量更新于2024-07-19 3 收藏 6.47MB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

资源详情

资源推荐

Chapter 1 ■ IntroduCtIon to deep LearnIng

Overview of Subsequent Chapters

We now provide an overall outline of the subsequent chapters for the reader. It is important to note that

each of the chapters covers either the concepts or the skills (or in certain cases both) with respect to deep

learning. We highlight these below so that the readers can ensure that they have internalized these concepts

and skills. It is highly recommended that the readers not only read the chapters but also work out the

mathematical details (using pen and paper) and play with the source code provided in each of the chapters.

1. Chapter 2 covers the basics of Machine Learning. The key take home point for

this chapter is the concept of generalizing over unseen examples, the ideas of

over-fitting and under-fitting the training data, the capacity of the model, and the

notion of regularization.

2. Chapter 3 covers Feed Forward Neural Networks and serves as the conceptual

foundation for the entire book. Concepts like the overall structure of the neural

network, the input, hidden and output layers, cost functions and their basis on

the principle of Maximum Likelihood are the important concepts in this chapter.

3. Chapter 4 provides a hands-on introduction to the Theano library. It covers how

to define networks as computational graphs, automatically derive gradients for

complicated networks, and train neural networks.

4. Chapter 5 covers Convolutional Neural Networks, which are perhaps the most

successful application of deep learning.

5. Chapter 6 covers Recurrent Neural Networks and Long Short Term Memory

(LSTM) networks, which are another successful application of deep learning.

6. Chapter 7 provides a hands-on introduction to the Keras library. The Keras

library provides a number of high-level abstractions over the Theano library

and is probably the ideal go-to tool when it comes to building deep learning

applications.

7. Chapter 8 introduces the reader to Stochastic Gradient Descent (SGD), which is

the most common procedure used to train Neural Networks. This chapter also

covers the shortcomings of SGD and a number of variations to SGD that address

these shortcomings.

8. Chapter 9 introduces the reader to Automatic Differentiation (commonly

referred to as backpropagation), which is a standard technique used to derive

gradients (required for SGD) for arbitrarily complicated networks.

9. Chapter 10 introduces the reader to Graphical Processing Units (GPUs) and

GPU-based computation, which has acted as a key enabling technology for deep

learning.

Installing the Required Libraries

There are a number of libraries that the reader will need to install in order to run the source code for

the examples in the chapters. We recommend that the reader install Anaconda Python Distribution

(https://www.continuum.io/downloads), which would make the process of installing the required packages

significantly easy (using either conda or pip). The list of packages the reader would need includes Scikit-learn,

Theano, Autograd, Keras, and PyOpenCL.

N. Ketkar, Deep Learning with Python, DOI 10.1007/978-1-4842-2766-4_2

CHAPTER 2

Machine Learning Fundamentals

Deep Learning is a branch of Machine Learning and in this chapter we will cover the fundamentals of

Machine Learning. While machine learning as a subject is inherently mathematical in nature, we will keep

mathematics to the basic minimum required to develop intuition about the subject. Prerequisites for the

subject matter covered in this chapter would be linear algebra, multivariable calculus, and basic probability

theory.

Intuition

As human beings we are intuitively aware of the concept of learning: it simply means to get better at a task

over a period of time. The task could be physical (like learning to drive a car) or intellectual (like learning

a new language). The subject of machine learning focuses on development of algorithms that can learn as

humans do; that is, they get better at a task over a period over time, with experience.

The first question to ask is why we would be interested in development of algorithms that improve

their performance over time, with experience. After all, there are many algorithms that are developed and

implemented to solve real world problems that don’t improve over time, they simply are developed by

humans and implemented in software and they get the job done. From banking to e-commerce and from

navigation systems in our cars to landing a spacecraft on the moon, algorithms are everywhere, and, a

majority of them do not improve over time. These algorithms simply perform the task they are intended to

perform, with some maintenance required from time to time. Why do we need machine learning?

The answer to this question is that for certain tasks it is easier to develop an algorithm that learns/

improves its performance with experience than to develop an algorithm manually. While this might seem

unintuitive to the reader at this point, we will build intuition for this during the course of this chapter.

Binary Classification

In order to further discuss the matter at hand, we need to be precise about some of the terms we have been

intuitively using, like task, learning, experience, and improvement. We will start with the task of binary

classification.

Consider an abstract problem domain where we have data of the form

D = {(x

, y

), (x

, y

), … (x

, y

)}

where x



and y = ±1. We do not have access to all such data but only a subset

SDÎ

. Using S, our task

is to generate a computational procedure that implements the function

fx y:

such that we can use f to

make predictions over unseen data

xy S

()

Ï that are correct, fx y

()

= . Let us denote

UDÎ

as the set of

CHAPTER 2 ■ MACHINE LEARNING FUNDAMENTALS

unseen data, that is,

xy S

()

Ï and xy U

()

Î . We measure performance over this task as the error over

unseen data,

EfDU

fx y

xy U

()

We now have a precise definition of the task, which is to categorize data into one of two categories

(y = ±1) based on some seen data S by generating f. We measure performance (and improvement in

performance) using the error E (f,D,U) over unseen data U. The size of the seen data |S| is the conceptual

equivalent of experience. In this context, we want to develop algorithms that generate such functions

f (which are commonly referred to as a model). In general, the field of machine learning studies the

development of such algorithms that produce models that make predictions over unseen data for such

algorithms, and other formal tasks (we will be introducing multiple such tasks later in the chapter). Note that

the x is commonly referred to as the input/input variable and y is referred to as the output/output variable.

As with any other discipline in computer science, the computational characteristics of such algorithms

is an important facet, but in addition to that we also would like to have a model f that achieves a lower error

E (f, D, U) with as small a |S| as possible.

Let us now relate this abstract but precise definition to a real world problem so that our abstractions

are grounded. Let us say an e-commerce web site wants to customize the landing page for registered users

to show them the products the users might be interested in buying. The web site has historical data on users

and would like to implement this as a feature so as to increase sales. Let us now see how this real world

problem maps onto the abstract problem of binary classification we described earlier.

The first thing that one might notice is that given a particular user and a particular product, one wants

to predict whether the user will buy the product. Since this is the value to be predicted, it maps onto y = ±1,

where we will let the value of y = +1 denote the prediction that the user will buy the product and we will

denote y = –1 as the prediction that the user does not buy the product. Note that that there is no particular

reason for picking these values; we could have swapped this (let y = +1 denote the does not buy case and

y = –1 denote the buy case) and there would be no difference. We just use y = ±1 to denote the two classes of

interest to categorize data. Next, let us assume that we can somehow represent the attributes of the product

and the user’s buying and browsing history as



. This step is referred to as feature engineering in

machine learning and we will cover it later in the chapter. For now, it suffices to say that we are able to

generate such a mapping. Thus, we have historical data of what the users browsed and bought, attributes of

a product and whether the user bought the product or not mapped onto {(x

,y

),(x

, y

), … (x

, y

)}. Now,

based on this data, we would like to generate a function or a model

fx y:

which we can use to determine

which products a particular user will buy and use this to populate the landing page for users. We can

measure how well the model is doing on unseen data by populating the landing page for users and see

whether they buy the products or not and evaluate the error E (f,D,U).

Regression

Let us introduce another task, namely regression. Here, we have data of the form Dxyxyxy

()()

()

{}

11 22

,, ,

where



and y

Î 

and our task is to generate a computational procedure that implements the function

fx y:

. Note that instead of the prediction being a binary class label y = ±1 like in binary classification, we have

real valued prediction. We measure performance over this task as the root mean squared error (RMSE) over

unseen data,

CHAPTER 2 ■ MACHINE LEARNING FUNDAMENTALS

model = numpy.dot(numpy.dot(numpy.linalg.inv(numpy.dot(X_train.transpose(),X_train)),X_

train.transpose()),y_train)

pylab.plot(x,y,'g')

pylab.xlabel("x")

pylab.ylabel("y")

predicted = numpy.dot(model, [numpy.power(x,i) for i in xrange(0,degree)])

pylab.plot(x, predicted,'r')

pylab.legend(["Actual", "Predicted"], loc = 2)

train_rmse1 = numpy.sqrt(numpy.sum(numpy.dot(y[0:80] - predicted[0:80], y_train -

predicted[0:80])))

test_rmse1 = numpy.sqrt(numpy.sum(numpy.dot(y[80:] - predicted[80:], y[80:] -

predicted[80:])))

print("Train RMSE (Degree = 1)", train_rmse1)

print("Test RMSE (Degree = 1)", test_rmse1)

# Model with degree 2

pylab.figure()

degree = 3

X_train = numpy.column_stack([numpy.power(x_train,i) for i in xrange(0,degree)])

model = numpy.dot(numpy.dot(numpy.linalg.inv(numpy.dot(X_train.transpose(),X_train)),

X_train.transpose()),y_train)

pylab.plot(x,y,'g')

pylab.xlabel("x")

pylab.ylabel("y")

predicted = numpy.dot(model, [numpy.power(x,i) for i in xrange(0,degree)])

pylab.plot(x, predicted,'r')

pylab.legend(["Actual", "Predicted"], loc = 2)

train_rmse1 = numpy.sqrt(numpy.sum(numpy.dot(y[0:80] - predicted[0:80],

y_train - predicted[0:80])))

test_rmse1 = numpy.sqrt(numpy.sum(numpy.dot(y[80:] - predicted[80:],

y[80:] - predicted[80:])))

print("Train RMSE (Degree = 2)", train_rmse1)

print("Test RMSE (Degree = 2)", test_rmse1)

# Model with degree 8

pylab.figure()

degree = 9

X_train = numpy.column_stack([numpy.power(x_train,i) for i in xrange(0,degree)])

model = numpy.dot(numpy.dot(numpy.linalg.inv(numpy.dot(X_train.transpose(),X_train)),

X_train.transpose()), y_train)

pylab.plot(x, y,'g')

pylab.xlabel("x")

pylab.ylabel("y")

predicted = numpy.dot(model, [numpy.power(x,i) for i in xrange(0,degree)])

pylab.plot(x, predicted,'r')

pylab.legend(["Actual", "Predicted"], loc = 3)

train_rmse2 = numpy.sqrt(numpy.sum(numpy.dot(y[0:80] - predicted[0:80],

y_train - predicted[0:80])))

test_rmse2 = numpy.sqrt(numpy.sum(numpy.dot(y[80:] - predicted[80:],

y[80:] - predicted[80:])))

print("Train RMSE (Degree = 8)", train_rmse2)

print("Test RMSE (Degree = 8)", test_rmse2)

dou.bz/35ODPo

剩余168页未读，继续阅读

黑猫警长

粉丝: 19
资源: 11

Python深度学习实战指南：初学者入门教程

python写的深度学习代码

【源代码】深度学习入门：基于Python的理论与实现.zip

Python+深度学习_LB752XFM3JMWROKYBIUPNSFAO6AWYGWW.azw3

基于Python深度学习的Web文本纠错系统

基于Python深度学习的中文纠错Web系统

"基于Python深度学习的优化聊天机器人系统

基于Python深度学习的Web中文纠错系统

"基于Python深度学习的聊天机器人数据库论文

Python深度学习基础与实战

Python深度学习基础解析

Python3 深度学习框架与应用

Python 中的深度学习入门

：Python深度学习：用Python探索深度学习的奥秘，打造智能应用

基于python深度学习

基于python深度学习入门

基于Python深度学习计算图片中秧苗的缺苗率代码

基于Python深度学习PyTorch计算图片中秧苗的缺苗率代码

帮我写一个基于python深度学习的代码

提供一个基于python深度学习识别手写数字图片的样例

基于python深度学习训练中文语音识别

最新资源