从零开始的Python深度学习实战

Python

深度学习

需积分: 9 176 浏览量更新于2024-07-18 1 收藏 12.8MB PDF 举报

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

30元优惠券

"《Deep Learning with Python》是关于使用Python进行深度学习的书籍，通过一系列实际的代码示例，展示了如何解决现实世界的问题，并逐步引入深度学习的概念。这本书旨在为已有一定Python基础，但对机器学习和深度学习不熟悉的工程师和学生提供从基础知识到高级实践应用的全面指导。即使已有深度学习经验的读者，也能在书的后几章找到有价值的内容。深度学习是机器学习的一个强大子领域，有着广泛的应用，包括机器感知、自然语言处理以及创造性AI等。尽管其核心概念非常简单，但在传统叙述中往往被赋予一定的神秘色彩。" 本书深入浅出地介绍了深度学习的基本理论，首先会讲解神经网络的基础知识，包括神经元模型、前馈神经网络（Feedforward Neural Networks）以及反向传播算法。这些是构建深度学习模型的基础，读者将了解到如何通过Python实现这些模型，并理解它们的工作原理。接下来，书中会涉及卷积神经网络（Convolutional Neural Networks, CNN），这是图像处理和计算机视觉领域的关键。读者将学习如何使用Python库如TensorFlow和Keras构建CNN，以识别图像特征并执行分类任务。此外，书中还会讨论循环神经网络（Recurrent Neural Networks, RNN）及其变体，如长短期记忆网络（LSTM），这些网络在处理序列数据，如自然语言和时间序列分析方面表现出色。在实践中，深度学习通常需要大量的数据进行训练。因此，数据预处理和增强也是本书的重要部分，读者将学习如何清洗、标准化数据，并使用数据增强技术扩大训练集，以提高模型的泛化能力。书中还会涉及生成对抗网络（Generative Adversarial Networks, GANs）和强化学习（Reinforcement Learning），这些都是深度学习的前沿领域。GANs可以用于图像生成、风格迁移等创意应用，而强化学习则用于让机器通过与环境交互来学习最优策略。为了使读者能够快速上手，本书不仅会讲解理论，还会提供实际项目的例子，让读者能够在自己的环境中实现和运行这些模型。此外，书中还将涵盖模型评估和调优，以及如何将模型部署到生产环境。《Deep Learning with Python》是一本全面且实用的指南，无论你是初学者还是有经验的开发者，都能从中受益，提升自己在深度学习领域的技能和理解。

资源详情

资源推荐

Deep learning has reached a level of public attention and industry investment never seen

before in the history of AI, but it isn’t the first successful form of machine learning. In

fact, it’s a safe bet to say that most of the machine learning algorithms in use in the

industry today are still not deep learning algorithms. Deep learning isn’t always the right

tool for the job—sometimes there just isn’t enough data for deep learning to be

applicable, and sometimes the problem is simply better solved by a different algorithm. If

deep learning is your first contact with machine learning, then you may find yourself in a

situation where all you have is the deep learning hammer and every machine learning

problem starts looking like a nail for this hammer. The only way not to fall into this trap

is to be familiar with other approaches and practice them when appropriate.

A detailed exposure of classical machine learning approaches is outside of the scope

of this book, but we will briefly go over them and describe the historical context in which

they were developed. This will allow us to place deep learning in the broader context of

machine learning, and better understand where deep learning comes from and why it

matters.

Probabilistic modeling is the application of the principles of statistics to data analysis. It

was one of the earliest forms of machine learning, yet it is still widely used to this day.

One of the best-known algorithms in this category is the Naive Bayes algorithm.

Naive Bayes is a type of machine learning classifier based on applying the Bayes

Theorem while assuming that the features in the input data are all independent (a strong,

or "naive" assumption, which is where the name comes from). This form of data analysis

actually predates computers, and was applied by hand decades before its first computer

implementation (most likely dating back to the 1950s). The Bayes Theorem and the

foundations of statistics themselves date back to the 18th century, and these are all you

need to start using Naive Bayes classifiers.

A closely related model is the Logistic Regression (logreg for short), which is

sometimes considered to be the "hello world" of modern machine learning. Don’t be

misled by its name—logreg is in fact a classification algorithm rather than a regression

algorithm. Much like Naive Bayes, logreg predates computing by a long time, yet it is

still very useful to this day, thanks to its simple and versatile nature. It is often the first

thing a data scientist will try on a dataset to get a feel for the classification task at hand.

1.2 Before deep learning: a brief history of machine learning

1.2.1 Probabilistic modeling

Licensed to <null>

更多免费学习资料：www.86mhz.com/python.html

Early iterations of neural networks have been completely supplanted by the modern

variants that we cover in these pages; however, it is helpful to be aware of how deep

learning originated. Although the core ideas of neural networks were investigated in toy

forms as early as the 1950s, the approach took decades to really get started. For a long

time, the missing piece was a lack of an efficient way to train large neural networks. This

changed in the mid-1980s, as multiple people independently rediscovered the

"backpropagation" algorithm, a way to train chains of parametric operations using

gradient descent optimization (later in the book, we will go on to precisely define these

concepts), and started applying it to neural networks.

The first successful practical application of neural nets came in 1989 from Bell Labs,

when Yann LeCun combined together the earlier ideas of convolutional neural networks

and backpropagation, and applied them to the problem of handwritten digits

classification. The resulting network, dubbed "LeNet", was used by the US Post Office in

the 1990s to automate the reading of ZIP codes on mail envelopes.

As neural networks started gaining some respect among researchers in the 1990s thanks

to this first success, a new approach to machine learning rose to fame and quickly sent

neural nets back to oblivion: kernel methods.

Kernel methods are a group of classification algorithms, the best known of which is

the Support Vector Machine (SVM). The modern formulation of SVM was developed by

Vapnik and Cortes in the early 1990s at Bell Labs and published in 1995, although an

older linear formulation was published by Vapnik and Chervonenkis as early as 1963.

SVM aims at solving classification problems by finding good "decision boundaries"

(Figure 1.10) between two sets of points belonging to two different categories. A

"decision boundary" can be thought of as a line or surface separating your training data

into two spaces corresponding to two categories. To classify new data points, you just

need to check which side of the decision boundary they fall on.

Figure 1.10 A decision boundary

1.2.2 Early neural networks

1.2.3 Kernel methods

Licensed to <null>

更多免费学习资料：www.86mhz.com/python.html

SVMs proceed to find these boundaries in two steps:

First, the data is mapped to a new high-dimensional representation where the decision

boundary can be expressed as an hyperplane (if the data is two-dimensional like in our

example, an "hyperplane" would simply be a straight line).

Then a good decision boundary (a separation hyperplane) is computed by trying to

maximize the distance between the hyperplane and the closest data points from each

class, a step called "maximizing the margin". This allows the boundary to generalize well

to new samples outside of the training dataset.

The technique of mapping data to a high-dimensional representation where a

classification problem becomes simpler may look good on paper, but in practice it is

often computationally intractable. That’s where the "kernel trick" comes in, the key idea

that kernel methods are named after. Here’s the gist of it: for finding good decision

hyperplanes in the new representation space, you don’t have to explicitly compute the

coordinates of your points in the new space, you just need to compute the distance

between pairs of points in that space, which can be done very efficiently using what is

called a "kernel function". A kernel function is a computationally tractable operation that

maps any two points in your initial space to the distance between these points in your

target representation space, completely by-passing the explicit computation of the new

representation. Kernel functions are typically crafted by hand rather than learned from

data—in the case of SVM, only the separation hyperplane is learned.

At the time they were developed, SVMs exhibited state of the art performance on

simple classification problems, and were one of the few machine learning methods

backed by extensive theory and amenable to serious mathematical analysis, making it

well-understood and easily interpretable. Because of these useful properties, it became

extremely popular in the field for a long time.

However, SVM proved hard to scale to large datasets and did not provide very good

results for "perceptual" problems such as image classification. Since SVM is a "shallow"

method, applying SVM to perceptual problems requires first extracting useful

representations manually (a step called "feature engineering"), which is difficult and

brittle.

Decision trees are flowchart-like structures that can allow to classify input data points or

predict output values given inputs. They are easy to visualize and interpret. Decisions

trees learned from data started getting significant research interest in the 2000s, and by

2010 they were often preferred to kernel methods.

1.2.4 Decision trees, Random Forests and Gradient Boosting Machines

Licensed to <null>

更多免费学习资料：www.86mhz.com/python.html

Figure 1.11 A decision tree: the parameters that are learned are the questions about the

data. A question could be, for instance, "is coefficient 2 in the data higher than 3.5?".

In particular, the "Random Forest" algorithm introduced a robust and practical take on

decision tree learning that involves building a large number of specialized decision trees

then ensembling their outputs. Random Forests are applicable to a very wide range of

problems --you could say that they are almost always the second-best algorithm for any

shallow machine learning task. When the popular machine learning competition website

Kaggle.com got started in 2010, Random Forests quickly became a favorite on the

platform—until 2014, when Gradient Boosting Machines took over. Gradient Boosting

Machines, much like Random Forests, is a machine learning technique based on

ensembling weak prediction models, generally decision trees. It leverages "gradient

boosting", a way to improve any machine learning model by iteratively training new

models that specialize in addressing the weak points of the previous models. Applied to

decision trees, the use of the "gradient boosting" technique results in models that strictly

outperform Random Forests most of the time, while having very similar properties. It

may be one of the best, if not the best, algorithm for dealing with non-perceptual data

today. Alongside deep learning, it is one of the most commonly used technique in Kaggle

competitions.

Around 2010, while neural networks were almost completely shunned by the scientific

community at large, a number of people still working on neural networks started making

important breakthroughs: the groups of Geoffrey Hinton at the University of Toronto,

Yoshua Bengio at the University of Montreal, Yann LeCun at New York University, and

IDSIA in Switzerland.

In 2011, Dan Ciresan from IDSIA started winning academic image classification

competitions with GPU-trained deep neural networks—the first practical success of

modern deep learning. But the watershed moment came in 2012, with the entry of

Hinton’s group in the yearly large-scale image classification challenge ImageNet. The

ImageNet challenge was notoriously difficult at the time, consisting in classifying

high-resolution color images into 1000 different categories after training on 1.4 million

images. In 2011, the top-5 accuracy of the winning model, based on classical approaches

1.2.5 Back to neural networks

Licensed to <null>

更多免费学习资料：www.86mhz.com/python.html

to computer vision, was only 74.3%. Then in 2012, a team led by Alex Krizhevsky and

advised by Geoffrey Hinton was able to achieve a top-5 accuracy of 83.6%—a significant

breakthrough. The competition has been dominated by deep convolutional neural

networks every year since. By 2015, we had reached an accuracy of 96.4%, and the

classification task on ImageNet was considered to be a completely solved problem.

Since 2012, deep convolutional neural networks ("convnets") have become the go-to

algorithm for all computer vision tasks, and generally all perceptual tasks. At major

computer vision conferences in 2015 or 2016, it had become nearly impossible to find

presentations that did not involve convnets in some form. At the same time, deep learning

has also found applications in many other types of problems, such as natural language

processing. It has come to completely replace SVMs and decision trees in a wide range of

applications. For instance, for several years, the European Organization for Nuclear

Research, CERN, used decision tree-based methods for analysis of particle data from the

ATLAS detector at the Large Hadron Collider (LHC), but they eventually switched to

Keras-based deep neural networks due to their higher performance and ease of training

on large datasets.

The reason why deep learning took off so quickly is primarily that it offered better

performance on many problems. But that’s not the only reason. Deep learning is also

making problem-solving much easier, because it completely automates what used to be

the most crucial step in a machine learning workflow: "feature engineering".

Previous machine learning techniques, "shallow" learning, only involved

transforming the input data into one or two successive representation spaces, usually via

very simple transformations such as high-dimensional non-linear projections (SVM) or

decision trees. But the refined representations required by complex problems generally

cannot be attained by such techniques. As such, humans had to go to great length to make

the initial input data more amenable to processing by these methods, i.e. they had to

manually engineer good layers of representations for their data. This is what is called

"feature engineering". Deep learning, on the other hand, completely automates this step:

with deep learning, you all features in one pass rather than having to engineer themlearn

yourself. This has greatly simplified machine learning workflows, often replacing very

sophisticated multi-stage pipelines with a single, simple, end-to-end deep learning model.

You may ask, if the crux of the issue is to have multiple successive layers of

representation, could shallow methods be applied repeatedly to emulate the effects of

deep learning? In practice, there are fast-diminishing returns to successive application of

shallow learning methods, because the optimal first representation layer in a 3-layer

. What is transformativemodel is not the optimal first layer in a 1-layer or 2-layer model

about deep learning is that it allows a model to learn all layers of representation , atjointly

the same time, rather than in succession ("greedily", as it is called). With joint feature

learning, whenever the model adjusts one of its internal features, all other features that

depend on it will automatically adapt to the change, without requiring human

1.2.6 What makes deep learning different

Licensed to <null>

更多免费学习资料：www.86mhz.com/python.html

剩余316页未读，继续阅读

han--han

粉丝: 32
资源: 71

从零开始的Python深度学习实战

deep learning with python

Deep Learning with Python: A Hands-on Introduction

deep learning with python 中文版

deep learning with python 2nd

deep learning with python francois chollet with j. j. allaire

编写程序统计英文句子“A strong foundation on neural networks and deep learning with Python libraries.”中各字符出现的次数，不区分大小写"

python machine learning machine learning and deep learning with python.pdf

python深度学习(deep learning with python),fran ois chollet, 张亮译,人民邮

程序统计英文句子“A strong foundation on neural networks and deep learning with Python libraries.”中各字符出现的次数，不区分大小写"

deep learning withpython

深度学习电子书免费下载的地方

Python深度学习教程

深度学习参考文献列表

对于深度强化学习的学习应该看哪些资料

deeplearning with pytorch csdn

人工智能深度学习参考文献

图像处理与深度学习相关书籍与作者

python图像识别推荐书籍

机器学习 大数据 书籍

最新资源

机器学习大数据书籍