Hi Chris, @ChrisRackauckas

I am trying to follow your tutorial on youtube, it's really nice and helpful. I got a bit lost here at data = Iterators.repeated((), 5000), for example, the Hooks law, I am quite new to NN, I was expecting the training data to be (position, force) pairs. Could you explain a bit ? Thanks

When I navigate to lecture 8 (Forward Mode AD), I get navigated to:

https://book.sciml.ai/notes/08-Forward-Mode_Automatic_Differentiation_/

which returns a 404 error.

However, it looks like the correct link is:

https://book.sciml.ai/notes/08-Forward-Mode_Automatic_Differentiation_(AD)_via_High_Dimensional_Algebras/

Suggestion

Identification

Correction

Screenshots

Additional context

https://youtu.be/KCTfPyVIxpc?t=2730

https://github.com/mitmath/18337/blob/6b9e8d02b44ec02554be7861c6c3381e5f2de726/lecture11/adjoints.jmd#L273-L276

Just curious, which one will you be using for the next iteration of the class: vs code or atom?

It seems that Ch. 12 went missing.
Furthermore, it would be nice to have the number of a Chapter displayed together with the heading at the top (or indicate the current chapter in some other way) to make navigation easier (maybe this is an issue of Weave).

Other than that, great course and thanks a lot for sharing!!

also the wengart list is not quite what is said
and what isn't said (what a list is, deserves to be said)

Make it easier for readers to submit new issues detailing any mistakes, typos, or problems navigating the site.

• Add link to a standard issue template
• Add template for new issues to include
  • page source
  • mistake, typo, or problem
  • suggested correction

Suggestion

Identification

Correction

Screenshots

Additional context

Everything from We can make this faster by preallocating the cache vector
to before And let's get the mean of the trajectory for each of the parameters.
hardly speeds anything up so one doesn't pick up the point of anything.
I feel my time was wasted looking at all these codes.

Also all the parallel speed ups that follow are also unimpressive -- downright discouraging.
Chapter 5 has a few good points

• threads having their own stack
• parallel codes can be slow downs
• parallel codes are best on big problems

but otherwise the examples are just horrible sadly.

This is used as a hack for storage images for the Weave files.

i was trying to find that pic you used in a number of presentations to explain stiff dynamics and couldnt find it

I'm learning about forward sensitivities. Thanks for sharing the lecture. The code raises some errors about half of the way down the page on https://book.sciml.ai/notes/08/

In the 03: SciML Intro, I tried out the code snippets and examples. I came accross the following issues, which probably must be corrected:

1. The code sequence

using InteractiveUtils
@which Dense(10,32,tanh)

produced on my Windows 11 machine with Julia 1.8.3 the following output

julia> using InteractiveUtils

julia> @which Dense(10,32,tanh)
Dense(in::Integer, out::Integer, σ; kw...) in Flux at C:\Users\Andreas\.julia\packages\Flux\ZdbJr\src\deprecations.jl:63

which is different from the present text (see also the deprecations.jl file mentioned)

2. The code sequence

f = Dense(32,32,tanh)
f(rand(32))

generated no errors:

julia> f = Dense(32,32,tanh)
Dense(32 => 32, tanh)  # 1_056 parameters

julia> f(rand(32))
32-element Vector{Float64}:
  0.9062770976213805
  0.8425807828837493
  0.26792840252578065
  0.666140647367476
  0.4405276873148863
  0.19332285187403578
 -0.13799441384013086
  0.7189609454578357
  0.2718110166518423
 -0.6121470269007114
  0.1182030593450979
 -0.5633580380133035
  0.10511116299410357
  ⋮
 -0.6040242147542774
  0.2563146309890773
 -0.6861582833270895
 -0.8277344376601083
 -0.6012511813196918
  0.27191114186414983
 -0.01659445287046109
  0.15963767325232198
  0.6874323041110563
 -0.7743081464822815
 -0.11817069631320432
 -0.43434795650833513

from @ChrisRackauckas
now Julia just takes any asynchronous tasks and can choose the multithread how it wants from that

There's a line in the Final Project section that says "Final project topics must be declared by October 18th with a 1 page extended abstract.". I looked at the commit history and it looks like this was here in Fall 2019, and it conflicts with the October 30th due date for the project proposal given earlier in the README.

Suggestion
In Lecture 3, "Tuples are contravariant and heterogeneously typed with a parameter per internal object." should be read as "Tuples are covariant...".

Identification

Correction
Change contravariant to covariant.

Hi,

I have found this (live) book very useful and would like to cite it in my Master's research essay. It would be great if there were a CITATION.cff file so that I knew how I should cite this work.

Thank you kindly!

Breaking out separate request from #48

it would be nice to have the number of a Chapter displayed together with the heading at the top (or indicate the current chapter in some other way) to make navigation easier (maybe this is an issue of Weave).

This would indeed improve the ability to navigate the site since currently the only clue as to which chapter a note belongs to is in the URL, e.g., book.sciml.ai/notes/<chapter number>/.

In this line in Lecture 2, you calculate val = A[i,j] + B[i,j], which should come out as a Float64. In the next line, you index into val, the Float64, which somehow works without erroring.
https://github.com/mitmath/18337/blob/cdd7b2078048d83ff1180f7c8832ff2efb3ad058/lecture2/optimizing.jmd#L157

The function compiles and runs correctly, however, I don't know if this is necessary or just leftover from a previous function. In addition, at least on my machine, the @btime is faster if you take the indexing out.

I am enjoying reading the book which builds the necessary mathematical background. Thanks for the content.
While reading I found some mistakes that is worth correcting.
Correction
I think this in chapter 14:
What ML can learning from SciComp: Stability of Convolutional RNNs
should be

What ML can learn from SciComp: Stability of Convolutional RNNs

This section

Also thanks for the book, excited to catch up on what's happening in sciml!

Suggest Correction
A clear and concise description of what corrections are needed.

Identify

• Chapter number
• Section (lectures, notes, link, etc.)

Suggested Correction
A clear and concise description of what would correct this issue.

Screenshots
If applicable, add screenshots to help explain.

Additional context
Add any other context about the problem here.

I'm assuming $\text{E}$ from here is the residual function value, i.e. $g(u_i) = \text{E}$. Is this correct? And is it scalarized or in vector form?

Does the relative tolerance $\tau_r$ ever take into account the scaling of $u$? For example, a hydraulic problem that has pressure values in the order of 1e7 and valve displacements in the order of 1e-6. If $\text{E}$ is in vector form then is $q$ computed as norm( E ./ (tau_r*u + tau_a) ) ?

Suggest Correction
Pretty sure eq (4) should read \dot{p} = - dH/dx; currently the left side of this equation is missing (making it look like dH/dp = -dH/dx).

Identify
Chapter 15, the section on Hamiltonian Monte Carlo.

This may need a non-standard CI script to call it.

"Recal" should be "recall"

Here, I wonder whether "imaginary" should be "complex"?

in the screenshot the 19 is above the "Optimizing serial code" creating an annoying need to scroll down just
to even see the title. Great if lectures can be moved up.

I'd like to look for people to work with, is there a forum we can use to look for people?

Suggestion
derivation mistake on ODE adjoints

Identification
Notes 11

Correction

$$ \int_{t_{0}}^{T}\lambda^{\ast}\left(s^{\prime}-f_{u}s-f_{p}\right)dt =\int_{t_{0}}^{T}\lambda^{\ast}s^{\prime}dt-\int_{t_{0}}^{T}\lambda^{\ast}\left(f_{u}s-f_{p}\right)dt $$

should be

$$ \int_{t_{0}}^{T}\lambda^{\ast}\left(s^{\prime}-f_{u}s-f_{p}\right)dt =\int_{t_{0}}^{T}\lambda^{\ast}s^{\prime}dt-\int_{t_{0}}^{T}\lambda^{\ast}\left(f_{u}s+f_{p}\right)dt $$

and that affects the latter derivations.

Screenshots

Additional context

Flux has been updated since the contents of lecture 3 were created. Should be updated to reflect the new field names etc (eg. for x of type "Dense" x.W and x.b are deprecated in favor of x.weight and x.bias)

Suggestion

Flux is not precompling when run with Julia 1.10

Identification

Lecture 03

Getting Started with Machine Learning: Adding Flux
As well as other cells which are dependent on Flux

Correction

I'm not actually sure exactly what the solution to the problem is, but the correct behaviour is for Flux to import properly and not throw an error 😉

Screenshots

Suggestion

The subtitle reads "Array of Structs Representation". But, the section describes using a struct of arrays representation instead. The title should probably be changed to "Struct of Arrays Representation".
Identification

• Chapter 8

• Section: "Array of Structs Representation"

Correction

The subtitle reads "Array of Structs Representation". But, the first sentence is "Instead of thinking about a vector of dual numbers, thus we can instead think of dual numbers with vectors for the components", which describes a struct of arrays (SoA) representation. Also, the \hdots in the equation just after this paragraph is not rendering on my browser (Firefox 116.0.1).
Screenshots

Suggest Correction

1. Line 378 in https://github.com/SciML/SciMLBook/blob/master/_weave/lecture03/sciml.jmd

NN[1].weights # The W matrix of the first layer

produces ERROR: type Dense has no field weights:

I think the line should read

NN[1].weight # The W matrix of the first layer

(weight instead of weights)

2. Line 384 also in https://github.com/SciML/SciMLBook/blob/master/_weave/lecture03/sciml.jmd

p = params(NN)

Produces ERROR: UndefVarError: params not defined

I don't think Flux is exposing params with the using Flux command any more so I think the line should now read

p = Flux.params(NN)

Those screenshots are taken from https://book.sciml.ai/notes/03/

Hi,

I think there is a mistake in lecture 5 notes, in the "Multithreaded Parameter Searches" section, in the following code:

const _u_cache_threads = [Vector{typeof(@SVector([1.0,0.0,0.0]))}(undef,1000) for i in 1:Threads.nthreads()]
function compute_trajectory_mean5(u0,p)
  # u is automatically captured
  solve_system_save!(_u_cache_threads[Threads.threadid()],lorenz,u0,p,1000);
  mean(_u_cache)
end
@btime compute_trajectory_mean5(@SVector([1.0,0.0,0.0]),p)

After solving the system, the iteration are stored in _u_cache_threads[Threads.threadid()], but then the mean is computed on _u_cache, which, in my understanding, is not used anymore at this point of the notes.
It can be deceiving since serial_out - threaded_out it's still all 0s, but if you check the output of any of serial_out or threaded_out, the means for different ps have all the same value.

I think it should be mean(_u_cache_threads[Threads.threadid()]), is that correct?

(I'm not actually taking the course, I'm not a MIT student, I studying from the lecture notes in this repo)

Giacomo Randazzo