automatic-differentiation

In operations_broadcast_test.go there are some tests that are not yet filled in. The point is to test that broadcasting works for different shapes. The semantics of broadcast probably isn't clear, so please do send me a message for anything.

This is a good first issue for anyone looking to get interested

I'm using TF 2.0, and I get this error when I import tangent, due to a list of non-differentiable functions that includes tf.to_float (line 60), which is deprecated:

https://www.tensorflow.org/versions/r1.14/api_docs/python/tf/to_float

I found that function mod2pi is not implemented yet, but mod works. Is there any list of implemented functions? Minimal working example is:

using Zygote

# This is working
gradient(x -> mod(x, 2pi), 1.)

# This is not
gradient(x -> mod2pi(x), 1.)

Feature details

The qml.transforms.insert() transform was recently added in PennyLaneAI/pennylane#1795, allowing users to insert a specified single qubit gate into a circuit with three orientations:

• at the start of the circuit
• at the end of the circuit
• after every gate in the circuit

However, it might also be nice to have the option of inserting multiqubi

Description

Unit vector transforms should work with a zero-length unconstrained vector.

Example

The size-1 unit vector is just a constant [1]'. This should be the result of transforming the unconstrained 0-vector []'.

Expected Output

Stan programs that use:

parameters {
  unit_vector[1] alpha;
}

should lead to alpha == [1]'.

Current Ver

Debugging Kotlin∇ code within IntelliJ IDEA can be somewhat cumbersome due to the functional API structure (lots of deeply-nested stack traces and context switching). To facilitate more user-friendly debugging, we should add support for visual debugging by exposing Kaliningraph’s built-in graph visualization capabilities. For example, the use

Change to aet.slinalg.Solve.perform to remove currently existing bug

The following mwe

import aesara.tensor as aet
import aesara
import numpy
import numpy as np


def main():
    b_dev = aet.matrix('b_dev')
    M_dev = aet.matrix('M_dev')
    sym_solve = aet.slinalg.Solve(assume_a='sym')
    sym_solve = sym_solve(M_dev, b_dev)
    sym_solve = aesara.function(
        i

The init module has been deprecated, and the recommend approach for generating initial weights is to use the Template.shape method:

>>> from pennylane.templates import StronglyEntanglingLayers
>>> qml.init.strong_ent_layers_normal(n_layers=3, n_wires=2) # deprecated
>>> np.random.random(StronglyEntanglingLayers.shape(n_layers=3, n_wires=2))  # new approach

We should upd

When Zygote takes a gradient of an expression with a product of more than 3 terms, it allocates and becomes 100,000 times slower!

julia> using Zygote
julia> f(x) = 2.0 * 2.0 * x
julia> g(x) = 2.0 * 2.0 * 2.0 * x
julia> h(x) = 8.0 * x
julia> @btime gradient(f, 1.0)
  2.125 ns (0 allocations: 0 bytes)
julia> @btime gradient(g, 1.0)
  119.250 μs (276 allocations: 10.91 KiB)
julia

At the moment profiles.h (in pkg/profiles) lacks many (any?) comments. Also lots of variables are declared somewhat separately from where they are associated with heap storage.

Both these make it a bit hard to read.

It would be nicer if it was called PROFILES.h too.