Luis Capelo [Luis Capelo] - Beginning Application Development with TensorFlow and Keras

• accuracy functions
  • using /
• activation functions
  • about /
• active training environment
  • creating /
• AlphaGo algorithm
  • about /
• Artificial Neural Networks
  • about /

• backpropagation /
  • about /
• Bitcoin dataset
  • exploring /
  • preparing, for model /
• Bitcoin model
  • evaluating /

• CIFAR dataset
  • about /
  • reference /
• class Model()
  • about /
• CoinMarketCap() class /
• common architectures, deep learning
  • about /
  • convolutional neural networks /
• contemporary neural network practice
  • about /
• convolution /
• convolutional layer
  • about /
• Convolutional Neural Network /
• convolutional neural networks (CNNs)
  • about /
• cryptonic
  • about /
  • using /
  • deploying /
• cryptonic application
  • about /
  • MODEL_NAME /
  • BITCOIN_START_DATE /
  • PERIOD_SIZE /
  • EPOCHS /
• custom neural network
  • training /

• data
  • and model, separating /
• data augmentation /
• data component
  • about /
• data normalization
  • about /
• deep learning
  • about /
  • limitations /
  • environment, configuring /
  • model architecture, selecting /
  • common architectures /
• deep learning application
  • deploying /
• deep learning model
  • optimizing /
• deep learning system
  • about /
  • assembling /
• DRL architecture
  • about /
• dropout strategy
  • about /
  • implementing /

• epochs
  • about /
  • implementing /
• error rates
  • using /
• ethical considerations /
• examples, neural networks
  • self-driving vehicles /
  • image recognition /
• existing model
  • re-training /

• Fetching Real-Time Data /
• forget gate
  • about /
• fully connected layers
  • about /

• generative adversarial networks (GANs)
  • about /
• Graphic Processing Units (GPUs) /

• hidden layers, neural networks
  • about /
• Hyperbolic Tangent (Tanh)
  • about /
• hyperparameter
  • about /
• hyperparameter optimization
  • about /
  • layers, adding /
  • nodes, adding /
  • layers, implementing /
  • epochs, adding /
  • epochs, implementing /
  • activation functions /
  • linear functions /
  • Hyperbolic Tangent (Tanh) /
  • Rectified Linear Unit /
  • regularization strategies /
  • optimization results /
  • optimization strategies, implementing /

• inherent bias /

• Jupyter Notebooks
  • about /

• Keras
  • about /
  • using, as TensorFlow interface /
  • model components /

• L2 regularization
  • about /
• layers categories, neural networks
  • input /
  • hidden /
  • output /
• linear functions
  • about /
  • using /
• long-short term memory (LSTM) networks
  • about /
• loss functions
  • about /
  • common loss functions /
  • using /
• LSTM model
  • predictions /
  • predictions, interpreting /

• maximum normalization
  • about /
• minimum normalization
  • about /
• MNIST dataset
  • about /
  • reference /
• model
  • deploying, as web application /
• Model() class /
• model component
  • about /
  • build() /
  • train() /
  • evaluate() /
  • save() /
  • predict() /
• model evaluation
  • about /
• model evaluation metrics
  • implementing /

• neural network graph
  • exploring /
• neural networks
  • about /
  • applications /
  • examples /
  • working /
  • function approximation /
  • common components /
  • operations /
  • layers categories /
  • training, with TensorFlow /
  • evaluating, in MNIST dataset /
  • training /
  • time-series data, reshaping /
  • overfitting /
• new data
  • handling /
  • dealing with /
• new model
  • training /
• Numpy
  • about /

• optimization results
  • about /
• optimization strategies
  • implementing /
• overfitting
  • about /

• Pandas
  • about /
• parameters
  • about /
• point-relative normalization
  • about /
• predictions
  • making /
  • denormalizing /
• problem
  • structuring /
• problem categories
  • classification /
  • regression /
• Python 3
  • about /

• Rectified Linear Unit (ReLUs)
  • about /
  • implementing /
• recurrent neural networks (RNNs)
  • about /
• regularization strategies
  • about /
  • L2 regularization /
  • dropout /
• representation learning
  • about /

• software components, deep learning
  • Python 3 /
  • TensorFlow /
  • Keras /
  • TensorBoard /
  • Jupyter Notebooks /
  • Pandas /
  • Numpy /
  • verifying /

• TensorBoard
  • about /
  • using /
• TensorFlow
  • about /
• TensorFlow model
  • creating, with Keras /
• TensorFlow Playground application
  • about /
• Tensor Processing Units (TPUs) /
• time-series data
  • reshaping /
• trained neural network
  • exploring /
• Transformer
  • about /
• Transformer algorithm
  • about /

• Z-score
  • about /

In this lesson, we will cover the basics of neural networks and how to set up a deep learning programming environment. We will also explore the common components of a neural network and its essential operations. We will conclude this lesson by exploring a trained neural network created using TensorFlow.

This lesson is about understanding what neural networks can do. We will not cover mathematical concepts underlying deep learning algorithms, but will instead describe the essential pieces that make a deep learning system. We will also look at examples where neural networks have been used to solve real-world problems.

This lesson will give you a practical intuition on how to engineer systems that use neural networks to solve problemsincluding how to determine if a given problem can be solved at all with such algorithms. At its core, this lesson challenges you to think about your problem as a mathematical representation of ideas. By the end of this lesson, you will be able to think about a problem as a collection of these representations and then start to recognize how these representations may be learned by deep learning algorithms.