Refactorization

Author: VaclavMacha

docs/make.jl

@@ -43,7 +43,8 @@ lecture_01 = [
 
 lecture_02 = [
     "Arrays" => "./lecture_02/arrays.md",
-    "Data structures" => "./lecture_02/data_structures.md",
+    "Tuples and named tuples" => "./lecture_02/tuples.md",
+    "Dictionaries" => "./lecture_02/dictionaries.md",
 ]
 
 lecture_03 = [
@@ -90,19 +91,22 @@ lecture_08 = joinpath.("./lecture_08/", [
     "unconstrained.md",
     "constrained.md",
     "exercises.md",
+    "homework.md",
 ])
 
 lecture_09 = joinpath.("./lecture_09/", [
     "theory.md",
     "linear.md",
     "logistic.md",
     "exercises.md",
+    "homework.md",
 ])
 
 lecture_10 = joinpath.("./lecture_10/", [
     "theory.md",
     "nn.md",
     "exercises.md",
+    "homework.md",
 ])
 
 lecture_11 = joinpath.("./lecture_11/", [

docs/src/lecture_02/dictionaries.md

@@ -0,0 +1,98 @@
+# Dictionaries
+
+Dictionaries are mutable, unordered (random order) collections of pairs of keys and values. The syntax for creating a dictionary is:
+
+```jldoctest dicts
+julia> d = Dict("a" => [1, 2, 3], "b" => 1)
+Dict{String, Any} with 2 entries:
+  "b" => 1
+  "a" => [1, 2, 3]
+```
+
+Another possibility is to use symbols instead of strings as keys.
+
+```jldoctest dicts
+julia> d = Dict(:a => [1, 2, 3], :b => 1)
+Dict{Symbol, Any} with 2 entries:
+  :a => [1, 2, 3]
+  :b => 1
+```
+
+It is possible to use almost any type as a key in a dictionary. Dictionary's elements can be accessed via square brackets and a key.
+
+```jldoctest dicts
+julia> d[:a]
+3-element Vector{Int64}:
+ 1
+ 2
+ 3
+```
+
+If the key does not exist in the dictionary, an error will occur if we try to access it.
+
+```jldoctest dicts
+julia> d[:c]
+ERROR: KeyError: key :c not found
+
+julia> haskey(d, :c)
+false
+```
+
+The `haskey` function checks whether the dictionary has the `:c` key. To avoid such errors, we can use the `get` function that accepts three arguments: a dictionary, key, and a default value for this key, which is returned if the key does not exist in the dictionary.
+
+```jldoctest dicts
+julia> get(d, :c, 42)
+42
+```
+
+There is also an in-place version of the `get` function. The `get!` function adds the default value to the dictionary if the key does not exist.
+
+```jldoctest dicts
+julia> get!(d, :c, 42)
+42
+
+julia> get!(d, :d, ["hello", "world"])
+2-element Vector{String}:
+ "hello"
+ "world"
+
+julia> d
+Dict{Symbol, Any} with 4 entries:
+  :a => [1, 2, 3]
+  :b => 1
+  :d => ["hello", "world"]
+  :c => 42
+```
+
+Unwanted keys from the dictionary can be removed by the `delete!` function.
+
+```jldoctest dicts
+julia> delete!(d, :d)
+Dict{Symbol, Any} with 3 entries:
+  :a => [1, 2, 3]
+  :b => 1
+  :c => 42
+
+julia> haskey(d, :d)
+false
+```
+
+An alternative is the `pop!` function, which removes the key from the dictionary, and returns the value corresponding to it.
+
+```jldoctest dicts
+julia> pop!(d, :c)
+42
+
+julia> haskey(d, :c)
+false
+```
+
+Optionally, it is possible to add a default value for a given key to the `pop!` function, which is returned if the key does not exist in the given dictionary.
+
+```jldoctest dicts
+julia> haskey(d, :c)
+false
+
+julia> pop!(d, :c, 444)
+444
+```

docs/src/lecture_02/data_structures.md renamed to docs/src/lecture_02/tuples.md

@@ -130,103 +130,4 @@ julia> a, b, c = t
 
 julia> println("The values stored in the tuple are: a = $a, b = $b")
 The values stored in the tuple are: a = 1, b = 2.0
-```
-
-## Dictionaries
-
-Dictionaries are mutable, unordered (random order) collections of pairs of keys and values. The syntax for creating a dictionary is:
-
-```jldoctest dicts
-julia> d = Dict("a" => [1, 2, 3], "b" => 1)
-Dict{String, Any} with 2 entries:
-  "b" => 1
-  "a" => [1, 2, 3]
-```
-
-Another possibility is to use symbols instead of strings as keys.
-
-```jldoctest dicts
-julia> d = Dict(:a => [1, 2, 3], :b => 1)
-Dict{Symbol, Any} with 2 entries:
-  :a => [1, 2, 3]
-  :b => 1
-```
-
-It is possible to use almost any type as a key in a dictionary. Dictionary's elements can be accessed via square brackets and a key.
-
-```jldoctest dicts
-julia> d[:a]
-3-element Vector{Int64}:
- 1
- 2
- 3
-```
-
-If the key does not exist in the dictionary, an error will occur if we try to access it.
-
-```jldoctest dicts
-julia> d[:c]
-ERROR: KeyError: key :c not found
-
-julia> haskey(d, :c)
-false
-```
-
-The `haskey` function checks whether the dictionary has the `:c` key. To avoid such errors, we can use the `get` function that accepts three arguments: a dictionary, key, and a default value for this key, which is returned if the key does not exist in the dictionary.
-
-```jldoctest dicts
-julia> get(d, :c, 42)
-42
-```
-
-There is also an in-place version of the `get` function. The `get!` function adds the default value to the dictionary if the key does not exist.
-
-```jldoctest dicts
-julia> get!(d, :c, 42)
-42
-
-julia> get!(d, :d, ["hello", "world"])
-2-element Vector{String}:
- "hello"
- "world"
-
-julia> d
-Dict{Symbol, Any} with 4 entries:
-  :a => [1, 2, 3]
-  :b => 1
-  :d => ["hello", "world"]
-  :c => 42
-```
-
-Unwanted keys from the dictionary can be removed by the `delete!` function.
-
-```jldoctest dicts
-julia> delete!(d, :d)
-Dict{Symbol, Any} with 3 entries:
-  :a => [1, 2, 3]
-  :b => 1
-  :c => 42
-
-julia> haskey(d, :d)
-false
-```
-
-An alternative is the `pop!` function, which removes the key from the dictionary, and returns the value corresponding to it.
-
-```jldoctest dicts
-julia> pop!(d, :c)
-42
-
-julia> haskey(d, :c)
-false
-```
-
-Optionally, it is possible to add a default value for a given key to the `pop!` function, which is returned if the key does not exist in the given dictionary.
-
-```jldoctest dicts
-julia> haskey(d, :c)
-false
-
-julia> pop!(d, :c, 444)
-444
-```
+```

docs/src/lecture_08/exercises.md

@@ -1,27 +1,5 @@
 # [Exercises](@id l7-exercises)
 
-```@raw html
-<div class="admonition is-category-homework">
-<header class="admonition-header">Homework: Newton's method</header>
-<div class="admonition-body">
-```
-
-Newton's method for solving equation ``g(x)=0`` is an iterative procedure which at every iteration ``x^k`` approximates the function ``g(x)`` by its first-order (linear) expansion ``g(x) \approx g(x^k) + \nabla g(x^k)(x-x^k)`` and finds the zero point of this approximation.
-
-Newton's method for unconstrained optimization replaces the optimization problem by its optimality condition and solves the resulting equation.
-
-Implement Newton's method to minimize
-
-```math
-f(x) = e^{x_1^2 + x_2^2 - 1} + (x_1-1)^2
-```
-
-with the starting point ``x^0=(0,0)``.
-
-```@raw html
-</div></div>
-```   
-
 ```@raw html
 <div class="admonition is-category-exercise">
 <header class="admonition-header">Exercise 1: Solving a system of linear equations</header>

docs/src/lecture_08/homework.md

@@ -0,0 +1,23 @@
+# Homework
+
+```@raw html
+<div class="admonition is-category-homework">
+<header class="admonition-header">Homework: Newton's method</header>
+<div class="admonition-body">
+```
+
+Newton's method for solving equation ``g(x)=0`` is an iterative procedure which at every iteration ``x^k`` approximates the function ``g(x)`` by its first-order (linear) expansion ``g(x) \approx g(x^k) + \nabla g(x^k)(x-x^k)`` and finds the zero point of this approximation.
+
+Newton's method for unconstrained optimization replaces the optimization problem by its optimality condition and solves the resulting equation.
+
+Implement Newton's method to minimize
+
+```math
+f(x) = e^{x_1^2 + x_2^2 - 1} + (x_1-1)^2
+```
+
+with the starting point ``x^0=(0,0)``.
+
+```@raw html
+</div></div>
+```

docs/src/lecture_09/exercises.md

@@ -40,18 +40,6 @@ w = log_reg(X, y, zeros(size(X,2)))
 
 # [Exercises](@id l8-exercises)
 
-!!! homework "Homework: Data normalization"
-    Data are often normalized. Each feature subtracts its mean and then divides the result by its standard deviation. The normalized features have zero mean and unit standard deviation. This may help in several cases:
-    - When each feature has a different order of magnitude (such as millimetres and kilometres). Then the gradient would ignore the feature with the smaller values.
-    - When problems such as vanishing gradients are present (we will elaborate on this in Exercise 4).
-
-    Write function ```normalize``` which takes as an input a dataset and normalizes it. Then train the same classifier as we did for [logistic regression](@ref log-reg). Use the original and normalized dataset. Which differences did you observe when
-    - the logistic regression is optimized via gradient descent?
-    - the logistic regression is optimized via Newton's method?
-    Do you have any intuition as to why?
-
-    Write a short report (in LaTeX) summarizing your findings.
-
 ```@raw html
 <div class="admonition is-category-exercise">
 <header class="admonition-header">Exercise 1:</header>

docs/src/lecture_09/homework.md

@@ -0,0 +1,13 @@
+# Homework
+
+!!! homework "Homework: Data normalization"
+    Data are often normalized. Each feature subtracts its mean and then divides the result by its standard deviation. The normalized features have zero mean and unit standard deviation. This may help in several cases:
+    - When each feature has a different order of magnitude (such as millimetres and kilometres). Then the gradient would ignore the feature with the smaller values.
+    - When problems such as vanishing gradients are present (we will elaborate on this in Exercise 4).
+
+    Write function ```normalize``` which takes as an input a dataset and normalizes it. Then train the same classifier as we did for [logistic regression](@ref log-reg). Use the original and normalized dataset. Which differences did you observe when
+    - the logistic regression is optimized via gradient descent?
+    - the logistic regression is optimized via Newton's method?
+    Do you have any intuition as to why?
+
+    Write a short report (in LaTeX) summarizing your findings.

docs/src/lecture_10/exercises.md

@@ -108,11 +108,6 @@ y = iris.Species
 
 # [Exercises](@id l9-exercises)
 
-!!! homework "Homework: Optimal setting"
-    Perform an analysis of hyperparameters of the neural network from this lecture. Examples may include network architecture, learning rate (stepsize), activation functions or normalization.
-
-    Write a short summary (in LaTeX) of your suggestions.
-
 ```@raw html
 <div class="admonition is-category-exercise">
 <header class="admonition-header">Exercise 1: Keyword arguments</header>

docs/src/lecture_10/homework.md

@@ -0,0 +1,6 @@
+# Homework
+
+!!! homework "Homework: Optimal setting"
+    Perform an analysis of hyperparameters of the neural network from this lecture. Examples may include network architecture, learning rate (stepsize), activation functions or normalization.
+
+    Write a short summary (in LaTeX) of your suggestions.