tequila-basic 1.9.9__py3-none-any.whl → 1.9.10__py3-none-any.whl

tequila/grouping/overlapping_methods.py

@@ -2,37 +2,41 @@ import numpy as np
 from tequila.grouping.binary_utils import sorted_insertion_grouping, term_commutes_with_group
 from copy import deepcopy
 
+
 class OverlappingAuxiliary:
-    '''
+    """
     Class required for passing cov_dict and number of iterations to
     OverlappingGroups. Eventually, this may also be used for building cov_dict from
     approximate wavefunction if the user provides only the latter.
-    '''
+    """
+
     def __init__(self, cov_dict, n_iter=5):
         self.cov_dict = cov_dict
         self.n_iter = n_iter
 
+
 class OverlappingGroupsWoFixed:
-    '''
-    In the overlapping grouping methods, the same Pauli string term can be grouped into 
-    multiple different fragments. However, for this procedure to reduce the total number of 
-    required measurements, the coefficients in different fragments have to be optimized with 
+    """
+    In the overlapping grouping methods, the same Pauli string term can be grouped into
+    multiple different fragments. However, for this procedure to reduce the total number of
+    required measurements, the coefficients in different fragments have to be optimized with
     the constraint that the sum of the fragments equal the original operator.
     This Class is required for this optimization process. The overlapping grouping methods
     starts from some nonoverlapping groups N_alpha; Pauli strings are then added to several
-    compatible fragments with coefficients c_alpha. Because the nonoverlapping groups sum to 
+    compatible fragments with coefficients c_alpha. Because the nonoverlapping groups sum to
     the original operator, the sum of coefficients c_alpha for a given Pauli string has to be
     zero. This is ensured by fixing one of these c_alpha's as -(sum over the rest of c_alpha).
     See Eq. (14) of arXiv: 2201.01471 (2022).
-    '''
+    """
+
     def __init__(self, o_groups, o_terms, term_exists_in):
         def exclude_fixed_coeffs(o_groups, o_terms, term_exists_in):
-            '''
+            """
             Remove fixed coefficients from o_groups and term_exists_in.
             These fixed coefficients are determined from other Pauli coefficients in order that
             the condition sum_alpha c_alpha = 0 is satisfied [see comment for OverlappingGroupsWoFixed
             and Eq. (14) of arXiv: 2201.01471 (2022)].
-            '''
+            """
             fixed_grp = []
             o_groups_wo_fixed = deepcopy(o_groups)
             term_exists_in_wo_fixed = deepcopy(term_exists_in)
@@ -45,10 +49,10 @@ class OverlappingGroupsWoFixed:
             return fixed_grp, o_groups_wo_fixed, term_exists_in_wo_fixed, n_coeff_grp, init_idx
 
         def get_term_idxs(o_terms, o_groups_wo_fixed, term_exists_in_wo_fixed, init_idx):
-            '''
+            """
             Obtain a dictionary (over i) of dictionaries (over alpha) containing
             the index corresponding to a Pauli coefficient c_{i}^{alpha}.
-            '''
+            """
             term_idxs = {}
             for term_idx, term in enumerate(o_terms):
                 cur_idxs = {}
@@ -57,55 +61,61 @@ class OverlappingGroupsWoFixed:
                 term_idxs[term.binary_tuple()] = cur_idxs
             return term_idxs
 
-        self.fixed_grp, self.o_groups, self.term_exists_in, self.n_coeff_grp, self.init_idx \
-                                                            = exclude_fixed_coeffs(o_groups, o_terms, term_exists_in)
+        self.fixed_grp, self.o_groups, self.term_exists_in, self.n_coeff_grp, self.init_idx = exclude_fixed_coeffs(
+            o_groups, o_terms, term_exists_in
+        )
         self.term_idxs = get_term_idxs(o_terms, self.o_groups, self.term_exists_in, self.init_idx)
         return None
 
+
 def get_cov(term1, term2, cov_dict):
-    '''
+    """
     Return the covariance between Pauli string term 1 and 2 from a dictionary
     under the assumption that Pauli strings term1 and term2 commute.
-    '''
+    """
     if (term1.binary_tuple(), term2.binary_tuple()) in cov_dict:
         return cov_dict[(term1.binary_tuple(), term2.binary_tuple())]
     if (term2.binary_tuple(), term1.binary_tuple()) in cov_dict:
         return cov_dict[(term2.binary_tuple(), term1.binary_tuple())]
 
+
 def cov_term_w_group(term, group, cov_dict):
-    '''
+    """
     Compute covariance between a Pauli string term and a group of Pauli strings.
-    '''
+    """
     cov = 0.0
     for grp_term in group:
         cov += grp_term.get_coeff() * get_cov(term, grp_term, cov_dict)
     return cov
 
+
 def get_opt_sample_size(groups, cov_dict):
-    '''
+    """
     Allocate sample_size optimally based on variance.
-    '''
+    """
     weights = np.zeros(len(groups))
     for idx, group in enumerate(groups):
-        cur_var = 0.
+        cur_var = 0.0
         for term1 in group:
             for term2 in group:
                 cur_var += term1.coeff * term2.coeff * get_cov(term1, term2, cov_dict)
         weights[idx] = np.sqrt(np.real(cur_var))
     return weights / np.sum(weights)
 
+
 class OverlappingGroups:
-    '''
+    """
     Class required for performing overlapping grouping techniques:
-    coefficient splitting (implemented), ghost paulis (todo), and iterative 
-    measurement allocation (todo). Unlike nonoverlapping grouping methods, in the overlapping methods, 
+    coefficient splitting (implemented), ghost paulis (todo), and iterative
+    measurement allocation (todo). Unlike nonoverlapping grouping methods, in the overlapping methods,
     the same Pauli string term can appear in multiple compatible groups. The optimization of the associated
-    Pauli string coefficients is performed using the estimated covariances from cov_dict. 
-    '''
+    Pauli string coefficients is performed using the estimated covariances from cov_dict.
+    """
+
     def __init__(self, no_groups, o_terms, term_exists_in):
-        self.no_groups = no_groups #Non-overlapping groups: required as a starting point.
-        self.o_terms = o_terms #List of Pauli products that are compatible in multiple groups.
-        self.term_exists_in = term_exists_in #List of indices indicating where overlapping Pauli products appear.
+        self.no_groups = no_groups  # Non-overlapping groups: required as a starting point.
+        self.o_terms = o_terms  # List of Pauli products that are compatible in multiple groups.
+        self.term_exists_in = term_exists_in  # List of indices indicating where overlapping Pauli products appear.
         self.o_groups = [[] for i in range(len(no_groups))]
         for idx, term in enumerate(o_terms):
             for grup_idx in term_exists_in[idx]:
@@ -114,20 +124,22 @@ class OverlappingGroups:
         return None
 
     @classmethod
-    def init_from_binary_terms(cls, terms, condition='fc'):
-        '''
+    def init_from_binary_terms(cls, terms, condition="fc"):
+        """
         Obtain a list of Pauli operators that are compatible in more than one group
         by using the overlapping version of the sorted insertion algorithm.
-        '''
+        """
         nonoverlapping_groups = sorted_insertion_grouping(terms, condition=condition)
         newly_added = [[] for i in range(len(nonoverlapping_groups))]
         sorted_terms = sorted(terms, key=lambda x: np.abs(x.coeff), reverse=True)
         overlapping_terms = []
-        term_exists_in = [] #List of group indices where overlapping terms are present.
+        term_exists_in = []  # List of group indices where overlapping terms are present.
         for term in sorted_terms:
             grup_idxs = []
             for idx, group in enumerate(nonoverlapping_groups):
-                commute = term_commutes_with_group(term, group, condition) and term_commutes_with_group(term, newly_added[idx], condition)
+                commute = term_commutes_with_group(term, group, condition) and term_commutes_with_group(
+                    term, newly_added[idx], condition
+                )
                 if commute:
                     grup_idxs.append(idx)
                     newly_added[idx].append(term)
@@ -138,31 +150,34 @@ class OverlappingGroups:
         return group
 
     def optimize_pauli_coefficients(self, cov_dict, sample_size):
-        '''
+        """
         Build the equation matrix @ x = b and solve it in order to obtain the
-        optimal overlapping coefficients for the measurable fragments 
+        optimal overlapping coefficients for the measurable fragments
         [see Eq. (14) on arXiv:2201.01471].
-        '''
+        """
+
         def prep_mat_single_row(term, group_index):
-            '''
-            Build the matrix row corresponding to Pauli term. 
-            '''
+            """
+            Build the matrix row corresponding to Pauli term.
+            """
             mat_single = np.zeros(np.sum(self.wo_fixed.n_coeff_grp))
             for term2_idx, term2 in enumerate(self.o_groups[group_index]):
                 term2_idx_dict = self.wo_fixed.term_idxs[term2.binary_tuple()]
                 cov = np.real_if_close(get_cov(term, term2, cov_dict))
                 if term2 in self.wo_fixed.o_groups[group_index]:
-                    mat_single[term2_idx_dict[group_index]] -= cov/sample_size[group_index]
+                    mat_single[term2_idx_dict[group_index]] -= cov / sample_size[group_index]
                 else:
                     for idx in term2_idx_dict.values():
-                        mat_single[idx] += cov/sample_size[group_index]
+                        mat_single[idx] += cov / sample_size[group_index]
             return mat_single
 
         def prep_b_single_row(term, group_index):
-            '''
-            Build b row corresponding to Pauli term. 
-            '''
-            return np.real_if_close(cov_term_w_group(term, self.no_groups[group_index], cov_dict) / sample_size[group_index])
+            """
+            Build b row corresponding to Pauli term.
+            """
+            return np.real_if_close(
+                cov_term_w_group(term, self.no_groups[group_index], cov_dict) / sample_size[group_index]
+            )
 
         mat_size = np.sum(self.wo_fixed.n_coeff_grp)
         matrix = np.zeros((mat_size, mat_size))
@@ -181,17 +196,19 @@ class OverlappingGroups:
         return sol.T[0]
 
     def overlapping_groups_from_coeff(self, coeff):
-        '''
+        """
         Find fixed coefficients from the optimal coefficients and
         return the optimal overlapping groups to be measured.
-        '''
+        """
+
         def add_coeff_times_term(coeff, term, group_index):
             added = False
             for igrp, group_term in enumerate(final_overlapping_groups[group_index]):
                 if group_term.binary_tuple() == term.binary_tuple():
-                    final_overlapping_groups[group_index][igrp].set_coeff( coeff + group_term.get_coeff() )
+                    final_overlapping_groups[group_index][igrp].set_coeff(coeff + group_term.get_coeff())
                     added = True
-            if not(added): final_overlapping_groups[group_index].append( term.term_w_coeff(coeff) )
+            if not (added):
+                final_overlapping_groups[group_index].append(term.term_w_coeff(coeff))
             return None
 
         final_overlapping_groups = deepcopy(self.no_groups)
@@ -207,9 +224,9 @@ class OverlappingGroups:
         return final_overlapping_groups
 
     def optimal_overlapping_groups(self, overlap_aux):
-        '''
+        """
         Find a set of overlapping groups with optimized coefficients.
-        '''
+        """
         cur_groups = self.no_groups
         for i in range(overlap_aux.n_iter):
             cur_sample_size = get_opt_sample_size(cur_groups, overlap_aux.cov_dict)

tequila/hamiltonian/paulis.py

@@ -3,6 +3,7 @@ Convenience initialization
 of Pauli Operators. Resulting structures can be added and multiplied together.
 Currently uses OpenFermion as backend (QubitOperators)
 """
+
 import typing
 from tequila.hamiltonian import QubitHamiltonian
 from tequila import BitString, TequilaException
@@ -10,9 +11,11 @@ from tequila.wavefunction.qubit_wavefunction import QubitWaveFunction
 from tequila.tools import list_assignment
 import numpy
 
+
 def from_string(string, openfermion_format=False):
     return QubitHamiltonian.from_string(string=string, openfermion_format=openfermion_format)
 
+
 def pauli(qubit, type) -> QubitHamiltonian:
     """
     Parameters
@@ -198,7 +201,7 @@ def Sp(qubit) -> QubitHamiltonian:
     qubit = list_assignment(qubit)
     result = I()
     for q in qubit:
-        result *= 0.5 * (X(qubit=q) + 1.j * Y(qubit=q))
+        result *= 0.5 * (X(qubit=q) + 1.0j * Y(qubit=q))
     return result
 
 
@@ -224,7 +227,7 @@ def Sm(qubit) -> QubitHamiltonian:
     qubit = list_assignment(qubit)
     result = I()
     for q in qubit:
-        result *= 0.5 * (X(qubit=q) - 1.j * Y(qubit=q))
+        result *= 0.5 * (X(qubit=q) - 1.0j * Y(qubit=q))
     return result
 
 
@@ -264,12 +267,13 @@ def Projector(wfn, threshold=0.0, n_qubits=None) -> QubitHamiltonian:
             c = v1.conjugate() * v2
             if not numpy.isclose(c, 0.0, atol=threshold):
                 H += c * decompose_transfer_operator(bra=k1, ket=k2)
-    assert (H.is_hermitian())
+    assert H.is_hermitian()
     return H
 
 
-def KetBra(ket: QubitWaveFunction, bra: QubitWaveFunction, hermitian: bool = False, threshold: float = 1.e-6,
-           n_qubits=None):
+def KetBra(
+    ket: QubitWaveFunction, bra: QubitWaveFunction, hermitian: bool = False, threshold: float = 1.0e-6, n_qubits=None
+):
     """
     Notes
     ----------
@@ -348,12 +352,7 @@ def decompose_transfer_operator(ket: BitString, bra: BitString, qubits: typing.L
 
     """
 
-    opmap = {
-        (0, 0): Qp,
-        (0, 1): Sp,
-        (1, 0): Sm,
-        (1, 1): Qm
-    }
+    opmap = {(0, 0): Qp, (0, 1): Sp, (1, 0): Sm, (1, 1): Qm}
 
     nbits = None
     if qubits is not None:
@@ -366,13 +365,13 @@ def decompose_transfer_operator(ket: BitString, bra: BitString, qubits: typing.L
 
     b_arr = bra.array
     k_arr = ket.array
-    assert (len(b_arr) == len(k_arr))
+    assert len(b_arr) == len(k_arr)
     n_qubits = len(k_arr)
 
     if qubits is None:
         qubits = range(n_qubits)
 
-    assert (n_qubits <= len(qubits))
+    assert n_qubits <= len(qubits)
 
     result = QubitHamiltonian.unit()
     for q, b in enumerate(b_arr):

tequila/hamiltonian/paulistring.py

@@ -1,7 +1,7 @@
 from tequila.hamiltonian import PauliString
 
 if __name__ == "__main__":
-    testdata = {0: 'x', 1: 'y', 2: 'z'}
+    testdata = {0: "x", 1: "y", 2: "z"}
     test = PauliString(data=testdata, coeff=2)
     print("test=", test)
     print("test: openfermion_key = ", test.key_openfermion())

tequila/hamiltonian/qubit_hamiltonian.py

@@ -1,3 +1,9 @@
+"""
+Explicit matrix forms for the Pauli operators for the tomatrix method
+For sparse matrices use the openfermion tool
+get the openfermion object with hamiltonian.hamiltonian
+"""
+
 import numbers
 import typing
 
@@ -10,20 +16,15 @@ from functools import reduce
 
 from collections import namedtuple
 
-BinaryPauli = namedtuple("BinaryPauli", "coeff, binary")
-
-"""
-Explicit matrix forms for the Pauli operators for the tomatrix method
-For sparse matrices use the openfermion tool
-get the openfermion object with hamiltonian.hamiltonian
-"""
 import numpy as np
 
+BinaryPauli = namedtuple("BinaryPauli", "coeff, binary")
+
 pauli_matrices = {
-    'I': np.array([[1, 0], [0, 1]], dtype=complex),
-    'Z': np.array([[1, 0], [0, -1]], dtype=complex),
-    'X': np.array([[0, 1], [1, 0]], dtype=complex),
-    'Y': np.array([[0, -1j], [1j, 0]], dtype=complex)
+    "I": np.array([[1, 0], [0, 1]], dtype=complex),
+    "Z": np.array([[1, 0], [0, -1]], dtype=complex),
+    "X": np.array([[0, 1], [1, 0]], dtype=complex),
+    "Y": np.array([[0, -1j], [1j, 0]], dtype=complex),
 }
 
 
@@ -98,12 +99,19 @@ class PauliString:
         # <psi|op|psi> = |a|**2<0|op|0> + (a*)*b<1|op|0> + (b*)*a<0|op|1> + |b|**2<1|op|1>
 
         if states is None:
-            states = [(1.0, 0.0)]*len(qubits)
+            states = [(1.0, 0.0)] * len(qubits)
 
         def make_coeff_vec(state_tuple):
-            return np.asarray([np.abs(state_tuple[0])**2, state_tuple[0].conjugate()*state_tuple[1], state_tuple[1].conjugate()*state_tuple[0] ,np.abs(state_tuple[1])**2])
-
-        factor=1.0
+            return np.asarray(
+                [
+                    np.abs(state_tuple[0]) ** 2,
+                    state_tuple[0].conjugate() * state_tuple[1],
+                    state_tuple[1].conjugate() * state_tuple[0],
+                    np.abs(state_tuple[1]) ** 2,
+                ]
+            )
+
+        factor = 1.0
         for q, state in zip(qubits, states):
             if q in self.keys():
                 matrix = pauli_matrices[self[q].upper()].reshape([4])
@@ -112,9 +120,8 @@ class PauliString:
                 if factor == 0.0:
                     break
 
-        new_data = {k:v for k,v in self.items() if k not in qubits}
-        return PauliString(data=new_data, coeff=self.coeff*factor)
-
+        new_data = {k: v for k, v in self.items() if k not in qubits}
+        return PauliString(data=new_data, coeff=self.coeff * factor)
 
     def map_qubits(self, qubit_map: dict):
         """
@@ -153,13 +160,13 @@ class PauliString:
         """
         data = dict()
         string = string.strip()
-        for part in string.split(')'):
+        for part in string.split(")"):
             part = part.strip()
             if part == "":
                 break
-            pauli_dim = part.split('(')
+            pauli_dim = part.split("(")
             string = pauli_dim[0].upper()
-            if not string in ['X', 'Y', 'Z']:
+            if string not in ["X", "Y", "Z"]:
                 raise TequilaException("PauliString.from_string initialization failed, unknown pauliterm: " + string)
             data[int(pauli_dim[1])] = string
 
@@ -223,8 +230,11 @@ class PauliString:
 
         if n_qubits < maxq:
             raise TequilaException(
-                "PauliString acts on qubit number larger than n_qubits given\n PauliString=" + self.__repr__() + ", n_qubits=" + str(
-                    n_qubits))
+                "PauliString acts on qubit number larger than n_qubits given\n PauliString="
+                + self.__repr__()
+                + ", n_qubits="
+                + str(n_qubits)
+            )
 
         binary = np.zeros(2 * n_qubits)
         for k, v in self._data.items():
@@ -310,9 +320,9 @@ class QubitHamiltonian:
         else:
             self._qubit_operator = qubit_operator
 
-        assert (isinstance(self._qubit_operator, QubitOperator))
+        assert isinstance(self._qubit_operator, QubitOperator)
 
-    def trace_out_qubits(self, qubits, states: list=None, *args, **kwargs):
+    def trace_out_qubits(self, qubits, states: list = None, *args, **kwargs):
         """
         Tracing out qubits with the assumption that they are in the |0> (default) or |1> state
 
@@ -328,7 +338,7 @@ class QubitHamiltonian:
         """
 
         if states is None:
-            states = [(1.0,0.0)]*len(qubits)
+            states = [(1.0, 0.0)] * len(qubits)
         else:
             assert len(states) == len(qubits)
             # states should be given as list of individual tq.QubitWaveFunctions
@@ -400,14 +410,14 @@ class QubitHamiltonian:
             string = string.replace("Y", " Y")
             string = string.replace("Z", " Z")
             string += " "
-            terms = string.split('+')
+            terms = string.split("+")
             for term in terms:
                 if term.strip() == "":
                     continue
 
                 coeff = term.split(" ")[0]
                 if coeff.strip() == "" or coeff[0] in ["X", "Y", "Z"]:
-                    coeff = '1.0'
+                    coeff = "1.0"
                     ps = term
                 else:
                     ps = term.replace(coeff, " ").replace(" ", "")
@@ -418,7 +428,7 @@ class QubitHamiltonian:
                     if "@" in coeff:
                         coeff = coeff.replace("@", "e-")
                     coeff = complex(coeff)
-                except Exception as E:
+                except Exception:
                     raise Exception("failed to convert coefficient : {}".format(coeff))
 
                 if coeff.imag == 0.0:
@@ -490,7 +500,7 @@ class QubitHamiltonian:
         return self.__neg__().__add__(other=other)
 
     def __pow__(self, power):
-        return QubitHamiltonian(qubit_operator=self.qubit_operator ** power)
+        return QubitHamiltonian(qubit_operator=self.qubit_operator**power)
 
     def __neg__(self):
         return self.__mul__(other=-1.0)
@@ -524,7 +534,7 @@ class QubitHamiltonian:
         anti_hermitian = QubitHamiltonian.zero()
         for k, v in self.qubit_operator.terms.items():
             hermitian.qubit_operator.terms[k] = v.real
-            anti_hermitian.qubit_operator.terms[k] = 1.j * v.imag
+            anti_hermitian.qubit_operator.terms[k] = 1.0j * v.imag
 
         return hermitian.simplify(), anti_hermitian.simplify()
 
@@ -575,10 +585,10 @@ class QubitHamiltonian:
 
         Returns a dense 2**N x 2**N matrix representation of this
         QubitHamiltonian. Watch for memory usage when N is >12!
-        
+
         Args:
             ignore_unused_qubits: If no non-trivial operator is defined on a qubits this qubit will be ignored in the matrix construction.
-                Take for example X(1). 
+                Take for example X(1).
                 If False the operator X(1) will get mapped to X(0)
                 and the function will return the matrix for X(0)
                 otherwise the function will return the matrix 1 \otimes X(1)
@@ -590,10 +600,10 @@ class QubitHamiltonian:
         if ignore_unused_qubits:
             nq = len(qubits)
         else:
-            nq = max(qubits)+1
+            nq = max(qubits) + 1
 
         I = np.eye(2, dtype=complex)
-        Hm = np.zeros((2 ** nq, 2 ** nq), dtype=complex)
+        Hm = np.zeros((2**nq, 2**nq), dtype=complex)
 
         for key, val in self.items():
             term = [I] * nq

tequila/ml/__init__.py

@@ -1,4 +1,5 @@
 from .ml_api import to_platform
 from .ml_api import HAS_TORCH
+
 if HAS_TORCH:
     from .interface_torch import TorchLayer

tequila/ml/interface_torch.py

@@ -24,11 +24,12 @@ def get_torch_function(objective: Objective, compile_args: dict = None, input_va
         the requisite pytorch autograd function, alongside necessary information for higher level classes.
     """
 
-    if isinstance(objective,tuple) or isinstance(objective,list) or isinstance(objective,Objective):
+    if isinstance(objective, tuple) or isinstance(objective, list) or isinstance(objective, Objective):
         objective = vectorize(list_assignment(objective))
-    comped_objective, compile_args, input_vars, weight_vars, i_grads, w_grads, first, second \
-        = preamble(objective, compile_args, input_vars)
-    samples = compile_args['samples']
+    comped_objective, compile_args, input_vars, weight_vars, i_grads, w_grads, first, second = preamble(
+        objective, compile_args, input_vars
+    )
+    samples = compile_args["samples"]
 
     def tensor_fix(tensor, angles, first, second):
         """
@@ -94,6 +95,7 @@ def get_torch_function(objective: Objective, compile_args: dict = None, input_va
                 takes a tensor and an (int: Variable) dict and returns a (Variable: float) dict.
 
         """
+
         @staticmethod
         def forward(ctx, inputs, angles):
             """
@@ -106,8 +108,8 @@ def get_torch_function(objective: Objective, compile_args: dict = None, input_va
             if not isinstance(result, np.ndarray):
                 # this happens if the Objective is a scalar since that's usually more convenient for pure quantum stuff.
                 result = np.array(result)
-            if hasattr(inputs,'device'):
-                if inputs.device == 'cuda':
+            if hasattr(inputs, "device"):
+                if inputs.device == "cuda":
                     r = torch.from_numpy(result).to(inputs.device)
                 else:
                     r = torch.from_numpy(result)
@@ -122,7 +124,7 @@ def get_torch_function(objective: Objective, compile_args: dict = None, input_va
             call_args = tensor_fix(inputs, angles, first, second)
             back_d = grad_backward.get_device()
             # build up weight and input gradient matrices... see what needs to be done to them.
-            grad_outs = [None,None]
+            grad_outs = [None, None]
             for i, grads in enumerate([i_grads, w_grads]):
                 if grads != {}:
                     g_keys = [j for j in grads.keys()]
@@ -138,7 +140,7 @@ def get_torch_function(objective: Objective, compile_args: dict = None, input_va
                     else:
                         g_tensor = torch.as_tensor(arr, dtype=grad_backward.dtype)
 
-                    b = grad_backward.reshape(-1,1)
+                    b = grad_backward.reshape(-1, 1)
                     jvp = torch.matmul(g_tensor, b)
                     jvp_out = jvp.flatten()
                     jvp_out.requires_grad_(True)
@@ -186,9 +188,9 @@ class TorchLayer(torch.nn.Module):
         super().__init__()
 
         self._objective = objective
-        self.function,  weight_vars, compile_args = get_torch_function(objective, compile_args, input_vars)
+        self.function, weight_vars, compile_args = get_torch_function(objective, compile_args, input_vars)
         self._input_len = len(objective.extract_variables()) - len(weight_vars)
-        inits = compile_args['initial_values']
+        inits = compile_args["initial_values"]
         self.weights = {}
         if inits is not None:
             for v in weight_vars:
@@ -197,7 +199,7 @@ class TorchLayer(torch.nn.Module):
                 self.register_parameter(str(v), self.weights[str(v)])
         else:
             for v in weight_vars:
-                self.weights[str(v)] = torch.nn.Parameter(torch.nn.init.uniform(torch.Tensor(1), a=0.0, b=2*np.pi)[0])
+                self.weights[str(v)] = torch.nn.Parameter(torch.nn.init.uniform(torch.Tensor(1), a=0.0, b=2 * np.pi)[0])
                 self.register_parameter(str(v), self.weights[str(v)])
 
     def forward(self, x=None):
@@ -231,7 +233,9 @@ class TorchLayer(torch.nn.Module):
             f = None
         if x is not None:
             if len(x) != self._input_len:
-                raise TequilaMLException('Received input of len {} when Objective takes {} inputs.'.format(len(x),self._input_len))
+                raise TequilaMLException(
+                    "Received input of len {} when Objective takes {} inputs.".format(len(x), self._input_len)
+                )
         return self.function.apply(x, f)
 
     def extra_repr(self) -> str:
@@ -241,8 +245,7 @@ class TorchLayer(torch.nn.Module):
         str:
             Information used by print(TorchLayer).
         """
-        string = 'Tequila TorchLayer. Represents: \n'
-        string += '{} \n'.format(str(self._objective))
-        string += 'Current Weights: {}'.format(self.weights)
+        string = "Tequila TorchLayer. Represents: \n"
+        string += "{} \n".format(str(self._objective))
+        string += "Current Weights: {}".format(self.weights)
         return string
-