From 8190cf26bfa7373ffaf71f1ccc4e6eaa07486f20 Mon Sep 17 00:00:00 2001 From: autodocs Date: Wed, 18 Oct 2017 11:43:57 +0000 Subject: [PATCH] build based on 92f65f9 --- latest/{contributing.html => community.html} | 4 ++-- latest/data/onehot.html | 2 +- latest/gpu.html | 4 ++-- latest/index.html | 2 +- latest/models/basics.html | 2 +- latest/models/layers.html | 4 ++-- latest/models/recurrence.html | 2 +- latest/search.html | 2 +- latest/search_index.js | 14 +++++++------- latest/training/optimisers.html | 4 ++-- latest/training/training.html | 2 +- 11 files changed, 21 insertions(+), 21 deletions(-) rename latest/{contributing.html => community.html} (53%) diff --git a/latest/contributing.html b/latest/community.html similarity index 53% rename from latest/contributing.html rename to latest/community.html index 32ca2dde..81bee480 100644 --- a/latest/contributing.html +++ b/latest/community.html @@ -1,9 +1,9 @@ -Contributing & Help · Flux
Contributing & Help

Contributing & Help

If you need help, please ask on the Julia forum, the slack (channel #machine-learning), or Flux's Gitter.

Right now, the best way to help out is to try out the examples and report any issues or missing features as you find them. The second best way is to help us spread the word, perhaps by starring the repo.

If you're interested in hacking on Flux, most of the code is pretty straightforward. Adding new layer definitions or cost functions is simple using the Flux DSL itself, and things like data utilities and training processes are all plain Julia code.

If you get stuck or need anything, let us know!

+
Community

Community

All Flux users are welcome to join our community on the Julia forum, the slack (channel #machine-learning), or Flux's Gitter. If you have questions or issues we'll try to help you out.

If you're interested in hacking on Flux, the source code is open and easy to understand – it's all just the same Julia code you work with normally. You might be interested in our intro issues to get started.

diff --git a/latest/data/onehot.html b/latest/data/onehot.html index 394dbbad..88cf15ca 100644 --- a/latest/data/onehot.html +++ b/latest/data/onehot.html @@ -6,7 +6,7 @@ m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m) ga('create', 'UA-36890222-9', 'auto'); ga('send', 'pageview'); -
One-Hot Encoding

One-Hot Encoding

It's common to encode categorical variables (like true, false or cat, dog) in "one-of-k" or "one-hot" form. Flux provides the onehot function to make this easy.

julia> using Flux: onehot
+
One-Hot Encoding
One-Hot Encoding
It's common to encode categorical variables (like true, false or cat, dog) in "one-of-k" or "one-hot" form. Flux provides the onehot function to make this easy.
julia> using Flux: onehot
 
 julia> onehot(:b, [:a, :b, :c])
 3-element Flux.OneHotVector:
diff --git a/latest/gpu.html b/latest/gpu.html
index fbbfd57b..c66b2b8e 100644
--- a/latest/gpu.html
+++ b/latest/gpu.html
@@ -6,7 +6,7 @@ m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
 
 ga('create', 'UA-36890222-9', 'auto');
 ga('send', 'pageview');
-
GPU Support
GPU Support
Support for array operations on other hardware backends, like GPUs, is provided by external packages like CuArrays and CLArrays. Flux doesn't care what array type you use, so we can just plug these in without any other changes.
For example, we can use CuArrays (with the cu converter) to run our basic example on an NVIDIA GPU.
using CuArrays
+
GPU Support
GPU Support
Support for array operations on other hardware backends, like GPUs, is provided by external packages like CuArrays and CLArrays. Flux doesn't care what array type you use, so we can just plug these in without any other changes.
For example, we can use CuArrays (with the cu converter) to run our basic example on an NVIDIA GPU.
using CuArrays
 
 W = cu(rand(2, 5)) # a 2×5 CuArray
 b = cu(rand(2))
@@ -22,4 +22,4 @@ d(cu(rand(10))) # CuArray output
 
 m = Chain(Dense(10, 5, σ), Dense(5, 2), softmax)
 m = mapleaves(cu, m)
-d(cu(rand(10)))
The mnist example contains the code needed to run the model on the GPU; just uncomment the lines after using CuArrays.

+d(cu(rand(10)))
The mnist example contains the code needed to run the model on the GPU; just uncomment the lines after using CuArrays.

diff --git a/latest/index.html b/latest/index.html
index e6699979..97873719 100644
--- a/latest/index.html
+++ b/latest/index.html
@@ -6,5 +6,5 @@ m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
 
 ga('create', 'UA-36890222-9', 'auto');
 ga('send', 'pageview');
-
Home
Flux: The Julia Machine Learning Library
Flux is a library for machine learning. It comes "batteries-included" with many useful tools built in, but also lets you use the full power of the Julia language where you need it. The whole stack is implemented in clean Julia code (right down to the GPU kernels) and any part can be tweaked to your liking.
Installation
Install Julia 0.6.0 or later, if you haven't already.
Pkg.add("Flux")
+
Home
Flux: The Julia Machine Learning Library
Flux is a library for machine learning. It comes "batteries-included" with many useful tools built in, but also lets you use the full power of the Julia language where you need it. The whole stack is implemented in clean Julia code (right down to the GPU kernels) and any part can be tweaked to your liking.
Installation
Install Julia 0.6.0 or later, if you haven't already.
Pkg.add("Flux")
 Pkg.test("Flux") # Check things installed correctly
Start with the basics. The model zoo is also a good starting point for many common kinds of models.

diff --git a/latest/models/basics.html b/latest/models/basics.html
index 9bc6d552..ec97d6f6 100644
--- a/latest/models/basics.html
+++ b/latest/models/basics.html
@@ -6,7 +6,7 @@ m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
 
 ga('create', 'UA-36890222-9', 'auto');
 ga('send', 'pageview');
-
Basics
Model-Building Basics
Taking Gradients
Consider a simple linear regression, which tries to predict an output array y from an input x. (It's a good idea to follow this example in the Julia repl.)
W = rand(2, 5)
+
Basics
Model-Building Basics
Taking Gradients
Consider a simple linear regression, which tries to predict an output array y from an input x. (It's a good idea to follow this example in the Julia repl.)
W = rand(2, 5)
 b = rand(2)
 
 predict(x) = W*x .+ b
diff --git a/latest/models/layers.html b/latest/models/layers.html
index 8888c305..f7d2e0ff 100644
--- a/latest/models/layers.html
+++ b/latest/models/layers.html
@@ -6,9 +6,9 @@ m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
 
 ga('create', 'UA-36890222-9', 'auto');
 ga('send', 'pageview');
-
Layer Reference
Model Layers
These core layers form the foundation of almost all neural networks.
Flux.Chain — Type.
Chain(layers...)
Chain multiple layers / functions together, so that they are called in sequence on a given input.
m = Chain(x -> x^2, x -> x+1)
+
Layer Reference
Model Layers
These core layers form the foundation of almost all neural networks.
Flux.Chain — Type.
Chain(layers...)
Chain multiple layers / functions together, so that they are called in sequence on a given input.
m = Chain(x -> x^2, x -> x+1)
 m(5) == 26
 
 m = Chain(Dense(10, 5), Dense(5, 2))
 x = rand(10)
-m(x) == m[2](m[1](x))
Chain also supports indexing and slicing, e.g. m[2] or m[1:end-1]. m[1:3](x) will calculate the output of the first three layers.
source
Flux.Dense — Type.
Dense(in::Integer, out::Integer, σ = identity)
Creates a traditional Dense layer with parameters W and b.
y = σ.(W * x .+ b)
The input x must be a vector of length in, or a batch of vectors represented as an in × N matrix. The out y will be a vector or batch of length in.
source

+m(x) == m[2](m[1](x))
Chain also supports indexing and slicing, e.g. m[2] or m[1:end-1]. m[1:3](x) will calculate the output of the first three layers.
source
Flux.Dense — Type.
Dense(in::Integer, out::Integer, σ = identity)
Creates a traditional Dense layer with parameters W and b.
y = σ.(W * x .+ b)
The input x must be a vector of length in, or a batch of vectors represented as an in × N matrix. The out y will be a vector or batch of length in.
source

diff --git a/latest/models/recurrence.html b/latest/models/recurrence.html
index 4c7eb1b2..871bae8c 100644
--- a/latest/models/recurrence.html
+++ b/latest/models/recurrence.html
@@ -6,7 +6,7 @@ m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
 
 ga('create', 'UA-36890222-9', 'auto');
 ga('send', 'pageview');
-
Recurrence
Recurrent Models
Recurrent Cells
In the simple feedforward case, our model m is a simple function from various inputs xᵢ to predictions yᵢ. (For example, each x might be an MNIST digit and each y a digit label.) Each prediction is completely independent of any others, and using the same x will always produce the same y.
y₁ = f(x₁)
+
Recurrence
Recurrent Models
Recurrent Cells
In the simple feedforward case, our model m is a simple function from various inputs xᵢ to predictions yᵢ. (For example, each x might be an MNIST digit and each y a digit label.) Each prediction is completely independent of any others, and using the same x will always produce the same y.
y₁ = f(x₁)
 y₂ = f(x₂)
 y₃ = f(x₃)
 # ...
Recurrent networks introduce a hidden state that gets carried over each time we run the model. The model now takes the old h as an input, and produces a new h as output, each time we run it.
h = # ... initial state ...
diff --git a/latest/search.html b/latest/search.html
index a9cd7ed4..af1c20e5 100644
--- a/latest/search.html
+++ b/latest/search.html
@@ -6,4 +6,4 @@ m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
 
 ga('create', 'UA-36890222-9', 'auto');
 ga('send', 'pageview');
-
Search
Search
Number of results: loading...
    
+
    Search
    Search
    Number of results: loading...
      
diff --git a/latest/search_index.js b/latest/search_index.js
index 18646cf8..cce8dd70 100644
--- a/latest/search_index.js
+++ b/latest/search_index.js
@@ -305,19 +305,19 @@ var documenterSearchIndex = {"docs": [
 },
 
 {
-    "location": "contributing.html#",
-    "page": "Contributing & Help",
-    "title": "Contributing & Help",
+    "location": "community.html#",
+    "page": "Community",
+    "title": "Community",
     "category": "page",
     "text": ""
 },
 
 {
-    "location": "contributing.html#Contributing-and-Help-1",
-    "page": "Contributing & Help",
-    "title": "Contributing & Help",
+    "location": "community.html#Community-1",
+    "page": "Community",
+    "title": "Community",
     "category": "section",
-    "text": "If you need help, please ask on the Julia forum, the slack (channel #machine-learning), or Flux's Gitter.Right now, the best way to help out is to try out the examples and report any issues or missing features as you find them. The second best way is to help us spread the word, perhaps by starring the repo.If you're interested in hacking on Flux, most of the code is pretty straightforward. Adding new layer definitions or cost functions is simple using the Flux DSL itself, and things like data utilities and training processes are all plain Julia code.If you get stuck or need anything, let us know!"
+    "text": "All Flux users are welcome to join our community on the Julia forum, the slack (channel #machine-learning), or Flux's Gitter. If you have questions or issues we'll try to help you out.If you're interested in hacking on Flux, the source code is open and easy to understand – it's all just the same Julia code you work with normally. You might be interested in our intro issues to get started."
 },
 
 ]}
diff --git a/latest/training/optimisers.html b/latest/training/optimisers.html
index 4aec9378..3a282e3d 100644
--- a/latest/training/optimisers.html
+++ b/latest/training/optimisers.html
@@ -6,7 +6,7 @@ m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
 
 ga('create', 'UA-36890222-9', 'auto');
 ga('send', 'pageview');
-
      Optimisers
      Optimisers
      Consider a simple linear regression. We create some dummy data, calculate a loss, and backpropagate to calculate gradients for the parameters W and b.
      W = param(rand(2, 5))
+
      Optimisers
      Optimisers
      Consider a simple linear regression. We create some dummy data, calculate a loss, and backpropagate to calculate gradients for the parameters W and b.
      W = param(rand(2, 5))
 b = param(rand(2))
 
 predict(x) = W*x .+ b
@@ -27,4 +27,4 @@ end
      If we call update, the parameters W
   Dense(10, 5, σ),
   Dense(5, 2), softmax)
      Instead of having to write [m[1].W, m[1].b, ...], Flux provides a params function params(m) that returns a list of all parameters in the model for you.
      For the update step, there's nothing whatsoever wrong with writing the loop above – it'll work just fine – but Flux provides various optimisers that make it more convenient.
      opt = SGD([W, b], 0.1) # Gradient descent with learning rate 0.1
 
-opt() # Carry out the update, modifying `W` and `b`.
      An optimiser takes a parameter list and returns a function that does the same thing as update above. We can pass either opt or update to our training loop, which will then run the optimiser after every mini-batch of data.
      Optimiser Reference
      All optimisers return a function that, when called, will update the parameters passed to it.
      Flux.Optimise.SGD — Function.
      SGD(params, η = 1; decay = 0)
      Classic gradient descent optimiser. For each parameter p and its gradient δp, this runs p -= η*δp.
      Supports decayed learning rate decay if the decay argument is provided.
      source
      Flux.Optimise.Momentum — Function.
      Momentum(params, ρ, decay = 0)
      SGD with momentum ρ and optional learning rate decay.
      source
      Flux.Optimise.Nesterov — Function.
      Nesterov(params, ρ, decay = 0)
      SGD with Nesterov momentum ρ and optional learning rate decay.
      source
      Flux.Optimise.RMSProp — Function.
      RMSProp(params; η = 0.001, ρ = 0.9, ϵ = 1e-8, decay = 0)
      RMSProp optimiser. Parameters other than learning rate don't need tuning. Often a good choice for recurrent networks.
      source
      Flux.Optimise.ADAM — Function.
      ADAM(params; η = 0.001, β1 = 0.9, β2 = 0.999, ϵ = 1e-08, decay = 0)
      ADAM optimiser.
      source
      Flux.Optimise.ADAGrad — Function.
      ADAGrad(params; η = 0.01, ϵ = 1e-8, decay = 0)
      ADAGrad optimiser. Parameters don't need tuning.
      source
      Flux.Optimise.ADADelta — Function.
      ADADelta(params; η = 0.01, ρ = 0.95, ϵ = 1e-8, decay = 0)
      ADADelta optimiser. Parameters don't need tuning.
      source
      
+opt() # Carry out the update, modifying `W` and `b`.
      An optimiser takes a parameter list and returns a function that does the same thing as update above. We can pass either opt or update to our training loop, which will then run the optimiser after every mini-batch of data.
      Optimiser Reference
      All optimisers return a function that, when called, will update the parameters passed to it.
      Flux.Optimise.SGD — Function.
      SGD(params, η = 1; decay = 0)
      Classic gradient descent optimiser. For each parameter p and its gradient δp, this runs p -= η*δp.
      Supports decayed learning rate decay if the decay argument is provided.
      source
      Flux.Optimise.Momentum — Function.
      Momentum(params, ρ, decay = 0)
      SGD with momentum ρ and optional learning rate decay.
      source
      Flux.Optimise.Nesterov — Function.
      Nesterov(params, ρ, decay = 0)
      SGD with Nesterov momentum ρ and optional learning rate decay.
      source
      Flux.Optimise.RMSProp — Function.
      RMSProp(params; η = 0.001, ρ = 0.9, ϵ = 1e-8, decay = 0)
      RMSProp optimiser. Parameters other than learning rate don't need tuning. Often a good choice for recurrent networks.
      source
      Flux.Optimise.ADAM — Function.
      ADAM(params; η = 0.001, β1 = 0.9, β2 = 0.999, ϵ = 1e-08, decay = 0)
      ADAM optimiser.
      source
      Flux.Optimise.ADAGrad — Function.
      ADAGrad(params; η = 0.01, ϵ = 1e-8, decay = 0)
      ADAGrad optimiser. Parameters don't need tuning.
      source
      Flux.Optimise.ADADelta — Function.
      ADADelta(params; η = 0.01, ρ = 0.95, ϵ = 1e-8, decay = 0)
      ADADelta optimiser. Parameters don't need tuning.
      source
      
diff --git a/latest/training/training.html b/latest/training/training.html
index d9379b1b..28215d8b 100644
--- a/latest/training/training.html
+++ b/latest/training/training.html
@@ -6,7 +6,7 @@ m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
 
 ga('create', 'UA-36890222-9', 'auto');
 ga('send', 'pageview');
-
      Training
      Training
      To actually train a model we need three things:
      • A model loss function, that evaluates how well a model is doing given some input data.
      • A collection of data points that will be provided to the loss function.
      • An optimiser that will update the model parameters appropriately.
      With these we can call Flux.train!:
      Flux.train!(modelLoss, data, opt)
      There are plenty of examples in the model zoo.
      Loss Functions
      The loss that we defined in basics is completely valid for training. We can also define a loss in terms of some model:
      m = Chain(
+
      Training
      Training
      To actually train a model we need three things:
      • A model loss function, that evaluates how well a model is doing given some input data.
      • A collection of data points that will be provided to the loss function.
      • An optimiser that will update the model parameters appropriately.
      With these we can call Flux.train!:
      Flux.train!(modelLoss, data, opt)
      There are plenty of examples in the model zoo.
      Loss Functions
      The loss that we defined in basics is completely valid for training. We can also define a loss in terms of some model:
      m = Chain(
   Dense(784, 32, σ),
   Dense(32, 10), softmax)