没有合适的资源?快使用搜索试试~ 我知道了~
首页Python与Keras深度学习实战:英文版 MEAP
"《Deep Learning with Python: Keras实战》(MEAPEdition, 第6版)是一本由Manning Publications出版的英文深度学习教程。该书专为希望从头开始学习深度学习并快速将其应用于实际问题解决的工程师和学生设计,尤其适合那些有一定Python基础但对机器学习和深度学习尚不熟悉的读者。作者力求将理论与实践相结合,从基础知识如神经网络原理,到高级应用如卷积神经网络(CNN)和循环神经网络(RNN),全面覆盖。 在本书中,作者会引导读者一步步构建深度学习模型,使用Keras库进行实现,这个库是基于Python编写的高级神经网络API,使得深度学习的开发过程更为简洁高效。作者强调,即使对于有深度学习经验的读者,也能在后面的章节中找到新的见解和实践技巧。 书中特别指出,购买了MEAP版本的读者可以参与论坛讨论,通过Manning社区获取更多信息和支持,以及在生产过程中提出宝贵的评论和建议,以帮助完善书籍质量。版权方面,此书受到许可,具体内容可能会在最终出版时经过编辑和校对团队的修订。 《Deep Learning with Python: Keras实战》是一本极具实用价值的资源,不仅适合初学者系统学习深度学习,也是经验丰富的开发者扩展知识库、提升技能的宝贵指南。无论你是想入门还是寻求进一步深化理解,这本书都能提供丰富的实践案例和理论支持,帮助你在深度学习领域取得突破。"
资源详情
资源推荐
![](https://csdnimg.cn/release/download_crawler_static/10715317/bg10.jpg)
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
©Manning Publications Co. We welcome reader comments about anything in the manuscript - other than typos and
other simple mistakes. These will be cleaned up during production of the book by copyeditors and proofreaders.
https://forums.manning.com/forums/deep-learning-with-python
12
Licensed to <null>
![](https://csdnimg.cn/release/download_crawler_static/10715317/bg11.jpg)
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
©Manning Publications Co. We welcome reader comments about anything in the manuscript - other than typos and
other simple mistakes. These will be cleaned up during production of the book by copyeditors and proofreaders.
https://forums.manning.com/forums/deep-learning-with-python
13
Licensed to <null>
![](https://csdnimg.cn/release/download_crawler_static/10715317/bg12.jpg)
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
©Manning Publications Co. We welcome reader comments about anything in the manuscript - other than typos and
other simple mistakes. These will be cleaned up during production of the book by copyeditors and proofreaders.
https://forums.manning.com/forums/deep-learning-with-python
14
Licensed to <null>
![](https://csdnimg.cn/release/download_crawler_static/10715317/bg13.jpg)
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
©Manning Publications Co. We welcome reader comments about anything in the manuscript - other than typos and
other simple mistakes. These will be cleaned up during production of the book by copyeditors and proofreaders.
https://forums.manning.com/forums/deep-learning-with-python
15
Licensed to <null>
![](https://csdnimg.cn/release/download_crawler_static/10715317/bg14.jpg)
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
©Manning Publications Co. We welcome reader comments about anything in the manuscript - other than typos and
other simple mistakes. These will be cleaned up during production of the book by copyeditors and proofreaders.
https://forums.manning.com/forums/deep-learning-with-python
16
Licensed to <null>
剩余316页未读,继续阅读
![zip](https://img-home.csdnimg.cn/images/20210720083736.png)
![zip](https://img-home.csdnimg.cn/images/20210720083736.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://csdnimg.cn/download_wenku/file_type_ask_c1.png)
![](https://profile-avatar.csdnimg.cn/default.jpg!1)
公众号学一点会一点
- 粉丝: 36
- 资源: 1
上传资源 快速赚钱
我的内容管理 展开
我的资源 快来上传第一个资源
我的收益
登录查看自己的收益我的积分 登录查看自己的积分
我的C币 登录后查看C币余额
我的收藏
我的下载
下载帮助
![](https://csdnimg.cn/release/wenkucmsfe/public/img/voice.245cc511.png)
最新资源
- Vue实现iOS原生Picker组件:详细解析与实现思路
- Arduino蓝牙小车:参数调试与功能控制
- 百度Java面试精华:200页精选资源涵盖核心知识点
- Swift使用CoreData填坑指南:CoreData在Swift 3.0的变化
- 微距离无线充电器创新设计及其实验探索
- MTK Android平台开发全攻略:44步详解流程
- RecyclerView全面解析:替代ListView的新选择
- Android开发:自动适配中英文键盘解决方案
- Android调用WebService接口教程
- Android开发:BitmapUtil图片处理全解析与实例
- Android多线程断点续传实现详解
- PCA算法在人脸识别会议签到系统中的应用
- EventBus 3.0:Android事件总线详解与实战应用
- Android FileUtil:全面解析文件操作实用技巧与实例
- RecyclerView添加头部和尾部实战教程
- Android实现微博滑动固定顶部栏实战与优化
资源上传下载、课程学习等过程中有任何疑问或建议,欢迎提出宝贵意见哦~我们会及时处理!
点击此处反馈
![](https://img-home.csdnimg.cn/images/20220527035711.png)
![](https://img-home.csdnimg.cn/images/20220527035711.png)
![](https://img-home.csdnimg.cn/images/20220527035111.png)
安全验证
文档复制为VIP权益,开通VIP直接复制
![](https://csdnimg.cn/release/wenkucmsfe/public/img/green-success.6a4acb44.png)