Start free trial
Trending New Genres Authors
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Searching...
SoBrief
Deep Learning with Python

Deep Learning with Python

Build neural networks that fit the data, and learn how to tell real progress from overfitting.
by François Chollet 2017 350 pages
4.57
1k+ ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Deep learning wins by learning useful representations, not by imitating a brain.

The core idea. Artificial intelligence is the broad effort to automate intellectual tasks. Machine learning finds rules from examples; deep learning is a form of machine learning that learns successive layers of representations, or useful ways of encoding data. A model adjusts numerical weights to transform inputs toward desired outputs. A loss function measures the mismatch, and an optimizer uses that feedback to update the weights. The book’s first demonstration trains on 60,000 handwritten digit images and tests on 10,000, turning pixels into digit predictions.

A layered transformation. Tensors are the numerical containers used for data, from a single value to multidimensional arrays. Layers apply simple operations to them, while backpropagation calculates how weights contributed to error. Deep networks are not brain simulations: their neural name is historical, and their learning is mathematical.

Analysis

What's useful here is the shift from asking whether a machine thinks to asking what representation makes a task solvable. That perspective connects deep learning to measurement: the same reality can be encoded in ways that expose or obscure its structure. The warning against brain metaphors also matters, because fluent performance invites human interpretations that the mechanism does not justify. Still, calling the process merely geometric can understate the importance of labels, data collection, and task design. The transformations are learned, but humans decide what counts as an example and what outcome deserves a low loss.

Treat data, computing power, and algorithms as one engine of progress.

Why the timing changed. The core ideas behind modern neural networks predated their breakthrough by decades. Their rapid rise required three ingredients to converge: large datasets, powerful parallel hardware, and methods that could train deeper networks. The internet made millions of images and text examples available; graphics processors, originally built for games, made the repeated matrix calculations practical; and algorithmic improvements helped learning signals travel through deeper models.

A visible turning point. On ImageNet, the leading model’s top-five accuracy rose from 74.3% in 2011 to 83.6% in 2012, then reached 96.4% by 2015. Yet deep learning is not the universal tool. The book’s 2017 snapshot distinguishes it from gradient-boosted trees, which often excel on structured data. Earlier AI booms also collapsed when bold predictions outpaced useful results, a reason to separate long-term promise from short-term hype.

Analysis

This account treats technological breakthroughs as systems events, not lone flashes of genius. A method can be mathematically available yet practically irrelevant until data, hardware, software, and incentives align. The gaming industry’s indirect contribution to AI is a particularly clear example of infrastructure built for one purpose enabling another. The ImageNet figures also show how benchmarks can accelerate a field by giving researchers a shared target. Their limitation is equally important: benchmark gains establish capability on a defined test, not reliable performance across every setting where a product might be deployed.

Protect evaluation from leakage, then earn complexity by beating a baseline.

Keep the test genuinely new. Training data teaches the model; validation data guides choices such as network size; test data is reserved for the final check. Repeatedly tuning against validation results leaks information about that set into the design, so validation performance can become misleading. With little data, K-fold validation rotates which subset is held out, then averages the results. In the Boston housing example, 506 records were too few for a single small validation split to give a dependable score.

Build evidence in stages. First define the prediction and success metric, prepare and normalize inputs, and test a simple baseline. Then increase model capacity until it overfits, which reveals that the model can learn the training patterns. Reduce overfitting with more data, a smaller network, weight penalties, or dropout. This is more informative than endlessly changing architecture without knowing whether the data supports the task.

Analysis

The split between training, validation, and test data is a practical form of intellectual honesty. It limits the temptation to mistake repeated experimentation for independent evidence. The baseline-first rule adds another safeguard: a model should beat something simple before its complexity is celebrated. This logic is closely related to experimental design, where the credibility of a result depends on protecting the comparison from contamination. A held-out test set is not magical, however. If the source data changes, or if examples are duplicated across splits, a clean score can still fail to predict real-world performance.

Match the network to the structure of the information it receives.

Architecture encodes assumptions. A network is a hypothesis space: its structure determines what patterns it can efficiently learn. Dense layers suit feature vectors, where each example is a list of measurements. Convolutional networks suit images because they reuse the same local pattern detector across locations. In the book’s MNIST comparison, a small convolutional network reached about 99.3% test accuracy, above the densely connected model’s 97.8%.

Respect order when it matters. Recurrent networks process sequences step by step while carrying information forward. One-dimensional convolutions also find local sequence patterns, but are less sensitive to global order. Before learning, data must be converted into tensors; incompatible scales should be normalized, and useful hand-designed features can still help, especially when data is scarce. The right choice depends not only on whether inputs are images or text, but on the structure that makes their target predictable.

Analysis

Architecture is best understood as a set of inductive biases, or built-in preferences about the world. Convolution assumes that a visual feature can matter wherever it appears; recurrence assumes that order and accumulated context can matter. These assumptions reduce the amount of data needed when they fit the problem. They can also mislead when they do not: a sequence model may waste effort tracking order that carries little signal, while a convolutional model may miss temporal direction. This makes architectural choice less like selecting a fashionable tool and more like stating a testable theory about the data.

Borrow pretrained visual features before asking a small dataset to teach everything.

Reuse what images have already taught. Training a vision model from scratch on only 2,000 cat and dog pictures reached about 71% accuracy. Randomly altering images during training, a technique called data augmentation, raised this to about 82% by creating varied versions of the same examples. But these variations do not add entirely new information.

Adapt in two stages. A pretrained network such as VGG16 has already learned visual patterns from ImageNet, a dataset of 1.4 million labeled images. Feature extraction freezes its convolutional base and trains a new classifier on top; with augmentation, the example reached about 96% validation accuracy. Fine-tuning then unfreezes a few upper layers and retrains them gently for the new task, reaching about 97% test accuracy. The lower layers tend to capture reusable edges and textures, while higher layers are more task-specific.

Analysis

Transfer learning turns prior computation into a resource. Instead of demanding that a small dataset teach a model what edges, textures, and object parts are, it starts with representations learned from a larger visual collection. This resembles cumulative learning in science: a new investigation can reuse instruments and methods rather than begin from zero. The results are impressive, but reuse is conditional. A pretrained model can carry biases from its original labels and image distribution, so high validation accuracy does not guarantee fair or reliable behavior on populations or settings that differ from the training data.

Choose sequence models according to whether position carries predictive meaning.

Memory versus local patterns. Recurrent neural networks process one step at a time and maintain a state representing what has come before. Simple recurrent layers struggle to preserve distant information; LSTM and GRU layers use gates that help retain or discard signals over longer sequences. In the weather example, a common-sense forecast of tomorrow’s temperature from today’s had an average error of about 2.57°C. A GRU reduced it to about 2.35°C, showing a real but modest gain.

Order determines the tool. For weather, recent readings are more informative than old ones, so chronological processing matters. For movie sentiment, local word patterns can be informative wherever they occur; a one-dimensional convolution can therefore be faster than a recurrent model. Bidirectional RNNs process a sequence in both directions and can help with text, where either direction can reveal context, but are less useful when future observations should not inform a past prediction.

Analysis

The comparison between weather and sentiment is a compact lesson in matching inductive bias to causality. Weather forecasting has a natural arrow of time: a model should not treat distant history as interchangeable with recent measurements. In many text tasks, a phrase can carry similar meaning in different positions, making local pattern detection efficient. This distinction also protects against a common modeling error: using a more elaborate sequence architecture simply because the data arrives in sequence form. A strong baseline remains essential, because temporal complexity can add computation without adding predictive information.

Build models as testable experiments, and make the objective match the real goal.

The loss is the model’s instruction. A neural network relentlessly reduces the quantity it is given, so a poorly chosen objective can reward an unwanted shortcut. The book illustrates this with a hypothetical system told to maximize average human well-being: it could improve the average by leaving fewer people alive. In practice, match the output and loss to the task, then monitor performance on data the model did not train on.

Make experimentation observable. Keras’s functional API supports multiple inputs, outputs, shared layers, and branching networks. Callbacks can save the best model or stop training when validation performance stalls; TensorBoard makes metrics and internal activations visible. Residual connections and normalization can help train deeper models. Hyperparameter search and ensembles can improve results, especially when models make different errors, but extensive tuning against one validation set can itself overfit that set.

Analysis

The objective-function example captures a problem that extends beyond machine learning: measurable proxies can drift away from the human purpose they are meant to represent. A model does not know that a metric is merely a proxy. In this sense, careful loss design is a form of institutional design, because it encodes which outcomes count and which tradeoffs are invisible. Monitoring tools make training more inspectable, but they cannot resolve value conflicts or guarantee that the metric is legitimate. Better engineering therefore requires both technical instrumentation and human scrutiny of the target being optimized.

Generate by learning statistical structure, then choose how much randomness to allow.

Prediction becomes creation. A language model learns to predict the next character or word from what came before. Repeatedly sampling its predictions produces a sequence; a temperature setting controls how predictable or surprising each choice is. Low randomness can make text repetitive, while higher randomness can make it inventive but incoherent.

Different generators offer different controls. DeepDream amplifies patterns a vision network already detects. Neural style transfer uses one image’s high-level content and another’s visual textures to construct a hybrid. Variational autoencoders learn continuous latent spaces, where nearby points can decode to related images and directions can correspond to edits such as a smile. Generative adversarial networks train a generator against a discriminator that judges whether images look real. GANs can produce convincing samples, but their latent spaces may be less orderly and their training less stable.

Analysis

These methods make creativity legible as a collection of operations: learn patterns, navigate a representation space, and select what to amplify or vary. That account is useful without claiming that a model has artistic intention. Human judgment supplies context and significance, while the system supplies a new way to explore possibilities. The temperature example makes the tradeoff especially clear: predictability and novelty are not opposites with one universally correct setting. The appropriate balance depends on the task, and realistic-looking output should not be confused with originality, meaning, or authorship.

Use deep learning for pattern mapping, not as proof of human-like understanding.

Competence has boundaries. Deep-learning models can map inputs to outputs impressively when training examples cover the task. They can also fail on small changes: an adversarial image can be altered so subtly that a person barely notices, while a network changes its prediction from panda to gibbon. This brittleness warns against treating accurate captions or classifications as evidence of human-like comprehension.

Generalization is not all-or-nothing. The book contrasts local generalization, which extends learned patterns to nearby cases, with extreme generalization, the human ability to reason about unfamiliar situations with little direct data. It argues that current models are limited in reasoning, long-term planning, and algorithmic manipulation. Chollet’s proposed direction is hybrid systems that combine learned pattern recognition with program-like operations, reusable subroutines, and less hand-tuned architecture. This is a research vision, not a capability demonstrated by the examples.

Analysis

The distinction between local and extreme generalization is memorable because it separates interpolation from abstraction. It also offers a useful test for claims about intelligence: does a system merely handle familiar examples, or can it construct and apply a model in a genuinely new situation? In practice, the boundary is gradual. Humans also depend on prior experience, and machine performance can improve substantially through better data and task design. The central caution remains sound: impressive performance within a benchmark does not establish robust understanding outside it, so deployment claims should specify the conditions under which a model has actually been tested.

Analysis

The book’s strongest contribution is not a catalog of neural-network layers. It teaches a way to reason from problem structure to model choice, and from model performance back to evidence. Its recurring pattern is empirical: encode the task as data and targets, select a measurable objective, establish a baseline, test a model, and inspect where training and generalization diverge. That makes the technical material useful to readers who may never use the specific Keras interfaces shown.

The examples give that method texture. MNIST demonstrates the mechanics of learning; the small cats-and-dogs dataset shows why augmentation and pretrained features matter; and the weather series shows that a sophisticated model should first beat a plain persistence forecast. These cases also prevent a common misconception: progress does not come from depth alone. It comes from a match among representation, data volume, architecture, and evaluation.

The book’s most consequential warning concerns objectives. A loss function is not a neutral measurement of success. It defines what the model is rewarded for doing, and a system can satisfy a proxy while violating its intended purpose. This connects model building to governance: choices about labels, metrics, and test populations are decisions about which outcomes count.

Its account of local versus extreme generalization is valuable as a conceptual contrast, though it can sound sharper than reality. Generalization depends on how far test conditions depart from training conditions, and humans also rely on learned regularities. The distinction is most useful as a diagnostic question, not a species boundary. Likewise, predictions about program-like models and lifelong learning should be read as a research agenda rather than an inevitable destination.

The book is rooted in its 2017 technical moment, so libraries and specific implementation recipes age faster than its durable lessons. Those lessons are to measure carefully, reuse prior learning, match assumptions to data, and resist mistaking fluent output for understanding.

Summary in 30 Seconds
Deep learning builds layered representations by adjusting weights against a measured error. Progress depends on suitable data, computing power, and algorithms, but a neural network is not right for every task. Match architecture to the structure of the input, establish a simple baseline, and keep test data separate from model tuning. Reuse pretrained features when examples are scarce. Choose objectives carefully: models optimize the metric they are given, which may not reflect the outcome people actually want.
Contains spoilers

Last updated:

Report Issue

Review Summary

4.57 out of 5
Average of 1k+ ratings from Goodreads and Amazon.

Deep Learning with Python receives overwhelmingly positive reviews, praised for its clear explanations, practical approach, and hands-on examples using Keras. Readers appreciate the balance between theory and application, finding it accessible for beginners while still valuable for experienced practitioners. The book is commended for its coverage of various deep learning architectures and techniques, with many highlighting its usefulness as a reference. Some reviewers note that it focuses more on implementation than mathematical theory, which suits its intended audience of programmers and practical learners.

Your rating:
4.69
272 ratings
Want to read the full book?

Glossary

Representation learning

Learning useful data encodings

A machine-learning process that discovers transformations of input data that make a task easier. In deep learning, multiple layers learn successive representations, such as visual edges becoming object parts and then class-relevant features. The representations are adjusted together using feedback from a loss function, rather than being entirely designed by hand.

Tensor

Multidimensional numerical array

A container for numerical data, described by its number of axes, its shape, and its data type. A scalar has no axes, a vector has one, and a matrix has two. Images, sequences, and batches of examples use tensors with more axes. Neural-network layers transform tensors as data moves through a model.

Hypothesis space

Set of candidate models

The range of transformations a model architecture can represent. Choosing layers and their arrangement narrows this range before training begins; learning then searches for weights within it. A model may fail not because optimization is poor, but because the desired relationship is difficult or impossible to express within the chosen hypothesis space.

Backpropagation

Computes parameter gradients

An algorithm that applies the calculus chain rule backward through a neural network, starting from its loss and determining how each parameter contributed to that loss. The resulting gradients guide an optimizer in updating the weights. Modern deep-learning frameworks calculate these gradients automatically for differentiable operations.

Overfitting

Learning training-specific patterns

A model overfits when it performs increasingly well on training examples but fails to improve, or performs worse, on new data. It has learned patterns that are specific to the training set rather than broadly predictive. More data, smaller models, weight regularization, dropout, and early stopping can help reduce overfitting.

Data augmentation

Creates varied training examples

A technique that generates altered versions of existing training samples, especially images, using transformations that preserve their labels. Rotating, shifting, zooming, or flipping images can expose a model to more variation and reduce overfitting. Augmentation reshapes existing information; it does not supply wholly independent examples.

Word embedding

Dense vector for a word

A learned, relatively low-dimensional vector associated with a word or token. Unlike one-hot vectors, embeddings can place related words near one another in a geometric space. They may be learned as part of a task-specific model or loaded from a separately trained source when labeled data is limited.

Long Short-Term Memory (LSTM)

Recurrent layer for long dependencies

A recurrent neural-network architecture designed to preserve useful information across many sequence steps. Its gated operations regulate what information is retained, added, or exposed, helping address the difficulty simple recurrent networks have learning long-term dependencies. LSTMs are used for text, timeseries, and other ordered data.

Variational autoencoder

Learns a structured latent space

A generative model that encodes an input as parameters of a probability distribution in a latent space, samples a point from that distribution, and decodes the point into a reconstruction. A reconstruction objective preserves the input, while a regularization objective encourages a continuous, organized latent space that can support image generation and editing.

Generative adversarial network

Generator competes with discriminator

A generative model with two networks trained in opposition. The generator creates synthetic examples, while the discriminator tries to distinguish them from real training data. The generator improves by learning to fool the discriminator. This competition can yield realistic images, but training can be unstable and the resulting latent space may lack useful structure.

Local generalization

Extending nearby learned patterns

The book’s term for a model’s ability to apply patterns learned from training examples to new cases that are sufficiently similar. Deep networks can perform this well across many perceptual tasks, but may fail when inputs depart substantially from training conditions. The contrast is with extreme generalization, which involves abstraction and adapting to radically unfamiliar situations.

FAQ

What's Deep Learning with Python about?

  • Focus on Deep Learning: Deep Learning with Python by François Chollet introduces deep learning concepts using Python and the Keras library, emphasizing practical applications and intuitive explanations.
  • Hands-on Approach: The book provides numerous examples and code snippets, allowing readers to implement deep learning models for various tasks, including image classification and text generation.
  • Comprehensive Coverage: It covers fundamental topics, advanced techniques, and generative models, making it suitable for both beginners and experienced practitioners.

Why should I read Deep Learning with Python?

  • Authoritative Insight: Written by François Chollet, the creator of Keras, the book offers unique insights into deep learning practices and the Keras framework.
  • Accessible Learning: Designed for readers with intermediate Python skills, it makes complex concepts approachable and understandable.
  • Real-World Applications: The book emphasizes practical applications of deep learning, preparing readers to apply these techniques in real-world scenarios.

What are the key takeaways of Deep Learning with Python?

  • Understanding Deep Learning: Readers will gain a solid understanding of deep learning fundamentals, including neural networks, convolutional networks, and recurrent networks.
  • Practical Implementation: The book provides hands-on experience with Keras, enabling readers to build and train their own deep learning models.
  • Advanced Techniques: It covers advanced topics such as generative models, neural style transfer, and text generation, equipping readers with a broad skill set.

What is the significance of Keras in Deep Learning with Python?

  • User-Friendly API: Keras is highlighted for its simplicity and ease of use, allowing users to build complex neural networks with minimal code.
  • Flexibility: It supports various backends, including TensorFlow and Theano, enabling users to switch between them seamlessly.
  • Rapid Prototyping: Keras facilitates rapid prototyping of deep learning models, making it an ideal choice for both beginners and experienced developers.

How does Deep Learning with Python address overfitting?

  • Understanding Overfitting: Overfitting occurs when a model learns patterns specific to the training data but fails to generalize to new data.
  • Regularization Techniques: The book discusses methods like L2 regularization and dropout to mitigate overfitting, helping improve model performance on unseen data.
  • Data Augmentation: It introduces data augmentation as a strategy to artificially increase the size of the training dataset, enhancing model robustness.

What are the mathematical building blocks of neural networks in Deep Learning with Python?

  • Tensors and Operations: Tensors are introduced as the fundamental data structure in deep learning, crucial for manipulating data in neural networks.
  • Gradient Descent: The book covers gradient descent as the optimization algorithm used to update model weights, with backpropagation for computing gradients efficiently.
  • Loss Functions: Emphasizes the importance of loss functions in measuring model performance, discussing types like binary crossentropy and mean squared error.

How does Deep Learning with Python explain convolutional neural networks (CNNs)?

  • Understanding CNNs: The book provides a detailed explanation of CNNs, highlighting their architecture and how they process image data.
  • Convolution and Pooling: It explains convolution as a way to learn local patterns in images, with max pooling for downsampling feature maps.
  • Practical Examples: Includes examples of using CNNs for image classification tasks, demonstrating implementation and training using Keras.

What is the role of data preprocessing in Deep Learning with Python?

  • Importance of Preprocessing: Data preprocessing is crucial for preparing raw data for neural networks, leading to better model performance and faster convergence.
  • Normalization Techniques: Discusses techniques like scaling input values to a specific range to ensure effective learning and prevent issues with varying feature scales.
  • Handling Missing Values: Addresses strategies for dealing with missing values, ensuring the model can learn from available data without being adversely affected.

How does Deep Learning with Python suggest evaluating machine learning models?

  • Training, Validation, and Test Sets: Emphasizes splitting data into these sets to evaluate model performance accurately, preventing overfitting.
  • K-Fold Cross-Validation: Introduces this method for obtaining reliable performance estimates, especially when data is limited.
  • Metrics for Success: Discusses metrics like accuracy, precision, and recall, essential for guiding model optimization.

What are the generative models discussed in Deep Learning with Python?

  • Variational Autoencoders (VAEs): Explains how VAEs learn structured latent spaces for generating new images and editing existing ones.
  • Generative Adversarial Networks (GANs): Covers the architecture and training of GANs, highlighting their ability to produce realistic images.
  • Practical Implementations: Provides code examples for implementing both VAEs and GANs, allowing readers to experiment with generative techniques.

How does Deep Learning with Python explain the concept of transfer learning?

  • Pretrained Models: Discusses using pretrained models to leverage existing knowledge, allowing for faster training and improved performance on new tasks.
  • Fine-Tuning: Covers the process of fine-tuning a pretrained model on a new dataset, adjusting the model to better fit the specific task.
  • Practical Examples: Provides examples of implementing transfer learning using Keras, making it easier to apply in real-world scenarios.

What are the limitations of deep learning discussed in Deep Learning with Python?

  • Lack of Understanding: Emphasizes that deep learning models do not truly understand their inputs, leading to potential misinterpretations.
  • Local vs. Extreme Generalization: Distinguishes between local generalization and extreme generalization, highlighting current model limitations.
  • Need for Reasoning: Points out that deep learning struggles with tasks requiring reasoning and long-term planning, essential for complex applications.

About the Author

François Chollet is a prominent figure in the field of artificial intelligence, known for creating the Keras deep learning library. As a French engineer and researcher, he has made significant contributions to the development and accessibility of machine learning technologies. Chollet's expertise in deep learning is widely recognized, and his work on Keras has greatly simplified the process of building and experimenting with neural networks. His book, "Deep Learning with Python," reflects his practical approach to teaching AI concepts and has become a popular resource for both beginners and experienced practitioners in the field.

Download PDF

To save this Deep Learning with Python summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.43 MB     Pages: 20

Download EPUB

To read this Deep Learning with Python summary on your e-reader device or app, download the free EPUB. The .epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.
Download EPUB
File size: 1.41 MB     Pages: 27
Want to read the full book?
Follow
Listen
Home
Swipe
Library
Get App
Try Full Access for 3 Days
Listen, bookmark, and more
Compare Features Free Pro
📖 Read Summaries
Read unlimited summaries. Free users get 3 per month
🎧 Listen to Summaries
Listen to unlimited summaries in 40 languages
—
❤️ Unlimited Bookmarks
Free users are limited to 4
—
📜 Unlimited History
Free users are limited to 4
—
📥 Unlimited Downloads
Free users are limited to 1
—
Risk-Free Timeline
Today: Get Instant Access
Listen to full summaries of 26,000+ books. That's 12,000+ hours of audio!
Day 2: Trial Reminder
We'll send you a notification that your trial is ending soon.
Day 3: Your subscription begins
You'll be charged on Nov 24,
cancel anytime before.
Consume 2.8× More Books
2.8× more books Listening Reading
Our users love us
1M+ readers
Trustpilot Rating
TrustPilot
4.6 Excellent
This site is a total game-changer. I've been flying through book summaries like never before. Highly, highly recommend.
— Dave G
Worth my money and time, and really well made. I've never seen this quality of summaries on other websites. Very helpful!
— Em
Highly recommended!! Fantastic service. Perfect for those that want a little more than a teaser but not all the intricate details of a full audio book.
— Greg M
Save 62%
Yearly
$119.88 $44.99/year/yr
$3.75/mo
Monthly
$9.99/mo
Start a 3-Day Free Trial
3 days free, then $44.99/year. Cancel anytime.
Unlock a world of fiction & nonfiction books
26,000+ books for the price of 2 books
Read any book in 10 minutes
Discover new books like Tinder
Request any book if it's not summarized
Read more books than anyone you know
#1 app for book lovers
Lifelike & immersive summaries
30-day money-back guarantee
Download summaries in EPUBs or PDFs
Cancel anytime in a few clicks

Why one summary?

Scanner
Find a barcode to scan

⭐
⭐
⭐
We have a special gift for you
Open
38% off
DISCOUNT FOR YOU
⭐
⭐
⭐
$79.99
$49.99/year
Only $4.16 per month
Continue
2 taps to start, super easy to cancel
Settings
General
Widget
Loading...