AI: Difference between revisions

From 太極
Jump to navigation Jump to search
Line 44: Line 44:
Keras (in order to use Keras, you need to install TensorFlow or CNTK or Theano):
Keras (in order to use Keras, you need to install TensorFlow or CNTK or Theano):
# Define your training data: input tensors and target tensors.
# Define your training data: input tensors and target tensors.
# Define a network of layers (or model). Two ways to define a model:
# Define a network of layers (or '''model'''). Two ways to define a model:
## using the '''keras_model_sequential()''' function (only for linear stacks of layers, which is the most common network architecture by far) or <syntaxhighlight lang='rsplus'>
## using the '''keras_model_sequential()''' function (only for linear stacks of layers, which is the most common network architecture by far) or <syntaxhighlight lang='rsplus'>
model <- keras_model_sequential() %>%
model <- keras_model_sequential() %>%
Line 59: Line 59:
model <- keras_model(inputs = input_tensor, outputs = output_tensor)
model <- keras_model(inputs = input_tensor, outputs = output_tensor)
</syntaxhighlight>
</syntaxhighlight>
# Configure the learning process by choosing a loss function, an optimizer, and some metrics to monitor. <syntaxhighlight lang='rsplus'>
# '''Compile''' the learning process by choosing a '''loss''' function, an '''optimizer''', and some '''metrics''' to monitor. <syntaxhighlight lang='rsplus'>
model %>% compile(
model %>% compile(
   optimizer = optimizer_rmsprop(lr = 0.0001),
   optimizer = optimizer_rmsprop(lr = 0.0001),
Line 66: Line 66:
)
)
</syntaxhighlight>
</syntaxhighlight>
# Iterate on your training data by calling the fit() method of your model. <syntaxhighlight lang='rsplus'>
# Iterate on your training data by calling the '''fit()''' method of your model. <syntaxhighlight lang='rsplus'>
model %>% fit(input_tensor, target_tensor, batch_size = 128, epochs = 10)
model %>% fit(input_tensor, target_tensor, batch_size = 128, epochs = 10)
</syntaxhighlight>
</syntaxhighlight>


The following examples can be found at [https://github.com/jjallaire/deep-learning-with-r-notebooks R Markdown Notebooks for "Deep Learning with R"]
The following examples can be found at [https://github.com/jjallaire/deep-learning-with-r-notebooks R Markdown Notebooks for "Deep Learning with R"]
== Some examples ==
== Some examples ==
* [https://jjallaire.github.io/deep-learning-with-r-notebooks/notebooks/3.4-classifying-movie-reviews.nb.html Binary data]
* [https://jjallaire.github.io/deep-learning-with-r-notebooks/notebooks/3.4-classifying-movie-reviews.nb.html Binary data]

Revision as of 14:51, 1 January 2019

Applications

TensorFlow

Keras

  • Derivative of a tensor operation: the gradient
    • Define loss_value = f(W) = dot(W, x)
    • W1 = W0 - step * gradient(f)(W0)
  • Stochastic gradient descent
  • Tensor operations:
    • relu(x) = max(0, x)
    • Each neural layer from our first network example transforms its input data:output = relu(dot(W, input) + b) where W and b are the weights or trainable parameters of the layer.

Training process

  1. Draw a batch of X and Y
  2. Run the network on x (a step called the forward pass) to obtain predictions y_pred.
  3. Compute the loss of the network on the batch
  4. Update all weights of the network in a way that slightly reduces the loss on this batch.

Keras (in order to use Keras, you need to install TensorFlow or CNTK or Theano):

  1. Define your training data: input tensors and target tensors.
  2. Define a network of layers (or model). Two ways to define a model:
    1. using the keras_model_sequential() function (only for linear stacks of layers, which is the most common network architecture by far) or
      model <- keras_model_sequential() %>%
        layer_dense(units = 32, input_shape = c(784)) %>%
        layer_dense(units = 10, activation = "softmax")
    2. the functional API (for directed acyclic graphs of layers, which let you build completely arbitrary architectures)
      input_tensor <- layer_input(shape = c(784))
      
      output_tensor <- input_tensor %>%
        layer_dense(units = 32, activation = "relu") %>%
        layer_dense(units = 10, activation = "softmax")
      
      model <- keras_model(inputs = input_tensor, outputs = output_tensor)
  3. Compile the learning process by choosing a loss function, an optimizer, and some metrics to monitor.
    model %>% compile(
      optimizer = optimizer_rmsprop(lr = 0.0001),
      loss = "mse",
      metrics = c("accuracy")
    )
  4. Iterate on your training data by calling the fit() method of your model.
    model %>% fit(input_tensor, target_tensor, batch_size = 128, epochs = 10)

The following examples can be found at R Markdown Notebooks for "Deep Learning with R"

Some examples

PyTorch

An R Shiny app to recognize flower species