Repository: qiskit-community/qiskit-machine-learning (language: python)

Issue:
Remove all deprecated code
For next release and preparation to be supported by community removed all deprecated code

- [x] Remove all deprecated code
- [x] Remove depecation.py and its test (going forwards the intent is to only use Qiskit decorators)
- [x] With the above removed migration notebooks will not run/build. Convert to .rst format so the content is kept but they are no longer run as has been done in other app repos.

Depending on timing we may choose  to add a reno that describes this change, and others, later so as to be consistent with what is said for the other apps etc.

I'll comment here since its about removing stuff. Maybe check over the release notes that come out that are new and make sure no notes that have not yet gone out in any release are being obsoleted by these changes - if so remove/change them as needed.

- [x] After above switch any remaining uses of QuantumCircuit `bind_parameters` over to `assign_parameters` as the former is now deprecated in Qiskit main (0.45)


Discussion / hints:

Fix patch:
diff --git a/constraints.txt b/constraints.txt
index b1d252751..ad6eb533c 100644
--- a/constraints.txt
+++ b/constraints.txt
@@ -1,2 +1,3 @@
 numpy>=1.20.0
 ipython<8.13;python_version<'3.9'
+
diff --git a/docs/migration/01_migration_guide_0.5.ipynb b/docs/migration/01_migration_guide_0.5.ipynb
deleted file mode 100644
index 1cc8ead5f..000000000
--- a/docs/migration/01_migration_guide_0.5.ipynb
+++ /dev/null
@@ -1,885 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "interracial-yellow",
-   "metadata": {},
-   "source": [
-    "# Qiskit Machine Learning v0.5 Migration Guide\n",
-    "\n",
-    "This tutorial will guide you through the process of migrating your code from Qiskit Machine Learning v0.4 to v0.5.\n",
-    "\n",
-    "## Introduction\n",
-    "\n",
-    "The main focus of the 0.5 release of Qiskit Machine Learning is the migration of the base computational blocks like quantum kernels and quantum neural networks to the primitives introduced in Qiskit as well as extended support of the primitives in the algorithms.\n",
-    "\n",
-    "Contents:\n",
-    "\n",
-    "- Overview of the primitives\n",
-    "- New quantum kernel\n",
-    "- New quantum neural networks\n",
-    "- Other notable deprecation\n",
-    "\n",
-    "\n",
-    "## Overview of the primitives\n",
-    "\n",
-    "The core capability of quantum computers that sets them apart from from classical computers is their ability to generate non-classical probability distributions at their outputs. The native operations that one can do with a probability distribution is to sample from it or to estimate quantities on it. Consequently, these operations of sampling and estimating form the fundamental building blocks of quantum algorithm development. Thus, as it was [announced](https://research.ibm.com/blog/qiskit-runtime-for-useful-quantum-computing), two basic primitives were introduced, Sampler and Estimator, respectively, that implement these two operations:\n",
-    "\n",
-    "- Sampler class calculates probabilities or quasi-probabilities of bitstrings from quantum circuits. The base class is [qiskit.primitives.BaseSampler](https://qiskit.org/documentation/stubs/qiskit.primitives.BaseSampler.html).\n",
-    "- Estimator class estimates expectation values of quantum circuits and observables. The base class is [qiskit.primitives.BaseEstimator](https://qiskit.org/documentation/stubs/qiskit.primitives.BaseEstimator.html).\n",
-    "\n",
-    "Qiskit Terra provides core interfaces and two implementations:\n",
-    "\n",
-    "- The reference implementation that is statevector based. This implementation does require a backend or a simulator, it relies on the classes from the [quantum_info](https://qiskit.org/documentation/apidoc/quantum_info.html) package.\n",
-    "- The backend based primitives are to support provider/backends that do not support primitives directly. This implementation requires an instance of a backend to be passed to a primitive.\n",
-    "\n",
-    "More information on the Qiskit Terra primitives can be found in the [documentation](https://qiskit.org/documentation/apidoc/primitives.html).\n",
-    "\n",
-    "It is worth mentioning other implementations as well:\n",
-    "\n",
-    "- Aer primitives should be used for Aer simulator. They extend corresponding interfaces from Terra and can be used in the same way as primitives from Terra. See [documentation](https://qiskit.org/documentation/apidoc/aer_primitives.html) for more information.\n",
-    "- The runtime primitives to be used with IBM devices. This is an implementation that is focused on cloud computing on actual hardware. See [here](https://qiskit.org/documentation/partners/qiskit_ibm_runtime/apidocs/runtime_service.html).\n",
-    "\n",
-    "Along with the primitives Terra has some primitive-like algorithms that are highly useful in QML and used by the new 0.5 functions:\n",
-    "\n",
-    "- Algorithms to calculate the gradient of a quantum circuit. For each core primitive there's a corresponding base interface that defines quantum circuit gradient. The documentation on gradients is [here](https://qiskit.org/documentation/stubs/qiskit.algorithms.gradients.html).\n",
-    "- Algorithms that compute the fidelity or \"closeness\" of pairs of quantum states. Currently, only one implementation is available that requires a sampler primitive and is based on the compute-uncompute method. The documentation is [here](https://qiskit.org/documentation/stubs/qiskit.algorithms.state_fidelities.html).\n",
-    "\n",
-    "Both two new algorithms are very similar to the core primitives, they share the same method signatures, so they may be called as high level primitives despite they are not in the primitives package.\n",
-    "\n",
-    "## New quantum kernel\n",
-    "\n",
-    "The previous implementation consisted of a single class [QuantumKernel](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.kernels.QuantumKernel.html) that did everything:\n",
-    "\n",
-    "- Constructed circuits\n",
-    "- Executed circuits and evaluated overlap between circuits\n",
-    "- Provided training parameters\n",
-    "- Kept track of the values assigned to the parameters.\n",
-    "\n",
-    "The implementation became sophisticated and inflexible and adding support of the new primitives could be tricky. To address the issues, a new flexible and extendable design of quantum kernels was introduced. The goals of the new design are: \n",
-    "\n",
-    "- Migrate to the primitives and leverage the fidelity algorithm. Now users may plug in their own implementations of fidelity calculations.\n",
-    "- Extract trainability feature to a dedicated class.\n",
-    "- Introduce a base class that can be extended by other kernel implementations.\n",
-    "\n",
-    "The new design of quantum kernel is shown on the next diagram."
-   ]
-  },
-  {
-   "attachments": {
-    "new_qk.png": {
-     "image/png": "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"
-    }
-   },
-   "cell_type": "markdown",
-   "id": "tough-timeline",
-   "metadata": {},
-   "source": [
-    "![new_qk.png](attachment:new_qk.png)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "fatal-forty",
-   "metadata": {},
-   "source": [
-    "The new kernels expose the same interface and the same parameters except the `quantum_instance` parameter. This parameter does not have a direct replacement and instead the `fidelity` parameter must be used. The backend handling/selection, which was previously done using the `quantum_instance`, is now taken care of via the Sampler primitive given to the `fidelity`.\n",
-    "\n",
-    "A new hierarchy shown on the diagram introduces:\n",
-    "\n",
-    " - A base and abstract class [BaseKernel](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.kernels.BaseKernel.html) is introduced. All concrete implementation must inherit this class.\n",
-    " - A fidelity based quantum kernel [FidelityQuantumKernel](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.kernels.FidelityQuantumKernel.html) is added. This is a direct **replacement** of the previous quantum kernel implementation. The difference is that the new class takes a fidelity instance to estimate overlaps and construct kernel matrix.\n",
-    " - A new abstract class [TrainableKernel](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.kernels.TrainableKernel.html) is introduced to generalize ability to train quantum kernels.\n",
-    " - A fidelity-based trainable quantum kernel [TrainableFidelityQuantumKernel](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.kernels.TrainableFidelityQuantumKernel.html) is introduced. This is a **replacement** of the previous quantum kernel if a trainable kernel is required. The trainer [QuantumKernelTrainer](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.kernels.alogrithms.QuantumKernelTrainer.html) now accepts both quantum kernel implementations, the new one and the previous one.\n",
-    " \n",
-    "For convenience, the previous quantum kernel implementation, [QuantumKernel](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.kernels.QuantumKernel.html), now extends both new abstract classes and thus it is compatible with the new introduced interfaces. This implementation is now **pending deprecation**, will be deprecated in a future release and subsequently removed after that. New, primitive-based quantum kernels should be used instead.\n",
-    "\n",
-    "The existing algorithms such as [QSVC](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.algorithms.QSVC.html), [QSVR](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.algorithms.QSVR.html) and other kernel-based algorithms are updated and work with both implementations.\n",
-    "\n",
-    "For example a QSVM classifier can be trained as follows."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "scientific-cameroon",
-   "metadata": {},
-   "source": [
-    "## Create a dataset\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "municipal-pencil",
-   "metadata": {},
-   "source": [
-    "Fixing randomization."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "id": "measured-germany",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit.utils import algorithm_globals\n",
-    "\n",
-    "algorithm_globals.random_seed = 123456"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "potential-florence",
-   "metadata": {},
-   "source": [
-    "Generate a simple dataset using scikit-learn."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "separated-assembly",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from sklearn.datasets import make_blobs\n",
-    "\n",
-    "features, labels = make_blobs(\n",
-    "    n_samples=20,\n",
-    "    centers=2,\n",
-    "    center_box=(-1, 1),\n",
-    "    cluster_std=0.1,\n",
-    "    random_state=algorithm_globals.random_seed,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "hollywood-preview",
-   "metadata": {},
-   "source": [
-    "### Previous implementation of quantum kernel"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "modified-referral",
-   "metadata": {},
-   "source": [
-    "In the previous implementation we start from creating an instance of `QuantumInstance`. This class defines where our quantum circuits are executed. In this case we wrap a statevector simulator in the quantum instance."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "emotional-terrain",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit import BasicAer\n",
-    "from qiskit.utils import QuantumInstance\n",
-    "\n",
-    "sv_qi = QuantumInstance(\n",
-    "    BasicAer.get_backend(\"statevector_simulator\"),\n",
-    "    seed_simulator=algorithm_globals.random_seed,\n",
-    "    seed_transpiler=algorithm_globals.random_seed,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "dutch-regular",
-   "metadata": {},
-   "source": [
-    "Then create a quantum kernel."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "adapted-fairy",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit.circuit.library import ZZFeatureMap\n",
-    "from qiskit_machine_learning.kernels import QuantumKernel\n",
-    "\n",
-    "feature_map = ZZFeatureMap(2)\n",
-    "previous_kernel = QuantumKernel(feature_map=feature_map, quantum_instance=sv_qi)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "burning-locking",
-   "metadata": {},
-   "source": [
-    "And finally we fit an SVM classifier."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "optimum-roommate",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0.95"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from qiskit_machine_learning.algorithms import QSVC\n",
-    "\n",
-    "qsvc = QSVC(quantum_kernel=previous_kernel)\n",
-    "qsvc.fit(features, labels)\n",
-    "qsvc.score(features, labels)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "secondary-census",
-   "metadata": {},
-   "source": [
-    "### New implementation of quantum kernel\n",
-    "\n",
-    "In the new implementation we start from creating a Fidelity instance. Fidelity is optional and quantum kernel will create it automatically if none is passed. But here, we create it manually for illustrative purposes. To create a fidelity instance we pass a sampler. The sampler is the reference implementation and defines where our quantum circuits are executed. You may create a sampler instance from [QiskitRuntimeService](https://qiskit.org/documentation/partners/qiskit_ibm_runtime/stubs/qiskit_ibm_runtime.QiskitRuntimeService.html) to leverage Qiskit runtime services."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "id": "increased-cartoon",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit.algorithms.state_fidelities import ComputeUncompute\n",
-    "from qiskit.primitives import Sampler\n",
-    "\n",
-    "fidelity = ComputeUncompute(sampler=Sampler())"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "emerging-century",
-   "metadata": {},
-   "source": [
-    "Next, we create a new quantum kernel with the fidelity instance."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "id": "eight-norway",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit_machine_learning.kernels import FidelityQuantumKernel\n",
-    "\n",
-    "feature_map = ZZFeatureMap(2)\n",
-    "new_kernel = FidelityQuantumKernel(feature_map=feature_map, fidelity=fidelity)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "fewer-department",
-   "metadata": {},
-   "source": [
-    "Then we fit an SVM classifier the same way as before."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "stretch-rainbow",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0.95"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from qiskit_machine_learning.algorithms import QSVC\n",
-    "\n",
-    "qsvc = QSVC(quantum_kernel=new_kernel)\n",
-    "qsvc.fit(features, labels)\n",
-    "qsvc.score(features, labels)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "challenging-anderson",
-   "metadata": {},
-   "source": [
-    "## New quantum neural networks\n",
-    "\n",
-    "Changes in the quantum neural networks are not as dramatic as in quantum kernels. In addition, and as a replacement to the existing neural networks, two new networks are introduced. The new networks introduced are [SamplerQNN](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.SamplerQNN.html) and [EstimatorQNN](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.EstimatorQNN.html) which are detailed below and are replacements for the pre-existing [CircuitQNN](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.CircuitQNN.html), [OpflowQNN](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.OpflowQNN.html) and [TwoLayerQNN](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.TwoLayerQNN.html) which are now pending deprecated.\n",
-    "\n",
-    "### SamplerQNN\n",
-    "\n",
-    "A new [Sampler Quantum Neural Network](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.SamplerQNN.html) leverages the sampler primitive, sampler gradients and is a **direct replacement** of [CircuitQNN](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.CircuitQNN.html).\n",
-    "\n",
-    "The new [SamplerQNN](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.SamplerQNN.html) exposes a similar interface to the existing [CircuitQNN](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.CircuitQNN.html), with a\n",
-    "few differences. One is the `quantum_instance` parameter. This parameter does not have a direct replacement, and instead the `sampler` parameter must be used. The `gradient` parameter keeps the same name as in the [CircuitQNN](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.CircuitQNN.html) implementation, but it no longer accepts Opflow gradient classes as inputs; instead, this parameter expects an (optionally custom) primitive gradient. The `sampling` option has been removed for the time being, as this information is not currently exposed by the sampler, and might correspond to future lower-level primitives.\n",
-    "\n",
-    "The existing training algorithms such as [VQC](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.algorithms.VQC.html) that were based on [CircuitQNN](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.CircuitQNN.html), are updated to accept both implementations. The implementation of [NeuralNetworkClassifier](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.algorithms.NeuralNetworkClassifier.html) has not changed.\n",
-    "\n",
-    "The existing [CircuitQNN](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.CircuitQNN.html) is now **pending deprecation**, will be deprecated in a future release and subsequently removed after that.\n",
-    "\n",
-    "We'll show how to train a variational quantum classifier using both networks. For this purposes we re-use the dataset generated for the quantum kernel. For both quantum neural networks we still have to construct a feature map, an ansatz and combine them into a single quantum circuit."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "reliable-special",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit import QuantumCircuit\n",
-    "from qiskit.circuit.library import RealAmplitudes\n",
-    "\n",
-    "num_inputs = 2\n",
-    "feature_map = ZZFeatureMap(num_inputs)\n",
-    "ansatz = RealAmplitudes(num_inputs, reps=1)\n",
-    "\n",
-    "circuit = QuantumCircuit(num_inputs)\n",
-    "circuit.compose(feature_map, inplace=True)\n",
-    "circuit.compose(ansatz, inplace=True)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "parliamentary-cheat",
-   "metadata": {},
-   "source": [
-    "We need an interpret function as well. We define our usual parity function that maps bitstrings either to $0$ or $1$."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "major-significance",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def parity(x):\n",
-    "    return \"{:b}\".format(x).count(\"1\") % 2"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "serial-device",
-   "metadata": {},
-   "source": [
-    "We fix the initial point to get the same results from both networks."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "sensitive-giant",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "initial_point = algorithm_globals.random.random(ansatz.num_parameters)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "considered-insured",
-   "metadata": {},
-   "source": [
-    "### Building a classifier using `CircuitQNN`\n",
-    "\n",
-    "We create a `CircuitQNN` instance and re-use the quantum instance created for the quantum kernel."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "id": "romantic-hormone",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit_machine_learning.neural_networks import CircuitQNN\n",
-    "\n",
-    "circuit_qnn = CircuitQNN(\n",
-    "    circuit=circuit,\n",
-    "    input_params=feature_map.parameters,\n",
-    "    weight_params=ansatz.parameters,\n",
-    "    interpret=parity,\n",
-    "    output_shape=2,\n",
-    "    quantum_instance=sv_qi,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "effective-determination",
-   "metadata": {},
-   "source": [
-    "Construct a classifier out of the network, train it and score it. We are not aiming for good results, so the number of iterations is set to a small number to reduce overall execution time."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "short-greece",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0.6"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from qiskit.algorithms.optimizers import COBYLA\n",
-    "from qiskit_machine_learning.algorithms import NeuralNetworkClassifier\n",
-    "\n",
-    "classifier = NeuralNetworkClassifier(\n",
-    "    neural_network=circuit_qnn,\n",
-    "    loss=\"cross_entropy\",\n",
-    "    one_hot=True,\n",
-    "    optimizer=COBYLA(maxiter=40),\n",
-    "    initial_point=initial_point,\n",
-    ")\n",
-    "classifier.fit(features, labels)\n",
-    "classifier.score(features, labels)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "reflected-observation",
-   "metadata": {},
-   "source": [
-    "### Building a classifier using `SamplerQNN`\n",
-    "\n",
-    "Instead of `QuantumInstance` create an instance of the reference `Sampler`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "charitable-abortion",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit.primitives import Sampler\n",
-    "\n",
-    "sampler = Sampler()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "skilled-slovenia",
-   "metadata": {},
-   "source": [
-    "Now, we create a instance of `SamplerQNN`. The difference with `CircuitQNN` is that we pass a sampler instead of a quantum instance."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "official-blogger",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit_machine_learning.neural_networks import SamplerQNN\n",
-    "\n",
-    "sampler_qnn = SamplerQNN(\n",
-    "    circuit=circuit,\n",
-    "    input_params=feature_map.parameters,\n",
-    "    weight_params=ansatz.parameters,\n",
-    "    interpret=parity,\n",
-    "    output_shape=2,\n",
-    "    sampler=sampler,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "mexican-bumper",
-   "metadata": {},
-   "source": [
-    "Construct a classifier and fit it as usual. As `neural_network` we pass a created `SamplerQNN` and this is the only difference."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "id": "moving-consultancy",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0.6"
-      ]
-     },
-     "execution_count": 16,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "classifier = NeuralNetworkClassifier(\n",
-    "    neural_network=sampler_qnn,\n",
-    "    loss=\"cross_entropy\",\n",
-    "    one_hot=True,\n",
-    "    optimizer=COBYLA(maxiter=40),\n",
-    "    initial_point=initial_point,\n",
-    ")\n",
-    "classifier.fit(features, labels)\n",
-    "classifier.score(features, labels)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "universal-multimedia",
-   "metadata": {
-    "slideshow": {
-     "slide_type": "slide"
-    }
-   },
-   "source": [
-    "Instead of constructing a quantum neural network manually, you may train `VQC`. It takes either a quantum instance or a sampler, depending on what is passed it automatically constructs either `CircuitQNN` or `SamplerQNN` respectively."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "damaged-bidding",
-   "metadata": {},
-   "source": [
-    "### EstimatorQNN\n",
-    "\n",
-    "A new [Estimator quantum neural network](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.EstimatorQNN.html) leverages the estimator primitive, estimator gradients and is a **direct replacement** of [OpflowQNN](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.OpflowQNN.html).\n",
-    "\n",
-    "The new [EstimatorQNN](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.EstimatorQNN.html) exposes a similar interface to the existing [OpflowQNN](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.OpflowQNN.html), with a\n",
-    "few differences. One is the `quantum_instance` parameter. This parameter does not have a direct replacement, and instead the `estimator` parameter must be used. The `gradient` parameter keeps the same name as in the [OpflowQNN](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.OpflowQNN.html) implementation, but it no longer accepts Opflow gradient classes as inputs; instead, this parameter expects an (optionally custom) primitive gradient.\n",
-    "\n",
-    "The existing training algorithms such as [VQR](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.algorithms.VQR.html) that were based on the [TwoLayerQNN](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.TwoLayerQNN.html), are updated to accept both implementations. The implementation of [NeuralNetworkRegressor](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.algorithms.NeuralNetworkRegressor.html) has not changed.\n",
-    "\n",
-    "The existing [OpflowQNN](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.OpflowQNN.html) is now **pending deprecation**, will be deprecated in a future release and subsequently removed after that.\n",
-    "\n",
-    "We'll show how to train a variational quantum regressor using both networks. We start from generating a simple regression dataset."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "id": "satisfactory-shark",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import numpy as np\n",
-    "\n",
-    "num_samples = 20\n",
-    "eps = 0.2\n",
-    "lb, ub = -np.pi, np.pi\n",
-    "features = (ub - lb) * np.random.rand(num_samples, 1) + lb\n",
-    "labels = np.sin(features[:, 0]) + eps * (2 * np.random.rand(num_samples) - 1)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "final-editor",
-   "metadata": {},
-   "source": [
-    "We still have to construct a feature map, an ansatz and combine them into a single quantum circuit for both quantum neural networks."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "id": "distributed-emphasis",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit.circuit import Parameter\n",
-    "\n",
-    "num_inputs = 1\n",
-    "feature_map = QuantumCircuit(1)\n",
-    "feature_map.ry(Parameter(\"input\"), 0)\n",
-    "\n",
-    "ansatz = QuantumCircuit(1)\n",
-    "ansatz.ry(Parameter(\"weight\"), 0)\n",
-    "\n",
-    "circuit = QuantumCircuit(num_inputs)\n",
-    "circuit.compose(feature_map, inplace=True)\n",
-    "circuit.compose(ansatz, inplace=True)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "accepting-bridal",
-   "metadata": {},
-   "source": [
-    "We fix the initial point to get the same results from both networks."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "id": "requested-juvenile",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "initial_point = algorithm_globals.random.random(ansatz.num_parameters)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "revolutionary-charter",
-   "metadata": {},
-   "source": [
-    "### Building a regressor using `OpflowQNN`\n",
-    "\n",
-    "We create an `OpflowQNN` instance and re-use the quantum instance created for the quantum kernel."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 20,
-   "id": "jewish-simpson",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit.opflow import PauliSumOp, StateFn\n",
-    "from qiskit_machine_learning.neural_networks import OpflowQNN\n",
-    "\n",
-    "observable = PauliSumOp.from_list([(\"Z\", 1)])\n",
-    "operator = StateFn(observable, is_measurement=True) @ StateFn(circuit)\n",
-    "\n",
-    "opflow_qnn = OpflowQNN(\n",
-    "    operator=operator,\n",
-    "    input_params=feature_map.parameters,\n",
-    "    weight_params=ansatz.parameters,\n",
-    "    quantum_instance=sv_qi,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "abroad-fault",
-   "metadata": {},
-   "source": [
-    "Construct a regressor out of the network, train it and score it. In this case we use a gradient based optimizer, thus the network makes use of the gradient framework and due to nature of the dataset converges very quickly."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 21,
-   "id": "exempt-contrast",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0.9609133430994375"
-      ]
-     },
-     "execution_count": 21,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from qiskit.algorithms.optimizers import L_BFGS_B\n",
-    "from qiskit_machine_learning.algorithms import NeuralNetworkRegressor\n",
-    "\n",
-    "regressor = NeuralNetworkRegressor(\n",
-    "    neural_network=opflow_qnn,\n",
-    "    optimizer=L_BFGS_B(maxiter=5),\n",
-    "    initial_point=initial_point,\n",
-    ")\n",
-    "regressor.fit(features, labels)\n",
-    "regressor.score(features, labels)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "thorough-reader",
-   "metadata": {},
-   "source": [
-    "### Building a regressor using `EstimatorQNN`\n",
-    "\n",
-    "Create an instance of the reference Estimator. You may create an estimator instance from [QiskitRuntimeService](https://qiskit.org/documentation/partners/qiskit_ibm_runtime/stubs/qiskit_ibm_runtime.QiskitRuntimeService.html) to leverage Qiskit runtime services."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 22,
-   "id": "rolled-living",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit.primitives import Estimator\n",
-    "\n",
-    "estimator = Estimator()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "muslim-smith",
-   "metadata": {},
-   "source": [
-    "Now, we create a instance of `EstimatorQNN`. The network creates an observable as $Z^{\\otimes n}$, where $n$ is the number of qubit, if it is not specified."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 23,
-   "id": "environmental-protein",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from qiskit_machine_learning.neural_networks import EstimatorQNN\n",
-    "\n",
-    "estimator_qnn = EstimatorQNN(\n",
-    "    circuit=circuit,\n",
-    "    input_params=feature_map.parameters,\n",
-    "    weight_params=ansatz.parameters,\n",
-    "    estimator=estimator,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "sapphire-eight",
-   "metadata": {},
-   "source": [
-    "Construct a variational quantum regressor and fit it. In this case we use a gradient based optimizer, thus the network makes use of the [default estimator gradient](https://qiskit.org/documentation/stubs/qiskit.algorithms.gradients.ParamShiftEstimatorGradient.html) that is created automatically."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 24,
-   "id": "acceptable-performance",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "0.9609133430994375"
-      ]
-     },
-     "execution_count": 24,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "from qiskit.algorithms.optimizers import L_BFGS_B\n",
-    "from qiskit_machine_learning.algorithms import VQR\n",
-    "\n",
-    "regressor = NeuralNetworkRegressor(\n",
-    "    neural_network=estimator_qnn,\n",
-    "    optimizer=L_BFGS_B(maxiter=5),\n",
-    "    initial_point=initial_point,\n",
-    ")\n",
-    "regressor.fit(features, labels)\n",
-    "regressor.score(features, labels)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "organic-solomon",
-   "metadata": {},
-   "source": [
-    "Instead of constructing a quantum neural network manually, you may train `VQR`. It takes either a quantum instance or an estimator, depending on what is passed it automatically constructs either `TwoLayerQNN` or `EstimatorQNN` respectively."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "domestic-captain",
-   "metadata": {},
-   "source": [
-    "## Other notable deprecation\n",
-    "\n",
-    "A few other components, not mentioned explicitly above, are also deprecated or pending deprecation:\n",
-    "\n",
-    "- [TwoLayerQNN](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.TwoLayerQNN.html) is pending deprecation. Users should use [EstimatorQNN](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.EstimatorQNN.html) instead.\n",
-    "- The Distribution Learners package is deprecated fully. This package contains such classes as [DiscriminativeNetwork](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.algorithms.DiscriminativeNetwork.html), [GenerativeNetwork](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.algorithms.GenerativeNetwork.html), [NumPyDiscriminator](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.algorithms.NumPyDiscriminator.html), [PyTorchDiscriminator](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.algorithms.PyTorchDiscriminator.html), [QuantumGenerator](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.algorithms.QuantumGenerator.html), [QGAN](https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.algorithms.QGAN.html). Instead, please refer to the [new QGAN tutorial](../tutorials/04_torch_qgan.ipynb). This tutorial introduces step-by-step how to build a PyTorch-based QGAN using quantum neural networks.\n",
-    "- The Runtime package is deprecated. This package contains a client to Qiskit Programs that embed Qiskit Runtime in the algorithmic interfaces and facilitate usage of algorithms and scripts in the cloud. You should use [QiskitRuntimeService](https://qiskit.org/documentation/partners/qiskit_ibm_runtime/stubs/qiskit_ibm_runtime.QiskitRuntimeService.html) to leverage primitives and runtimes."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 25,
-   "id": "veterinary-intervention",
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/html": [
-       "<h3>Version Information</h3><table><tr><th>Qiskit Software</th><th>Version</th></tr><tr><td><code>qiskit-terra</code></td><td>0.22.1</td></tr><tr><td><code>qiskit-aer</code></td><td>0.11.1</td></tr><tr><td><code>qiskit-ignis</code></td><td>0.7.0</td></tr><tr><td><code>qiskit</code></td><td>0.33.0</td></tr><tr><td><code>qiskit-machine-learning</code></td><td>0.5.0</td></tr><tr><th>System information</th></tr><tr><td>Python version</td><td>3.7.9</td></tr><tr><td>Python compiler</td><td>MSC v.1916 64 bit (AMD64)</td></tr><tr><td>Python build</td><td>default, Aug 31 2020 17:10:11</td></tr><tr><td>OS</td><td>Windows</td></tr><tr><td>CPUs</td><td>4</td></tr><tr><td>Memory (Gb)</td><td>31.837730407714844</td></tr><tr><td colspan='2'>Mon Nov 07 23:08:59 2022 GMT Standard Time</td></tr></table>"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "data": {
-      "text/html": [
-       "<div style='width: 100%; background-color:#d5d9e0;padding-left: 10px; padding-bottom: 10px; padding-right: 10px; padding-top: 5px'><h3>This code is a part of Qiskit</h3><p>&copy; Copyright IBM 2017, 2022.</p><p>This code is licensed under the Apache License, Version 2.0. You may<br>obtain a copy of this license in the LICENSE.txt file in the root directory<br> of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.<p>Any modifications or derivative works of this code must retain this<br>copyright notice, and modified files need to carry a notice indicating<br>that they have been altered from the originals.</p></div>"
-      ],
-      "text/plain": [
-       "<IPython.core.display.HTML object>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import qiskit.tools.jupyter\n",
-    "\n",
-    "%qiskit_version_table\n",
-    "%qiskit_copyright"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.8.13"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}
diff --git a/docs/migration/01_migration_guide_0.5.rst b/docs/migration/01_migration_guide_0.5.rst
new file mode 100644
index 000000000..97d5293d4
--- /dev/null
+++ b/docs/migration/01_migration_guide_0.5.rst
@@ -0,0 +1,704 @@
+Qiskit Machine Learning v0.5 Migration Guide
+============================================
+
+This tutorial will guide you through the process of migrating your code
+from Qiskit Machine Learning v0.4 to v0.5.
+
+Introduction
+------------
+
+The main focus of the 0.5 release of Qiskit Machine Learning is the
+migration of the base computational blocks like quantum kernels and
+quantum neural networks to the primitives introduced in Qiskit as well
+as extended support of the primitives in the algorithms.
+
+Contents:
+
+-  Overview of the primitives
+-  New quantum kernel
+-  New quantum neural networks
+-  Other notable deprecation
+
+Overview of the primitives
+--------------------------
+
+The core capability of quantum computers that sets them apart from from
+classical computers is their ability to generate non-classical
+probability distributions at their outputs. The native operations that
+one can do with a probability distribution is to sample from it or to
+estimate quantities on it. Consequently, these operations of sampling
+and estimating form the fundamental building blocks of quantum algorithm
+development. Thus, as it was
+`announced <https://research.ibm.com/blog/qiskit-runtime-for-useful-quantum-computing>`__,
+two basic primitives were introduced, Sampler and Estimator,
+respectively, that implement these two operations:
+
+-  Sampler class calculates probabilities or quasi-probabilities of
+   bitstrings from quantum circuits. The base class is
+   `qiskit.primitives.BaseSampler <https://qiskit.org/documentation/stubs/qiskit.primitives.BaseSampler.html>`__.
+-  Estimator class estimates expectation values of quantum circuits and
+   observables. The base class is
+   `qiskit.primitives.BaseEstimator <https://qiskit.org/documentation/stubs/qiskit.primitives.BaseEstimator.html>`__.
+
+Qiskit Terra provides core interfaces and two implementations:
+
+-  The reference implementation that is statevector based. This
+   implementation does require a backend or a simulator, it relies on
+   the classes from the
+   `quantum_info <https://qiskit.org/documentation/apidoc/quantum_info.html>`__
+   package.
+-  The backend based primitives are to support provider/backends that do
+   not support primitives directly. This implementation requires an
+   instance of a backend to be passed to a primitive.
+
+More information on the Qiskit Terra primitives can be found in the
+`documentation <https://qiskit.org/documentation/apidoc/primitives.html>`__.
+
+It is worth mentioning other implementations as well:
+
+-  Aer primitives should be used for Aer simulator. They extend
+   corresponding interfaces from Terra and can be used in the same way
+   as primitives from Terra. See
+   `documentation <https://qiskit.org/documentation/apidoc/aer_primitives.html>`__
+   for more information.
+-  The runtime primitives to be used with IBM devices. This is an
+   implementation that is focused on cloud computing on actual hardware.
+   See
+   `here <https://qiskit.org/documentation/partners/qiskit_ibm_runtime/apidocs/runtime_service.html>`__.
+
+Along with the primitives Terra has some primitive-like algorithms that
+are highly useful in QML and used by the new 0.5 functions:
+
+-  Algorithms to calculate the gradient of a quantum circuit. For each
+   core primitive there’s a corresponding base interface that defines
+   quantum circuit gradient. The documentation on gradients is
+   `here <https://qiskit.org/documentation/stubs/qiskit.algorithms.gradients.html>`__.
+-  Algorithms that compute the fidelity or “closeness” of pairs of
+   quantum states. Currently, only one implementation is available that
+   requires a sampler primitive and is based on the compute-uncompute
+   method. The documentation is
+   `here <https://qiskit.org/documentation/stubs/qiskit.algorithms.state_fidelities.html>`__.
+
+Both two new algorithms are very similar to the core primitives, they
+share the same method signatures, so they may be called as high level
+primitives despite they are not in the primitives package.
+
+New quantum kernel
+------------------
+
+The previous implementation consisted of a single class
+`QuantumKernel <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.kernels.QuantumKernel.html>`__
+that did everything:
+
+-  Constructed circuits
+-  Executed circuits and evaluated overlap between circuits
+-  Provided training parameters
+-  Kept track of the values assigned to the parameters.
+
+The implementation became sophisticated and inflexible and adding
+support of the new primitives could be tricky. To address the issues, a
+new flexible and extendable design of quantum kernels was introduced.
+The goals of the new design are:
+
+-  Migrate to the primitives and leverage the fidelity algorithm. Now
+   users may plug in their own implementations of fidelity calculations.
+-  Extract trainability feature to a dedicated class.
+-  Introduce a base class that can be extended by other kernel
+   implementations.
+
+The new design of quantum kernel is shown on the next diagram.
+
+
+.. figure:: aux_files/quantum_kernel.png
+   :alt: Quantum Kernel Diagram
+
+
+The new kernels expose the same interface and the same parameters except
+the ``quantum_instance`` parameter. This parameter does not have a
+direct replacement and instead the ``fidelity`` parameter must be used.
+The backend handling/selection, which was previously done using the
+``quantum_instance``, is now taken care of via the Sampler primitive
+given to the ``fidelity``.
+
+A new hierarchy shown on the diagram introduces:
+
+-  A base and abstract class
+   `BaseKernel <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.kernels.BaseKernel.html>`__
+   is introduced. All concrete implementation must inherit this class.
+-  A fidelity based quantum kernel
+   `FidelityQuantumKernel <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.kernels.FidelityQuantumKernel.html>`__
+   is added. This is a direct **replacement** of the previous quantum
+   kernel implementation. The difference is that the new class takes a
+   fidelity instance to estimate overlaps and construct kernel matrix.
+-  A new abstract class
+   `TrainableKernel <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.kernels.TrainableKernel.html>`__
+   is introduced to generalize ability to train quantum kernels.
+-  A fidelity-based trainable quantum kernel
+   `TrainableFidelityQuantumKernel <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.kernels.TrainableFidelityQuantumKernel.html>`__
+   is introduced. This is a **replacement** of the previous quantum
+   kernel if a trainable kernel is required. The trainer
+   `QuantumKernelTrainer <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.kernels.alogrithms.QuantumKernelTrainer.html>`__
+   now accepts both quantum kernel implementations, the new one and the
+   previous one.
+
+For convenience, the previous quantum kernel implementation,
+`QuantumKernel <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.kernels.QuantumKernel.html>`__,
+now extends both new abstract classes and thus it is compatible with the
+new introduced interfaces. This implementation is now **pending
+deprecation**, will be deprecated in a future release and subsequently
+removed after that. New, primitive-based quantum kernels should be used
+instead.
+
+The existing algorithms such as
+`QSVC <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.algorithms.QSVC.html>`__,
+`QSVR <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.algorithms.QSVR.html>`__
+and other kernel-based algorithms are updated and work with both
+implementations.
+
+For example a QSVM classifier can be trained as follows.
+
+Create a dataset
+----------------
+
+Fixing randomization.
+
+.. code:: ipython3
+
+    from qiskit.utils import algorithm_globals
+
+    algorithm_globals.random_seed = 123456
+
+Generate a simple dataset using scikit-learn.
+
+.. code:: ipython3
+
+    from sklearn.datasets import make_blobs
+
+    features, labels = make_blobs(
+        n_samples=20,
+        centers=2,
+        center_box=(-1, 1),
+        cluster_std=0.1,
+        random_state=algorithm_globals.random_seed,
+    )
+
+Previous implementation of quantum kernel
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+In the previous implementation we start from creating an instance of
+``QuantumInstance``. This class defines where our quantum circuits are
+executed. In this case we wrap a statevector simulator in the quantum
+instance.
+
+.. code:: ipython3
+
+    from qiskit import BasicAer
+    from qiskit.utils import QuantumInstance
+
+    sv_qi = QuantumInstance(
+        BasicAer.get_backend("statevector_simulator"),
+        seed_simulator=algorithm_globals.random_seed,
+        seed_transpiler=algorithm_globals.random_seed,
+    )
+
+
+Then create a quantum kernel.
+
+.. code:: ipython3
+
+    from qiskit.circuit.library import ZZFeatureMap
+    from qiskit_machine_learning.kernels import QuantumKernel
+
+    feature_map = ZZFeatureMap(2)
+    previous_kernel = QuantumKernel(feature_map=feature_map, quantum_instance=sv_qi)
+
+
+And finally we fit an SVM classifier.
+
+.. code:: ipython3
+
+    from qiskit_machine_learning.algorithms import QSVC
+
+    qsvc = QSVC(quantum_kernel=previous_kernel)
+    qsvc.fit(features, labels)
+    qsvc.score(features, labels)
+
+
+
+
+.. parsed-literal::
+
+    0.95
+
+
+
+New implementation of quantum kernel
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+In the new implementation we start from creating a Fidelity instance.
+Fidelity is optional and quantum kernel will create it automatically if
+none is passed. But here, we create it manually for illustrative
+purposes. To create a fidelity instance we pass a sampler. The sampler
+is the reference implementation and defines where our quantum circuits
+are executed. You may create a sampler instance from
+`QiskitRuntimeService <https://qiskit.org/documentation/partners/qiskit_ibm_runtime/stubs/qiskit_ibm_runtime.QiskitRuntimeService.html>`__
+to leverage Qiskit runtime services.
+
+.. code:: ipython3
+
+    from qiskit.algorithms.state_fidelities import ComputeUncompute
+    from qiskit.primitives import Sampler
+
+    fidelity = ComputeUncompute(sampler=Sampler())
+
+Next, we create a new quantum kernel with the fidelity instance.
+
+.. code:: ipython3
+
+    from qiskit_machine_learning.kernels import FidelityQuantumKernel
+
+    feature_map = ZZFeatureMap(2)
+    new_kernel = FidelityQuantumKernel(feature_map=feature_map, fidelity=fidelity)
+
+Then we fit an SVM classifier the same way as before.
+
+.. code:: ipython3
+
+    from qiskit_machine_learning.algorithms import QSVC
+
+    qsvc = QSVC(quantum_kernel=new_kernel)
+    qsvc.fit(features, labels)
+    qsvc.score(features, labels)
+
+
+
+
+.. parsed-literal::
+
+    0.95
+
+
+
+New quantum neural networks
+---------------------------
+
+Changes in the quantum neural networks are not as dramatic as in quantum
+kernels. In addition, and as a replacement to the existing neural
+networks, two new networks are introduced. The new networks introduced
+are
+`SamplerQNN <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.SamplerQNN.html>`__
+and
+`EstimatorQNN <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.EstimatorQNN.html>`__
+which are detailed below and are replacements for the pre-existing
+`CircuitQNN <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.CircuitQNN.html>`__,
+`OpflowQNN <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.OpflowQNN.html>`__
+and
+`TwoLayerQNN <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.TwoLayerQNN.html>`__
+which are now pending deprecated.
+
+SamplerQNN
+~~~~~~~~~~
+
+A new `Sampler Quantum Neural
+Network <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.SamplerQNN.html>`__
+leverages the sampler primitive, sampler gradients and is a **direct
+replacement** of
+`CircuitQNN <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.CircuitQNN.html>`__.
+
+The new
+`SamplerQNN <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.SamplerQNN.html>`__
+exposes a similar interface to the existing
+`CircuitQNN <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.CircuitQNN.html>`__,
+with a few differences. One is the ``quantum_instance`` parameter. This
+parameter does not have a direct replacement, and instead the
+``sampler`` parameter must be used. The ``gradient`` parameter keeps the
+same name as in the
+`CircuitQNN <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.CircuitQNN.html>`__
+implementation, but it no longer accepts Opflow gradient classes as
+inputs; instead, this parameter expects an (optionally custom) primitive
+gradient. The ``sampling`` option has been removed for the time being,
+as this information is not currently exposed by the sampler, and might
+correspond to future lower-level primitives.
+
+The existing training algorithms such as
+`VQC <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.algorithms.VQC.html>`__
+that were based on
+`CircuitQNN <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.CircuitQNN.html>`__,
+are updated to accept both implementations. The implementation of
+`NeuralNetworkClassifier <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.algorithms.NeuralNetworkClassifier.html>`__
+has not changed.
+
+The existing
+`CircuitQNN <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.CircuitQNN.html>`__
+is now **pending deprecation**, will be deprecated in a future release
+and subsequently removed after that.
+
+We’ll show how to train a variational quantum classifier using both
+networks. For this purposes we re-use the dataset generated for the
+quantum kernel. For both quantum neural networks we still have to
+construct a feature map, an ansatz and combine them into a single
+quantum circuit.
+
+.. code:: ipython3
+
+    from qiskit import QuantumCircuit
+    from qiskit.circuit.library import RealAmplitudes
+
+    num_inputs = 2
+    feature_map = ZZFeatureMap(num_inputs)
+    ansatz = RealAmplitudes(num_inputs, reps=1)
+
+    circuit = QuantumCircuit(num_inputs)
+    circuit.compose(feature_map, inplace=True)
+    circuit.compose(ansatz, inplace=True)
+
+We need an interpret function as well. We define our usual parity
+function that maps bitstrings either to :math:`0` or :math:`1`.
+
+.. code:: ipython3
+
+    def parity(x):
+        return "{:b}".format(x).count("1") % 2
+
+We fix the initial point to get the same results from both networks.
+
+.. code:: ipython3
+
+    initial_point = algorithm_globals.random.random(ansatz.num_parameters)
+
+Building a classifier using ``CircuitQNN``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+We create a ``CircuitQNN`` instance and re-use the quantum instance
+created for the quantum kernel.
+
+.. code:: ipython3
+
+    from qiskit_machine_learning.neural_networks import CircuitQNN
+
+    circuit_qnn = CircuitQNN(
+        circuit=circuit,
+        input_params=feature_map.parameters,
+        weight_params=ansatz.parameters,
+        interpret=parity,
+        output_shape=2,
+        quantum_instance=sv_qi,
+    )
+
+
+Construct a classifier out of the network, train it and score it. We are
+not aiming for good results, so the number of iterations is set to a
+small number to reduce overall execution time.
+
+.. code:: ipython3
+
+    from qiskit.algorithms.optimizers import COBYLA
+    from qiskit_machine_learning.algorithms import NeuralNetworkClassifier
+
+    classifier = NeuralNetworkClassifier(
+        neural_network=circuit_qnn,
+        loss="cross_entropy",
+        one_hot=True,
+        optimizer=COBYLA(maxiter=40),
+        initial_point=initial_point,
+    )
+    classifier.fit(features, labels)
+    classifier.score(features, labels)
+
+
+
+
+.. parsed-literal::
+
+    0.6
+
+
+
+Building a classifier using ``SamplerQNN``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Instead of ``QuantumInstance`` create an instance of the reference
+``Sampler``.
+
+.. code:: ipython3
+
+    from qiskit.primitives import Sampler
+
+    sampler = Sampler()
+
+Now, we create a instance of ``SamplerQNN``. The difference with
+``CircuitQNN`` is that we pass a sampler instead of a quantum instance.
+
+.. code:: ipython3
+
+    from qiskit_machine_learning.neural_networks import SamplerQNN
+
+    sampler_qnn = SamplerQNN(
+        circuit=circuit,
+        input_params=feature_map.parameters,
+        weight_params=ansatz.parameters,
+        interpret=parity,
+        output_shape=2,
+        sampler=sampler,
+    )
+
+Construct a classifier and fit it as usual. As ``neural_network`` we
+pass a created ``SamplerQNN`` and this is the only difference.
+
+.. code:: ipython3
+
+    classifier = NeuralNetworkClassifier(
+        neural_network=sampler_qnn,
+        loss="cross_entropy",
+        one_hot=True,
+        optimizer=COBYLA(maxiter=40),
+        initial_point=initial_point,
+    )
+    classifier.fit(features, labels)
+    classifier.score(features, labels)
+
+
+
+
+.. parsed-literal::
+
+    0.6
+
+
+
+Instead of constructing a quantum neural network manually, you may train
+``VQC``. It takes either a quantum instance or a sampler, depending on
+what is passed it automatically constructs either ``CircuitQNN`` or
+``SamplerQNN`` respectively.
+
+EstimatorQNN
+~~~~~~~~~~~~
+
+A new `Estimator quantum neural
+network <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.EstimatorQNN.html>`__
+leverages the estimator primitive, estimator gradients and is a **direct
+replacement** of
+`OpflowQNN <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.OpflowQNN.html>`__.
+
+The new
+`EstimatorQNN <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.EstimatorQNN.html>`__
+exposes a similar interface to the existing
+`OpflowQNN <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.OpflowQNN.html>`__,
+with a few differences. One is the ``quantum_instance`` parameter. This
+parameter does not have a direct replacement, and instead the
+``estimator`` parameter must be used. The ``gradient`` parameter keeps
+the same name as in the
+`OpflowQNN <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.OpflowQNN.html>`__
+implementation, but it no longer accepts Opflow gradient classes as
+inputs; instead, this parameter expects an (optionally custom) primitive
+gradient.
+
+The existing training algorithms such as
+`VQR <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.algorithms.VQR.html>`__
+that were based on the
+`TwoLayerQNN <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.TwoLayerQNN.html>`__,
+are updated to accept both implementations. The implementation of
+`NeuralNetworkRegressor <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.algorithms.NeuralNetworkRegressor.html>`__
+has not changed.
+
+The existing
+`OpflowQNN <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.OpflowQNN.html>`__
+is now **pending deprecation**, will be deprecated in a future release
+and subsequently removed after that.
+
+We’ll show how to train a variational quantum regressor using both
+networks. We start from generating a simple regression dataset.
+
+.. code:: ipython3
+
+    import numpy as np
+
+    num_samples = 20
+    eps = 0.2
+    lb, ub = -np.pi, np.pi
+    features = (ub - lb) * np.random.rand(num_samples, 1) + lb
+    labels = np.sin(features[:, 0]) + eps * (2 * np.random.rand(num_samples) - 1)
+
+We still have to construct a feature map, an ansatz and combine them
+into a single quantum circuit for both quantum neural networks.
+
+.. code:: ipython3
+
+    from qiskit.circuit import Parameter
+
+    num_inputs = 1
+    feature_map = QuantumCircuit(1)
+    feature_map.ry(Parameter("input"), 0)
+
+    ansatz = QuantumCircuit(1)
+    ansatz.ry(Parameter("weight"), 0)
+
+    circuit = QuantumCircuit(num_inputs)
+    circuit.compose(feature_map, inplace=True)
+    circuit.compose(ansatz, inplace=True)
+
+We fix the initial point to get the same results from both networks.
+
+.. code:: ipython3
+
+    initial_point = algorithm_globals.random.random(ansatz.num_parameters)
+
+Building a regressor using ``OpflowQNN``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+We create an ``OpflowQNN`` instance and re-use the quantum instance
+created for the quantum kernel.
+
+.. code:: ipython3
+
+    from qiskit.opflow import PauliSumOp, StateFn
+    from qiskit_machine_learning.neural_networks import OpflowQNN
+
+    observable = PauliSumOp.from_list([("Z", 1)])
+    operator = StateFn(observable, is_measurement=True) @ StateFn(circuit)
+
+    opflow_qnn = OpflowQNN(
+        operator=operator,
+        input_params=feature_map.parameters,
+        weight_params=ansatz.parameters,
+        quantum_instance=sv_qi,
+    )
+
+
+Construct a regressor out of the network, train it and score it. In this
+case we use a gradient based optimizer, thus the network makes use of
+the gradient framework and due to nature of the dataset converges very
+quickly.
+
+.. code:: ipython3
+
+    from qiskit.algorithms.optimizers import L_BFGS_B
+    from qiskit_machine_learning.algorithms import NeuralNetworkRegressor
+
+    regressor = NeuralNetworkRegressor(
+        neural_network=opflow_qnn,
+        optimizer=L_BFGS_B(maxiter=5),
+        initial_point=initial_point,
+    )
+    regressor.fit(features, labels)
+    regressor.score(features, labels)
+
+
+
+
+.. parsed-literal::
+
+    0.9681198723451012
+
+
+
+Building a regressor using ``EstimatorQNN``
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Create an instance of the reference Estimator. You may create an
+estimator instance from
+`QiskitRuntimeService <https://qiskit.org/documentation/partners/qiskit_ibm_runtime/stubs/qiskit_ibm_runtime.QiskitRuntimeService.html>`__
+to leverage Qiskit runtime services.
+
+.. code:: ipython3
+
+    from qiskit.primitives import Estimator
+
+    estimator = Estimator()
+
+Now, we create a instance of ``EstimatorQNN``. The network creates an
+observable as :math:`Z^{\otimes n}`, where :math:`n` is the number of
+qubit, if it is not specified.
+
+.. code:: ipython3
+
+    from qiskit_machine_learning.neural_networks import EstimatorQNN
+
+    estimator_qnn = EstimatorQNN(
+        circuit=circuit,
+        input_params=feature_map.parameters,
+        weight_params=ansatz.parameters,
+        estimator=estimator,
+    )
+
+Construct a variational quantum regressor and fit it. In this case we
+use a gradient based optimizer, thus the network makes use of the
+`default estimator
+gradient <https://qiskit.org/documentation/stubs/qiskit.algorithms.gradients.ParamShiftEstimatorGradient.html>`__
+that is created automatically.
+
+.. code:: ipython3
+
+    from qiskit.algorithms.optimizers import L_BFGS_B
+    from qiskit_machine_learning.algorithms import VQR
+
+    regressor = NeuralNetworkRegressor(
+        neural_network=estimator_qnn,
+        optimizer=L_BFGS_B(maxiter=5),
+        initial_point=initial_point,
+    )
+    regressor.fit(features, labels)
+    regressor.score(features, labels)
+
+
+
+
+.. parsed-literal::
+
+    0.9681198723451012
+
+
+
+Instead of constructing a quantum neural network manually, you may train
+``VQR``. It takes either a quantum instance or an estimator, depending
+on what is passed it automatically constructs either ``TwoLayerQNN`` or
+``EstimatorQNN`` respectively.
+
+Other notable deprecation
+-------------------------
+
+A few other components, not mentioned explicitly above, are also
+deprecated or pending deprecation:
+
+-  `TwoLayerQNN <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.TwoLayerQNN.html>`__
+   is pending deprecation. Users should use
+   `EstimatorQNN <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.neural_networks.EstimatorQNN.html>`__
+   instead.
+-  The Distribution Learners package is deprecated fully. This package
+   contains such classes as
+   `DiscriminativeNetwork <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.algorithms.DiscriminativeNetwork.html>`__,
+   `GenerativeNetwork <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.algorithms.GenerativeNetwork.html>`__,
+   `NumPyDiscriminator <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.algorithms.NumPyDiscriminator.html>`__,
+   `PyTorchDiscriminator <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.algorithms.PyTorchDiscriminator.html>`__,
+   `QuantumGenerator <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.algorithms.QuantumGenerator.html>`__,
+   `QGAN <https://qiskit.org/documentation/machine-learning/stubs/qiskit_machine_learning.algorithms.QGAN.html>`__.
+   Instead, please refer to the `new QGAN
+   tutorial <../tutorials/04_torch_qgan.ipynb>`__. This tutorial
+   introduces step-by-step how to build a PyTorch-based QGAN using
+   quantum neural networks.
+-  The Runtime package is deprecated. This package contains a client to
+   Qiskit Programs that embed Qiskit Runtime in the algorithmic
+   interfaces and facilitate usage of algorithms and scripts in the
+   cloud. You should use
+   `QiskitRuntimeService <https://qiskit.org/documentation/partners/qiskit_ibm_runtime/stubs/qiskit_ibm_runtime.QiskitRuntimeService.html>`__
+   to leverage primitives and runtimes.
+
+.. code:: ipython3
+
+    import qiskit.tools.jupyter
+
+    %qiskit_version_table
+    %qiskit_copyright
+
+
+
+.. raw:: html
+
+    <h3>Version Information</h3><table><tr><th>Qiskit Software</th><th>Version</th></tr><tr><td><code>qiskit-terra</code></td><td>0.25.0</td></tr><tr><td><code>qiskit-aer</code></td><td>0.13.0</td></tr><tr><td><code>qiskit-machine-learning</code></td><td>0.7.0</td></tr><tr><th>System information</th></tr><tr><td>Python version</td><td>3.8.13</td></tr><tr><td>Python compiler</td><td>Clang 12.0.0 </td></tr><tr><td>Python build</td><td>default, Oct 19 2022 17:54:22</td></tr><tr><td>OS</td><td>Darwin</td></tr><tr><td>CPUs</td><td>10</td></tr><tr><td>Memory (Gb)</td><td>64.0</td></tr><tr><td colspan='2'>Thu Sep 14 13:57:31 2023 IST</td></tr></table>
+
+
+
+.. raw:: html
+
+    <div style='width: 100%; background-color:#d5d9e0;padding-left: 10px; padding-bottom: 10px; padding-right: 10px; padding-top: 5px'><h3>This code is a part of Qiskit</h3><p>&copy; Copyright IBM 2017, 2023.</p><p>This code is licensed under the Apache License, Version 2.0. You may<br>obtain a copy of this license in the LICENSE.txt file in the root directory<br> of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.<p>Any modifications or derivative works of this code must retain this<br>copyright notice, and modified files need to carry a notice indicating<br>that they have been altered from the originals.</p></div>
+
diff --git a/docs/migration/aux_files/quantum_kernel.png b/docs/migration/aux_files/quantum_kernel.png
new file mode 100644
index 000000000..810466d75
Binary files /dev/null and b/docs/migration/aux_files/quantum_kernel.png differ
diff --git a/qiskit_machine_learning/algorithms/classifiers/vqc.py b/qiskit_machine_learning/algorithms/classifiers/vqc.py
index 4192522f3..f20372bbb 100644
--- a/qiskit_machine_learning/algorithms/classifiers/vqc.py
+++ b/qiskit_machine_learning/algorithms/classifiers/vqc.py
@@ -20,7 +20,7 @@
 from qiskit.algorithms.optimizers import Optimizer, OptimizerResult, Minimizer
 from qiskit.primitives import BaseSampler
 
-from ...neural_networks import CircuitQNN, SamplerQNN
+from ...neural_networks import SamplerQNN
 from ...utils import derive_num_qubits_feature_map_ansatz
 from ...utils.loss_functions import Loss
 
@@ -158,7 +158,7 @@ def _fit_internal(self, X: np.ndarray, y: np.ndarray) -> OptimizerResult:
         num_classes = self._num_classes
 
         # instance check required by mypy (alternative to cast)
-        if isinstance(self._neural_network, (CircuitQNN, SamplerQNN)):
+        if isinstance(self._neural_network, SamplerQNN):
             self._neural_network.set_interpret(self._get_interpret(num_classes), num_classes)
 
         function = self._create_objective(X, y)
diff --git a/qiskit_machine_learning/algorithms/regressors/vqr.py b/qiskit_machine_learning/algorithms/regressors/vqr.py
index d6ecf6c33..8ea343d87 100644
--- a/qiskit_machine_learning/algorithms/regressors/vqr.py
+++ b/qiskit_machine_learning/algorithms/regressors/vqr.py
@@ -17,7 +17,6 @@
 import numpy as np
 from qiskit import QuantumCircuit
 from qiskit.algorithms.optimizers import Optimizer, Minimizer
-from qiskit.opflow import PauliSumOp
 from qiskit.primitives import BaseEstimator
 from qiskit.quantum_info.operators.base_operator import BaseOperator
 
@@ -35,7 +34,7 @@ def __init__(
         num_qubits: int | None = None,
         feature_map: QuantumCircuit | None = None,
         ansatz: QuantumCircuit | None = None,
-        observable: BaseOperator | PauliSumOp | None = None,
+        observable: BaseOperator | None = None,
         loss: str | Loss = "squared_error",
         optimizer: Optimizer | Minimizer | None = None,
         warm_start: bool = False,
@@ -81,10 +80,10 @@ def __init__(
                 can't be adjusted to ``num_qubits``.
             ValueError: if the type of the observable is not compatible with ``estimator``.
         """
-        if observable is not None and not isinstance(observable, (BaseOperator, PauliSumOp)):
+        if observable is not None and not isinstance(observable, BaseOperator):
             raise ValueError(
                 f"Unsupported type of the observable, expected "
-                f"'BaseOperator | PauliSumOp', got {type(observable)}"
+                f"'BaseOperator', got {type(observable)}"
             )
 
         self._estimator = estimator
diff --git a/qiskit_machine_learning/deprecation.py b/qiskit_machine_learning/deprecation.py
deleted file mode 100644
index 1d4b3d95d..000000000
--- a/qiskit_machine_learning/deprecation.py
+++ /dev/null
@@ -1,440 +0,0 @@
-# This code is part of a Qiskit project.
-#
-# (C) Copyright IBM 2021, 2023.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-"""Contains the Deprecation message methods."""
-
-from abc import abstractmethod
-import warnings
-import functools
-import inspect
-from typing import NamedTuple, Optional, Callable, Dict, Set, cast, Any, Type
-from enum import Enum, EnumMeta
-
-
-class MachineLearningDeprecationWarning(DeprecationWarning):
-    """Deprecation Category for Qiskit Machine Learning."""
-
-    pass
-
-
-class DeprecatedEnum(Enum):
-    """
-    Shows deprecate message whenever member is accessed
-    """
-
-    def __new__(cls, value, *args):
-        member = object.__new__(cls)
-        member._value_ = value
-        member._args = args
-        member._show_deprecate = member.deprecate
-        return member
-
-    @abstractmethod
-    def deprecate(self):
-        """show deprecate message"""
-        pass
-
-
-class DeprecatedEnumMeta(EnumMeta):
-    """
-    Shows deprecate message whenever member is accessed
-    """
-
-    def __getattribute__(cls, name):
-        obj = super().__getattribute__(name)
-        if isinstance(obj, DeprecatedEnum) and obj._show_deprecate:
-            obj._show_deprecate()
-        return obj
-
-    def __getitem__(cls, name):
-        member = super().__getitem__(name)
-        if member._show_deprecate:
-            member._show_deprecate()
-        return member
-
-    # pylint: disable=redefined-builtin
-    def __call__(cls, value, names=None, *, module=None, qualname=None, type=None, start=1):
-        obj = super().__call__(
-            value, names, module=module, qualname=qualname, type=type, start=start
-        )
-        if isinstance(obj, DeprecatedEnum) and obj._show_deprecate:
-            obj._show_deprecate()
-        return obj
-
-
-class DeprecatedType(Enum):
-    """ " Deprecation Types"""
-
-    PACKAGE = "package"
-    ENUM = "enum"
-    CLASS = "class"
-    METHOD = "method"
-    FUNCTION = "function"
-    ARGUMENT = "argument"
-    PROPERTY = "property"
-
-
-class _DeprecatedTypeName(NamedTuple):
-    version: str
-    old_type: DeprecatedType
-    old_name: str
-    new_type: DeprecatedType
-    new_name: str
-    additional_msg: str
-
-
-class _DeprecatedArgument(NamedTuple):
-    version: str
-    func_qualname: str
-    old_arg: str
-    new_arg: str
-    additional_msg: str
-
-
-class _DeprecatedValue(NamedTuple):
-    version: str
-    func_qualname: str
-    argument: str
-    old_value: str
-    new_value: str
-    additional_msg: str
-
-
-_DEPRECATED_OBJECTS: Set[NamedTuple] = set()
-
-
-def warn_deprecated(
-    version: str,
-    old_type: DeprecatedType,
-    old_name: str,
-    new_type: Optional[DeprecatedType] = None,
-    new_name: Optional[str] = None,
-    additional_msg: Optional[str] = None,
-    stack_level: int = 2,
-    category: Type[Warning] = DeprecationWarning,
-) -> None:
-    """Emits deprecation warning the first time only
-    Args:
-        version: Version to be used
-        old_type: Old type to be used
-        old_name: Old name to be used
-        new_type: New type to be used, if None, old_type is used instead.
-        new_name: New name to be used
-        additional_msg: any additional message
-        stack_level: stack level
-        category: warning category
-    """
-    # skip if it was already added
-    obj = _DeprecatedTypeName(version, old_type, old_name, new_type, new_name, additional_msg)
-    if obj in _DEPRECATED_OBJECTS:
-        return
-
-    _DEPRECATED_OBJECTS.add(cast(NamedTuple, obj))
-
-    msg = (
-        f"The {old_name} {old_type.value} is deprecated as of version {version} "
-        "and will be removed no sooner than 3 months after the release"
-    )
-    if new_name:
-        type_str = new_type.value if new_type is not None else old_type.value
-        msg += f". Instead use the {new_name} {type_str}"
-    if additional_msg:
-        msg += f" {additional_msg}"
-    msg += "."
-
-    warnings.warn(msg, category=category, stacklevel=stack_level + 1)
-
-
-def warn_deprecated_same_type_name(
-    version: str,
-    new_type: DeprecatedType,
-    new_name: str,
-    additional_msg: Optional[str] = None,
-    stack_level: int = 2,
-    category: Type[Warning] = DeprecationWarning,
-) -> None:
-    """Emits deprecation warning the first time only
-       Used when the type and name remained the same.
-    Args:
-        version: Version to be used
-        new_type: new type to be used
-        new_name: new name to be used
-        additional_msg: any additional message
-        stack_level: stack level
-        category: category: warning category
-    """
-    warn_deprecated(
-        version,
-        old_type=new_type,
-        old_name=new_name,
-        new_type=new_type,
-        new_name=new_name,
-        additional_msg=additional_msg,
-        stack_level=stack_level + 1,
-        category=category,
-    )
-
-
-def _rename_kwargs(version, qualname, func_name, kwargs, kwarg_map, additional_msg, stack_level):
-    for old_arg, new_arg in kwarg_map.items():
-        if old_arg in kwargs:
-            if new_arg in kwargs:
-                raise TypeError(f"{func_name} received both {new_arg} and {old_arg} (deprecated).")
-
-            # skip if it was already added
-            obj = _DeprecatedArgument(version, qualname, old_arg, new_arg, additional_msg)
-            if obj not in _DEPRECATED_OBJECTS:
-                _DEPRECATED_OBJECTS.add(obj)
-
-                msg = (
-                    f"{func_name}: the {old_arg} {DeprecatedType.ARGUMENT.value} is deprecated "
-                    f"as of version {version} and will be removed no sooner "
-                    "than 3 months after the release. Instead use the "
-                    f"{new_arg} {DeprecatedType.ARGUMENT.value}"
-                )
-                if additional_msg:
-                    msg += f" {additional_msg}"
-                msg += "."
-                warnings.warn(msg, DeprecationWarning, stacklevel=stack_level)
-            kwargs[new_arg] = kwargs.pop(old_arg)
-
-
-def deprecate_arguments(
-    version: str,
-    kwarg_map: Dict[str, str],
-    additional_msg: Optional[str] = None,
-    stack_level: int = 3,
-) -> Callable:
-    """Decorator to alias deprecated argument names and warn upon use.
-    Args:
-        version: Version to be used
-        kwarg_map: Args dictionary with old, new arguments
-        additional_msg: any additional message
-        stack_level: stack level
-
-    Returns:
-        The decorated function
-    """
-
-    def decorator(func):
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            if kwargs:
-                _rename_kwargs(
-                    version,
-                    func.__qualname__,
-                    func.__name__,
-                    kwargs,
-                    kwarg_map,
-                    additional_msg,
-                    stack_level,
-                )
-            return func(*args, **kwargs)
-
-        return wrapper
-
-    return decorator
-
-
-def _check_values(version, qualname, args, kwargs, kwarg_map, additional_msg, stack_level):
-    for arg, value_dict in kwarg_map.items():
-        index = value_dict["index"]
-        values_map = value_dict["values"]
-        old_value = None
-        if args and 0 < index < len(args):
-            old_value = args[index]
-        if kwargs and arg in kwargs:
-            old_value = kwargs[arg]
-
-        if old_value in values_map:
-            new_value = values_map[old_value]
-
-            # skip if it was already added
-            obj = _DeprecatedValue(version, qualname, arg, old_value, new_value, additional_msg)
-            if obj in _DEPRECATED_OBJECTS:
-                continue
-
-            _DEPRECATED_OBJECTS.add(obj)
-
-            msg = (
-                f'The {arg} {DeprecatedType.ARGUMENT.value} value "{old_value}" is deprecated '
-                f"as of version {version} and will be removed no sooner "
-                "than 3 months after the release. Instead use the "
-                f'"{new_value}" value'
-            )
-            if additional_msg:
-                msg += f" {additional_msg}"
-            msg += "."
-            warnings.warn(msg, DeprecationWarning, stacklevel=stack_level)
-
-
-def deprecate_values(
-    version: str,
-    kwarg_map: Dict[str, Dict[Any, Any]],
-    additional_msg: Optional[str] = None,
-    stack_level: int = 3,
-) -> Callable:
-    """Decorator to alias deprecated default values and warn upon use.
-    Args:
-        version: Version to be used
-        kwarg_map: Args dictionary with argument and map of old, new values
-        additional_msg: any additional message
-        stack_level: stack level
-
-    Returns:
-        The decorated function
-    """
-
-    def decorator(func):
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            if args or kwargs:
-                parameter_names = list(inspect.signature(func).parameters.keys())
-                new_kwarg_map = {}
-                for name, values_map in kwarg_map.items():
-                    new_kwarg_map[name] = {
-                        "index": parameter_names.index(name),
-                        "values": values_map,
-                    }
-                _check_values(
-                    version,
-                    func.__qualname__,
-                    args,
-                    kwargs,
-                    new_kwarg_map,
-                    additional_msg,
-                    stack_level,
-                )
-            return func(*args, **kwargs)
-
-        return wrapper
-
-    return decorator
-
-
-def _deprecate_object(
-    version: str,
-    old_type: DeprecatedType,
-    new_type: DeprecatedType,
-    new_name: str,
-    additional_msg: str,
-    stack_level: int,
-) -> Callable:
-    """Decorator that prints deprecated message
-    Args:
-        version: Version to be used
-        old_type: New type to be used
-        new_type: New type to be used, if None, old_type is used instead.
-        new_name: New name to be used
-        additional_msg: any additional message
-        stack_level: stack level
-
-    Returns:
-        The decorated method
-    """
-
-    def decorator(func):
-        msg = (
-            f"The {func.__name__} {old_type.value} is deprecated as of version {version} "
-            "and will be removed no sooner than 3 months after the release"
-        )
-        if new_name:
-            type_str = new_type.value if new_type is not None else old_type.value
-            msg += f". Instead use the {new_name} {type_str}"
-        if additional_msg:
-            msg += f" {additional_msg}"
-        msg += "."
-
-        @functools.wraps(func)
-        def wrapper(*args, **kwargs):
-            # warn only once
-            if not wrapper._warned:
-                warnings.warn(msg, DeprecationWarning, stacklevel=stack_level)
-                wrapper._warned = True
-            return func(*args, **kwargs)
-
-        wrapper._warned = False
-        return wrapper
-
-    return decorator
-
-
-def deprecate_method(
-    version: str,
-    new_type: Optional[DeprecatedType] = None,
-    new_name: Optional[str] = None,
-    additional_msg: Optional[str] = None,
-    stack_level: int = 2,
-) -> Callable:
-    """Decorator that prints deprecated message for an instance method
-    Args:
-        version: Version to be used
-        new_type: New type to be used
-        new_name: New name to be used
-        additional_msg: any additional message
-        stack_level: stack level
-
-    Returns:
-        The decorated method
-    """
-    return _deprecate_object(
-        version, DeprecatedType.METHOD, new_type, new_name, additional_msg, stack_level
-    )
-
-
-def deprecate_property(
-    version: str,
-    new_type: Optional[DeprecatedType] = None,
-    new_name: Optional[str] = None,
-    additional_msg: Optional[str] = None,
-    stack_level: int = 2,
-) -> Callable:
-    """Decorator that prints deprecated message for a property
-
-    *** This decorator must be placed below the property decorator ***
-
-    Args:
-        version: Version to be used
-        new_type: New type to be used
-        new_name: New name to be used
-        additional_msg: any additional message
-        stack_level: stack level
-
-    Returns:
-        The decorated property
-    """
-    return _deprecate_object(
-        version, DeprecatedType.PROPERTY, new_type, new_name, additional_msg, stack_level
-    )
-
-
-def deprecate_function(
-    version: str,
-    new_type: Optional[DeprecatedType] = None,
-    new_name: Optional[str] = None,
-    additional_msg: Optional[str] = None,
-    stack_level: int = 2,
-) -> Callable:
-    """Decorator that prints deprecated message for a function
-    Args:
-        version: Version to be used
-        new_type: New type to be used
-        new_name: New name to be used
-        additional_msg: any additional message
-        stack_level: stack level
-
-    Returns:
-        The decorated function
-    """
-    return _deprecate_object(
-        version, DeprecatedType.FUNCTION, new_type, new_name, additional_msg, stack_level
-    )
diff --git a/qiskit_machine_learning/kernels/__init__.py b/qiskit_machine_learning/kernels/__init__.py
index 7367756b8..8c2980d1c 100644
--- a/qiskit_machine_learning/kernels/__init__.py
+++ b/qiskit_machine_learning/kernels/__init__.py
@@ -42,7 +42,6 @@
    :toctree: ../stubs/
    :nosignatures:
 
-   QuantumKernel
    BaseKernel
    FidelityQuantumKernel
    FidelityStatevectorKernel
@@ -59,7 +58,6 @@
    algorithms
 """
 
-from .quantum_kernel import QuantumKernel
 from .base_kernel import BaseKernel
 from .fidelity_quantum_kernel import FidelityQuantumKernel
 from .fidelity_statevector_kernel import FidelityStatevectorKernel
@@ -68,7 +66,6 @@
 from .trainable_fidelity_statevector_kernel import TrainableFidelityStatevectorKernel
 
 __all__ = [
-    "QuantumKernel",
     "BaseKernel",
     "FidelityQuantumKernel",
     "FidelityStatevectorKernel",
diff --git a/qiskit_machine_learning/kernels/fidelity_statevector_kernel.py b/qiskit_machine_learning/kernels/fidelity_statevector_kernel.py
index 58f3c7769..8d9935ff0 100644
--- a/qiskit_machine_learning/kernels/fidelity_statevector_kernel.py
+++ b/qiskit_machine_learning/kernels/fidelity_statevector_kernel.py
@@ -139,7 +139,7 @@ def _evaluate(self, x_vec: np.ndarray, y_vec: np.ndarray, is_symmetric: bool):
 
     def _get_statevector_(self, param_values: tuple[float]) -> np.ndarray:
         # lru_cache requires hashable function arguments.
-        qc = self._feature_map.bind_parameters(param_values)
+        qc = self._feature_map.assign_parameters(param_values)
         return self._statevector_type(qc).data
 
     def _compute_kernel_entry(self, x: np.ndarray, y: np.ndarray) -> float:
diff --git a/qiskit_machine_learning/kernels/quantum_kernel.py b/qiskit_machine_learning/kernels/quantum_kernel.py
deleted file mode 100644
index e9e350667..000000000
--- a/qiskit_machine_learning/kernels/quantum_kernel.py
+++ /dev/null
@@ -1,651 +0,0 @@
-# This code is part of a Qiskit project.
-#
-# (C) Copyright IBM 2021, 2023.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-"""Quantum Kernel Algorithm"""
-from __future__ import annotations
-
-import copy
-import numbers
-from typing import Sequence, Mapping, List, Tuple, NoReturn
-
-import numpy as np
-from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
-from qiskit.circuit import Parameter, ParameterVector, ParameterExpression
-from qiskit.circuit.library import ZZFeatureMap
-from qiskit.circuit.parameterexpression import ParameterValueType
-from qiskit.providers import Backend
-from qiskit.result import Result
-from qiskit.utils import QuantumInstance
-from qiskit.utils.deprecation import deprecate_func
-
-from .trainable_kernel import TrainableKernel
-from .base_kernel import BaseKernel
-from ..exceptions import QiskitMachineLearningError
-
-
-class QuantumKernel(TrainableKernel, BaseKernel):
-    r"""Deprecated: A dedicated trainable quantum kernel implementation that constructs
-    and executes quantum circuits directly.
-
-    The general task of machine learning is to find and study patterns in data. For many
-    algorithms, the datapoints are better understood in a higher dimensional feature space,
-    through the use of a kernel function:
-
-    .. math::
-
-        K(x, y) = \langle f(x), f(y)\rangle.
-
-    Here K is the kernel function, x, y are n dimensional inputs. f is a map from n-dimension
-    to m-dimension space. :math:`\langle x, y \rangle` denotes the dot product.
-    Usually m is much larger than n.
-
-    The quantum kernel algorithm calculates a kernel matrix, given datapoints x and y and feature
-    map f, all of n dimension. This kernel matrix can then be used in classical machine learning
-    algorithms such as support vector classification, spectral clustering or ridge regression.
-    """
-
-    @deprecate_func(
-        since="0.7.0",
-        additional_msg="Instead, use the ``qiskit_machine_learning.kernels.FidelityQuantumKernel``"
-        " and ``qiskit_machine_learning.kernels.TrainableFidelityQuantumKernel`` classes.",
-        package_name="qiskit-machine-learning",
-    )
-    def __init__(
-        self,
-        feature_map: QuantumCircuit | None = None,
-        enforce_psd: bool = True,
-        batch_size: int = 900,
-        quantum_instance: QuantumInstance | Backend | None = None,
-        training_parameters: ParameterVector | Sequence[Parameter] | None = None,
-        evaluate_duplicates: str = "off_diagonal",
-    ) -> None:
-        """
-        Args:
-            feature_map: Parameterized circuit to be used as the feature map. If None is given,
-                the `ZZFeatureMap` is used with two qubits.
-            enforce_psd: Project to closest positive semidefinite matrix if x = y.
-                Only enforced when not using the state vector simulator. Default True.
-            batch_size: Number of circuits to batch together for computation. Default 900.
-            quantum_instance: Quantum Instance or Backend
-            training_parameters: Iterable containing ``Parameter`` objects which correspond to
-                 quantum gates on the feature map circuit which may be tuned. If users intend to
-                 tune feature map parameters to find optimal values, this field should be set.
-            evaluate_duplicates: Defines a strategy how kernel matrix elements are evaluated if
-               duplicate samples are found. Possible values are:
-
-               - ``all`` means that all kernel matrix elements are evaluated, even the diagonal
-                 ones when training. This may introduce additional noise in the matrix.
-               - ``off_diagonal`` when training the matrix diagonal is set to `1`, the rest
-                 elements are fully evaluated, e.g., for two identical samples in the
-                 dataset. When inferring, all elements are evaluated. This is the default
-                 value.
-               - ``none`` when training the diagonal is set to `1` and if two identical samples
-                 are found in the dataset the corresponding matrix element is set to `1`.
-                 When inferring, matrix elements for identical samples are set to `1`.
-
-        Raises:
-            ValueError: When unsupported value is passed to `evaluate_duplicates`.
-        """
-        super().__init__(feature_map=feature_map, enforce_psd=enforce_psd)
-        # Class fields
-        self._feature_map: QuantumCircuit | None = None  # type is required by mypy
-        self._unbound_feature_map = None
-        self._training_parameters = None
-        self._training_parameter_binds = None
-        self._enforce_psd = enforce_psd
-        self._batch_size = batch_size
-
-        # convert to QuantumInstance if an instance of Backend is passed
-        self.quantum_instance = quantum_instance
-
-        eval_duplicates = evaluate_duplicates.lower()
-        if eval_duplicates not in ("all", "off_diagonal", "none"):
-            raise ValueError(
-                f"Unsupported value passed as evaluate_duplicates: {evaluate_duplicates}"
-            )
-        self._evaluate_duplicates = eval_duplicates
-
-        # Setters
-        self.feature_map = feature_map if feature_map is not None else ZZFeatureMap(2)
-        if training_parameters is not None:
-            self.training_parameters = training_parameters
-
-    @property
-    def feature_map(self) -> QuantumCircuit:
-        """Return feature map"""
-        return self._feature_map
-
-    @feature_map.setter
-    def feature_map(self, feature_map: QuantumCircuit) -> None:
-        """
-        Set feature map.
-
-        The ``unbound_feature_map`` field will be automatically updated when this field is set,
-        and ``training_parameters`` and ``training_parameter_binds`` fields will be reset to ``None``.
-        """
-        self._feature_map = feature_map
-        self._unbound_feature_map = copy.deepcopy(self._feature_map)
-        self._training_parameters = None
-        self._training_parameter_binds = None
-
-    @property
-    def unbound_feature_map(self) -> QuantumCircuit:
-        """Return unbound feature map"""
-        return copy.deepcopy(self._unbound_feature_map)
-
-    @property
-    def quantum_instance(self) -> QuantumInstance:
-        """Return quantum instance"""
-        return self._quantum_instance
-
-    @quantum_instance.setter
-    def quantum_instance(self, quantum_instance: Backend | QuantumInstance) -> None:
-        """Set quantum instance"""
-        if isinstance(quantum_instance, Backend):
-            quantum_instance = QuantumInstance(quantum_instance)
-        self._quantum_instance = quantum_instance
-
-    @property
-    def training_parameters(self) -> ParameterVector | Sequence[Parameter] | None:
-        """Return the vector of training parameters."""
-        return copy.copy(self._training_parameters)
-
-    @training_parameters.setter
-    def training_parameters(self, training_params: ParameterVector | Sequence[Parameter]) -> None:
-        """Set the training parameters"""
-        self._training_parameter_binds = {
-            training_param: training_param for training_param in training_params
-        }
-        self._training_parameters = copy.deepcopy(training_params)
-
-    def assign_training_parameters(
-        self,
-        parameter_values: Mapping[Parameter, ParameterValueType] | Sequence[ParameterValueType],
-    ) -> None:
-        """
-        Assign training parameters in the quantum kernel's feature map.
-
-        Args:
-            parameter_values (dict or iterable): Either a dictionary or iterable specifying the new
-            parameter values. If a dict, it specifies the mapping from ``current_parameter`` to
-            ``new_parameter``, where ``new_parameter`` can be a parameter expression or a
-            numeric value. If an iterable, the elements are assigned to the existing parameters
-            in the order of ``QuantumKernel.training_parameters``.
-
-        Raises:
-            ValueError: Incompatible number of training parameters and values
-
-        """
-        values = parameter_values
-        if self._training_parameters is None:
-            raise ValueError(
-                f"""
-                The number of parameter values ({len(values)}) does not
-                match the number of training parameters tracked by the quantum kernel
-                (None).
-                """
-            )
-
-        # Get the input parameters. These should remain unaffected by assigning of training parameters.
-        input_params = list(
-            set(self._unbound_feature_map.parameters) - set(self._training_parameters)
-        )
-
-        # If iterable of values is passed, the length must match length of training_parameters field
-        if isinstance(values, (Sequence, np.ndarray)):
-            if len(values) != len(self._training_parameters):
-                raise ValueError(
-                    f"""
-                The number of parameter values ({len(values)}) does not
-                match the number of training parameters tracked by the quantum kernel
-                ({len(self._training_parameters)}).
-                """
-                )
-            values = {p: values[i] for i, p in enumerate(self._training_parameters)}
-        else:
-            if not isinstance(values, dict):
-                raise ValueError(
-                    f"""
-                    'values' must be of type Dict or Sequence.
-                    Type {type(values)} is not supported.
-                    """
-                )
-
-            # All input keys must exist in the circuit
-            # This check actually catches some well defined assignments;
-            # however; we throw an error to be consistent with the behavior
-            # of QuantumCircuit's parameter binding.
-            unknown_parameters = list(set(values.keys()) - set(self._training_parameters))
-            if len(unknown_parameters) > 0:
-                raise ValueError(
-                    f"Cannot bind parameters ({unknown_parameters}) not tracked by the quantum kernel."
-                )
-
-        # Because QuantumKernel supports parameter rebinding, entries of the `values` dictionary must
-        # be handled differently depending on whether they represent numerical assignments or parameter
-        # reassignments. However, re-ordering the values dictionary inherently changes the expected
-        # behavior of parameter binding, as entries in the values dict do not commute with one another
-        # in general. To resolve this issue, we handle each entry of the values dict one at a time.
-        for param, bind in values.items():
-            if isinstance(bind, ParameterExpression):
-                self._unbound_feature_map.assign_parameters({param: bind}, inplace=True)
-
-                # Training params are all non-input params in the unbound feature map
-                # This list comprehension ensures that self._training_parameters is ordered
-                # in a way that is consistent with self.feature_map.parameters
-                self._training_parameters = [
-                    p for p in self._unbound_feature_map.parameters if (p not in input_params)
-                ]
-
-                # Remove param if it was overwritten
-                if param not in self._training_parameters:
-                    del self._training_parameter_binds[param]
-
-                # Add new parameters
-                for sub_param in bind.parameters:
-                    if sub_param not in self._training_parameter_binds.keys():
-                        self._training_parameter_binds[sub_param] = sub_param
-
-                # If parameter is being set to expression of itself, training_parameter_binds
-                # reflects a self-bind
-                if param in bind.parameters:
-                    self._training_parameter_binds[param] = param
-
-            # If assignment is numerical, update the param_binds
-            elif isinstance(bind, numbers.Number):
-                self._training_parameter_binds[param] = bind
-
-            else:
-                raise ValueError(
-                    f"""
-                    Parameters can only be bound to numeric values,
-                    Parameters, or ParameterExpressions. Type {type(bind)}
-                    is not supported.
-                    """
-                )
-
-        # Reorder dict according to self._training_parameters
-        self._training_parameter_binds = {
-            param: self._training_parameter_binds[param] for param in self._training_parameters
-        }
-
-        # Update feature map with numerical parameter assignments
-        self._feature_map = self._unbound_feature_map.assign_parameters(
-            self._training_parameter_binds
-        )
-
-    @property
-    def training_parameter_binds(self) -> Mapping[Parameter, float] | None:
-        """Return a copy of the current training parameter mappings for the feature map circuit."""
-        return copy.deepcopy(self._training_parameter_binds)
-
-    def bind_training_parameters(
-        self, values: Mapping[Parameter, ParameterValueType] | Sequence[ParameterValueType]
-    ) -> None:
-        """
-        Alternate function signature for ``assign_training_parameters``
-        """
-        self.assign_training_parameters(values)
-
-    def get_unbound_training_parameters(self) -> List[Parameter]:
-        """Return a list of any unbound training parameters in the feature map circuit."""
-        unbound_training_params = []
-        if self._training_parameter_binds is not None:
-            # Get all training parameters not associated with numerical values
-            unbound_training_params = [
-                val
-                for val in self._training_parameter_binds.values()
-                if not isinstance(val, numbers.Number)
-            ]
-
-        return unbound_training_params
-
-    def construct_circuit(
-        self,
-        x: ParameterVector,
-        y: ParameterVector = None,
-        measurement: bool = True,
-        is_statevector_sim: bool = False,
-    ) -> QuantumCircuit:
-        r"""
-        Construct inner product circuit for given datapoints and feature map.
-
-        If using `statevector_simulator`, only construct circuit for :math:`\Psi(x)|0\rangle`,
-        otherwise construct :math:`Psi^dagger(y) x Psi(x)|0>`
-        If y is None and not using `statevector_simulator`, self inner product is calculated.
-
-        Args:
-            x: first data point parameter vector
-            y: second data point parameter vector, ignored if using statevector simulator
-            measurement: include measurement if not using statevector simulator
-            is_statevector_sim: use state vector simulator
-
-        Returns:
-            QuantumCircuit
-
-        Raises:
-            ValueError:
-                - x and/or y have incompatible dimension with feature map
-                - unbound training parameters in the feature map circuit
-        """
-        qc = self._construct_circuit_with_feature_map(x, y)
-
-        if y is None:
-            y = x
-
-        if not is_statevector_sim:
-            y_dict = dict(zip(self._feature_map.parameters, y))
-            psi_y_dag = self._feature_map.assign_parameters(y_dict)
-            qc.append(psi_y_dag.to_instruction().inverse(), qc.qubits)
-
-            if measurement:
-                qc.barrier(qc.qregs[0])
-                qc.measure(qc.qregs[0], qc.cregs[0])
-
-        return qc
-
-    def _construct_circuit_with_feature_map(
-        self, x: ParameterVector, y: ParameterVector = None
-    ) -> QuantumCircuit:
-        self._check_training_parameters_bound()
-
-        if len(x) != self._feature_map.num_parameters:
-            self._raise_incompatible_feature_map("x", len(x))
-
-        if y is not None and len(y) != self._feature_map.num_parameters:
-            self._raise_incompatible_feature_map("y", len(y))
-
-        q = QuantumRegister(self._feature_map.num_qubits, "q")
-        c = ClassicalRegister(self._feature_map.num_qubits, "c")
-        qc = QuantumCircuit(q, c)
-
-        x_dict = dict(zip(self._feature_map.parameters, x))
-        psi_x = self._feature_map.assign_parameters(x_dict)
-        qc.append(psi_x.to_instruction(), qc.qubits)
-
-        return qc
-
-    # just a synonym for consistency with other "*_statevector()" methods
-    def _construct_circuit_statevector(
-        self, x: ParameterVector, y: ParameterVector = None
-    ) -> QuantumCircuit:
-        """This is just a synonym for ``_construct_circuit_with_feature_map``"""
-        return self._construct_circuit_with_feature_map(x, y)
-
-    def _compute_overlap_statevector(
-        self, idx1: int, idx2: int, results: List[np.ndarray]
-    ) -> float:
-        """
-        Helper function to compute overlap for given input if a statevector simulator is used.
-        """
-        # |<0|Psi^dagger(y) x Psi(x)|0>|^2, take the amplitude
-        v_a, v_b = results[idx1], results[idx2]
-        tmp = np.vdot(v_a, v_b)
-        kernel_value = np.vdot(tmp, tmp).real  # pylint: disable=no-member
-
-        return kernel_value
-
-    def _compute_overlap(self, idx: int, results: Result) -> float:
-        """
-        Helper function to compute overlap for given input when a non-statevector simulator or
-        device is used.
-        """
-        measurement_basis = "0" * self._feature_map.num_qubits
-
-        result = results.get_counts(idx)
-        kernel_value = result.get(measurement_basis, 0) / sum(result.values())
-
-        return kernel_value
-
-    def evaluate(self, x_vec: np.ndarray, y_vec: np.ndarray = None) -> np.ndarray:
-        r"""
-        Construct kernel matrix for given data and feature map
-
-        If y_vec is None, self inner product is calculated.
-        If using `statevector_simulator`, only build circuits for :math:`\Psi(x)|0\rangle`,
-        then perform inner product classically.
-
-        Args:
-            x_vec: 1D or 2D array of datapoints, NxD, where N is the number of datapoints,
-                                                            D is the feature dimension
-            y_vec: 1D or 2D array of datapoints, MxD, where M is the number of datapoints,
-                                                            D is the feature dimension
-
-        Returns:
-            2D matrix, NxM
-
-        Raises:
-            QiskitMachineLearningError:
-                - A quantum instance or backend has not been provided
-            ValueError:
-                - unbound training parameters in the feature map circuit
-                - x_vec and/or y_vec are not one or two dimensional arrays
-                - x_vec and y_vec have have incompatible dimensions
-                - x_vec and/or y_vec have incompatible dimension with feature map and
-                    and feature map can not be modified to match.
-        """
-        self._check_training_parameters_bound()
-
-        if self._quantum_instance is None:
-            raise QiskitMachineLearningError(
-                "A QuantumInstance or Backend must be supplied to evaluate a quantum kernel."
-            )
-
-        x_vec, y_vec = self._validate_input(x_vec, y_vec)
-
-        # determine if calculating self inner product
-        is_symmetric = True
-        if y_vec is None:
-            y_vec = x_vec
-        elif not np.array_equal(x_vec, y_vec):
-            is_symmetric = False
-
-        # initialize kernel matrix
-        kernel = np.zeros((x_vec.shape[0], y_vec.shape[0]))
-        if is_symmetric and self._evaluate_duplicates != "all":
-            np.fill_diagonal(kernel, 1)
-
-        # calculate kernel
-        if self._quantum_instance.is_statevector:
-            kernel = self._calculate_kernel_statevector(x_vec, y_vec, is_symmetric, kernel)
-        else:
-            kernel = self._calculate_kernel(x_vec, y_vec, is_symmetric, kernel)
-
-        return kernel
-
-    def _validate_input(
-        self, x_vec: np.ndarray, y_vec: np.ndarray
-    ) -> Tuple[np.ndarray, np.ndarray]:
-        x_vec = np.asarray(x_vec)
-
-        if x_vec.ndim > 2:
-            raise ValueError("x_vec must be a 1D or 2D array")
-
-        if x_vec.ndim == 1:
-            x_vec = np.reshape(x_vec, (-1, len(x_vec)))
-
-        if x_vec.shape[1] != self._feature_map.num_parameters:
-            # before raising an error we try to adjust the feature map
-            # to the required number of qubit.
-            try:
-                self._feature_map.num_qubits = x_vec.shape[1]
-            except AttributeError:
-                self._raise_incompatible_feature_map("x_vec", x_vec.shape[1])
-
-        if y_vec is not None:
-            y_vec = np.asarray(y_vec)
-
-            if y_vec.ndim == 1:
-                y_vec = np.reshape(y_vec, (-1, len(y_vec)))
-
-            if y_vec.ndim > 2:
-                raise ValueError("y_vec must be a 1D or 2D array")
-
-            if y_vec.shape[1] != x_vec.shape[1]:
-                raise ValueError(
-                    "x_vec and y_vec have incompatible dimensions.\n"
-                    f"x_vec has {x_vec.shape[1]} dimensions, but y_vec has {y_vec.shape[1]}."
-                )
-
-        return x_vec, y_vec
-
-    def _calculate_kernel_statevector(
-        self, x_vec: np.ndarray, y_vec: np.ndarray, is_symmetric: bool, kernel: np.ndarray
-    ) -> np.ndarray:
-        # get indices to calculate
-        row_indices, col_indices = self._get_indices(x_vec, y_vec, is_symmetric)
-
-        if is_symmetric:
-            to_be_computed_data = x_vec
-        else:  # not symmetric
-            to_be_computed_data = np.concatenate((x_vec, y_vec))
-
-        feature_map_params = ParameterVector("par_x", self._feature_map.num_parameters)
-        parameterized_circuit = self._construct_circuit_statevector(
-            feature_map_params,
-            feature_map_params,
-        )
-        parameterized_circuit = self._quantum_instance.transpile(
-            parameterized_circuit, pass_manager=self._quantum_instance.unbound_pass_manager
-        )[0]
-        statevectors = []
-
-        for min_idx in range(0, len(to_be_computed_data), self._batch_size):
-            max_idx = min(min_idx + self._batch_size, len(to_be_computed_data))
-            circuits = [
-                parameterized_circuit.assign_parameters({feature_map_params: x})
-                for x in to_be_computed_data[min_idx:max_idx]
-            ]
-            if self._quantum_instance.bound_pass_manager is not None:
-                circuits = self._quantum_instance.transpile(
-                    circuits, pass_manager=self._quantum_instance.bound_pass_manager
-                )
-            results = self._quantum_instance.execute(circuits, had_transpiled=True)
-            for j in range(max_idx - min_idx):
-                statevectors.append(results.get_statevector(j))
-
-        offset = 0 if is_symmetric else len(x_vec)
-        for (i, j) in zip(row_indices, col_indices):
-            x_i = x_vec[i]
-            y_j = y_vec[j]
-
-            # fill in ones for identical samples
-            if np.all(x_i == y_j) and self._evaluate_duplicates == "none":
-                kernel_value = 1.0
-            else:
-                kernel_value = self._compute_overlap_statevector(i, j + offset, statevectors)
-
-            kernel[i, j] = kernel_value
-            if is_symmetric:
-                kernel[j, i] = kernel_value
-
-        return kernel
-
-    def _calculate_kernel(
-        self, x_vec: np.ndarray, y_vec: np.ndarray, is_symmetric: bool, kernel: np.ndarray
-    ) -> np.ndarray:
-        # get indices to calculate
-        row_indices, col_indices = self._get_indices(x_vec, y_vec, is_symmetric)
-
-        feature_map_params_x = ParameterVector("par_x", self._feature_map.num_parameters)
-        feature_map_params_y = ParameterVector("par_y", self._feature_map.num_parameters)
-        parameterized_circuit = self.construct_circuit(feature_map_params_x, feature_map_params_y)
-        parameterized_circuit = self._quantum_instance.transpile(
-            parameterized_circuit, pass_manager=self._quantum_instance.unbound_pass_manager
-        )[0]
-
-        for idx in range(0, len(row_indices), self._batch_size):
-            to_be_computed_data_pair = []
-            to_be_computed_index = []
-            for sub_idx in range(idx, min(idx + self._batch_size, len(row_indices))):
-                i = row_indices[sub_idx]
-                j = col_indices[sub_idx]
-                x_i = x_vec[i]
-                y_j = y_vec[j]
-
-                # fill in ones for identical samples
-                if np.all(x_i == y_j) and self._evaluate_duplicates == "none":
-                    kernel[i, j] = 1
-                    if is_symmetric:
-                        kernel[j, i] = 1
-                else:
-                    # otherwise evaluate the element
-                    to_be_computed_data_pair.append((x_i, y_j))
-                    to_be_computed_index.append((i, j))
-
-            circuits = [
-                parameterized_circuit.assign_parameters(
-                    {feature_map_params_x: x, feature_map_params_y: y}
-                )
-                for x, y in to_be_computed_data_pair
-            ]
-            if self._quantum_instance.bound_pass_manager is not None:
-                circuits = self._quantum_instance.transpile(
-                    circuits, pass_manager=self._quantum_instance.bound_pass_manager
-                )
-
-            results = self._quantum_instance.execute(circuits, had_transpiled=True)
-
-            matrix_elements = [
-                self._compute_overlap(circuit, results) for circuit in range(len(circuits))
-            ]
-
-            for (i, j), value in zip(to_be_computed_index, matrix_elements):
-                kernel[i, j] = value
-                if is_symmetric:
-                    kernel[j, i] = kernel[i, j]
-
-        if self._enforce_psd and is_symmetric:
-            # Find the closest positive semi-definite approximation to symmetric kernel matrix.
-            # The (symmetric) matrix should always be positive semi-definite by construction,
-            # but this can be violated in case of noise, such as sampling noise, thus the
-            # adjustment is only done if NOT using the statevector simulation.
-            D, U = np.linalg.eig(kernel)  # pylint: disable=invalid-name
-            kernel = U @ np.diag(np.maximum(0, D)) @ U.transpose()
-
-        return kernel
-
-    def _get_indices(
-        self, x_vec: np.ndarray, y_vec: np.ndarray, is_symmetric: bool
-    ) -> Tuple[np.ndarray, np.ndarray]:
-        # get indices to calculate
-        if is_symmetric:
-            if self._evaluate_duplicates == "all":
-                row_indices, col_indices = np.triu_indices(x_vec.shape[0])
-            else:
-                # exclude diagonal
-                row_indices, col_indices = np.triu_indices(x_vec.shape[0], k=1)
-        else:
-            row_indices, col_indices = np.indices((x_vec.shape[0], y_vec.shape[0]))
-            row_indices = np.asarray(row_indices.flat)
-            col_indices = np.asarray(col_indices.flat)
-
-        return row_indices, col_indices
-
-    def _check_training_parameters_bound(self) -> None:
-        # Ensure all training parameters have been bound in the feature map circuit.
-        unbound_params = self.get_unbound_training_parameters()
-        if unbound_params:
-            raise ValueError(
-                f"""
-                The feature map circuit contains unbound training parameters ({unbound_params}).
-                All training parameters must be bound to numerical values before evaluating
-                the kernel matrix.
-                """
-            )
-
-    def _raise_incompatible_feature_map(self, vec_name: str, vec_len: int) -> NoReturn:
-        raise ValueError(
-            f"{vec_name} and class feature map have incompatible dimensions.\n"
-            f"{vec_name} has {vec_len} dimensions, "
-            f"but feature map has {self._feature_map.num_parameters}."
-        )
diff --git a/qiskit_machine_learning/kernels/trainable_fidelity_quantum_kernel.py b/qiskit_machine_learning/kernels/trainable_fidelity_quantum_kernel.py
index 63948d62c..eb26b7cf6 100644
--- a/qiskit_machine_learning/kernels/trainable_fidelity_quantum_kernel.py
+++ b/qiskit_machine_learning/kernels/trainable_fidelity_quantum_kernel.py
@@ -96,7 +96,7 @@ def __init__(
         self._feature_parameters = [
             parameter
             for parameter in feature_map.parameters
-            if parameter not in training_parameters
+            if parameter not in self._training_parameters
         ]
         self._parameter_dict = {parameter: None for parameter in feature_map.parameters}
 
diff --git a/qiskit_machine_learning/kernels/trainable_fidelity_statevector_kernel.py b/qiskit_machine_learning/kernels/trainable_fidelity_statevector_kernel.py
index 8e764abb7..9a4e890ea 100644
--- a/qiskit_machine_learning/kernels/trainable_fidelity_statevector_kernel.py
+++ b/qiskit_machine_learning/kernels/trainable_fidelity_statevector_kernel.py
@@ -92,7 +92,7 @@ def __init__(
         self._feature_parameters = [
             parameter
             for parameter in feature_map.parameters
-            if parameter not in training_parameters
+            if parameter not in self._training_parameters
         ]
         self._parameter_dict = {parameter: None for parameter in self.feature_map.parameters}
 
diff --git a/qiskit_machine_learning/neural_networks/__init__.py b/qiskit_machine_learning/neural_networks/__init__.py
index b75f02324..fe7a3b9dc 100644
--- a/qiskit_machine_learning/neural_networks/__init__.py
+++ b/qiskit_machine_learning/neural_networks/__init__.py
@@ -35,7 +35,6 @@
    :nosignatures:
 
    NeuralNetwork
-   SamplingNeuralNetwork
 
 Neural Networks
 ===============
@@ -44,9 +43,6 @@
    :toctree: ../stubs/
    :nosignatures:
 
-   OpflowQNN
-   TwoLayerQNN
-   CircuitQNN
    EstimatorQNN
    SamplerQNN
 
@@ -61,21 +57,13 @@
    LocalEffectiveDimension
 """
 
-from .circuit_qnn import CircuitQNN
 from .effective_dimension import EffectiveDimension, LocalEffectiveDimension
 from .estimator_qnn import EstimatorQNN
 from .neural_network import NeuralNetwork
-from .opflow_qnn import OpflowQNN
-from .sampling_neural_network import SamplingNeuralNetwork
-from .two_layer_qnn import TwoLayerQNN
 from .sampler_qnn import SamplerQNN
 
 __all__ = [
     "NeuralNetwork",
-    "OpflowQNN",
-    "TwoLayerQNN",
-    "SamplingNeuralNetwork",
-    "CircuitQNN",
     "EffectiveDimension",
     "LocalEffectiveDimension",
     "EstimatorQNN",
diff --git a/qiskit_machine_learning/neural_networks/circuit_qnn.py b/qiskit_machine_learning/neural_networks/circuit_qnn.py
deleted file mode 100644
index a199e325a..000000000
--- a/qiskit_machine_learning/neural_networks/circuit_qnn.py
+++ /dev/null
@@ -1,544 +0,0 @@
-# This code is part of a Qiskit project.
-#
-# (C) Copyright IBM 2020, 2023.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-"""A Sampling Neural Network based on a given quantum circuit."""
-import logging
-from numbers import Integral
-from typing import Tuple, Union, List, Callable, Optional, cast, Iterable
-
-import numpy as np
-
-from scipy.sparse import coo_matrix
-
-from qiskit import QuantumCircuit
-from qiskit.circuit import Parameter
-from qiskit.opflow import Gradient, CircuitSampler, StateFn, OpflowError, OperatorBase
-from qiskit.providers import Backend
-from qiskit.utils import QuantumInstance, deprecate_func
-
-import qiskit_machine_learning.optionals as _optionals
-from .sampling_neural_network import SamplingNeuralNetwork
-from ..exceptions import QiskitMachineLearningError, QiskitError
-
-if _optionals.HAS_SPARSE:
-    # pylint: disable=import-error
-    from sparse import SparseArray
-else:
-
-    class SparseArray:  # type: ignore
-        """Empty SparseArray class
-        Replacement if sparse.SparseArray is not present.
-        """
-
-        pass
-
-
-logger = logging.getLogger(__name__)
-
-
-class CircuitQNN(SamplingNeuralNetwork):
-    """Deprecated: A sampling neural network based on a given quantum circuit."""
-
-    @deprecate_func(
-        since="0.7.0",
-        additional_msg="Instead, use the ``qiskit_machine_learning.neural_networks.SamplerQNN``"
-        " class.",
-        package_name="qiskit-machine-learning",
-    )
-    def __init__(
-        self,
-        circuit: QuantumCircuit,
-        input_params: Optional[List[Parameter]] = None,
-        weight_params: Optional[List[Parameter]] = None,
-        sparse: bool = False,
-        sampling: bool = False,
-        interpret: Optional[Callable[[int], Union[int, Tuple[int, ...]]]] = None,
-        output_shape: Union[int, Tuple[int, ...]] = None,
-        gradient: Gradient = None,
-        quantum_instance: Optional[Union[QuantumInstance, Backend]] = None,
-        input_gradients: bool = False,
-    ) -> None:
-        """
-        Args:
-            circuit: The parametrized quantum circuit that generates the samples of this network.
-                There will be an attempt to transpile this circuit and cache the transpiled circuit
-                for subsequent usages by the network. If for some reasons the circuit can't be
-                transpiled, e.g. it originates from
-                :class:`~qiskit_machine_learning.circuit.library.RawFeatureVector`, the circuit
-                will be transpiled every time it is required to be executed and only when all
-                parameters are bound. This may impact overall performance on the network.
-            input_params: The parameters of the circuit corresponding to the input.
-            weight_params: The parameters of the circuit corresponding to the trainable weights.
-            sparse: Returns whether the output is sparse or not.
-            sampling: Determines whether the network returns a batch of samples or (possibly
-                sparse) array of probabilities in its forward pass. In case of probabilities,
-                the backward pass returns the probability gradients, while it returns
-                ``(None, None)`` in the case of samples. Note that ``sampling==True`` will always
-                result in a dense return array independent of the other settings.
-            interpret: A callable that maps the measured integer to another unsigned integer or
-                tuple of unsigned integers. These are used as new indices for the (potentially
-                sparse) output array. If this is used, and ``sampling==False``, the output shape of
-                the output needs to be given as a separate argument. If no interpret function is
-                passed, then an identity function will be used by this neural network.
-            output_shape: The output shape of the custom interpretation, only used in the case
-                where an interpret function is provided and ``sampling==False``. Note that in the
-                remaining cases, the output shape is automatically inferred by: ``2^num_qubits`` if
-                ``sampling==False`` and ``interpret==None``, ``(num_samples,1)``
-                if ``sampling==True`` and ``interpret==None``, and
-                ``(num_samples, interpret_shape)`` if ``sampling==True`` and an interpret function
-                is provided.
-            gradient: The gradient converter to be used for the probability gradients.
-            quantum_instance: The quantum instance to evaluate the circuits. Note that
-                if ``sampling==True``, a statevector simulator is not a valid backend for the
-                quantum instance.
-            input_gradients: Determines whether to compute gradients with respect to input data.
-                Note that this parameter is ``False`` by default, and must be explicitly set to
-                ``True`` for a proper gradient computation when using ``TorchConnector``.
-        Raises:
-            QiskitMachineLearningError: if ``interpret`` is passed without ``output_shape``.
-
-        """
-        self._gradient_circuit_constructed: bool = False
-        self._input_params = list(input_params or [])
-        self._weight_params = list(weight_params or [])
-
-        # initialize gradient properties
-        self.input_gradients = input_gradients
-
-        sparse = False if sampling else sparse
-        if sparse:
-            _optionals.HAS_SPARSE.require_now("DOK")
-
-        # copy circuit and add measurements in case non are given
-        # TODO: need to be able to handle partial measurements! (partial trace...)
-        self._circuit = circuit.copy()
-        # we have not transpiled the circuit yet
-        self._circuit_transpiled = False
-        # these original values may be re-used when a quantum instance is set,
-        # but initially it was None
-        self._original_output_shape = output_shape
-        # next line is required by pylint only
-        self._interpret = interpret
-        self._original_interpret = interpret
-
-        # we need this property in _set_quantum_instance despite it is initialized
-        # in the super class later on, review of SamplingNN is required.
-        self._sampling = sampling
-
-        # set quantum instance and derive target output_shape and interpret
-        self._set_quantum_instance(quantum_instance, output_shape, interpret)
-
-        # init super class
-        super().__init__(
-            len(self._input_params),
-            len(self._weight_params),
-            sparse,
-            sampling,
-            self._output_shape,
-            self._input_gradients,
-        )
-
-        self._original_circuit = circuit
-        # use given gradient or default
-        self._gradient = gradient or Gradient()
-
-    def _construct_gradient_circuit(self) -> None:
-        if self._gradient_circuit_constructed:
-            return
-
-        self._gradient_circuit: OperatorBase = None
-        try:
-            # todo: avoid copying the circuit
-            grad_circuit = self._original_circuit.copy()
-            grad_circuit.remove_final_measurements()  # ideally this would not be necessary
-            if self._input_gradients:
-                params = self._input_params + self._weight_params
-            else:
-                params = self._weight_params
-            self._gradient_circuit = self._gradient.convert(StateFn(grad_circuit), params)
-        except (ValueError, TypeError, OpflowError, QiskitError):
-            logger.warning("Cannot compute gradient operator! Continuing without gradients!")
-
-        self._gradient_circuit_constructed = True
-
-    def _compute_output_shape(self, interpret, output_shape, sampling) -> Tuple[int, ...]:
-        """Validate and compute the output shape."""
-        # a safety check cause we use quantum instance below
-        if self._quantum_instance is None:
-            raise QiskitMachineLearningError(
-                "A quantum instance is required to compute output shape!"
-            )
-
-        # this definition is required by mypy
-        output_shape_: Tuple[int, ...] = (-1,)
-        # todo: move sampling code to the super class
-        if sampling:
-            if output_shape is not None:
-                # Warn user that output_shape parameter will be ignored
-                logger.warning(
-                    "In sampling mode, output_shape will be automatically inferred "
-                    "from the number of samples and interpret function, if provided."
-                )
-
-            num_samples = self._quantum_instance.run_config.shots
-            if interpret is not None:
-                ret = interpret(0)  # infer shape from function
-                result = np.array(ret)
-                if len(result.shape) == 0:
-                    output_shape_ = (num_samples, 1)
-                else:
-                    output_shape_ = (num_samples, *result.shape)
-            else:
-                output_shape_ = (num_samples, 1)
-        else:
-            if interpret is not None:
-                if output_shape is None:
-                    raise QiskitMachineLearningError(
-                        "No output shape given, but required in case of custom interpret!"
-                    )
-                if isinstance(output_shape, Integral):
-                    output_shape = int(output_shape)
-                    output_shape_ = (output_shape,)
-                else:
-                    output_shape_ = output_shape
-            else:
-                if output_shape is not None:
-                    # Warn user that output_shape parameter will be ignored
-                    logger.warning(
-                        "No interpret function given, output_shape will be automatically "
-                        "determined as 2^num_qubits."
-                    )
-
-                output_shape_ = (2**self._circuit.num_qubits,)
-
-        # final validation
-        output_shape_ = self._validate_output_shape(output_shape_)
-
-        return output_shape_
-
-    @property
-    def circuit(self) -> QuantumCircuit:
-        """Returns the underlying quantum circuit."""
-        return self._circuit
-
-    @property
-    def input_params(self) -> List:
-        """Returns the list of input parameters."""
-        return self._input_params
-
-    @property
-    def weight_params(self) -> List:
-        """Returns the list of trainable weights parameters."""
-        return self._weight_params
-
-    @property
-    def interpret(self) -> Optional[Callable[[int], Union[int, Tuple[int, ...]]]]:
-        """Returns interpret function to be used by the neural network. If it is not set in
-        the constructor or can not be implicitly derived (e.g. a quantum instance is not provided),
-        then ``None`` is returned."""
-        return self._interpret
-
-    @property
-    def quantum_instance(self) -> QuantumInstance:
-        """Returns the quantum instance to evaluate the circuit."""
-        return self._quantum_instance
-
-    @quantum_instance.setter
-    def quantum_instance(self, quantum_instance: Optional[Union[QuantumInstance, Backend]]) -> None:
-        """Sets the quantum instance to evaluate the circuit and make sure circuit has
-        measurements or not depending on the type of backend used.
-        """
-        self._set_quantum_instance(
-            quantum_instance, self._original_output_shape, self._original_interpret
-        )
-
-    def _set_quantum_instance(
-        self,
-        quantum_instance: Optional[Union[QuantumInstance, Backend]],
-        output_shape: Union[int, Tuple[int, ...]],
-        interpret: Optional[Callable[[int], Union[int, Tuple[int, ...]]]],
-    ) -> None:
-        """
-        Internal method to set a quantum instance and compute/initialize internal properties such
-        as an interpret function, output shape and a sampler.
-
-        Args:
-            quantum_instance: A quantum instance to set.
-            output_shape: An output shape of the custom interpretation.
-            interpret: A callable that maps the measured integer to another unsigned integer or
-                tuple of unsigned integers.
-        """
-        if isinstance(quantum_instance, Backend):
-            quantum_instance = QuantumInstance(quantum_instance)
-        self._quantum_instance = quantum_instance
-
-        if self._quantum_instance is not None:
-            # add measurements in case none are given
-            if self._quantum_instance.is_statevector:
-                if len(self._circuit.clbits) > 0:
-                    self._circuit.remove_final_measurements()
-            elif len(self._circuit.clbits) == 0:
-                self._circuit.measure_all()
-
-            # set interpret and compute output shape
-            self.set_interpret(interpret, output_shape)
-
-            # prepare sampler
-            self._sampler = CircuitSampler(self._quantum_instance, param_qobj=False, caching="all")
-
-            # transpile the QNN circuit
-            try:
-                self._circuit = self._quantum_instance.transpile(
-                    self._circuit, pass_manager=self._quantum_instance.unbound_pass_manager
-                )[0]
-                self._circuit_transpiled = True
-            except QiskitError:
-                # likely it is caused by RawFeatureVector, we just ignore this error and
-                # transpile circuits when it is required.
-                self._circuit_transpiled = False
-        else:
-            self._output_shape = output_shape
-
-    @property
-    def input_gradients(self) -> bool:
-        """Returns whether gradients with respect to input data are computed by this neural network
-        in the ``backward`` method or not. By default such gradients are not computed."""
-        return self._input_gradients
-
-    @input_gradients.setter
-    def input_gradients(self, input_gradients: bool) -> None:
-        """Turn on/off gradient with respect to input data."""
-        self._input_gradients = input_gradients
-
-        # reset gradient circuit
-        self._gradient_circuit = None
-        self._gradient_circuit_constructed = False
-
-    def set_interpret(
-        self,
-        interpret: Optional[Callable[[int], Union[int, Tuple[int, ...]]]],
-        output_shape: Union[int, Tuple[int, ...]] = None,
-    ) -> None:
-        """Change 'interpret' and corresponding 'output_shape'. If self.sampling==True, the
-        output _shape does not have to be set and is inferred from the interpret function.
-        Otherwise, the output_shape needs to be given.
-
-        Args:
-            interpret: A callable that maps the measured integer to another unsigned integer or
-                tuple of unsigned integers. See constructor for more details.
-            output_shape: The output shape of the custom interpretation, only used in the case
-                where an interpret function is provided and ``sampling==False``. See constructor
-                for more details.
-        """
-
-        # save original values
-        self._original_output_shape = output_shape
-        self._original_interpret = interpret
-
-        # derive target values to be used in computations
-        self._output_shape = self._compute_output_shape(interpret, output_shape, self._sampling)
-        self._interpret = interpret if interpret is not None else lambda x: x
-
-    def _sample(
-        self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray]
-    ) -> np.ndarray:
-        self._check_quantum_instance("samples")
-
-        if self._quantum_instance.is_statevector:
-            raise QiskitMachineLearningError("Sampling does not work with statevector simulator!")
-
-        # evaluate operator
-        orig_memory = self._quantum_instance.backend_options.get("memory")
-        self._quantum_instance.backend_options["memory"] = True
-
-        circuits = []
-        # iterate over samples, each sample is an element of a batch
-        num_samples = input_data.shape[0]
-        for i in range(num_samples):
-            param_values = {
-                input_param: input_data[i, j] for j, input_param in enumerate(self._input_params)
-            }
-            param_values.update(
-                {weight_param: weights[j] for j, weight_param in enumerate(self._weight_params)}
-            )
-            circuits.append(self._circuit.bind_parameters(param_values))
-
-        if self._quantum_instance.bound_pass_manager is not None:
-            circuits = self._quantum_instance.transpile(
-                circuits, pass_manager=self._quantum_instance.bound_pass_manager
-            )
-
-        result = self._quantum_instance.execute(circuits, had_transpiled=self._circuit_transpiled)
-        # set the memory setting back
-        self._quantum_instance.backend_options["memory"] = orig_memory
-
-        # return samples
-        samples = np.zeros((num_samples, *self._output_shape))
-        # collect them from all executed circuits
-        for i, circuit in enumerate(circuits):
-            memory = result.get_memory(circuit)
-            for j, b in enumerate(memory):
-                samples[i, j, :] = self._interpret(int(b, 2))
-        return samples
-
-    def _probabilities(
-        self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray]
-    ) -> Union[np.ndarray, SparseArray]:
-        self._check_quantum_instance("probabilities")
-
-        # evaluate operator
-        circuits = []
-        num_samples = input_data.shape[0]
-        for i in range(num_samples):
-            param_values = {
-                input_param: input_data[i, j] for j, input_param in enumerate(self._input_params)
-            }
-            param_values.update(
-                {weight_param: weights[j] for j, weight_param in enumerate(self._weight_params)}
-            )
-            circuits.append(self._circuit.bind_parameters(param_values))
-
-        if self._quantum_instance.bound_pass_manager is not None:
-            circuits = self._quantum_instance.transpile(
-                circuits, pass_manager=self._quantum_instance.bound_pass_manager
-            )
-
-        result = self._quantum_instance.execute(circuits, had_transpiled=self._circuit_transpiled)
-        # initialize probabilities
-        if self._sparse:
-            # pylint: disable=import-error
-            from sparse import DOK
-
-            prob = DOK((num_samples, *self._output_shape))
-        else:
-            prob = np.zeros((num_samples, *self._output_shape))
-
-        for i, circuit in enumerate(circuits):
-            counts = result.get_counts(circuit)
-            shots = sum(counts.values())
-
-            # evaluate probabilities
-            for b, v in counts.items():
-                key = self._interpret(int(b, 2))
-                if isinstance(key, Integral):
-                    key = (cast(int, key),)
-                key = (i, *key)  # type: ignore
-                prob[key] += v / shots
-
-        if self._sparse:
-            return prob.to_coo()
-        else:
-            return prob
-
-    def _probability_gradients(
-        self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray]
-    ) -> Tuple[Union[np.ndarray, SparseArray], Union[np.ndarray, SparseArray]]:
-        self._check_quantum_instance("probability gradients")
-
-        self._construct_gradient_circuit()
-
-        # check whether gradient circuit could be constructed
-        if self._gradient_circuit is None:
-            return None, None
-
-        num_samples = input_data.shape[0]
-
-        # initialize empty gradients
-        input_grad = None  # by default we don't have data gradients
-        if self._sparse:
-            # pylint: disable=import-error
-            from sparse import DOK
-
-            if self._input_gradients:
-                input_grad = DOK((num_samples, *self._output_shape, self._num_inputs))
-            weights_grad = DOK((num_samples, *self._output_shape, self._num_weights))
-        else:
-            if self._input_gradients:
-                input_grad = np.zeros((num_samples, *self._output_shape, self._num_inputs))
-            weights_grad = np.zeros((num_samples, *self._output_shape, self._num_weights))
-
-        param_values = {
-            input_param: input_data[:, j] for j, input_param in enumerate(self._input_params)
-        }
-        param_values.update(
-            {
-                weight_param: np.full(num_samples, weights[j])
-                for j, weight_param in enumerate(self._weight_params)
-            }
-        )
-
-        converted_op = self._sampler.convert(self._gradient_circuit, param_values)
-        # if statement is a workaround for https://github.com/Qiskit/qiskit-terra/issues/7608
-        if len(converted_op.parameters) > 0:
-            # create an list of parameter bindings, each element corresponds to a sample in the dataset
-            param_bindings = [
-                {param: param_values[i] for param, param_values in param_values.items()}
-                for i in range(num_samples)
-            ]
-
-            grad = []
-            # iterate over gradient vectors and bind the correct leftover parameters
-            for g_i, param_i in zip(converted_op, param_bindings):
-                # bind or re-bind remaining values and evaluate the gradient
-                grad.append(g_i.bind_parameters(param_i).eval())
-        else:
-            grad = converted_op.eval()
-
-        if self._input_gradients:
-            num_grad_vars = self._num_inputs + self._num_weights
-        else:
-            num_grad_vars = self._num_weights
-
-        # construct gradients
-        for sample in range(num_samples):
-            for i in range(num_grad_vars):
-                coo_grad = coo_matrix(grad[sample][i])  # this works for sparse and dense case
-
-                # get index for input or weights gradients
-                if self._input_gradients:
-                    grad_index = i if i < self._num_inputs else i - self._num_inputs
-                else:
-                    grad_index = i
-
-                for _, k, val in zip(coo_grad.row, coo_grad.col, coo_grad.data):
-                    # interpret integer and construct key
-                    key = self._interpret(k)
-                    if isinstance(key, Integral):
-                        key = (sample, int(key), grad_index)
-                    else:
-                        # if key is an array-type, cast to hashable tuple
-                        key = tuple(cast(Iterable[int], key))
-                        key = (sample, *key, grad_index)
-
-                    # store value for inputs or weights gradients
-                    if self._input_gradients:
-                        # we compute input gradients first
-                        if i < self._num_inputs:
-                            input_grad[key] += np.real(val)
-                        else:
-                            weights_grad[key] += np.real(val)
-                    else:
-                        weights_grad[key] += np.real(val)
-        # end of for each sample
-
-        if self._sparse:
-            if self._input_gradients:
-                input_grad = input_grad.to_coo()
-            weights_grad = weights_grad.to_coo()
-
-        return input_grad, weights_grad
-
-    def _check_quantum_instance(self, feature: str):
-        if self._quantum_instance is None:
-            raise QiskitMachineLearningError(
-                f"Evaluation of {feature} requires a quantum instance!"
-            )
diff --git a/qiskit_machine_learning/neural_networks/effective_dimension.py b/qiskit_machine_learning/neural_networks/effective_dimension.py
index 2415ff8f2..8e869d8bb 100644
--- a/qiskit_machine_learning/neural_networks/effective_dimension.py
+++ b/qiskit_machine_learning/neural_networks/effective_dimension.py
@@ -21,7 +21,6 @@
 from qiskit.utils import algorithm_globals
 from qiskit_machine_learning import QiskitMachineLearningError
 from .estimator_qnn import EstimatorQNN
-from .opflow_qnn import OpflowQNN
 from .neural_network import NeuralNetwork
 
 logger = logging.getLogger(__name__)
@@ -173,9 +172,9 @@ def run_monte_carlo(self) -> Tuple[np.ndarray, np.ndarray]:
             grads[self._num_input_samples * i : self._num_input_samples * (i + 1)] = backward_pass
             outputs[self._num_input_samples * i : self._num_input_samples * (i + 1)] = forward_pass
 
-        # post-processing in the case of OpflowQNN and EstimatorQNN output, to match
-        # the CircuitQNN output format
-        if isinstance(self._model, (OpflowQNN, EstimatorQNN)):
+        # post-processing in the case of EstimatorQNN output, to match
+        # the SamplerQNN output format
+        if isinstance(self._model, EstimatorQNN):
             grads = np.concatenate([grads / 2, -1 * grads / 2], 1)
             outputs = np.concatenate([(outputs + 1) / 2, (1 - outputs) / 2], 1)
 
diff --git a/qiskit_machine_learning/neural_networks/estimator_qnn.py b/qiskit_machine_learning/neural_networks/estimator_qnn.py
index 4b319673c..85d00d9c8 100644
--- a/qiskit_machine_learning/neural_networks/estimator_qnn.py
+++ b/qiskit_machine_learning/neural_networks/estimator_qnn.py
@@ -25,7 +25,6 @@
     ParamShiftEstimatorGradient,
 )
 from qiskit.circuit import Parameter, QuantumCircuit
-from qiskit.opflow import PauliSumOp
 from qiskit.primitives import BaseEstimator, Estimator, EstimatorResult
 from qiskit.quantum_info import SparsePauliOp
 from qiskit.quantum_info.operators.base_operator import BaseOperator
@@ -107,7 +106,7 @@ def __init__(
         *,
         circuit: QuantumCircuit,
         estimator: BaseEstimator | None = None,
-        observables: Sequence[BaseOperator | PauliSumOp] | BaseOperator | PauliSumOp | None = None,
+        observables: Sequence[BaseOperator] | BaseOperator | None = None,
         input_params: Sequence[Parameter] | None = None,
         weight_params: Sequence[Parameter] | None = None,
         gradient: BaseEstimatorGradient | None = None,
@@ -152,7 +151,7 @@ def __init__(
         self._circuit = circuit
         if observables is None:
             observables = SparsePauliOp.from_list([("Z" * circuit.num_qubits, 1)])
-        if isinstance(observables, (PauliSumOp, BaseOperator)):
+        if isinstance(observables, BaseOperator):
             observables = (observables,)
         self._observables = observables
         if isinstance(circuit, QNNCircuit):
@@ -180,7 +179,7 @@ def circuit(self) -> QuantumCircuit:
         return copy(self._circuit)
 
     @property
-    def observables(self) -> Sequence[BaseOperator | PauliSumOp] | BaseOperator | PauliSumOp:
+    def observables(self) -> Sequence[BaseOperator] | BaseOperator:
         """Returns the underlying observables of this QNN."""
         return copy(self._observables)
 
diff --git a/qiskit_machine_learning/neural_networks/opflow_qnn.py b/qiskit_machine_learning/neural_networks/opflow_qnn.py
deleted file mode 100644
index 198a2d378..000000000
--- a/qiskit_machine_learning/neural_networks/opflow_qnn.py
+++ /dev/null
@@ -1,320 +0,0 @@
-# This code is part of a Qiskit project.
-#
-# (C) Copyright IBM 2020, 2023.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-"""An Opflow Quantum Neural Network that allows to use a parametrized opflow object as a
-neural network."""
-import logging
-from typing import List, Optional, Union, Tuple, Dict
-
-import numpy as np
-from qiskit.circuit import Parameter
-from qiskit.opflow import (
-    Gradient,
-    CircuitSampler,
-    ListOp,
-    OperatorBase,
-    ExpectationBase,
-    OpflowError,
-    ComposedOp,
-)
-from qiskit.providers import Backend
-from qiskit.utils import QuantumInstance, deprecate_func
-from qiskit.utils.backend_utils import is_aer_provider
-import qiskit_machine_learning.optionals as _optionals
-from .neural_network import NeuralNetwork
-from ..exceptions import QiskitMachineLearningError, QiskitError
-
-if _optionals.HAS_SPARSE:
-    # pylint: disable=import-error
-    from sparse import SparseArray
-else:
-
-    class SparseArray:  # type: ignore
-        """Empty SparseArray class
-        Replacement if sparse.SparseArray is not present.
-        """
-
-        pass
-
-
-logger = logging.getLogger(__name__)
-
-
-class OpflowQNN(NeuralNetwork):
-    """Deprecated: Opflow Quantum Neural Network."""
-
-    @deprecate_func(
-        since="0.7.0",
-        additional_msg="Instead, use the ``qiskit_machine_learning.neural_networks.EstimatorQNN``"
-        " class.",
-        package_name="qiskit-machine-learning",
-    )
-    def __init__(
-        self,
-        operator: OperatorBase,
-        input_params: Optional[List[Parameter]] = None,
-        weight_params: Optional[List[Parameter]] = None,
-        exp_val: Optional[ExpectationBase] = None,
-        gradient: Optional[Gradient] = None,
-        quantum_instance: Optional[Union[QuantumInstance, Backend]] = None,
-        input_gradients: bool = False,
-    ):
-        """
-        Args:
-            operator: The parametrized operator that represents the neural network.
-            input_params: The operator parameters that correspond to the input of the network.
-            weight_params: The operator parameters that correspond to the trainable weights.
-            exp_val: The Expected Value converter to be used for the operator.
-            gradient: The Gradient converter to be used for the operator's backward pass.
-            quantum_instance: The quantum instance to evaluate the network.
-            input_gradients: Determines whether to compute gradients with respect to input data.
-                Note that this parameter is ``False`` by default, and must be explicitly set to
-                ``True`` for a proper gradient computation when using ``TorchConnector``.
-        """
-        self._gradient_operator_constructed: bool = False
-        self._input_params = list(input_params) or []
-        self._weight_params = list(weight_params) or []
-        self._set_quantum_instance(quantum_instance)
-        self._operator = operator
-        self._forward_operator = exp_val.convert(operator) if exp_val else operator
-        self._gradient = gradient
-
-        # initialize gradient properties
-        self.input_gradients = input_gradients
-
-        output_shape = self._compute_output_shape(operator)
-        super().__init__(
-            len(self._input_params),
-            len(self._weight_params),
-            sparse=False,
-            output_shape=output_shape,
-            input_gradients=input_gradients,
-        )
-
-    def _construct_gradient_operator(self) -> None:
-        if self._gradient_operator_constructed:
-            return
-
-        self._gradient_operator: OperatorBase = None
-        try:
-            gradient = self._gradient or Gradient()
-            if self._input_gradients:
-                params = self._input_params + self._weight_params
-            else:
-                params = self._weight_params
-
-            self._gradient_operator = gradient.convert(self._operator, params)
-        except (ValueError, TypeError, OpflowError, QiskitError):
-            logger.warning("Cannot compute gradient operator! Continuing without gradients!")
-
-        self._gradient_operator_constructed = True
-
-    def _compute_output_shape(self, op: OperatorBase) -> Tuple[int, ...]:
-        """Determines the output shape of a given operator."""
-        # TODO: the whole method should eventually be moved to opflow and rewritten in a better way.
-        # if the operator is a composed one, then we only need to look at the first element of it.
-        if isinstance(op, ComposedOp):
-            return self._compute_output_shape(op.oplist[0].primitive)
-        # this "if" statement is on purpose, to prevent sub-classes.
-        # pylint:disable=unidiomatic-typecheck
-        if type(op) == ListOp:
-            shapes = [self._compute_output_shape(op_) for op_ in op.oplist]
-            if not np.all([shape == shapes[0] for shape in shapes]):
-                raise QiskitMachineLearningError(
-                    "Only supports ListOps with children that return the same shape."
-                )
-            if shapes[0] == (1,):
-                out = op.combo_fn(np.zeros((len(op.oplist))))
-            else:
-                out = op.combo_fn(np.zeros((len(op.oplist), *shapes[0])))
-            return out.shape
-        else:
-            return (1,)
-
-    @property
-    def operator(self):
-        """Returns the underlying operator of this QNN."""
-        return self._operator
-
-    @property
-    def input_gradients(self) -> bool:
-        """Returns whether gradients with respect to input data are computed by this neural network
-        in the ``backward`` method or not. By default such gradients are not computed."""
-        return self._input_gradients
-
-    @input_gradients.setter
-    def input_gradients(self, input_gradients: bool) -> None:
-        """Turn on/off computation of gradients with respect to input data."""
-        self._input_gradients = input_gradients
-
-        # reset gradient operator
-        self._gradient_operator = None
-        self._gradient_operator_constructed = False
-
-    @property
-    def quantum_instance(self) -> QuantumInstance:
-        """Returns the quantum instance to evaluate the operator."""
-        return self._quantum_instance
-
-    @quantum_instance.setter
-    def quantum_instance(self, quantum_instance: Optional[Union[QuantumInstance, Backend]]) -> None:
-        """Sets the quantum instance to evaluate the operator."""
-        self._set_quantum_instance(quantum_instance)
-
-    def _set_quantum_instance(
-        self, quantum_instance: Optional[Union[QuantumInstance, Backend]]
-    ) -> None:
-        """
-        Internal method to set a quantum instance and compute/initialize a sampler.
-
-        Args:
-            quantum_instance: A quantum instance to set.
-
-        Returns:
-            None.
-        """
-
-        if isinstance(quantum_instance, Backend):
-            quantum_instance = QuantumInstance(quantum_instance)
-        self._quantum_instance = quantum_instance
-
-        if quantum_instance is not None:
-            self._circuit_sampler = CircuitSampler(
-                self._quantum_instance,
-                param_qobj=is_aer_provider(self._quantum_instance.backend),
-                caching="all",
-            )
-        else:
-            self._circuit_sampler = None
-
-    def _forward(
-        self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray]
-    ) -> Union[np.ndarray, SparseArray]:
-        # combine parameter dictionary
-        # take i-th column as values for the i-th param in a batch
-        param_values = {p: input_data[:, i].tolist() for i, p in enumerate(self._input_params)}
-        param_values.update(
-            {p: [weights[i]] * input_data.shape[0] for i, p in enumerate(self._weight_params)}
-        )
-
-        # evaluate operator
-        if self._circuit_sampler:
-            op = self._circuit_sampler.convert(self._forward_operator, param_values)
-            result = np.real(op.eval())
-        else:
-            op = self._forward_operator.bind_parameters(param_values)
-            result = np.real(op.eval())
-        result = np.array(result)
-        return result.reshape(-1, *self._output_shape)
-
-    def _backward(
-        self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray]
-    ) -> Tuple[Optional[Union[np.ndarray, SparseArray]], Optional[Union[np.ndarray, SparseArray]],]:
-
-        self._construct_gradient_operator()
-
-        # check whether gradient circuit could be constructed
-        if self._gradient_operator is None:
-            return None, None
-
-        num_samples = input_data.shape[0]
-        if self._input_gradients:
-            num_params = self._num_inputs + self._num_weights
-        else:
-            num_params = self._num_weights
-
-        param_values = {
-            input_param: input_data[:, j] for j, input_param in enumerate(self._input_params)
-        }
-        param_values.update(
-            {
-                weight_param: np.full(num_samples, weights[j])
-                for j, weight_param in enumerate(self._weight_params)
-            }
-        )
-
-        if self._circuit_sampler:
-            converted_op = self._circuit_sampler.convert(self._gradient_operator, param_values)
-            # if statement is a workaround for https://github.com/Qiskit/qiskit-terra/issues/7608
-            if len(converted_op.parameters) > 0:
-                # rebind the leftover parameters and evaluate the gradient
-                grad = self._evaluate_operator(converted_op, num_samples, param_values)
-            else:
-                # all parameters are bound by CircuitSampler, so we evaluate the operator directly
-                grad = np.asarray(converted_op.eval())
-        else:
-            # we evaluate gradient operator for each sample separately, so we create a list of operators.
-            grad = self._evaluate_operator(
-                [self._gradient_operator] * num_samples, num_samples, param_values
-            )
-
-        grad = np.real(grad)
-
-        # this is another workaround to fix output shape of the invocation result of CircuitSampler
-        if self._output_shape == (1,):
-            # at least 3 dimensions: batch, output, num_parameters, but in this case we don't have
-            # output dimension, so we add a dimension that corresponds to the output
-            grad = grad.reshape((num_samples, 1, num_params))
-        else:
-            # swap last axis that corresponds to parameters and axes correspond to the output shape
-            last_axis = len(grad.shape) - 1
-            grad = grad.transpose([0, last_axis, *(range(1, last_axis))])
-
-        # split into and return input and weights gradients
-        if self._input_gradients:
-            input_grad = grad[:, :, : self._num_inputs].reshape(
-                -1, *self._output_shape, self._num_inputs
-            )
-
-            weights_grad = grad[:, :, self._num_inputs :].reshape(
-                -1, *self._output_shape, self._num_weights
-            )
-        else:
-            input_grad = None
-            weights_grad = grad.reshape(-1, *self._output_shape, self._num_weights)
-
-        return input_grad, weights_grad
-
-    def _evaluate_operator(
-        self,
-        operator: Union[OperatorBase, List[OperatorBase]],
-        num_samples: int,
-        param_values: Dict[Parameter, np.ndarray],
-    ) -> np.ndarray:
-        """
-        Evaluates an operator or a list of operators for the samples in the dataset. If an operator
-        is passed then it is considered as an iterable that has `num_samples` elements. Usually such
-        operators are obtained as an output from `CircuitSampler`. If a list of operators is passed
-        then each operator in this list is evaluated with a set of values/parameters corresponding
-        to the sample index in the `param_values` as the operator in the list.
-
-        Args:
-            operator: operator or list of operators to evaluate.
-            num_samples: a total number of samples
-            param_values: parameter values to use for operator evaluation.
-
-        Returns:
-            the result of operator evaluation as an array.
-        """
-        # create an list of parameter bindings, each element corresponds to a sample in the dataset
-        param_bindings = [
-            {param: param_values[i] for param, param_values in param_values.items()}
-            for i in range(num_samples)
-        ]
-
-        grad = []
-        # iterate over gradient vectors and bind the correct parameters
-        for oper_i, param_i in zip(operator, param_bindings):
-            # bind or re-bind remaining values and evaluate the gradient
-            grad.append(oper_i.bind_parameters(param_i).eval())
-
-        return np.asarray(grad)
diff --git a/qiskit_machine_learning/neural_networks/sampling_neural_network.py b/qiskit_machine_learning/neural_networks/sampling_neural_network.py
deleted file mode 100644
index bd54cc3e0..000000000
--- a/qiskit_machine_learning/neural_networks/sampling_neural_network.py
+++ /dev/null
@@ -1,190 +0,0 @@
-# This code is part of a Qiskit project.
-#
-# (C) Copyright IBM 2020, 2023.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-"""A Sampling Neural Network abstract class."""
-
-from abc import abstractmethod
-from typing import Tuple, Union, List, Optional
-
-import numpy as np
-
-import qiskit_machine_learning.optionals as _optionals
-from .neural_network import NeuralNetwork
-
-if _optionals.HAS_SPARSE:
-    # pylint: disable=import-error
-    from sparse import SparseArray
-else:
-
-    class SparseArray:  # type: ignore
-        """Empty SparseArray class
-        Replacement if sparse.SparseArray is not present.
-        """
-
-        pass
-
-
-class SamplingNeuralNetwork(NeuralNetwork):
-    """
-    A sampling neural network abstract class for all (quantum) neural networks within the
-    Qiskit Machine Learning module that generate samples instead of (expected) values.
-    """
-
-    def __init__(
-        self,
-        num_inputs: int,
-        num_weights: int,
-        sparse: bool,
-        sampling: bool,
-        output_shape: Union[int, Tuple[int, ...]],
-        input_gradients: bool = False,
-    ) -> None:
-        """
-
-        Args:
-            num_inputs: The number of input features.
-            num_weights: The number of trainable weights.
-            sparse: Returns whether the output is sparse or not.
-            sampling: Determines whether the network returns a batch of samples or (possibly
-                sparse) array of probabilities in its forward pass. In case of probabilities,
-                the backward pass returns the probability gradients, while it returns (None, None)
-                in the case of samples.
-            output_shape: The shape of the output.
-            input_gradients: Determines whether to compute gradients with respect to input data.
-                Note that this parameter is ``False`` by default, and must be explicitly set to
-                ``True`` for a proper gradient computation when using ``TorchConnector``.
-        Raises:
-            QiskitMachineLearningError: Invalid parameter values.
-        """
-        self._sampling = sampling
-        super().__init__(num_inputs, num_weights, sparse, output_shape, input_gradients)
-
-    @property
-    def sampling(self) -> bool:
-        """
-        Returns:
-             ``True`` if the network returns a batch of samples and ``False`` if a sparse
-             vector (dictionary) of probabilities in its forward pass.
-        """
-        return self._sampling
-
-    def _forward(
-        self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray]
-    ) -> Union[np.ndarray, SparseArray]:
-        """Forward pass of the network. Returns an array of samples or the probabilities, depending
-        on the setting. Format depends on the set interpret function.
-        """
-        if self._sampling:
-            return self._sample(input_data, weights)
-        else:
-            return self._probabilities(input_data, weights)
-
-    def _backward(
-        self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray]
-    ) -> Tuple[Optional[Union[np.ndarray, SparseArray]], Optional[Union[np.ndarray, SparseArray]],]:
-        """Backward pass of the network. Returns (None, None) in case of samples and the
-        corresponding here probability gradients otherwise.
-        """
-        if self._sampling:
-            return None, None
-        else:
-            return self._probability_gradients(input_data, weights)
-
-    def sample(
-        self,
-        input_data: Union[List[float], np.ndarray, float],
-        weights: Union[List[float], np.ndarray, float],
-    ) -> np.ndarray:
-        """Samples from the network. Returns an array of samples. Format depends on the set
-        interpret function.
-
-        Args:
-            input_data: input data of the shape (num_inputs). In case of a single scalar input it is
-                directly cast to and interpreted like a one-element array.
-            weights: trainable weights of the shape (num_weights). In case of a single scalar weight
-                it is directly cast to and interpreted like a one-element array.
-        Returns:
-            The sample results of the neural network of the shape (output_shape).
-        """
-        input_, shape = self._validate_input(input_data)
-        weights_ = self._validate_weights(weights)
-        output_data = self._sample(input_, weights_)
-        return self._validate_forward_output(output_data, shape)
-
-    @abstractmethod
-    def _sample(
-        self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray]
-    ) -> np.ndarray:
-        """Returns samples from the network."""
-        raise NotImplementedError
-
-    def probabilities(
-        self,
-        input_data: Union[List[float], np.ndarray, float],
-        weights: Union[List[float], np.ndarray, float],
-    ) -> Union[np.ndarray, SparseArray]:
-        """Histogram (as dict) of the samples from the network. Returns an array of samples. Format
-        depends on the set interpret function.
-
-        Args:
-            input_data: input data of the shape (num_inputs). In case of a single scalar input it is
-                directly cast to and interpreted like a one-element array.
-            weights: trainable weights of the shape (num_weights). In case of a single scalar weight
-                it is directly cast to and interpreted like a one-element array.
-        Returns:
-            The sample histogram of the neural network.
-        """
-        input_, shape = self._validate_input(input_data)
-        weights_ = self._validate_weights(weights)
-        output_data = self._probabilities(input_, weights_)
-        return self._validate_forward_output(output_data, shape)
-
-    @abstractmethod
-    def _probabilities(
-        self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray]
-    ) -> Union[np.ndarray, SparseArray]:
-        """Returns the sample probabilities."""
-        raise NotImplementedError
-
-    def probability_gradients(
-        self,
-        input_data: Optional[Union[List[float], np.ndarray, float]],
-        weights: Optional[Union[List[float], np.ndarray, float]],
-    ) -> Tuple[Union[np.ndarray, SparseArray], Union[np.ndarray, SparseArray]]:
-        """Probability gradients of histogram resulting from the network. Format depends on the set
-        interpret function. Shape is (input_grad, weights_grad), where each grad has one dict for
-        each parameter and each dict contains as value the derivative of the probability of
-        measuring the key.
-
-        Args:
-            input_data: input data of the shape (num_inputs). In case of a single scalar input it is
-                directly cast to and interpreted like a one-element array.
-            weights: trainable weights of the shape (num_weights). In case of a single scalar weight
-                it is directly cast to and interpreted like a one-element array.
-        Returns:
-            The probability gradients.
-        """
-        input_, shape = self._validate_input(input_data)
-        weights_ = self._validate_weights(weights)
-        input_grad, weight_grad = self._probability_gradients(input_, weights_)
-        input_grad_reshaped, weight_grad_reshaped = self._validate_backward_output(
-            input_grad, weight_grad, shape
-        )
-
-        return input_grad_reshaped, weight_grad_reshaped
-
-    @abstractmethod
-    def _probability_gradients(
-        self, input_data: Optional[np.ndarray], weights: Optional[np.ndarray]
-    ) -> Tuple[Union[np.ndarray, SparseArray], Union[np.ndarray, SparseArray]]:
-        """Returns the probability gradients."""
-        raise NotImplementedError
diff --git a/qiskit_machine_learning/neural_networks/two_layer_qnn.py b/qiskit_machine_learning/neural_networks/two_layer_qnn.py
deleted file mode 100644
index 828a182b4..000000000
--- a/qiskit_machine_learning/neural_networks/two_layer_qnn.py
+++ /dev/null
@@ -1,124 +0,0 @@
-# This code is part of a Qiskit project.
-#
-# (C) Copyright IBM 2020, 2023.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-"""A Two Layer Neural Network consisting of a first parametrized circuit representing a feature map
-to map the input data to a quantum states and a second one representing a ansatz that can
-be trained to solve a particular tasks."""
-from __future__ import annotations
-
-from qiskit import QuantumCircuit
-from qiskit.opflow import PauliSumOp, StateFn, OperatorBase, ExpectationBase
-from qiskit.providers import Backend
-from qiskit.utils import QuantumInstance, deprecate_func
-
-from .opflow_qnn import OpflowQNN
-from ..utils import derive_num_qubits_feature_map_ansatz
-
-
-class TwoLayerQNN(OpflowQNN):
-    """Deprecated: Two Layer Quantum Neural Network consisting of a feature map, a ansatz,
-    and an observable.
-    """
-
-    @deprecate_func(
-        since="0.7.0",
-        additional_msg="Instead, use the ``qiskit_machine_learning.neural_networks.EstimatorQNN``"
-        " class.",
-        package_name="qiskit-machine-learning",
-    )
-    def __init__(
-        self,
-        num_qubits: int | None = None,
-        feature_map: QuantumCircuit | None = None,
-        ansatz: QuantumCircuit | None = None,
-        observable: OperatorBase | QuantumCircuit | None = None,
-        exp_val: ExpectationBase | None = None,
-        quantum_instance: QuantumInstance | Backend | None = None,
-        input_gradients: bool = False,
-    ):
-        r"""
-        Args:
-            num_qubits: The number of qubits to represent the network. If ``None`` is given,
-                the number of qubits is derived from the feature map or ansatz. If neither of those
-                is given, raises an exception. The number of qubits in the feature map and ansatz
-                are adjusted to this number if required.
-            feature_map: The (parametrized) circuit to be used as a feature map. If ``None`` is given,
-                the ``ZZFeatureMap`` is used if the number of qubits is larger than 1. For
-                a single qubit two-layer QNN the ``ZFeatureMap`` circuit is used per default.
-            ansatz: The (parametrized) circuit to be used as an ansatz. If ``None`` is given,
-                the ``RealAmplitudes`` circuit is used.
-            observable: observable to be measured to determine the output of the network. If
-                ``None`` is given, the :math:`Z^{\otimes num\_qubits}` observable is used.
-            exp_val: The Expected Value converter to be used for the operator obtained from the
-                feature map and ansatz.
-            quantum_instance: The quantum instance to evaluate the network.
-            input_gradients: Determines whether to compute gradients with respect to input data.
-                Note that this parameter is ``False`` by default, and must be explicitly set to
-                ``True`` for a proper gradient computation when using
-                :class:`~qiskit_machine_learning.connectors.TorchConnector`.
-        Raises:
-            QiskitMachineLearningError: Needs at least one out of ``num_qubits``, ``feature_map`` or
-                ``ansatz`` to be given. Or the number of qubits in the feature map and/or ansatz
-                can't be adjusted to ``num_qubits``.
-        """
-
-        num_qubits, feature_map, ansatz = derive_num_qubits_feature_map_ansatz(
-            num_qubits, feature_map, ansatz
-        )
-
-        self._feature_map = feature_map
-        input_params = list(self._feature_map.parameters)
-
-        self._ansatz = ansatz
-        weight_params = list(self._ansatz.parameters)
-
-        # construct circuit
-        self._circuit = QuantumCircuit(num_qubits)
-        self._circuit.append(self._feature_map, range(num_qubits))
-        self._circuit.append(self._ansatz, range(num_qubits))
-
-        # construct observable
-        self.observable = (
-            observable if observable is not None else PauliSumOp.from_list([("Z" * num_qubits, 1)])
-        )
-
-        # combine all to operator
-        operator = StateFn(self.observable, is_measurement=True) @ StateFn(self._circuit)
-
-        super().__init__(
-            operator=operator,
-            input_params=input_params,
-            weight_params=weight_params,
-            exp_val=exp_val,
-            quantum_instance=quantum_instance,
-            input_gradients=input_gradients,
-        )
-
-    @property
-    def feature_map(self) -> QuantumCircuit:
-        """Returns the used feature map."""
-        return self._feature_map
-
-    @property
-    def ansatz(self) -> QuantumCircuit:
-        """Returns the used ansatz."""
-        return self._ansatz
-
-    @property
-    def circuit(self) -> QuantumCircuit:
-        """Returns the underlying quantum circuit."""
-        return self._circuit
-
-    @property
-    def num_qubits(self) -> int:
-        """Returns the number of qubits used by ansatz and feature map."""
-        return self._circuit.num_qubits
diff --git a/releasenotes/notes/deprecate-old-qk-qnn-af16b379ef3fc0c8.yaml b/releasenotes/notes/deprecate-old-qk-qnn-af16b379ef3fc0c8.yaml
deleted file mode 100644
index 984de918a..000000000
--- a/releasenotes/notes/deprecate-old-qk-qnn-af16b379ef3fc0c8.yaml
+++ /dev/null
@@ -1,26 +0,0 @@
----
-deprecations:
-  - |
-    Since :mod:`qiskit.opflow` and :class:`~qiskit.utils.QuantumInstance` are deprecated in Qiskit,
-    Qiskit Machine Learning classes based on the deprecated Qiskit classes have been
-    deprecated as well:
-
-      - Class :class:`qiskit_machine_learning.neural_networks.CircuitQNN` is deprecated and
-        is superseded by :class:`qiskit_machine_learning.neural_networks.SamplerQNN`.
-
-      - Class :class:`qiskit_machine_learning.neural_networks.OpflowQNN` is deprecated and
-        is superseded by :class:`qiskit_machine_learning.neural_networks.EstimatorQNN`.
-
-      - Class :class:`qiskit_machine_learning.neural_networks.TwoLayerQNN` is deprecated and
-        has no direct replacement. Please make use of
-        :class:`qiskit_machine_learning.neural_networks.EstimatorQNN` instead.
-
-      - Class :class:`qiskit_machine_learning.kernels.QuantumKernel` is deprecated and
-        is superseded by :class:`qiskit_machine_learning.kernels.FidelityQuantumKernel`,
-        :class:`qiskit_machine_learning.kernels.TrainableFidelityQuantumKernel`, and
-        :class:`qiskit_machine_learning.kernels.FidelityStatevectorKernel`.
-
-    The above mentioned classes will be removed no sooner than 3 months after the release. Please
-    refer to the `migration guide <https://qiskit.org/ecosystem/machine-learning/migration/01_migration_guide_0.5.html>`__
-    on how to replace the deprecated classes with new ones.
-
diff --git a/releasenotes/notes/remove-deprecated-3c8493dd0b92c4a3.yaml b/releasenotes/notes/remove-deprecated-3c8493dd0b92c4a3.yaml
index 50e0cbf79..4ac3606f3 100644
--- a/releasenotes/notes/remove-deprecated-3c8493dd0b92c4a3.yaml
+++ b/releasenotes/notes/remove-deprecated-3c8493dd0b92c4a3.yaml
@@ -1,17 +1,34 @@
 ---
 upgrade:
   - |
-    Removed support of the deprecated parameter `user_parameters` in the constructor of
-    :class:`~qiskit_machine_learning.kernels.QuantumKernel`. Use ``training_parameters`` instead.
-    The corresponding property and methods have been removed as well. Replace as follows:
-
-      - ``user_parameters`` with ``training_parameters``
-      - ``user_param_binds`` with ``training_param_binds``
-      - ``bind_user_parameters`` with ``training_user_parameters``
-      - ``get_unbound_user_parameters`` with ``get_unbound_training_parameters``.
-
     Removed support of the deprecated parameter `quantum_instance` in the constructor of
     :class:`~qiskit_machine_learning.algorithms.VQC` and in :class:`~qiskit_machine_learning.algorithms.VQR`.
     Please use `sampler` and `estimator` respectively. Refer to the
     `migration guide <https://qiskit.org/ecosystem/machine-learning/migration/01_migration_guide_0.5.html>`__
     for more information.
+
+    Since :mod:`qiskit.opflow` and :class:`~qiskit.utils.QuantumInstance` are deprecated in Qiskit,
+    Qiskit Machine Learning classes based on the deprecated Qiskit classes have been
+    removed:
+
+      - Class :class:`qiskit_machine_learning.neural_networks.SamplingNeuralNetwork` is removed and
+        has no direct replacement as this is a base class.
+
+      - Class :class:`qiskit_machine_learning.neural_networks.CircuitQNN` is removed and
+        is superseded by :class:`qiskit_machine_learning.neural_networks.SamplerQNN`.
+
+      - Class :class:`qiskit_machine_learning.neural_networks.OpflowQNN` is removed and
+        is superseded by :class:`qiskit_machine_learning.neural_networks.EstimatorQNN`.
+
+      - Class :class:`qiskit_machine_learning.neural_networks.TwoLayerQNN` is removed and
+        has no direct replacement. Please make use of
+        :class:`qiskit_machine_learning.neural_networks.EstimatorQNN` instead.
+
+      - Class :class:`qiskit_machine_learning.kernels.QuantumKernel` is removed and
+        is superseded by :class:`qiskit_machine_learning.kernels.FidelityQuantumKernel`,
+        :class:`qiskit_machine_learning.kernels.TrainableFidelityQuantumKernel`, and
+        :class:`qiskit_machine_learning.kernels.FidelityStatevectorKernel`.
+
+    Please refer to the
+    `migration guide <https://qiskit.org/ecosystem/machine-learning/migration/01_migration_guide_0.5.html>`__
+    on how to replace the deprecated classes with new ones.


Test patch:
diff --git a/test/algorithms/classifiers/test_neural_network_classifier.py b/test/algorithms/classifiers/test_neural_network_classifier.py
index 1f860b4d8..3a30d4d7a 100644
--- a/test/algorithms/classifiers/test_neural_network_classifier.py
+++ b/test/algorithms/classifiers/test_neural_network_classifier.py
@@ -1,6 +1,6 @@
 # This code is part of a Qiskit project.
 #
-# (C) Copyright IBM 2018, 2023.
+# (C) Copyright IBM 2022, 2023.
 #
 # This code is licensed under the Apache License, Version 2.0. You may
 # obtain a copy of this license in the LICENSE.txt file in the root directory
@@ -10,13 +10,14 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 """ Test Neural Network Classifier """
+from __future__ import annotations
+
 import itertools
 import os
 import tempfile
 import unittest
-import warnings
 from functools import partial
-from typing import Tuple, Optional, Callable
+from typing import Callable
 
 from test import QiskitMachineLearningTestCase
 
@@ -26,18 +27,17 @@
 from qiskit.algorithms.optimizers import COBYLA, L_BFGS_B, SPSA, Optimizer
 from qiskit.circuit import QuantumCircuit
 from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap
-from qiskit.utils import QuantumInstance, algorithm_globals, optionals
+from qiskit.utils import algorithm_globals, optionals
 from scipy.optimize import minimize
 
 from qiskit_machine_learning.algorithms import SerializableModelMixin
 from qiskit_machine_learning.algorithms.classifiers import NeuralNetworkClassifier
 from qiskit_machine_learning.exceptions import QiskitMachineLearningError
-from qiskit_machine_learning.neural_networks import TwoLayerQNN, CircuitQNN, NeuralNetwork
+from qiskit_machine_learning.neural_networks import NeuralNetwork, EstimatorQNN, SamplerQNN
 from qiskit_machine_learning.utils.loss_functions import CrossEntropyLoss
 
 OPTIMIZERS = ["cobyla", "bfgs", "callable", None]
 L1L2_ERRORS = ["absolute_error", "squared_error"]
-QUANTUM_INSTANCES = ["statevector", "qasm"]
 CALLBACKS = [True, False]
 
 
@@ -54,52 +54,22 @@ class TestNeuralNetworkClassifier(QiskitMachineLearningTestCase):
     @unittest.skipUnless(optionals.HAS_AER, "qiskit-aer is required to run this test")
     def setUp(self):
         super().setUp()
-        warnings.filterwarnings("ignore", category=DeprecationWarning)
 
         # specify quantum instances
         algorithm_globals.random_seed = 12345
-        from qiskit_aer import Aer
-
-        self.sv_quantum_instance = QuantumInstance(
-            Aer.get_backend("aer_simulator_statevector"),
-            seed_simulator=algorithm_globals.random_seed,
-            seed_transpiler=algorithm_globals.random_seed,
-        )
-        self.qasm_quantum_instance = QuantumInstance(
-            Aer.get_backend("aer_simulator"),
-            shots=100,
-            seed_simulator=algorithm_globals.random_seed,
-            seed_transpiler=algorithm_globals.random_seed,
-        )
-
-    def tearDown(self) -> None:
-        super().tearDown()
-        warnings.filterwarnings("always", category=DeprecationWarning)
-        # enable the warnings if they were disabled for COBYLA
-        warnings.filterwarnings("always", category=RuntimeWarning)
 
-    def _create_optimizer(self, opt: str) -> Optional[Optimizer]:
+    def _create_optimizer(self, opt: str) -> Optimizer | None:
         if opt == "bfgs":
             optimizer = L_BFGS_B(maxiter=5)
         elif opt == "cobyla":
             optimizer = COBYLA(maxiter=25)
         elif opt == "callable":
-            # COBYLA raises a warning in the callable case
-            warnings.filterwarnings("ignore", category=RuntimeWarning)
             optimizer = partial(minimize, method="COBYLA", options={"maxiter": 25})
         else:
             optimizer = None
 
         return optimizer
 
-    def _create_quantum_instance(self, q_i: str) -> QuantumInstance:
-        if q_i == "statevector":
-            quantum_instance = self.sv_quantum_instance
-        else:
-            quantum_instance = self.qasm_quantum_instance
-
-        return quantum_instance
-
     def _create_callback(self, cb_flag):
         if cb_flag:
             history = {"weights": [], "values": []}
@@ -113,18 +83,25 @@ def callback(objective_weights, objective_value):
             callback = None
         return callback, history
 
-    @idata(itertools.product(OPTIMIZERS, L1L2_ERRORS, QUANTUM_INSTANCES, CALLBACKS))
+    @idata(itertools.product(OPTIMIZERS, L1L2_ERRORS, CALLBACKS))
     @unpack
-    def test_classifier_with_opflow_qnn(self, opt, loss, q_i, cb_flag):
-        """Test Neural Network Classifier with Opflow QNN (Two Layer QNN)."""
+    def test_classifier_with_estimator_qnn(self, opt, loss, cb_flag):
+        """Test Neural Network Classifier with Estimator QNN."""
 
-        quantum_instance = self._create_quantum_instance(q_i)
         optimizer = self._create_optimizer(opt)
         callback, history = self._create_callback(cb_flag)
 
         num_inputs = 2
+        feature_map = ZZFeatureMap(num_inputs)
         ansatz = RealAmplitudes(num_inputs, reps=1)
-        qnn = TwoLayerQNN(num_inputs, ansatz=ansatz, quantum_instance=quantum_instance)
+
+        qc = QuantumCircuit(num_inputs)
+        qc.compose(feature_map, inplace=True)
+        qc.compose(ansatz, inplace=True)
+
+        qnn = EstimatorQNN(
+            circuit=qc, input_params=feature_map.parameters, weight_params=ansatz.parameters
+        )
 
         classifier = self._create_classifier(qnn, ansatz.num_parameters, optimizer, loss, callback)
 
@@ -156,9 +133,7 @@ def _verify_callback_values(self, callback, history, num_weights):
                 self.assertEqual(len(weights), num_weights)
                 self.assertTrue(all(isinstance(weight, float) for weight in weights))
 
-    def _create_circuit_qnn(
-        self, quantum_instance: QuantumInstance, output_shape=2
-    ) -> Tuple[CircuitQNN, int, int]:
+    def _create_sampler_qnn(self, output_shape=2) -> tuple[SamplerQNN, int, int]:
         num_inputs = 2
         feature_map = ZZFeatureMap(num_inputs)
         ansatz = RealAmplitudes(num_inputs, reps=1)
@@ -172,19 +147,18 @@ def _create_circuit_qnn(
         def parity(x):
             return f"{x:b}".count("1") % 2
 
-        qnn = CircuitQNN(
-            qc,
+        qnn = SamplerQNN(
+            circuit=qc,
             input_params=feature_map.parameters,
             weight_params=ansatz.parameters,
             sparse=False,
             interpret=parity,
             output_shape=output_shape,
-            quantum_instance=quantum_instance,
         )
 
         return qnn, num_inputs, ansatz.num_parameters
 
-    def _generate_data(self, num_inputs: int) -> Tuple[np.ndarray, np.ndarray]:
+    def _generate_data(self, num_inputs: int) -> tuple[np.ndarray, np.ndarray]:
         # construct data
         num_samples = 6
         features = algorithm_globals.random.random((num_samples, num_inputs))
@@ -198,7 +172,7 @@ def _create_classifier(
         num_parameters: int,
         optimizer: Optimizer,
         loss: str,
-        callback: Optional[Callable[[np.ndarray, float], None]] = None,
+        callback: Callable[[np.ndarray, float], None] | None = None,
         one_hot: bool = False,
     ):
         initial_point = np.array([0.5] * num_parameters)
@@ -214,16 +188,15 @@ def _create_classifier(
         )
         return classifier
 
-    @idata(itertools.product(OPTIMIZERS, L1L2_ERRORS, QUANTUM_INSTANCES, CALLBACKS))
+    @idata(itertools.product(OPTIMIZERS, L1L2_ERRORS, CALLBACKS))
     @unpack
-    def test_classifier_with_circuit_qnn(self, opt, loss, q_i, cb_flag):
-        """Test Neural Network Classifier with Circuit QNN."""
+    def test_classifier_with_sampler_qnn(self, opt, loss, cb_flag):
+        """Test Neural Network Classifier with SamplerQNN."""
 
-        quantum_instance = self._create_quantum_instance(q_i)
         optimizer = self._create_optimizer(opt)
         callback, history = self._create_callback(cb_flag)
 
-        qnn, num_inputs, num_parameters = self._create_circuit_qnn(quantum_instance)
+        qnn, num_inputs, num_parameters = self._create_sampler_qnn()
 
         classifier = self._create_classifier(qnn, num_parameters, optimizer, loss, callback)
 
@@ -243,14 +216,12 @@ def test_classifier_with_circuit_qnn(self, opt, loss, q_i, cb_flag):
         np.testing.assert_array_equal(classifier.fit_result.x, classifier.weights)
         self.assertEqual(len(classifier.weights), num_parameters)
 
-    @idata(itertools.product(OPTIMIZERS, QUANTUM_INSTANCES))
-    @unpack
-    def test_classifier_with_circuit_qnn_and_cross_entropy(self, opt, q_i):
+    @idata(OPTIMIZERS)
+    def test_classifier_with_sampler_qnn_and_cross_entropy(self, opt):
         """Test Neural Network Classifier with Circuit QNN and Cross Entropy loss."""
 
-        quantum_instance = self._create_quantum_instance(q_i)
         optimizer = self._create_optimizer(opt)
-        qnn, num_inputs, num_parameters = self._create_circuit_qnn(quantum_instance)
+        qnn, num_inputs, num_parameters = self._create_sampler_qnn()
 
         loss = CrossEntropyLoss()
         classifier = self._create_classifier(qnn, num_parameters, optimizer, loss, one_hot=True)
@@ -278,10 +249,9 @@ def test_categorical_data(self, config):
 
         one_hot, loss = config
 
-        quantum_instance = self.sv_quantum_instance
         optimizer = L_BFGS_B(maxiter=5)
 
-        qnn, num_inputs, num_parameters = self._create_circuit_qnn(quantum_instance)
+        qnn, num_inputs, num_parameters = self._create_sampler_qnn()
 
         classifier = self._create_classifier(qnn, num_parameters, optimizer, loss, one_hot=one_hot)
 
@@ -301,13 +271,11 @@ def test_categorical_data(self, config):
         predict = classifier.predict(features[0, :])
         self.assertIn(predict, ["A", "B"])
 
-    @idata(itertools.product(QUANTUM_INSTANCES, L1L2_ERRORS + ["cross_entropy"]))
-    @unpack
-    def test_sparse_arrays(self, q_i, loss):
+    @idata(L1L2_ERRORS + ["cross_entropy"])
+    def test_sparse_arrays(self, loss):
         """Tests classifier with sparse arrays as features and labels."""
         optimizer = L_BFGS_B(maxiter=5)
-        quantum_instance = self._create_quantum_instance(q_i)
-        qnn, _, num_parameters = self._create_circuit_qnn(quantum_instance)
+        qnn, _, num_parameters = self._create_sampler_qnn()
         classifier = self._create_classifier(qnn, num_parameters, optimizer, loss, one_hot=True)
 
         features = scipy.sparse.csr_matrix([[0, 0], [1, 1]])
@@ -320,23 +288,29 @@ def test_sparse_arrays(self, q_i, loss):
         score = classifier.score(features, labels)
         self.assertGreater(score, 0.5)
 
-    @idata(["opflow", "circuit_qnn"])
+    @idata(["estimator_qnn", "sampler_qnn"])
     def test_save_load(self, qnn_type):
         """Tests save and load models."""
         features = np.array([[0, 0], [0.1, 0.2], [1, 1], [0.9, 0.8]])
 
-        if qnn_type == "opflow":
+        if qnn_type == "estimator_qnn":
             labels = np.array([-1, -1, 1, 1])
 
             num_qubits = 2
+            feature_map = ZZFeatureMap(num_qubits)
             ansatz = RealAmplitudes(num_qubits, reps=1)
-            qnn = TwoLayerQNN(
-                num_qubits, ansatz=ansatz, quantum_instance=self.qasm_quantum_instance
+            qc = QuantumCircuit(num_qubits)
+            qc.compose(feature_map, inplace=True)
+            qc.compose(ansatz, inplace=True)
+            qnn = EstimatorQNN(
+                circuit=qc,
+                input_params=feature_map.parameters,
+                weight_params=ansatz.parameters,
             )
             num_parameters = ansatz.num_parameters
-        elif qnn_type == "circuit_qnn":
+        elif qnn_type == "sampler_qnn":
             labels = np.array([0, 0, 1, 1])
-            qnn, _, num_parameters = self._create_circuit_qnn(self.qasm_quantum_instance)
+            qnn, _, num_parameters = self._create_sampler_qnn()
         else:
             raise ValueError(f"Unsupported QNN type: {qnn_type}")
 
@@ -373,7 +347,7 @@ def test_num_classes_data(self, one_hot):
         """Test the number of assumed classes for one-hot and not one-hot data."""
 
         optimizer = L_BFGS_B(maxiter=5)
-        qnn, num_inputs, num_parameters = self._create_circuit_qnn(self.sv_quantum_instance)
+        qnn, num_inputs, num_parameters = self._create_sampler_qnn()
         features, labels = self._generate_data(num_inputs)
 
         if one_hot:
@@ -399,9 +373,7 @@ def test_binary_classification_with_multiclass_data(self):
         """Test that trying to train a binary classifier with multiclass data raises an error."""
 
         optimizer = L_BFGS_B(maxiter=5)
-        qnn, num_inputs, num_parameters = self._create_circuit_qnn(
-            self.sv_quantum_instance, output_shape=1
-        )
+        qnn, num_inputs, num_parameters = self._create_sampler_qnn(output_shape=1)
         classifier = self._create_classifier(
             qnn,
             num_parameters,
@@ -421,9 +393,7 @@ def test_bad_binary_shape(self):
         """Test that trying to train a binary classifier with misshaped data raises an error."""
 
         optimizer = L_BFGS_B(maxiter=5)
-        qnn, num_inputs, num_parameters = self._create_circuit_qnn(
-            self.sv_quantum_instance, output_shape=1
-        )
+        qnn, num_inputs, num_parameters = self._create_sampler_qnn(output_shape=1)
         classifier = self._create_classifier(
             qnn,
             num_parameters,
@@ -443,9 +413,7 @@ def test_bad_one_hot_data(self):
         """Test that trying to train a one-hot classifier with incompatible data raises an error."""
 
         optimizer = L_BFGS_B(maxiter=5)
-        qnn, num_inputs, num_parameters = self._create_circuit_qnn(
-            self.sv_quantum_instance, output_shape=2
-        )
+        qnn, num_inputs, num_parameters = self._create_sampler_qnn(output_shape=2)
         classifier = self._create_classifier(
             qnn, num_parameters, optimizer, loss="absolute_error", one_hot=True
         )
@@ -460,7 +428,7 @@ def test_bad_one_hot_data(self):
 
     def test_untrained(self):
         """Test untrained classifier."""
-        qnn, _, _ = self._create_circuit_qnn(self.sv_quantum_instance)
+        qnn, _, _ = self._create_sampler_qnn()
         classifier = NeuralNetworkClassifier(qnn)
         with self.assertRaises(QiskitMachineLearningError, msg="classifier.predict()"):
             classifier.predict(np.asarray([]))
@@ -473,7 +441,15 @@ def test_untrained(self):
 
     def test_callback_setter(self):
         """Test the callback setter."""
-        qnn = TwoLayerQNN(2, quantum_instance=self.qasm_quantum_instance)
+        num_qubits = 2
+        feature_map = ZZFeatureMap(num_qubits)
+        ansatz = RealAmplitudes(num_qubits)
+        qc = QuantumCircuit(2)
+        qc.compose(feature_map, inplace=True)
+        qc.compose(ansatz, inplace=True)
+        qnn = EstimatorQNN(
+            circuit=qc, input_params=feature_map.parameters, weight_params=ansatz.parameters
+        )
         single_step_opt = SPSA(maxiter=1, learning_rate=0.01, perturbation=0.1)
         classifier = NeuralNetworkClassifier(qnn, optimizer=single_step_opt)
 
diff --git a/test/algorithms/classifiers/test_neural_network_classifier_sampler_qnn.py b/test/algorithms/classifiers/test_neural_network_classifier_sampler_qnn.py
deleted file mode 100644
index 76e279cce..000000000
--- a/test/algorithms/classifiers/test_neural_network_classifier_sampler_qnn.py
+++ /dev/null
@@ -1,472 +0,0 @@
-# This code is part of a Qiskit project.
-#
-# (C) Copyright IBM 2022, 2023.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-""" Test Neural Network Classifier """
-from __future__ import annotations
-
-import itertools
-import os
-import tempfile
-import unittest
-from functools import partial
-from typing import Callable
-
-from test import QiskitMachineLearningTestCase
-
-import numpy as np
-import scipy
-from ddt import ddt, data, idata, unpack
-from qiskit.algorithms.optimizers import COBYLA, L_BFGS_B, SPSA, Optimizer
-from qiskit.circuit import QuantumCircuit
-from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap
-from qiskit.utils import algorithm_globals, optionals
-from scipy.optimize import minimize
-
-from qiskit_machine_learning.algorithms import SerializableModelMixin
-from qiskit_machine_learning.algorithms.classifiers import NeuralNetworkClassifier
-from qiskit_machine_learning.exceptions import QiskitMachineLearningError
-from qiskit_machine_learning.neural_networks import NeuralNetwork, EstimatorQNN, SamplerQNN
-from qiskit_machine_learning.utils.loss_functions import CrossEntropyLoss
-
-OPTIMIZERS = ["cobyla", "bfgs", "callable", None]
-L1L2_ERRORS = ["absolute_error", "squared_error"]
-CALLBACKS = [True, False]
-
-
-def _one_hot_encode(y: np.ndarray) -> np.ndarray:
-    y_one_hot = np.zeros((y.size, int(y.max() + 1)), dtype=int)
-    y_one_hot[np.arange(y.size), y] = 1
-    return y_one_hot
-
-
-@ddt
-class TestNeuralNetworkClassifier(QiskitMachineLearningTestCase):
-    """Neural Network Classifier Tests."""
-
-    @unittest.skipUnless(optionals.HAS_AER, "qiskit-aer is required to run this test")
-    def setUp(self):
-        super().setUp()
-
-        # specify quantum instances
-        algorithm_globals.random_seed = 12345
-
-    def _create_optimizer(self, opt: str) -> Optimizer | None:
-        if opt == "bfgs":
-            optimizer = L_BFGS_B(maxiter=5)
-        elif opt == "cobyla":
-            optimizer = COBYLA(maxiter=25)
-        elif opt == "callable":
-            optimizer = partial(minimize, method="COBYLA", options={"maxiter": 25})
-        else:
-            optimizer = None
-
-        return optimizer
-
-    def _create_callback(self, cb_flag):
-        if cb_flag:
-            history = {"weights": [], "values": []}
-
-            def callback(objective_weights, objective_value):
-                history["weights"].append(objective_weights)
-                history["values"].append(objective_value)
-
-        else:
-            history = None
-            callback = None
-        return callback, history
-
-    @idata(itertools.product(OPTIMIZERS, L1L2_ERRORS, CALLBACKS))
-    @unpack
-    def test_classifier_with_estimator_qnn(self, opt, loss, cb_flag):
-        """Test Neural Network Classifier with Estimator QNN."""
-
-        optimizer = self._create_optimizer(opt)
-        callback, history = self._create_callback(cb_flag)
-
-        num_inputs = 2
-        feature_map = ZZFeatureMap(num_inputs)
-        ansatz = RealAmplitudes(num_inputs, reps=1)
-
-        qc = QuantumCircuit(num_inputs)
-        qc.compose(feature_map, inplace=True)
-        qc.compose(ansatz, inplace=True)
-
-        qnn = EstimatorQNN(
-            circuit=qc, input_params=feature_map.parameters, weight_params=ansatz.parameters
-        )
-
-        classifier = self._create_classifier(qnn, ansatz.num_parameters, optimizer, loss, callback)
-
-        # construct data
-        num_samples = 6
-        X = algorithm_globals.random.random(  # pylint: disable=invalid-name
-            (num_samples, num_inputs)
-        )
-        y = 2.0 * (np.sum(X, axis=1) <= 1) - 1.0
-
-        # fit to data
-        classifier.fit(X, y)
-
-        # score
-        score = classifier.score(X, y)
-        self.assertGreater(score, 0.5)
-
-        self._verify_callback_values(callback, history, qnn.num_weights)
-
-        self.assertIsNotNone(classifier.fit_result)
-        self.assertIsNotNone(classifier.weights)
-        np.testing.assert_array_equal(classifier.fit_result.x, classifier.weights)
-        self.assertEqual(len(classifier.weights), ansatz.num_parameters)
-
-    def _verify_callback_values(self, callback, history, num_weights):
-        if callback is not None:
-            self.assertTrue(all(isinstance(value, float) for value in history["values"]))
-            for weights in history["weights"]:
-                self.assertEqual(len(weights), num_weights)
-                self.assertTrue(all(isinstance(weight, float) for weight in weights))
-
-    def _create_sampler_qnn(self, output_shape=2) -> tuple[SamplerQNN, int, int]:
-        num_inputs = 2
-        feature_map = ZZFeatureMap(num_inputs)
-        ansatz = RealAmplitudes(num_inputs, reps=1)
-
-        # construct circuit
-        qc = QuantumCircuit(num_inputs)
-        qc.append(feature_map, range(2))
-        qc.append(ansatz, range(2))
-
-        # construct qnn
-        def parity(x):
-            return f"{x:b}".count("1") % 2
-
-        qnn = SamplerQNN(
-            circuit=qc,
-            input_params=feature_map.parameters,
-            weight_params=ansatz.parameters,
-            sparse=False,
-            interpret=parity,
-            output_shape=output_shape,
-        )
-
-        return qnn, num_inputs, ansatz.num_parameters
-
-    def _generate_data(self, num_inputs: int) -> tuple[np.ndarray, np.ndarray]:
-        # construct data
-        num_samples = 6
-        features = algorithm_globals.random.random((num_samples, num_inputs))
-        labels = 1.0 * (np.sum(features, axis=1) <= 1)
-
-        return features, labels
-
-    def _create_classifier(
-        self,
-        qnn: NeuralNetwork,
-        num_parameters: int,
-        optimizer: Optimizer,
-        loss: str,
-        callback: Callable[[np.ndarray, float], None] | None = None,
-        one_hot: bool = False,
-    ):
-        initial_point = np.array([0.5] * num_parameters)
-
-        # construct classifier
-        classifier = NeuralNetworkClassifier(
-            qnn,
-            optimizer=optimizer,
-            loss=loss,
-            one_hot=one_hot,
-            initial_point=initial_point,
-            callback=callback,
-        )
-        return classifier
-
-    @idata(itertools.product(OPTIMIZERS, L1L2_ERRORS, CALLBACKS))
-    @unpack
-    def test_classifier_with_sampler_qnn(self, opt, loss, cb_flag):
-        """Test Neural Network Classifier with SamplerQNN."""
-
-        optimizer = self._create_optimizer(opt)
-        callback, history = self._create_callback(cb_flag)
-
-        qnn, num_inputs, num_parameters = self._create_sampler_qnn()
-
-        classifier = self._create_classifier(qnn, num_parameters, optimizer, loss, callback)
-
-        features, labels = self._generate_data(num_inputs)
-
-        # fit to data
-        classifier.fit(features, labels)
-
-        # score
-        score = classifier.score(features, labels)
-        self.assertGreater(score, 0.5)
-
-        self._verify_callback_values(callback, history, qnn.num_weights)
-
-        self.assertIsNotNone(classifier.fit_result)
-        self.assertIsNotNone(classifier.weights)
-        np.testing.assert_array_equal(classifier.fit_result.x, classifier.weights)
-        self.assertEqual(len(classifier.weights), num_parameters)
-
-    @idata(OPTIMIZERS)
-    def test_classifier_with_circuit_qnn_and_cross_entropy(self, opt):
-        """Test Neural Network Classifier with Circuit QNN and Cross Entropy loss."""
-
-        optimizer = self._create_optimizer(opt)
-        qnn, num_inputs, num_parameters = self._create_sampler_qnn()
-
-        loss = CrossEntropyLoss()
-        classifier = self._create_classifier(qnn, num_parameters, optimizer, loss, one_hot=True)
-
-        features, labels = self._generate_data(num_inputs)
-        labels = np.array([labels, 1 - labels]).transpose()
-
-        # fit to data
-        classifier.fit(features, labels)
-
-        # score
-        score = classifier.score(features, labels)
-        self.assertGreater(score, 0.5)
-
-    @data(
-        # one-hot, loss
-        (True, "absolute_error"),
-        (True, "squared_error"),
-        (True, "cross_entropy"),
-        (False, "absolute_error"),
-        (False, "squared_error"),
-    )
-    def test_categorical_data(self, config):
-        """Test categorical labels using QNN"""
-
-        one_hot, loss = config
-
-        optimizer = L_BFGS_B(maxiter=5)
-
-        qnn, num_inputs, num_parameters = self._create_sampler_qnn()
-
-        classifier = self._create_classifier(qnn, num_parameters, optimizer, loss, one_hot=one_hot)
-
-        features, labels = self._generate_data(num_inputs)
-        labels = labels.astype(str)
-        # convert to categorical
-        labels[labels == "0.0"] = "A"
-        labels[labels == "1.0"] = "B"
-
-        # fit to data
-        classifier.fit(features, labels)
-
-        # score
-        score = classifier.score(features, labels)
-        self.assertGreater(score, 0.5)
-
-        predict = classifier.predict(features[0, :])
-        self.assertIn(predict, ["A", "B"])
-
-    @idata(L1L2_ERRORS + ["cross_entropy"])
-    def test_sparse_arrays(self, loss):
-        """Tests classifier with sparse arrays as features and labels."""
-        optimizer = L_BFGS_B(maxiter=5)
-        qnn, _, num_parameters = self._create_sampler_qnn()
-        classifier = self._create_classifier(qnn, num_parameters, optimizer, loss, one_hot=True)
-
-        features = scipy.sparse.csr_matrix([[0, 0], [1, 1]])
-        labels = scipy.sparse.csr_matrix([[1, 0], [0, 1]])
-
-        # fit to data
-        classifier.fit(features, labels)
-
-        # score
-        score = classifier.score(features, labels)
-        self.assertGreater(score, 0.5)
-
-    @idata(["opflow", "circuit_qnn"])
-    def test_save_load(self, qnn_type):
-        """Tests save and load models."""
-        features = np.array([[0, 0], [0.1, 0.2], [1, 1], [0.9, 0.8]])
-
-        if qnn_type == "opflow":
-            labels = np.array([-1, -1, 1, 1])
-
-            num_qubits = 2
-            feature_map = ZZFeatureMap(num_qubits)
-            ansatz = RealAmplitudes(num_qubits, reps=1)
-            qc = QuantumCircuit(num_qubits)
-            qc.compose(feature_map, inplace=True)
-            qc.compose(ansatz, inplace=True)
-            qnn = EstimatorQNN(
-                circuit=qc,
-                input_params=feature_map.parameters,
-                weight_params=ansatz.parameters,
-            )
-            num_parameters = ansatz.num_parameters
-        elif qnn_type == "circuit_qnn":
-            labels = np.array([0, 0, 1, 1])
-            qnn, _, num_parameters = self._create_sampler_qnn()
-        else:
-            raise ValueError(f"Unsupported QNN type: {qnn_type}")
-
-        classifier = self._create_classifier(
-            qnn, num_parameters=num_parameters, optimizer=COBYLA(), loss="squared_error"
-        )
-        classifier.fit(features, labels)
-
-        # predicted labels from the newly trained model
-        test_features = np.array([[0.2, 0.1], [0.8, 0.9]])
-        original_predicts = classifier.predict(test_features)
-
-        # save/load, change the quantum instance and check if predicted values are the same
-        with tempfile.TemporaryDirectory() as dir_name:
-            file_name = os.path.join(dir_name, "classifier.model")
-            classifier.save(file_name)
-
-            classifier_load = NeuralNetworkClassifier.load(file_name)
-            loaded_model_predicts = classifier_load.predict(test_features)
-
-            np.testing.assert_array_almost_equal(original_predicts, loaded_model_predicts)
-
-            # test loading warning
-            class FakeModel(SerializableModelMixin):
-                """Fake model class for test purposes."""
-
-                pass
-
-            with self.assertRaises(TypeError):
-                FakeModel.load(file_name)
-
-    @idata((True, False))
-    def test_num_classes_data(self, one_hot):
-        """Test the number of assumed classes for one-hot and not one-hot data."""
-
-        optimizer = L_BFGS_B(maxiter=5)
-        qnn, num_inputs, num_parameters = self._create_sampler_qnn()
-        features, labels = self._generate_data(num_inputs)
-
-        if one_hot:
-            # convert to one-hot
-            labels = _one_hot_encode(labels.astype(int))
-        else:
-            # convert to categorical
-            labels = labels.astype(str)
-            labels[labels == "0.0"] = "A"
-            labels[labels == "1.0"] = "B"
-
-        classifier = self._create_classifier(
-            qnn, num_parameters, optimizer, loss="absolute_error", one_hot=one_hot
-        )
-
-        # fit to data
-        classifier.fit(features, labels)
-        num_classes = classifier.num_classes
-
-        self.assertEqual(num_classes, 2)
-
-    def test_binary_classification_with_multiclass_data(self):
-        """Test that trying to train a binary classifier with multiclass data raises an error."""
-
-        optimizer = L_BFGS_B(maxiter=5)
-        qnn, num_inputs, num_parameters = self._create_sampler_qnn(output_shape=1)
-        classifier = self._create_classifier(
-            qnn,
-            num_parameters,
-            optimizer,
-            loss="absolute_error",
-        )
-
-        # construct data
-        num_samples = 3
-        x = algorithm_globals.random.random((num_samples, num_inputs))
-        y = np.asarray([0, 1, 2])
-
-        with self.assertRaises(QiskitMachineLearningError):
-            classifier.fit(x, y)
-
-    def test_bad_binary_shape(self):
-        """Test that trying to train a binary classifier with misshaped data raises an error."""
-
-        optimizer = L_BFGS_B(maxiter=5)
-        qnn, num_inputs, num_parameters = self._create_sampler_qnn(output_shape=1)
-        classifier = self._create_classifier(
-            qnn,
-            num_parameters,
-            optimizer,
-            loss="absolute_error",
-        )
-
-        # construct data
-        num_samples = 2
-        x = algorithm_globals.random.random((num_samples, num_inputs))
-        y = np.array([[0, 1], [1, 0]])
-
-        with self.assertRaises(QiskitMachineLearningError):
-            classifier.fit(x, y)
-
-    def test_bad_one_hot_data(self):
-        """Test that trying to train a one-hot classifier with incompatible data raises an error."""
-
-        optimizer = L_BFGS_B(maxiter=5)
-        qnn, num_inputs, num_parameters = self._create_sampler_qnn(output_shape=2)
-        classifier = self._create_classifier(
-            qnn, num_parameters, optimizer, loss="absolute_error", one_hot=True
-        )
-
-        # construct data
-        num_samples = 2
-        x = algorithm_globals.random.random((num_samples, num_inputs))
-        y = np.array([[0, 1], [2, 0]])
-
-        with self.assertRaises(QiskitMachineLearningError):
-            classifier.fit(x, y)
-
-    def test_untrained(self):
-        """Test untrained classifier."""
-        qnn, _, _ = self._create_sampler_qnn()
-        classifier = NeuralNetworkClassifier(qnn)
-        with self.assertRaises(QiskitMachineLearningError, msg="classifier.predict()"):
-            classifier.predict(np.asarray([]))
-
-        with self.assertRaises(QiskitMachineLearningError, msg="classifier.fit_result"):
-            _ = classifier.fit_result
-
-        with self.assertRaises(QiskitMachineLearningError, msg="classifier.weights"):
-            _ = classifier.weights
-
-    def test_callback_setter(self):
-        """Test the callback setter."""
-        num_qubits = 2
-        feature_map = ZZFeatureMap(num_qubits)
-        ansatz = RealAmplitudes(num_qubits)
-        qc = QuantumCircuit(2)
-        qc.compose(feature_map, inplace=True)
-        qc.compose(ansatz, inplace=True)
-        qnn = EstimatorQNN(
-            circuit=qc, input_params=feature_map.parameters, weight_params=ansatz.parameters
-        )
-        single_step_opt = SPSA(maxiter=1, learning_rate=0.01, perturbation=0.1)
-        classifier = NeuralNetworkClassifier(qnn, optimizer=single_step_opt)
-
-        loss_history = []
-
-        def store_loss(_, loss):
-            loss_history.append(loss)
-
-        # use setter for the callback instead of providing in the initialize method
-        classifier.callback = store_loss
-
-        features = np.array([[0, 0], [1, 1]])
-        labels = np.array([0, 1])
-        classifier.fit(features, labels)
-
-        self.assertEqual(len(loss_history), 3)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/algorithms/classifiers/test_pegasos_qsvc.py b/test/algorithms/classifiers/test_pegasos_qsvc.py
index 937000b6a..6fcb80fea 100644
--- a/test/algorithms/classifiers/test_pegasos_qsvc.py
+++ b/test/algorithms/classifiers/test_pegasos_qsvc.py
@@ -14,22 +14,17 @@
 import os
 import tempfile
 import unittest
-import warnings
 
 from test import QiskitMachineLearningTestCase
 
 import numpy as np
-
+from qiskit.circuit.library import ZFeatureMap
+from qiskit.utils import algorithm_globals
 from sklearn.datasets import make_blobs
 from sklearn.preprocessing import MinMaxScaler
 
-from qiskit import BasicAer
-from qiskit.circuit.library import ZFeatureMap
-from qiskit.utils import QuantumInstance, algorithm_globals
 from qiskit_machine_learning.algorithms import PegasosQSVC, SerializableModelMixin
-
-from qiskit_machine_learning.kernels import QuantumKernel, FidelityQuantumKernel
-from qiskit_machine_learning.exceptions import QiskitMachineLearningError
+from qiskit_machine_learning.kernels import FidelityQuantumKernel
 
 
 class TestPegasosQSVC(QiskitMachineLearningTestCase):
@@ -37,17 +32,8 @@ class TestPegasosQSVC(QiskitMachineLearningTestCase):
 
     def setUp(self):
         super().setUp()
-        warnings.filterwarnings("ignore", category=DeprecationWarning)
-
         algorithm_globals.random_seed = 10598
 
-        self.statevector_simulator = QuantumInstance(
-            BasicAer.get_backend("statevector_simulator"),
-            shots=1,
-            seed_simulator=algorithm_globals.random_seed,
-            seed_transpiler=algorithm_globals.random_seed,
-        )
-
         # number of qubits is equal to the number of features
         self.q = 2
         # number of steps performed during the training procedure
@@ -82,15 +68,9 @@ def setUp(self):
         self.sample_test_4d = sample_4d[15:]
         self.label_test_4d = label_4d[15:]
 
-    def tearDown(self) -> None:
-        super().tearDown()
-        warnings.filterwarnings("always", category=DeprecationWarning)
-
     def test_qsvc(self):
         """Test PegasosQSVC"""
-        qkernel = QuantumKernel(
-            feature_map=self.feature_map, quantum_instance=self.statevector_simulator
-        )
+        qkernel = FidelityQuantumKernel(feature_map=self.feature_map)
 
         pegasos_qsvc = PegasosQSVC(quantum_kernel=qkernel, C=1000, num_steps=self.tau)
 
@@ -101,9 +81,7 @@ def test_qsvc(self):
 
     def test_decision_function(self):
         """Test PegasosQSVC."""
-        qkernel = QuantumKernel(
-            feature_map=self.feature_map, quantum_instance=self.statevector_simulator
-        )
+        qkernel = FidelityQuantumKernel(feature_map=self.feature_map)
 
         pegasos_qsvc = PegasosQSVC(quantum_kernel=qkernel, C=1000, num_steps=self.tau)
 
@@ -114,9 +92,7 @@ def test_decision_function(self):
 
     def test_qsvc_4d(self):
         """Test PegasosQSVC with 4-dimensional input data"""
-        qkernel = QuantumKernel(
-            feature_map=self.feature_map_4d, quantum_instance=self.statevector_simulator
-        )
+        qkernel = FidelityQuantumKernel(feature_map=self.feature_map_4d)
 
         pegasos_qsvc = PegasosQSVC(quantum_kernel=qkernel, C=1000, num_steps=self.tau)
 
@@ -126,9 +102,7 @@ def test_qsvc_4d(self):
 
     def test_precomputed_kernel(self):
         """Test PegasosQSVC with a precomputed kernel matrix"""
-        qkernel = QuantumKernel(
-            feature_map=self.feature_map, quantum_instance=self.statevector_simulator
-        )
+        qkernel = FidelityQuantumKernel(feature_map=self.feature_map)
 
         pegasos_qsvc = PegasosQSVC(C=1000, num_steps=self.tau, precomputed=True)
 
@@ -142,19 +116,9 @@ def test_precomputed_kernel(self):
 
         self.assertEqual(score, 1.0)
 
-    def test_empty_kernel(self):
-        """Test PegasosQSVC with empty QuantumKernel"""
-        qkernel = QuantumKernel()
-        pegasos_qsvc = PegasosQSVC(quantum_kernel=qkernel)
-
-        with self.assertRaises(QiskitMachineLearningError):
-            pegasos_qsvc.fit(self.sample_train, self.label_train)
-
     def test_change_kernel(self):
-        """Test QSVC with QuantumKernel later"""
-        qkernel = QuantumKernel(
-            feature_map=self.feature_map, quantum_instance=self.statevector_simulator
-        )
+        """Test QSVC with FidelityQuantumKernel later"""
+        qkernel = FidelityQuantumKernel(feature_map=self.feature_map)
 
         pegasos_qsvc = PegasosQSVC(C=1000, num_steps=self.tau)
         pegasos_qsvc.quantum_kernel = qkernel
@@ -165,9 +129,7 @@ def test_change_kernel(self):
 
     def test_labels(self):
         """Test PegasosQSVC with different integer labels than {0, 1}"""
-        qkernel = QuantumKernel(
-            feature_map=self.feature_map, quantum_instance=self.statevector_simulator
-        )
+        qkernel = FidelityQuantumKernel(feature_map=self.feature_map)
 
         pegasos_qsvc = PegasosQSVC(quantum_kernel=qkernel, C=1000, num_steps=self.tau)
 
@@ -193,11 +155,9 @@ def test_constructor(self):
             self.assertEqual(pegasos_qsvc.num_steps, 1000)
 
         with self.subTest("PegasosQSVC with QuantumKernel"):
-            qkernel = QuantumKernel(
-                feature_map=self.feature_map, quantum_instance=self.statevector_simulator
-            )
+            qkernel = FidelityQuantumKernel(feature_map=self.feature_map)
             pegasos_qsvc = PegasosQSVC(quantum_kernel=qkernel)
-            self.assertIsInstance(pegasos_qsvc.quantum_kernel, QuantumKernel)
+            self.assertIsInstance(pegasos_qsvc.quantum_kernel, FidelityQuantumKernel)
             self.assertFalse(pegasos_qsvc.precomputed)
 
         with self.subTest("PegasosQSVC with precomputed kernel"):
@@ -206,23 +166,17 @@ def test_constructor(self):
             self.assertTrue(pegasos_qsvc.precomputed)
 
         with self.subTest("PegasosQSVC with wrong parameters"):
-            qkernel = QuantumKernel(
-                feature_map=self.feature_map, quantum_instance=self.statevector_simulator
-            )
+            qkernel = FidelityQuantumKernel(feature_map=self.feature_map)
             with self.assertRaises(ValueError):
                 _ = PegasosQSVC(quantum_kernel=qkernel, precomputed=True)
 
         with self.subTest("Both kernel and precomputed are passed"):
-            qkernel = QuantumKernel(
-                feature_map=self.feature_map, quantum_instance=self.statevector_simulator
-            )
+            qkernel = FidelityQuantumKernel(feature_map=self.feature_map)
             self.assertRaises(ValueError, PegasosQSVC, quantum_kernel=qkernel, precomputed=True)
 
     def test_change_kernel_types(self):
         """Test PegasosQSVC with a precomputed kernel matrix"""
-        qkernel = QuantumKernel(
-            feature_map=self.feature_map, quantum_instance=self.statevector_simulator
-        )
+        qkernel = FidelityQuantumKernel(feature_map=self.feature_map)
 
         pegasos_qsvc = PegasosQSVC(C=1000, num_steps=self.tau, precomputed=True)
 
@@ -231,9 +185,7 @@ def test_change_kernel_types(self):
         pegasos_qsvc.fit(kernel_matrix_train, self.label_train)
 
         # now train the same instance, but with a new quantum kernel
-        pegasos_qsvc.quantum_kernel = QuantumKernel(
-            feature_map=self.feature_map, quantum_instance=self.statevector_simulator
-        )
+        pegasos_qsvc.quantum_kernel = FidelityQuantumKernel(feature_map=self.feature_map)
         pegasos_qsvc.fit(self.sample_train, self.label_train)
         score = pegasos_qsvc.score(self.sample_test, self.label_test)
 
@@ -244,9 +196,7 @@ def test_save_load(self):
         features = np.array([[0, 0], [0.1, 0.2], [1, 1], [0.9, 0.8]])
         labels = np.array([0, 0, 1, 1])
 
-        qkernel = QuantumKernel(
-            feature_map=self.feature_map, quantum_instance=self.statevector_simulator
-        )
+        qkernel = FidelityQuantumKernel(feature_map=self.feature_map)
 
         regressor = PegasosQSVC(quantum_kernel=qkernel, C=1000, num_steps=self.tau)
         regressor.fit(features, labels)
diff --git a/test/algorithms/classifiers/test_qsvc.py b/test/algorithms/classifiers/test_qsvc.py
index 60cc27c2d..243e81f8a 100644
--- a/test/algorithms/classifiers/test_qsvc.py
+++ b/test/algorithms/classifiers/test_qsvc.py
@@ -14,19 +14,16 @@
 import os
 import tempfile
 import unittest
-import warnings
 
 from test import QiskitMachineLearningTestCase
 
 import numpy as np
 
-from qiskit import BasicAer
 from qiskit.circuit.library import ZZFeatureMap
-from qiskit.utils import QuantumInstance, algorithm_globals
+from qiskit.utils import algorithm_globals
 from qiskit_machine_learning.algorithms import QSVC, SerializableModelMixin
-from qiskit_machine_learning.kernels import QuantumKernel
+from qiskit_machine_learning.kernels import FidelityQuantumKernel
 from qiskit_machine_learning.exceptions import (
-    QiskitMachineLearningError,
     QiskitMachineLearningWarning,
 )
 
@@ -36,17 +33,9 @@ class TestQSVC(QiskitMachineLearningTestCase):
 
     def setUp(self):
         super().setUp()
-        warnings.filterwarnings("ignore", category=DeprecationWarning)
 
         algorithm_globals.random_seed = 10598
 
-        self.statevector_simulator = QuantumInstance(
-            BasicAer.get_backend("statevector_simulator"),
-            shots=1,
-            seed_simulator=algorithm_globals.random_seed,
-            seed_transpiler=algorithm_globals.random_seed,
-        )
-
         self.feature_map = ZZFeatureMap(feature_dimension=2, reps=2)
 
         self.sample_train = np.asarray(
@@ -62,15 +51,9 @@ def setUp(self):
         self.sample_test = np.asarray([[2.199114860, 5.15221195], [0.50265482, 0.06283185]])
         self.label_test = np.asarray([0, 1])
 
-    def tearDown(self) -> None:
-        super().tearDown()
-        warnings.filterwarnings("always", category=DeprecationWarning)
-
     def test_qsvc(self):
         """Test QSVC"""
-        qkernel = QuantumKernel(
-            feature_map=self.feature_map, quantum_instance=self.statevector_simulator
-        )
+        qkernel = FidelityQuantumKernel(feature_map=self.feature_map)
 
         qsvc = QSVC(quantum_kernel=qkernel)
         qsvc.fit(self.sample_train, self.label_train)
@@ -78,19 +61,9 @@ def test_qsvc(self):
 
         self.assertEqual(score, 0.5)
 
-    def test_empty_kernel(self):
-        """Test QSVC with empty QuantumKernel"""
-        qkernel = QuantumKernel()
-        qsvc = QSVC(quantum_kernel=qkernel)
-
-        with self.assertRaises(QiskitMachineLearningError):
-            _ = qsvc.fit(self.sample_train, self.label_train)
-
     def test_change_kernel(self):
-        """Test QSVC with QuantumKernel later"""
-        qkernel = QuantumKernel(
-            feature_map=self.feature_map, quantum_instance=self.statevector_simulator
-        )
+        """Test QSVC with FidelityQuantumKernel later"""
+        qkernel = FidelityQuantumKernel(feature_map=self.feature_map)
 
         qsvc = QSVC()
         qsvc.quantum_kernel = qkernel
@@ -101,9 +74,7 @@ def test_change_kernel(self):
 
     def test_qsvc_parameters(self):
         """Test QSVC with extra constructor parameters"""
-        qkernel = QuantumKernel(
-            feature_map=self.feature_map, quantum_instance=self.statevector_simulator
-        )
+        qkernel = FidelityQuantumKernel(feature_map=self.feature_map)
 
         qsvc = QSVC(quantum_kernel=qkernel, tol=1e-4, C=0.5)
         qsvc.fit(self.sample_train, self.label_train)
@@ -126,9 +97,7 @@ def test_save_load(self):
         features = np.array([[0, 0], [0.1, 0.2], [1, 1], [0.9, 0.8]])
         labels = np.array([0, 0, 1, 1])
 
-        quantum_kernel = QuantumKernel(
-            feature_map=ZZFeatureMap(2), quantum_instance=self.statevector_simulator
-        )
+        quantum_kernel = FidelityQuantumKernel(feature_map=ZZFeatureMap(2))
         classifier = QSVC(quantum_kernel=quantum_kernel)
         classifier.fit(features, labels)
 
diff --git a/test/algorithms/classifiers/test_vqc.py b/test/algorithms/classifiers/test_vqc.py
index 19177fd39..d74df0d4a 100644
--- a/test/algorithms/classifiers/test_vqc.py
+++ b/test/algorithms/classifiers/test_vqc.py
@@ -20,7 +20,6 @@
 import functools
 import itertools
 import unittest
-import warnings
 
 from ddt import ddt, idata, unpack
 import numpy as np
@@ -86,14 +85,6 @@ def setUp(self):
             "no_one_hot": _create_dataset(6, 2, one_hot=False),
         }
 
-        # ignore deprecation warnings
-        warnings.filterwarnings("ignore", category=DeprecationWarning)
-
-    def tearDown(self) -> None:
-        # restore warnings
-        super().tearDown()
-        warnings.filterwarnings("always", category=DeprecationWarning)
-
     @idata(itertools.product(NUM_QUBITS_LIST, FEATURE_MAPS, ANSATZES, OPTIMIZERS, DATASETS))
     @unpack
     def test_VQC(self, num_qubits, f_m, ans, opt, d_s):
@@ -171,7 +162,7 @@ def test_warm_start(self, d_s):
         self.assertGreater(score, 0.5)
 
     def _get_num_classes(self, func):
-        """Wrapper to record the number of classes assumed when building CircuitQNN."""
+        """Wrapper to record the number of classes assumed when building SamplerQNN."""
 
         @functools.wraps(func)
         def wrapper(num_classes):
@@ -207,7 +198,7 @@ def test_batches_with_incomplete_labels(self):
         with self.subTest("Test all batches assume the correct number of classes."):
             self.assertTrue((np.asarray(num_classes_list) == 3).all())
 
-        with self.subTest("Check correct number of classes is used to build CircuitQNN."):
+        with self.subTest("Check correct number of classes is used to build SamplerQNN."):
             self.assertTrue((np.asarray(self.num_classes_by_batch) == 3).all())
 
     def test_multilabel_targets_raise_an_error(self):
diff --git a/test/algorithms/regressors/test_neural_network_regressor.py b/test/algorithms/regressors/test_neural_network_regressor.py
index 5d51d0770..5e6acdcb0 100644
--- a/test/algorithms/regressors/test_neural_network_regressor.py
+++ b/test/algorithms/regressors/test_neural_network_regressor.py
@@ -1,6 +1,6 @@
 # This code is part of a Qiskit project.
 #
-# (C) Copyright IBM 2018, 2023.
+# (C) Copyright IBM 2022, 2023.
 #
 # This code is licensed under the Apache License, Version 2.0. You may
 # obtain a copy of this license in the LICENSE.txt file in the root directory
@@ -10,13 +10,13 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 """ Test Neural Network Regressor """
+from __future__ import annotations
+
 import itertools
 import os
 import tempfile
 import unittest
-import warnings
 from functools import partial
-from typing import Tuple
 
 from test import QiskitMachineLearningTestCase
 
@@ -25,14 +25,13 @@
 from qiskit.algorithms.optimizers import COBYLA, L_BFGS_B, SPSA
 from qiskit.circuit import Parameter, QuantumCircuit
 from qiskit.circuit.library import ZZFeatureMap, RealAmplitudes
-from qiskit.opflow import PauliSumOp
-from qiskit.utils import QuantumInstance, algorithm_globals, optionals
+from qiskit.utils import algorithm_globals
 from scipy.optimize import minimize
 
 from qiskit_machine_learning import QiskitMachineLearningError
 from qiskit_machine_learning.algorithms import SerializableModelMixin
 from qiskit_machine_learning.algorithms.regressors import NeuralNetworkRegressor
-from qiskit_machine_learning.neural_networks import TwoLayerQNN
+from qiskit_machine_learning.neural_networks import EstimatorQNN
 
 QUANTUM_INSTANCES = ["statevector", "qasm"]
 OPTIMIZERS = ["cobyla", "bfgs", "callable", None]
@@ -43,26 +42,11 @@
 class TestNeuralNetworkRegressor(QiskitMachineLearningTestCase):
     """Test Neural Network Regressor."""
 
-    @unittest.skipUnless(optionals.HAS_AER, "qiskit-aer is required to run this test")
     def setUp(self):
         super().setUp()
-        warnings.filterwarnings("ignore", category=DeprecationWarning)
 
         # specify quantum instances
         algorithm_globals.random_seed = 12345
-        from qiskit_aer import Aer
-
-        self.sv_quantum_instance = QuantumInstance(
-            Aer.get_backend("aer_simulator_statevector"),
-            seed_simulator=algorithm_globals.random_seed,
-            seed_transpiler=algorithm_globals.random_seed,
-        )
-        self.qasm_quantum_instance = QuantumInstance(
-            Aer.get_backend("aer_simulator"),
-            shots=100,
-            seed_simulator=algorithm_globals.random_seed,
-            seed_transpiler=algorithm_globals.random_seed,
-        )
 
         num_samples = 20
         eps = 0.2
@@ -73,13 +57,9 @@ def setUp(self):
         self.X = (ub - lb) * rng.random((num_samples, 1)) + lb
         self.y = np.sin(self.X[:, 0]) + eps * (2 * rng.random(num_samples) - 1)
 
-    def tearDown(self) -> None:
-        super().tearDown()
-        warnings.filterwarnings("always", category=DeprecationWarning)
-
     def _create_regressor(
-        self, opt, q_i, callback=None
-    ) -> Tuple[NeuralNetworkRegressor, TwoLayerQNN, QuantumCircuit]:
+        self, opt, callback=None
+    ) -> tuple[NeuralNetworkRegressor, EstimatorQNN, QuantumCircuit]:
         num_qubits = 1
 
         # construct simple feature map
@@ -92,12 +72,9 @@ def _create_regressor(
         ansatz = QuantumCircuit(num_qubits, name="vf")
         ansatz.ry(param_y, 0)
 
-        if q_i == "statevector":
-            quantum_instance = self.sv_quantum_instance
-        elif q_i == "qasm":
-            quantum_instance = self.qasm_quantum_instance
-        else:
-            raise ValueError(f"Unsupported quantum instance: {q_i}")
+        qc = QuantumCircuit(num_qubits)
+        qc.compose(feature_map, inplace=True)
+        qc.compose(ansatz, inplace=True)
 
         if opt == "bfgs":
             optimizer = L_BFGS_B(maxiter=5)
@@ -109,27 +86,27 @@ def _create_regressor(
             optimizer = None
 
         # construct QNN
-        regression_opflow_qnn = TwoLayerQNN(
-            num_qubits, feature_map, ansatz, quantum_instance=quantum_instance
+        regression_estimator_qnn = EstimatorQNN(
+            circuit=qc, input_params=feature_map.parameters, weight_params=ansatz.parameters
         )
 
         initial_point = np.zeros(ansatz.num_parameters)
 
         # construct the regressor from the neural network
         regressor = NeuralNetworkRegressor(
-            neural_network=regression_opflow_qnn,
+            neural_network=regression_estimator_qnn,
             loss="squared_error",
             optimizer=optimizer,
             initial_point=initial_point,
             callback=callback,
         )
 
-        return regressor, regression_opflow_qnn, ansatz
+        return regressor, regression_estimator_qnn, ansatz
 
-    @idata(itertools.product(OPTIMIZERS, QUANTUM_INSTANCES, CALLBACKS))
+    @idata(itertools.product(OPTIMIZERS, CALLBACKS))
     @unpack
-    def test_regressor_with_opflow_qnn(self, opt, q_i, cb_flag):
-        """Test Neural Network Regressor with Opflow QNN (Two Layer QNN)."""
+    def test_regressor_with_estimator_qnn(self, opt, cb_flag):
+        """Test Neural Network Regressor with Estimator QNN."""
         if cb_flag:
             history = {"weights": [], "values": []}
 
@@ -140,7 +117,7 @@ def callback(objective_weights, objective_value):
         else:
             callback = None
 
-        regressor, qnn, ansatz = self._create_regressor(opt, q_i, callback)
+        regressor, qnn, ansatz = self._create_regressor(opt, callback)
 
         # fit to data
         regressor.fit(self.X, self.y)
@@ -161,11 +138,10 @@ def callback(objective_weights, objective_value):
         np.testing.assert_array_equal(regressor.fit_result.x, regressor.weights)
         self.assertEqual(len(regressor.weights), ansatz.num_parameters)
 
-    @idata(itertools.product(OPTIMIZERS, QUANTUM_INSTANCES))
-    @unpack
-    def test_warm_start(self, opt, q_i):
+    @idata(OPTIMIZERS)
+    def test_warm_start(self, opt):
         """Test VQC when training from a warm start."""
-        regressor, _, _ = self._create_regressor(opt, q_i)
+        regressor, _, _ = self._create_regressor(opt)
         regressor.warm_start = True
 
         # Fit the regressor to the first half of the data.
@@ -188,12 +164,17 @@ def test_save_load(self):
         features = np.array([[0, 0], [0.1, 0.1], [0.4, 0.4], [1, 1]])
         labels = np.array([0, 0.1, 0.4, 1])
         num_inputs = 2
-        qnn = TwoLayerQNN(
-            num_inputs,
-            feature_map=ZZFeatureMap(num_inputs),
-            ansatz=RealAmplitudes(num_inputs),
-            observable=PauliSumOp.from_list([("Z" * num_inputs, 1)]),
-            quantum_instance=self.qasm_quantum_instance,
+
+        feature_map = ZZFeatureMap(num_inputs)
+        ansatz = RealAmplitudes(num_inputs)
+        qc = QuantumCircuit(num_inputs)
+        qc.compose(feature_map, inplace=True)
+        qc.compose(ansatz, inplace=True)
+
+        qnn = EstimatorQNN(
+            circuit=qc,
+            input_params=feature_map.parameters,
+            weight_params=ansatz.parameters,
         )
         regressor = NeuralNetworkRegressor(qnn, optimizer=COBYLA())
         regressor.fit(features, labels)
@@ -223,7 +204,8 @@ class FakeModel(SerializableModelMixin):
 
     def test_untrained(self):
         """Test untrained regressor."""
-        qnn = TwoLayerQNN(2)
+        qnn = EstimatorQNN(circuit=QuantumCircuit(2))
+
         regressor = NeuralNetworkRegressor(qnn)
         with self.assertRaises(QiskitMachineLearningError, msg="regressor.predict()"):
             regressor.predict(np.asarray([]))
@@ -236,7 +218,19 @@ def test_untrained(self):
 
     def test_callback_setter(self):
         """Test the callback setter."""
-        qnn = TwoLayerQNN(2, quantum_instance=self.qasm_quantum_instance)
+        num_inputs = 2
+        feature_map = ZZFeatureMap(num_inputs)
+        ansatz = RealAmplitudes(num_inputs)
+        qc = QuantumCircuit(num_inputs)
+        qc.compose(feature_map, inplace=True)
+        qc.compose(ansatz, inplace=True)
+
+        qnn = EstimatorQNN(
+            circuit=qc,
+            input_params=feature_map.parameters,
+            weight_params=ansatz.parameters,
+        )
+
         single_step_opt = SPSA(maxiter=1, learning_rate=0.01, perturbation=0.1)
         regressor = NeuralNetworkRegressor(qnn, optimizer=single_step_opt)
 
diff --git a/test/algorithms/regressors/test_neural_network_regressor_estimator_qnn.py b/test/algorithms/regressors/test_neural_network_regressor_estimator_qnn.py
deleted file mode 100644
index 5e6acdcb0..000000000
--- a/test/algorithms/regressors/test_neural_network_regressor_estimator_qnn.py
+++ /dev/null
@@ -1,253 +0,0 @@
-# This code is part of a Qiskit project.
-#
-# (C) Copyright IBM 2022, 2023.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-""" Test Neural Network Regressor """
-from __future__ import annotations
-
-import itertools
-import os
-import tempfile
-import unittest
-from functools import partial
-
-from test import QiskitMachineLearningTestCase
-
-import numpy as np
-from ddt import ddt, unpack, idata
-from qiskit.algorithms.optimizers import COBYLA, L_BFGS_B, SPSA
-from qiskit.circuit import Parameter, QuantumCircuit
-from qiskit.circuit.library import ZZFeatureMap, RealAmplitudes
-from qiskit.utils import algorithm_globals
-from scipy.optimize import minimize
-
-from qiskit_machine_learning import QiskitMachineLearningError
-from qiskit_machine_learning.algorithms import SerializableModelMixin
-from qiskit_machine_learning.algorithms.regressors import NeuralNetworkRegressor
-from qiskit_machine_learning.neural_networks import EstimatorQNN
-
-QUANTUM_INSTANCES = ["statevector", "qasm"]
-OPTIMIZERS = ["cobyla", "bfgs", "callable", None]
-CALLBACKS = [True, False]
-
-
-@ddt
-class TestNeuralNetworkRegressor(QiskitMachineLearningTestCase):
-    """Test Neural Network Regressor."""
-
-    def setUp(self):
-        super().setUp()
-
-        # specify quantum instances
-        algorithm_globals.random_seed = 12345
-
-        num_samples = 20
-        eps = 0.2
-
-        # pylint: disable=invalid-name
-        lb, ub = -np.pi, np.pi
-        rng = np.random.default_rng(101)
-        self.X = (ub - lb) * rng.random((num_samples, 1)) + lb
-        self.y = np.sin(self.X[:, 0]) + eps * (2 * rng.random(num_samples) - 1)
-
-    def _create_regressor(
-        self, opt, callback=None
-    ) -> tuple[NeuralNetworkRegressor, EstimatorQNN, QuantumCircuit]:
-        num_qubits = 1
-
-        # construct simple feature map
-        param_x = Parameter("x")
-        feature_map = QuantumCircuit(num_qubits, name="fm")
-        feature_map.ry(param_x, 0)
-
-        # construct simple feature map
-        param_y = Parameter("y")
-        ansatz = QuantumCircuit(num_qubits, name="vf")
-        ansatz.ry(param_y, 0)
-
-        qc = QuantumCircuit(num_qubits)
-        qc.compose(feature_map, inplace=True)
-        qc.compose(ansatz, inplace=True)
-
-        if opt == "bfgs":
-            optimizer = L_BFGS_B(maxiter=5)
-        elif opt == "cobyla":
-            optimizer = COBYLA(maxiter=25)
-        elif opt == "callable":
-            optimizer = partial(minimize, method="COBYLA", options={"maxiter": 25})
-        else:
-            optimizer = None
-
-        # construct QNN
-        regression_estimator_qnn = EstimatorQNN(
-            circuit=qc, input_params=feature_map.parameters, weight_params=ansatz.parameters
-        )
-
-        initial_point = np.zeros(ansatz.num_parameters)
-
-        # construct the regressor from the neural network
-        regressor = NeuralNetworkRegressor(
-            neural_network=regression_estimator_qnn,
-            loss="squared_error",
-            optimizer=optimizer,
-            initial_point=initial_point,
-            callback=callback,
-        )
-
-        return regressor, regression_estimator_qnn, ansatz
-
-    @idata(itertools.product(OPTIMIZERS, CALLBACKS))
-    @unpack
-    def test_regressor_with_estimator_qnn(self, opt, cb_flag):
-        """Test Neural Network Regressor with Estimator QNN."""
-        if cb_flag:
-            history = {"weights": [], "values": []}
-
-            def callback(objective_weights, objective_value):
-                history["weights"].append(objective_weights)
-                history["values"].append(objective_value)
-
-        else:
-            callback = None
-
-        regressor, qnn, ansatz = self._create_regressor(opt, callback)
-
-        # fit to data
-        regressor.fit(self.X, self.y)
-
-        # score the result
-        score = regressor.score(self.X, self.y)
-        self.assertGreater(score, 0.5)
-
-        # callback
-        if callback is not None:
-            self.assertTrue(all(isinstance(value, float) for value in history["values"]))
-            for weights in history["weights"]:
-                self.assertEqual(len(weights), qnn.num_weights)
-                self.assertTrue(all(isinstance(weight, float) for weight in weights))
-
-        self.assertIsNotNone(regressor.fit_result)
-        self.assertIsNotNone(regressor.weights)
-        np.testing.assert_array_equal(regressor.fit_result.x, regressor.weights)
-        self.assertEqual(len(regressor.weights), ansatz.num_parameters)
-
-    @idata(OPTIMIZERS)
-    def test_warm_start(self, opt):
-        """Test VQC when training from a warm start."""
-        regressor, _, _ = self._create_regressor(opt)
-        regressor.warm_start = True
-
-        # Fit the regressor to the first half of the data.
-        num_start = len(self.y) // 2
-        regressor.fit(self.X[:num_start, :], self.y[:num_start])
-        first_fit_final_point = regressor.weights
-
-        # Fit the regressor to the second half of the data with a warm start.
-        regressor.fit(self.X[num_start:, :], self.y[num_start:])
-        second_fit_initial_point = regressor._initial_point
-
-        # Check the final optimization point from the first fit was used to start the second fit.
-        np.testing.assert_allclose(first_fit_final_point, second_fit_initial_point)
-
-        score = regressor.score(self.X, self.y)
-        self.assertGreater(score, 0.5)
-
-    def test_save_load(self):
-        """Tests save and load models."""
-        features = np.array([[0, 0], [0.1, 0.1], [0.4, 0.4], [1, 1]])
-        labels = np.array([0, 0.1, 0.4, 1])
-        num_inputs = 2
-
-        feature_map = ZZFeatureMap(num_inputs)
-        ansatz = RealAmplitudes(num_inputs)
-        qc = QuantumCircuit(num_inputs)
-        qc.compose(feature_map, inplace=True)
-        qc.compose(ansatz, inplace=True)
-
-        qnn = EstimatorQNN(
-            circuit=qc,
-            input_params=feature_map.parameters,
-            weight_params=ansatz.parameters,
-        )
-        regressor = NeuralNetworkRegressor(qnn, optimizer=COBYLA())
-        regressor.fit(features, labels)
-
-        # predicted labels from the newly trained model
-        test_features = np.array([[0.5, 0.5]])
-        original_predicts = regressor.predict(test_features)
-
-        # save/load, change the quantum instance and check if predicted values are the same
-        with tempfile.TemporaryDirectory() as dir_name:
-            file_name = os.path.join(dir_name, "regressor.model")
-            regressor.save(file_name)
-
-            regressor_load = NeuralNetworkRegressor.load(file_name)
-            loaded_model_predicts = regressor_load.predict(test_features)
-
-            np.testing.assert_array_almost_equal(original_predicts, loaded_model_predicts)
-
-            # test loading warning
-            class FakeModel(SerializableModelMixin):
-                """Fake model class for test purposes."""
-
-                pass
-
-            with self.assertRaises(TypeError):
-                FakeModel.load(file_name)
-
-    def test_untrained(self):
-        """Test untrained regressor."""
-        qnn = EstimatorQNN(circuit=QuantumCircuit(2))
-
-        regressor = NeuralNetworkRegressor(qnn)
-        with self.assertRaises(QiskitMachineLearningError, msg="regressor.predict()"):
-            regressor.predict(np.asarray([]))
-
-        with self.assertRaises(QiskitMachineLearningError, msg="regressor.fit_result"):
-            _ = regressor.fit_result
-
-        with self.assertRaises(QiskitMachineLearningError, msg="regressor.weights"):
-            _ = regressor.weights
-
-    def test_callback_setter(self):
-        """Test the callback setter."""
-        num_inputs = 2
-        feature_map = ZZFeatureMap(num_inputs)
-        ansatz = RealAmplitudes(num_inputs)
-        qc = QuantumCircuit(num_inputs)
-        qc.compose(feature_map, inplace=True)
-        qc.compose(ansatz, inplace=True)
-
-        qnn = EstimatorQNN(
-            circuit=qc,
-            input_params=feature_map.parameters,
-            weight_params=ansatz.parameters,
-        )
-
-        single_step_opt = SPSA(maxiter=1, learning_rate=0.01, perturbation=0.1)
-        regressor = NeuralNetworkRegressor(qnn, optimizer=single_step_opt)
-
-        loss_history = []
-
-        def store_loss(_, loss):
-            loss_history.append(loss)
-
-        # use setter for the callback instead of providing in the initialize method
-        regressor.callback = store_loss
-
-        features = np.array([[0, 0], [0.1, 0.1], [0.4, 0.4], [1, 1]])
-        labels = np.array([0, 0.1, 0.4, 1])
-        regressor.fit(features, labels)
-
-        self.assertEqual(len(loss_history), 3)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/algorithms/regressors/test_qsvr.py b/test/algorithms/regressors/test_qsvr.py
index 442d366c2..442dedb5a 100644
--- a/test/algorithms/regressors/test_qsvr.py
+++ b/test/algorithms/regressors/test_qsvr.py
@@ -14,21 +14,16 @@
 import os
 import tempfile
 import unittest
-import warnings
 
 from test import QiskitMachineLearningTestCase
 
 import numpy as np
 
-from qiskit import BasicAer
 from qiskit.circuit.library import ZZFeatureMap
-from qiskit.utils import QuantumInstance, algorithm_globals
+from qiskit.utils import algorithm_globals
 from qiskit_machine_learning.algorithms import QSVR, SerializableModelMixin
-from qiskit_machine_learning.exceptions import (
-    QiskitMachineLearningError,
-    QiskitMachineLearningWarning,
-)
-from qiskit_machine_learning.kernels import QuantumKernel
+from qiskit_machine_learning.exceptions import QiskitMachineLearningWarning
+from qiskit_machine_learning.kernels import FidelityQuantumKernel
 
 
 class TestQSVR(QiskitMachineLearningTestCase):
@@ -36,17 +31,9 @@ class TestQSVR(QiskitMachineLearningTestCase):
 
     def setUp(self):
         super().setUp()
-        warnings.filterwarnings("ignore", category=DeprecationWarning)
 
         algorithm_globals.random_seed = 10598
 
-        self.statevector_simulator = QuantumInstance(
-            BasicAer.get_backend("statevector_simulator"),
-            shots=1,
-            seed_simulator=algorithm_globals.random_seed,
-            seed_transpiler=algorithm_globals.random_seed,
-        )
-
         self.feature_map = ZZFeatureMap(feature_dimension=2, reps=2)
 
         self.sample_train = np.asarray(
@@ -62,49 +49,31 @@ def setUp(self):
         self.sample_test = np.asarray([[2.199114860, 5.15221195], [0.50265482, 0.06283185]])
         self.label_test = np.asarray([0, 1])
 
-    def tearDown(self) -> None:
-        super().tearDown()
-        warnings.filterwarnings("always", category=DeprecationWarning)
-
     def test_qsvr(self):
         """Test QSVR"""
-        qkernel = QuantumKernel(
-            feature_map=self.feature_map, quantum_instance=self.statevector_simulator
-        )
+        qkernel = FidelityQuantumKernel(feature_map=self.feature_map)
 
         qsvr = QSVR(quantum_kernel=qkernel)
         qsvr.fit(self.sample_train, self.label_train)
         score = qsvr.score(self.sample_test, self.label_test)
 
-        self.assertAlmostEqual(score, 0.38365, places=4)
-
-    def test_empty_kernel(self):
-        """Test QSVR with empty QuantumKernel"""
-        qkernel = QuantumKernel()
-        qsvr = QSVR(quantum_kernel=qkernel)
-
-        with self.assertRaises(QiskitMachineLearningError):
-            _ = qsvr.fit(self.sample_train, self.label_train)
+        self.assertAlmostEqual(score, 0.38359, places=4)
 
     def test_change_kernel(self):
         """Test QSVR with QuantumKernel later"""
-        qkernel = QuantumKernel(
-            feature_map=self.feature_map, quantum_instance=self.statevector_simulator
-        )
+        qkernel = FidelityQuantumKernel(feature_map=self.feature_map)
 
         qsvr = QSVR()
         qsvr.quantum_kernel = qkernel
         qsvr.fit(self.sample_train, self.label_train)
         score = qsvr.score(self.sample_test, self.label_test)
 
-        self.assertAlmostEqual(score, 0.38365, places=4)
+        self.assertAlmostEqual(score, 0.38359, places=4)
 
     def test_qsvr_parameters(self):
         """Test QSVR with extra constructor parameters"""
 
-        qkernel = QuantumKernel(
-            feature_map=self.feature_map, quantum_instance=self.statevector_simulator
-        )
+        qkernel = FidelityQuantumKernel(feature_map=self.feature_map)
 
         qsvr = QSVR(quantum_kernel=qkernel, tol=1e-4, C=0.5)
         qsvr.fit(self.sample_train, self.label_train)
@@ -127,9 +96,7 @@ def test_save_load(self):
         features = np.array([[0, 0], [0.1, 0.1], [0.4, 0.4], [1, 1]])
         labels = np.array([0, 0.1, 0.4, 1])
 
-        quantum_kernel = QuantumKernel(
-            feature_map=ZZFeatureMap(2), quantum_instance=self.statevector_simulator
-        )
+        quantum_kernel = FidelityQuantumKernel(feature_map=ZZFeatureMap(2))
         regressor = QSVR(quantum_kernel=quantum_kernel)
         regressor.fit(features, labels)
 
diff --git a/test/algorithms/regressors/test_vqr.py b/test/algorithms/regressors/test_vqr.py
index b8a11a61b..0f69341f4 100644
--- a/test/algorithms/regressors/test_vqr.py
+++ b/test/algorithms/regressors/test_vqr.py
@@ -19,7 +19,6 @@
 from qiskit.algorithms.optimizers import COBYLA, L_BFGS_B
 from qiskit.circuit import Parameter, QuantumCircuit
 from qiskit.circuit.library import ZZFeatureMap, RealAmplitudes
-from qiskit.opflow import StateFn
 from qiskit.primitives import Estimator
 from qiskit.utils import algorithm_globals
 
@@ -117,8 +116,6 @@ def test_incorrect_observable(self):
         """Test VQR with a wrong observable."""
         with self.assertRaises(ValueError):
             _ = VQR(num_qubits=2, observable=QuantumCircuit(2))
-        with self.assertRaises(ValueError):
-            _ = VQR(num_qubits=2, observable=StateFn(QuantumCircuit(2)))
 
 
 if __name__ == "__main__":
diff --git a/test/circuit/library/test_raw_feature_vector.py b/test/circuit/library/test_raw_feature_vector.py
index 3653896e2..72263c43f 100644
--- a/test/circuit/library/test_raw_feature_vector.py
+++ b/test/circuit/library/test_raw_feature_vector.py
@@ -55,7 +55,7 @@ def test_fully_bound(self):
         params = np.random.random(8) + 1j * np.random.random(8)
         params /= np.linalg.norm(params)
 
-        bound = circuit.bind_parameters(params)
+        bound = circuit.assign_parameters(params)
 
         ref = QuantumCircuit(3)
         ref.initialize(params, ref.qubits)
@@ -128,7 +128,7 @@ def test_bind_after_composition(self):
         raw = RawFeatureVector(4)
         circuit.append(raw, [0, 1])
 
-        bound = circuit.bind_parameters([1, 0, 0, 0])
+        bound = circuit.assign_parameters([1, 0, 0, 0])
 
         self.assertTrue(Statevector.from_label("00").equiv(bound))
 
diff --git a/test/connectors/test_cpu_torch_connector.py b/test/connectors/test_cpu_torch_connector.py
index 86c234af4..5dc52f7f1 100644
--- a/test/connectors/test_cpu_torch_connector.py
+++ b/test/connectors/test_cpu_torch_connector.py
@@ -27,10 +27,6 @@ def setUp(self):
 
         self._device = torch.device("cpu")
 
-    def tearDown(self) -> None:
-        super().tear_down()
-        super().tearDown()
-
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/test/connectors/test_cpu_torch_networks.py b/test/connectors/test_cpu_torch_networks.py
index a2147a477..3200c9d2b 100644
--- a/test/connectors/test_cpu_torch_networks.py
+++ b/test/connectors/test_cpu_torch_networks.py
@@ -27,10 +27,6 @@ def setUp(self):
 
         self._device = torch.device("cpu")
 
-    def tearDown(self) -> None:
-        super().tearDown()
-        super().tear_down()
-
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/test/connectors/test_gpu_torch_connector.py b/test/connectors/test_gpu_torch_connector.py
index 78fe1d771..8958f0250 100644
--- a/test/connectors/test_gpu_torch_connector.py
+++ b/test/connectors/test_gpu_torch_connector.py
@@ -32,10 +32,6 @@ def setUp(self):
         else:
             self._device = torch.device("cuda")
 
-    def tearDown(self) -> None:
-        super().tearDown()
-        super().tear_down()
-
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/test/connectors/test_gpu_torch_networks.py b/test/connectors/test_gpu_torch_networks.py
index 3838a4364..a63622671 100644
--- a/test/connectors/test_gpu_torch_networks.py
+++ b/test/connectors/test_gpu_torch_networks.py
@@ -31,10 +31,6 @@ def setUp(self):
         else:
             self._device = torch.device("cuda")
 
-    def tearDown(self) -> None:
-        super().tearDown()
-        super().tear_down()
-
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/test/connectors/test_torch.py b/test/connectors/test_torch.py
index 6e3f0bc4a..75f74a3c5 100644
--- a/test/connectors/test_torch.py
+++ b/test/connectors/test_torch.py
@@ -14,9 +14,8 @@
 
 import unittest
 import builtins
-import warnings
 from abc import ABC, abstractmethod
-from qiskit.utils import QuantumInstance, algorithm_globals, optionals
+from qiskit.utils import algorithm_globals
 import qiskit_machine_learning.optionals as _optionals
 
 
@@ -28,37 +27,15 @@ def __init__(self):
         self._sv_quantum_instance = None
         self._qasm_quantum_instance = None
 
-    @unittest.skipUnless(optionals.HAS_AER, "qiskit-aer is required to run this test")
     @unittest.skipUnless(_optionals.HAS_TORCH, "PyTorch not available.")
     def setup_test(self):
         """Base setup."""
-        # suppress warnings from the deprecated networks
-        warnings.filterwarnings("ignore", category=DeprecationWarning)
 
         algorithm_globals.random_seed = 12345
-        # specify quantum instances
-        from qiskit_aer import Aer, AerSimulator
-
-        self._sv_quantum_instance = QuantumInstance(
-            Aer.get_backend("aer_simulator_statevector"),
-            seed_simulator=algorithm_globals.random_seed,
-            seed_transpiler=algorithm_globals.random_seed,
-        )
-        # pylint: disable=no-member
-        self._qasm_quantum_instance = QuantumInstance(
-            AerSimulator(),
-            shots=100,
-            seed_simulator=algorithm_globals.random_seed,
-            seed_transpiler=algorithm_globals.random_seed,
-        )
         import torch
 
         torch.manual_seed(algorithm_globals.random_seed)
 
-    def tear_down(self):
-        """Tear down the test."""
-        warnings.filterwarnings("always", category=DeprecationWarning)
-
     @abstractmethod
     def subTest(self, msg, **kwargs):
         # pylint: disable=invalid-name
diff --git a/test/connectors/test_torch_connector.py b/test/connectors/test_torch_connector.py
index f849ab622..eeb526dc5 100644
--- a/test/connectors/test_torch_connector.py
+++ b/test/connectors/test_torch_connector.py
@@ -11,30 +11,20 @@
 # that they have been altered from the originals.
 
 """Test Torch Connector."""
-import builtins
 import itertools
-import sys
-from typing import List, cast
+from typing import cast
 
 from test.connectors.test_torch import TestTorch
 
 import numpy as np
 from ddt import ddt, data, unpack, idata
 from qiskit import QuantumCircuit
-from qiskit.circuit import Parameter
-from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap, ZFeatureMap
-from qiskit.opflow import StateFn, ListOp, PauliSumOp
+from qiskit.circuit.library import RealAmplitudes, ZFeatureMap
 from qiskit.quantum_info import SparsePauliOp
 
 from qiskit_machine_learning import QiskitMachineLearningError
 from qiskit_machine_learning.connectors import TorchConnector
-from qiskit_machine_learning.neural_networks import (
-    CircuitQNN,
-    TwoLayerQNN,
-    OpflowQNN,
-    SamplerQNN,
-    EstimatorQNN,
-)
+from qiskit_machine_learning.neural_networks import SamplerQNN, EstimatorQNN
 
 
 @ddt
@@ -54,59 +44,6 @@ def setup_test(self):
             torch.tensor([[[1.0], [2.0]], [[3.0], [4.0]]]),
         ]
 
-    def _validate_output_shape(self, model: TorchConnector, test_data: List) -> None:
-        """Creates a Linear PyTorch module with the same in/out dimensions as the given model,
-        applies the list of test input data to both, and asserts that they have the same
-        output shape.
-
-        Args:
-            model: model to be tested
-            test_data: list of test input tensors
-
-        Raises:
-            QiskitMachineLearningError: Invalid input.
-        """
-        from torch.nn import Linear
-
-        # create benchmark model
-        in_dim = model.neural_network.num_inputs
-        if len(model.neural_network.output_shape) != 1:
-            raise QiskitMachineLearningError("Function only works for one dimensional output")
-        out_dim = model.neural_network.output_shape[0]
-        # we target our tests to either cpu or gpu
-        linear = Linear(in_dim, out_dim, device=self._device)
-        model.to(self._device)
-
-        # iterate over test data and validate behavior of model
-        for x in test_data:
-            x = x.to(self._device)
-            # test linear model and track whether it failed or store the output shape
-            c_worked = True
-            try:
-                c_shape = linear(x).shape
-            except builtins.Exception:  # pylint: disable=broad-except
-                c_worked = False
-
-            # test quantum model and track whether it failed or store the output shape
-            q_worked = True
-            try:
-                output = model(x)
-
-                # check output is sparse
-                model_sparse = model.sparse if model.sparse else False
-                self.assertEqual(output.is_sparse, model_sparse)
-
-                q_shape = output.shape
-            except builtins.Exception:  # pylint: disable=broad-except
-                q_worked = False
-
-            # compare results and assert that the behavior is equal
-            with self.subTest("c_worked == q_worked", tensor=x):
-                self.assertEqual(c_worked, q_worked)
-            if c_worked and q_worked:
-                with self.subTest("c_shape == q_shape", tensor=x):
-                    self.assertEqual(c_shape, q_shape)
-
     def _validate_backward_automatically(self, model: TorchConnector) -> None:
         """Uses PyTorch to validate the backward pass / autograd.
 
@@ -136,484 +73,6 @@ def _validate_backward_automatically(self, model: TorchConnector) -> None:
         test = torch.autograd.gradcheck(func, input_data, eps=1e-4, atol=1e-3)  # type: ignore
         self.assertTrue(test)
 
-    @data("sv", "qasm")
-    def test_opflow_qnn_1_1(self, q_i):
-        """Test Torch Connector + Opflow QNN with input/output dimension 1/1."""
-        if q_i == "sv":
-            quantum_instance = self._sv_quantum_instance
-        else:
-            quantum_instance = self._qasm_quantum_instance
-
-        # construct simple feature map
-        param_x = Parameter("x")
-        feature_map = QuantumCircuit(1, name="fm")
-        feature_map.ry(param_x, 0)
-
-        # construct simple feature map
-        param_y = Parameter("y")
-        ansatz = QuantumCircuit(1, name="vf")
-        ansatz.ry(param_y, 0)
-
-        # construct QNN with statevector simulator
-        qnn = TwoLayerQNN(
-            1, feature_map, ansatz, quantum_instance=quantum_instance, input_gradients=True
-        )
-        model = TorchConnector(qnn)
-
-        # test model
-        self._validate_output_shape(model, self._test_data)
-        if q_i == "sv":
-            self._validate_backward_automatically(model)
-
-    @data("sv", "qasm")
-    def test_opflow_qnn_2_1(self, q_i):
-        """Test Torch Connector + Opflow QNN with input/output dimension 2/1."""
-
-        if q_i == "sv":
-            quantum_instance = self._sv_quantum_instance
-        else:
-            quantum_instance = self._qasm_quantum_instance
-
-        # construct QNN
-        qnn = TwoLayerQNN(2, quantum_instance=quantum_instance, input_gradients=True)
-        model = TorchConnector(qnn)
-
-        # test model
-        self._validate_output_shape(model, self._test_data)
-        if q_i == "sv":
-            self._validate_backward_automatically(model)
-
-    @data("sv", "qasm")
-    def test_opflow_qnn_2_2(self, q_i):
-        """Test Torch Connector + Opflow QNN with input/output dimension 2/2."""
-
-        if q_i == "sv":
-            quantum_instance = self._sv_quantum_instance
-        else:
-            quantum_instance = self._qasm_quantum_instance
-
-        # construct parametrized circuit
-        params_1 = [Parameter("input1"), Parameter("weight1")]
-        qc_1 = QuantumCircuit(1)
-        qc_1.h(0)
-        qc_1.ry(params_1[0], 0)
-        qc_1.rx(params_1[1], 0)
-        qc_sfn_1 = StateFn(qc_1)
-
-        # construct cost operator
-        h_1 = StateFn(PauliSumOp.from_list([("Z", 1.0), ("X", 1.0)]))
-
-        # combine operator and circuit to objective function
-        op_1 = ~h_1 @ qc_sfn_1
-
-        # construct parametrized circuit
-        params_2 = [Parameter("input2"), Parameter("weight2")]
-        qc_2 = QuantumCircuit(1)
-        qc_2.h(0)
-        qc_2.ry(params_2[0], 0)
-        qc_2.rx(params_2[1], 0)
-        qc_sfn_2 = StateFn(qc_2)
-
-        # construct cost operator
-        h_2 = StateFn(PauliSumOp.from_list([("Z", 1.0), ("X", 1.0)]))
-
-        # combine operator and circuit to objective function
-        op_2 = ~h_2 @ qc_sfn_2
-
-        op = ListOp([op_1, op_2])
-
-        qnn = OpflowQNN(
-            op,
-            [params_1[0], params_2[0]],
-            [params_1[1], params_2[1]],
-            quantum_instance=quantum_instance,
-            input_gradients=True,
-        )
-        model = TorchConnector(qnn)
-
-        # test model
-        self._validate_output_shape(model, self._test_data)
-        if q_i == "sv":
-            self._validate_backward_automatically(model)
-
-    @data(
-        # interpret, output_shape, sparse, quantum_instance
-        (None, None, False, "sv"),
-        (None, None, True, "sv"),
-        (lambda x: np.sum(x) % 2, 2, False, "sv"),
-        (lambda x: np.sum(x) % 2, 2, True, "sv"),
-        (None, None, False, "qasm"),
-        (None, None, True, "qasm"),
-        (lambda x: np.sum(x) % 2, 2, False, "qasm"),
-        (lambda x: np.sum(x) % 2, 2, True, "qasm"),
-    )
-    @unpack
-    def test_circuit_qnn_1_1(self, interpret, output_shape, sparse, q_i):
-        """Torch Connector + Circuit QNN with no interpret, dense output,
-        and input/output shape 1/1 ."""
-
-        if q_i == "sv":
-            quantum_instance = self._sv_quantum_instance
-        else:
-            quantum_instance = self._qasm_quantum_instance
-
-        qc = QuantumCircuit(1)
-
-        # construct simple feature map
-        param_x = Parameter("x")
-        qc.ry(param_x, 0)
-
-        # construct simple feature map
-        param_y = Parameter("y")
-        qc.ry(param_y, 0)
-
-        qnn = CircuitQNN(
-            qc,
-            [param_x],
-            [param_y],
-            sparse=sparse,
-            sampling=False,
-            interpret=interpret,
-            output_shape=output_shape,
-            quantum_instance=quantum_instance,
-            input_gradients=True,
-        )
-        if sparse and sys.version_info < (3, 8):
-            with self.assertRaises(QiskitMachineLearningError):
-                _ = TorchConnector(qnn, sparse=sparse)
-        else:
-            model = TorchConnector(qnn, sparse=sparse)
-
-            # test model
-            self._validate_output_shape(model, self._test_data)
-            if q_i == "sv":
-                self._validate_backward_automatically(model)
-
-    @data(
-        # interpret, output_shape, sparse, quantum_instance
-        (None, None, False, "sv"),
-        (None, None, True, "sv"),
-        (lambda x: np.sum(x) % 2, 2, False, "sv"),
-        (lambda x: np.sum(x) % 2, 2, True, "sv"),
-        (None, None, False, "qasm"),
-        (None, None, True, "qasm"),
-        (lambda x: np.sum(x) % 2, 2, False, "qasm"),
-        (lambda x: np.sum(x) % 2, 2, True, "qasm"),
-    )
-    @unpack
-    def test_circuit_qnn_1_8(self, interpret, output_shape, sparse, q_i):
-        """Torch Connector + Circuit QNN with no interpret, dense output,
-        and input/output shape 1/8 ."""
-
-        if q_i == "sv":
-            quantum_instance = self._sv_quantum_instance
-        else:
-            quantum_instance = self._qasm_quantum_instance
-
-        qc = QuantumCircuit(3)
-
-        # construct simple feature map
-        param_x = Parameter("x")
-        qc.ry(param_x, range(3))
-
-        # construct simple feature map
-        param_y = Parameter("y")
-        qc.ry(param_y, range(3))
-
-        qnn = CircuitQNN(
-            qc,
-            [param_x],
-            [param_y],
-            sparse=sparse,
-            sampling=False,
-            interpret=interpret,
-            output_shape=output_shape,
-            quantum_instance=quantum_instance,
-            input_gradients=True,
-        )
-        if sparse and sys.version_info < (3, 8):
-            with self.assertRaises(QiskitMachineLearningError):
-                _ = TorchConnector(qnn, sparse=sparse)
-        else:
-            model = TorchConnector(qnn, sparse=sparse)
-
-            # test model
-            self._validate_output_shape(model, self._test_data)
-            if q_i == "sv":
-                self._validate_backward_automatically(model)
-
-    @data(
-        # interpret, output_shape, sparse, quantum_instance
-        (None, None, False, "sv"),
-        (None, None, True, "sv"),
-        (lambda x: np.sum(x) % 2, 2, False, "sv"),
-        (lambda x: np.sum(x) % 2, 2, True, "sv"),
-        (None, None, False, "qasm"),
-        (None, None, True, "qasm"),
-        (lambda x: np.sum(x) % 2, 2, False, "qasm"),
-        (lambda x: np.sum(x) % 2, 2, True, "qasm"),
-    )
-    @unpack
-    def test_circuit_qnn_2_4(self, interpret, output_shape, sparse, q_i):
-        """Torch Connector + Circuit QNN with no interpret, dense output,
-        and input/output shape 1/8 ."""
-
-        if q_i == "sv":
-            quantum_instance = self._sv_quantum_instance
-        else:
-            quantum_instance = self._qasm_quantum_instance
-
-        qc = QuantumCircuit(2)
-
-        # construct simple feature map
-        param_x_1, param_x_2 = Parameter("x1"), Parameter("x2")
-        qc.ry(param_x_1, range(2))
-        qc.ry(param_x_2, range(2))
-
-        # construct simple feature map
-        param_y = Parameter("y")
-        qc.ry(param_y, range(2))
-
-        qnn = CircuitQNN(
-            qc,
-            [param_x_1, param_x_2],
-            [param_y],
-            sparse=sparse,
-            sampling=False,
-            interpret=interpret,
-            output_shape=output_shape,
-            quantum_instance=quantum_instance,
-            input_gradients=True,
-        )
-        if sparse and sys.version_info < (3, 8):
-            with self.assertRaises(QiskitMachineLearningError):
-                _ = TorchConnector(qnn, sparse=sparse)
-        else:
-            model = TorchConnector(qnn, sparse=sparse)
-
-            # test model
-            self._validate_output_shape(model, self._test_data)
-            if q_i == "sv":
-                self._validate_backward_automatically(model)
-
-    def test_circuit_qnn_without_parameters(self):
-        """Tests CircuitQNN without parameters."""
-        quantum_instance = self._sv_quantum_instance
-        qc = QuantumCircuit(2)
-        param_y = Parameter("y")
-        qc.ry(param_y, range(2))
-
-        qnn = CircuitQNN(
-            circuit=qc,
-            input_params=[param_y],
-            sparse=False,
-            quantum_instance=quantum_instance,
-            input_gradients=True,
-        )
-        model = TorchConnector(qnn)
-        self._validate_backward_automatically(model)
-
-        qnn = CircuitQNN(
-            circuit=qc,
-            weight_params=[param_y],
-            sparse=False,
-            quantum_instance=quantum_instance,
-            input_gradients=True,
-        )
-        model = TorchConnector(qnn)
-        self._validate_backward_automatically(model)
-
-    @data(
-        # interpret
-        (None),
-        (lambda x: np.sum(x) % 2),
-    )
-    def test_circuit_qnn_sampling(self, interpret):
-        """Test Torch Connector + Circuit QNN for sampling."""
-        from torch import Tensor
-
-        qc = QuantumCircuit(2)
-
-        # construct simple feature map
-        param_x1, param_x2 = Parameter("x1"), Parameter("x2")
-        qc.ry(param_x1, range(2))
-        qc.ry(param_x2, range(2))
-
-        # construct simple feature map
-        param_y = Parameter("y")
-        qc.ry(param_y, range(2))
-
-        qnn = CircuitQNN(
-            qc,
-            [param_x1, param_x2],
-            [param_y],
-            sparse=False,
-            sampling=True,
-            interpret=interpret,
-            output_shape=None,
-            quantum_instance=self._qasm_quantum_instance,
-            input_gradients=True,
-        )
-        model = TorchConnector(qnn)
-        model.to(self._device)
-
-        test_data = [Tensor([2, 2]), Tensor([[1, 1], [2, 2]])]
-        for i, x in enumerate(test_data):
-            x = x.to(self._device)
-            if i == 0:
-                self.assertEqual(model(x).shape, qnn.output_shape)
-            else:
-                shape = model(x).shape
-                self.assertEqual(shape, (len(x), *qnn.output_shape))
-
-    def test_opflow_qnn_batch_gradients(self):
-        """Test backward pass for batch input."""
-        import torch
-
-        # construct random data set
-        num_inputs = 2
-        num_samples = 10
-        x = np.random.rand(num_samples, num_inputs)
-
-        # set up QNN
-        qnn = TwoLayerQNN(
-            num_qubits=num_inputs,
-            quantum_instance=self._sv_quantum_instance,
-        )
-
-        # set up PyTorch module
-        initial_weights = np.random.rand(qnn.num_weights)
-        model = TorchConnector(qnn, initial_weights=initial_weights)
-        model.to(self._device)
-
-        # test single gradient
-        w = model.weight.detach().cpu().numpy()
-        res_qnn = qnn.forward(x[0, :], w)
-
-        # construct finite difference gradient for weight
-        eps = 1e-4
-        grad = np.zeros(w.shape)
-        for k in range(len(w)):
-            delta = np.zeros(w.shape)
-            delta[k] += eps
-
-            f_1 = qnn.forward(x[0, :], w + delta)
-            f_2 = qnn.forward(x[0, :], w - delta)
-
-            grad[k] = (f_1 - f_2) / (2 * eps)
-
-        grad_qnn = qnn.backward(x[0, :], w)[1][0, 0, :]
-        self.assertAlmostEqual(np.linalg.norm(grad - grad_qnn), 0.0, places=4)
-
-        model.zero_grad()
-        res_model = model(torch.tensor(x[0, :], device=self._device))
-        self.assertAlmostEqual(
-            np.linalg.norm(res_model.detach().cpu().numpy() - res_qnn[0]), 0.0, places=4
-        )
-        res_model.backward()
-        grad_model = model.weight.grad
-        self.assertAlmostEqual(
-            np.linalg.norm(grad_model.detach().cpu().numpy() - grad_qnn), 0.0, places=4
-        )
-
-        # test batch input
-        batch_grad = np.zeros((*w.shape, num_samples, 1))
-        for k in range(len(w)):
-            delta = np.zeros(w.shape)
-            delta[k] += eps
-
-            f_1 = qnn.forward(x, w + delta)
-            f_2 = qnn.forward(x, w - delta)
-
-            batch_grad[k] = (f_1 - f_2) / (2 * eps)
-
-        batch_grad = np.sum(batch_grad, axis=1)
-        batch_grad_qnn = np.sum(qnn.backward(x, w)[1], axis=0)
-        self.assertAlmostEqual(
-            np.linalg.norm(batch_grad - batch_grad_qnn.transpose()), 0.0, places=4
-        )
-
-        model.zero_grad()
-        batch_res_model = sum(model(torch.tensor(x, device=self._device)))
-        batch_res_model.backward()
-        self.assertAlmostEqual(
-            np.linalg.norm(model.weight.grad.detach().cpu().numpy() - batch_grad.transpose()[0]),
-            0.0,
-            places=4,
-        )
-
-    @data(
-        # output_shape, interpret
-        (4, None),
-        (2, lambda x: f"{x:b}".count("1") % 2),
-    )
-    @unpack
-    def test_circuit_qnn_batch_gradients(self, output_shape, interpret):
-        """Test batch gradient computation of CircuitQNN gives the same result as the sum of
-        individual gradients."""
-        import torch
-        from torch.nn import MSELoss
-        from torch.optim import SGD
-
-        num_inputs = 2
-
-        feature_map = ZZFeatureMap(num_inputs)
-        ansatz = RealAmplitudes(num_inputs, entanglement="linear", reps=1)
-
-        qc = QuantumCircuit(num_inputs)
-        qc.append(feature_map, range(num_inputs))
-        qc.append(ansatz, range(num_inputs))
-
-        qnn = CircuitQNN(
-            qc,
-            input_params=feature_map.parameters,
-            weight_params=ansatz.parameters,
-            interpret=interpret,
-            output_shape=output_shape,
-            quantum_instance=self._sv_quantum_instance,
-        )
-
-        # set up PyTorch module
-        initial_weights = np.array([0.1] * qnn.num_weights)
-        model = TorchConnector(qnn, initial_weights)
-        model.to(self._device)
-
-        # random data set
-        x = torch.rand(5, 2)
-        y = torch.rand(5, output_shape)
-
-        # define optimizer and loss
-        optimizer = SGD(model.parameters(), lr=0.1)
-        f_loss = MSELoss(reduction="sum")
-
-        sum_of_individual_losses = 0.0
-        for x_i, y_i in zip(x, y):
-            x_i = x_i.to(self._device)
-            y_i = y_i.to(self._device)
-            output = model(x_i)
-            sum_of_individual_losses += f_loss(output, y_i)
-        optimizer.zero_grad()
-        sum_of_individual_losses.backward()
-        sum_of_individual_gradients = model.weight.grad.detach().cpu()
-
-        x = x.to(self._device)
-        y = y.to(self._device)
-        output = model(x)
-        batch_loss = f_loss(output, y)
-        optimizer.zero_grad()
-        batch_loss.backward()
-        batch_gradients = model.weight.grad.detach().cpu()
-
-        self.assertAlmostEqual(
-            np.linalg.norm(sum_of_individual_gradients - batch_gradients), 0.0, places=4
-        )
-
-        self.assertAlmostEqual(
-            sum_of_individual_losses.detach().cpu().numpy(),
-            batch_loss.detach().cpu().numpy(),
-            places=4,
-        )
-
     def _validate_forward(self, model: TorchConnector):
         import torch
 
@@ -639,6 +98,11 @@ def _validate_forward(self, model: TorchConnector):
 
             np.testing.assert_almost_equal(connector_output.numpy(), qnn_output)
 
+        # test with a wrong input size
+        wrong_input = torch.rand((1, model.neural_network.num_inputs + 1))
+        with self.assertRaises(QiskitMachineLearningError):
+            model(wrong_input)
+
     def _validate_backward(self, model: TorchConnector):
         import torch
 
diff --git a/test/connectors/test_torch_networks.py b/test/connectors/test_torch_networks.py
index 1e7d1eda5..52530c830 100644
--- a/test/connectors/test_torch_networks.py
+++ b/test/connectors/test_torch_networks.py
@@ -19,13 +19,7 @@
 
 from qiskit import QuantumCircuit
 from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap
-from qiskit_machine_learning.neural_networks import (
-    CircuitQNN,
-    TwoLayerQNN,
-    NeuralNetwork,
-    EstimatorQNN,
-    SamplerQNN,
-)
+from qiskit_machine_learning.neural_networks import NeuralNetwork, EstimatorQNN, SamplerQNN
 from qiskit_machine_learning.connectors import TorchConnector
 
 
@@ -59,42 +53,6 @@ def forward(self, x):
 
         return Net()
 
-    def _create_circuit_qnn(self) -> CircuitQNN:
-        output_shape = 2
-        num_inputs = 2
-
-        def interpret(x):
-            return f"{x:b}".count("1") % 2
-
-        feature_map = ZZFeatureMap(num_inputs)
-        ansatz = RealAmplitudes(num_inputs, entanglement="linear", reps=1)
-
-        qc = QuantumCircuit(num_inputs)
-        qc.append(feature_map, range(num_inputs))
-        qc.append(ansatz, range(num_inputs))
-
-        qnn = CircuitQNN(
-            qc,
-            input_params=feature_map.parameters,
-            weight_params=ansatz.parameters,
-            input_gradients=True,  # for hybrid qnn
-            interpret=interpret,
-            output_shape=output_shape,
-            quantum_instance=self._sv_quantum_instance,
-        )
-        return qnn
-
-    def _create_opflow_qnn(self) -> TwoLayerQNN:
-        num_inputs = 2
-
-        # set up QNN
-        qnn = TwoLayerQNN(
-            num_qubits=num_inputs,
-            quantum_instance=self._sv_quantum_instance,
-            input_gradients=True,  # for hybrid qnn
-        )
-        return qnn
-
     def _create_estimator_qnn(self) -> EstimatorQNN:
         num_inputs = 2
 
@@ -137,21 +95,15 @@ def interpret(x):
         )
         return qnn
 
-    @idata(["opflow", "circuit_qnn", "sampler_qnn", "estimator_qnn"])
+    @idata(["sampler_qnn", "estimator_qnn"])
     def test_hybrid_batch_gradients(self, qnn_type: str):
         """Test gradient back-prop for batch input in a qnn."""
         import torch
         from torch.nn import MSELoss
         from torch.optim import SGD
 
-        qnn: Optional[Union[CircuitQNN, TwoLayerQNN, SamplerQNN, EstimatorQNN]] = None
-        if qnn_type == "opflow":
-            qnn = self._create_opflow_qnn()
-            output_size = 1
-        elif qnn_type == "circuit_qnn":
-            qnn = self._create_circuit_qnn()
-            output_size = 2
-        elif qnn_type == "sampler_qnn":
+        qnn: Optional[Union[SamplerQNN, EstimatorQNN]] = None
+        if qnn_type == "sampler_qnn":
             qnn = self._create_sampler_qnn()
             output_size = 2
         elif qnn_type == "estimator_qnn":
diff --git a/test/kernels/algorithms/test_fidelity_qkernel_trainer.py b/test/kernels/algorithms/test_fidelity_qkernel_trainer.py
index cab006d2d..92e6329fb 100644
--- a/test/kernels/algorithms/test_fidelity_qkernel_trainer.py
+++ b/test/kernels/algorithms/test_fidelity_qkernel_trainer.py
@@ -100,6 +100,22 @@ def test_fit_with_params(self, trainable_kernel_type):
 
         self._fit_and_assert_score(qkt_result)
 
+    @data(
+        TrainableFidelityQuantumKernel,
+        TrainableFidelityStatevectorKernel,
+    )
+    def test_fit_with_no_params(self, trainable_kernel_type):
+        """Test trainer with custom parameters."""
+        quantum_kernel = trainable_kernel_type(
+            feature_map=self.feature_map,
+            training_parameters=None,
+        )
+        loss = SVCLoss(C=0.8, gamma="auto")
+        optimizer = partial(minimize, method="COBYLA", options={"maxiter": 25})
+        qkt = QuantumKernelTrainer(quantum_kernel=quantum_kernel, loss=loss, optimizer=optimizer)
+        with self.assertRaises(ValueError):
+            qkt.fit(self.sample_train, self.label_train)
+
     @data(
         TrainableFidelityQuantumKernel,
         TrainableFidelityStatevectorKernel,
diff --git a/test/kernels/algorithms/test_qkernel_trainer.py b/test/kernels/algorithms/test_qkernel_trainer.py
deleted file mode 100644
index 00bfa327a..000000000
--- a/test/kernels/algorithms/test_qkernel_trainer.py
+++ /dev/null
@@ -1,104 +0,0 @@
-# This code is part of a Qiskit project.
-#
-# (C) Copyright IBM 2021, 2023.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-""" Test QuantumKernelTrainer """
-import unittest
-import warnings
-from functools import partial
-
-from test import QiskitMachineLearningTestCase
-
-import numpy as np
-from qiskit.circuit.library import ZZFeatureMap
-from qiskit.utils import algorithm_globals, optionals
-from scipy.optimize import minimize
-
-from qiskit_machine_learning.algorithms.classifiers import QSVC
-from qiskit_machine_learning.kernels import QuantumKernel
-from qiskit_machine_learning.kernels.algorithms import QuantumKernelTrainer
-from qiskit_machine_learning.utils.loss_functions import SVCLoss
-
-
-class TestQuantumKernelTrainer(QiskitMachineLearningTestCase):
-    """Test QuantumKernelTrainer Algorithm"""
-
-    @unittest.skipUnless(optionals.HAS_AER, "qiskit-aer is required to run this test")
-    def setUp(self):
-        super().setUp()
-        warnings.filterwarnings("ignore", category=DeprecationWarning)
-        algorithm_globals.random_seed = 10598
-        # pylint: disable=no-member
-        from qiskit_aer import AerSimulator
-
-        self.backend = AerSimulator(method="statevector")
-        data_block = ZZFeatureMap(2)
-        trainable_block = ZZFeatureMap(2, parameter_prefix="θ")
-        training_parameters = trainable_block.parameters
-
-        self.feature_map = data_block.compose(trainable_block).compose(data_block)
-        self.training_parameters = training_parameters
-
-        self.sample_train = np.asarray(
-            [
-                [3.07876080, 1.75929189],
-                [6.03185789, 5.27787566],
-                [6.22035345, 2.70176968],
-                [0.18849556, 2.82743339],
-            ]
-        )
-        self.label_train = np.asarray([0, 0, 1, 1])
-
-        self.sample_test = np.asarray([[2.199114860, 5.15221195], [0.50265482, 0.06283185]])
-        self.label_test = np.asarray([1, 0])
-
-        self.quantum_kernel = QuantumKernel(
-            feature_map=self.feature_map,
-            training_parameters=self.training_parameters,
-            quantum_instance=self.backend,
-        )
-
-    def tearDown(self) -> None:
-        super().tearDown()
-        warnings.filterwarnings("always", category=DeprecationWarning)
-
-    def test_default_fit(self):
-        """Test trainer with default parameters."""
-        qkt = QuantumKernelTrainer(quantum_kernel=self.quantum_kernel)
-        qkt_result = qkt.fit(self.sample_train, self.label_train)
-
-        # Ensure kernel training functions and is deterministic
-        qsvc = QSVC(quantum_kernel=qkt_result.quantum_kernel)
-        qsvc.fit(self.sample_train, self.label_train)
-        score = qsvc.score(self.sample_test, self.label_test)
-        self.assertGreaterEqual(score, 0.5)
-
-    def test_fit_with_params(self):
-        """Test trainer with custom parameters."""
-        loss = SVCLoss(C=0.8, gamma="auto")
-        optimizer = partial(minimize, method="COBYLA", options={"maxiter": 25})
-        qkt = QuantumKernelTrainer(
-            quantum_kernel=self.quantum_kernel, loss=loss, optimizer=optimizer
-        )
-        qkt_result = qkt.fit(self.sample_train, self.label_train)
-
-        # Ensure user parameters are bound to real values
-        self.assertEqual(len(qkt_result.quantum_kernel.get_unbound_training_parameters()), 0)
-
-        # Ensure kernel training functions and is deterministic
-        qsvc = QSVC(quantum_kernel=qkt_result.quantum_kernel)
-        qsvc.fit(self.sample_train, self.label_train)
-        score = qsvc.score(self.sample_test, self.label_test)
-        self.assertGreaterEqual(score, 0.5)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/kernels/test_fidelity_statevector_kernel.py b/test/kernels/test_fidelity_statevector_kernel.py
index 8eabbc5aa..f15b396b8 100644
--- a/test/kernels/test_fidelity_statevector_kernel.py
+++ b/test/kernels/test_fidelity_statevector_kernel.py
@@ -15,6 +15,7 @@
 
 import functools
 import itertools
+import sys
 import unittest
 
 from test import QiskitMachineLearningTestCase
@@ -126,7 +127,9 @@ def test_enforce_psd(self):
             # all eigenvalues are non-negative with some tolerance
             self.assertTrue(np.all(np.greater_equal(w, -1e-10)))
 
+    # todo: enable the test on macOS when fixed: https://github.com/Qiskit/qiskit-aer/issues/1886
     @unittest.skipUnless(optionals.HAS_AER, "qiskit-aer is required to run this test")
+    @unittest.skipIf(sys.platform.startswith("darwin"), "macOS is not supported")
     def test_aer_statevector(self):
         """Test statevector kernel when using AerStatevector type statevectors."""
         from qiskit_aer.quantum_info import AerStatevector
diff --git a/test/kernels/test_new_vs_old_kernel.py b/test/kernels/test_new_vs_old_kernel.py
deleted file mode 100644
index 4a81ced0e..000000000
--- a/test/kernels/test_new_vs_old_kernel.py
+++ /dev/null
@@ -1,96 +0,0 @@
-# This code is part of a Qiskit project.
-#
-# (C) Copyright IBM 2021, 2023.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-"""Test primitive-based quantum kernel versus the original implementation."""
-
-from __future__ import annotations
-
-import itertools
-import warnings
-
-from test import QiskitMachineLearningTestCase
-
-import numpy as np
-from ddt import ddt, idata, unpack
-from qiskit import BasicAer
-from qiskit.circuit.library import ZFeatureMap, ZZFeatureMap
-from qiskit.utils import algorithm_globals, QuantumInstance
-
-from qiskit_machine_learning.kernels import QuantumKernel
-from qiskit_machine_learning.kernels import FidelityQuantumKernel
-
-
-@ddt
-class TestNewVsOldQuantumKernel(QiskitMachineLearningTestCase):
-    """
-    Test new quantum kernel versus the old one. The old one is evaluated on a statevector
-    simulator. To be removed when old quantum kernel is removed.
-    """
-
-    def setUp(self):
-        super().setUp()
-        warnings.filterwarnings("ignore", category=DeprecationWarning)
-        algorithm_globals.random_seed = 10598
-
-        self.statevector_simulator = QuantumInstance(BasicAer.get_backend("statevector_simulator"))
-        self.properties = {
-            "z1": ZFeatureMap(1),
-            "z2": ZFeatureMap(2),
-            "zz2": ZZFeatureMap(2),
-            "z4": ZFeatureMap(4),
-            "zz4": ZZFeatureMap(4),
-        }
-
-    def tearDown(self) -> None:
-        super().tearDown()
-        warnings.filterwarnings("always", category=DeprecationWarning)
-
-    @idata(
-        itertools.product(
-            ["z1", "z2", "zz2", "z4", "zz4"],
-            [True, False],
-            ["none", "off_diagonal", "all"],
-        )
-    )
-    @unpack
-    def test_new_vs_old(self, feature_map_name, enforce_psd, duplicates):
-        """Test new versus old."""
-        feature_map = self.properties[feature_map_name]
-        features = algorithm_globals.random.random((10, feature_map.num_qubits))
-        # add some duplicates
-        features = np.concatenate((features, features[0, :].reshape(1, -1)))
-
-        new_qk = FidelityQuantumKernel(
-            feature_map=feature_map,
-            enforce_psd=enforce_psd,
-            evaluate_duplicates=duplicates,
-        )
-        old_qk = QuantumKernel(
-            feature_map,
-            enforce_psd=enforce_psd,
-            quantum_instance=self.statevector_simulator,
-            evaluate_duplicates=duplicates,
-        )
-
-        new_matrix = new_qk.evaluate(features)
-        old_matrix = old_qk.evaluate(features)
-
-        np.testing.assert_almost_equal(new_matrix, old_matrix)
-
-        # test asymmetric case
-        unseen_features = algorithm_globals.random.random((5, feature_map.num_qubits))
-        # add some duplicates from the seen features
-        unseen_features = np.concatenate((unseen_features, features[0, :].reshape(1, -1)))
-
-        new_matrix = new_qk.evaluate(features, unseen_features)
-        old_matrix = old_qk.evaluate(features, unseen_features)
-
-        np.testing.assert_almost_equal(new_matrix, old_matrix)
diff --git a/test/kernels/test_new_vs_old_kernel_sv.py b/test/kernels/test_new_vs_old_kernel_sv.py
deleted file mode 100644
index 5eb50d061..000000000
--- a/test/kernels/test_new_vs_old_kernel_sv.py
+++ /dev/null
@@ -1,91 +0,0 @@
-# This code is part of a Qiskit project.
-#
-# (C) Copyright IBM 2023.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-"""Test statevector kernel versus the original quantum kernel implementation."""
-
-from __future__ import annotations
-
-import itertools
-import warnings
-
-from test import QiskitMachineLearningTestCase
-
-import numpy as np
-from ddt import ddt, idata, unpack
-from qiskit import BasicAer
-from qiskit.circuit.library import ZFeatureMap, ZZFeatureMap
-from qiskit.utils import algorithm_globals, QuantumInstance
-
-from qiskit_machine_learning.kernels import QuantumKernel, FidelityStatevectorKernel
-
-
-@ddt
-class TestNewVsOldFidelityStatevectorKernel(QiskitMachineLearningTestCase):
-    """
-    Test new statevector kernel versus the old QuantumKernel evaluated on a statevector simulator.
-    To be removed when old quantum kernel is removed.
-    """
-
-    def setUp(self):
-        super().setUp()
-        warnings.filterwarnings("ignore", category=DeprecationWarning)
-        algorithm_globals.random_seed = 10598
-
-        self.statevector_simulator = QuantumInstance(BasicAer.get_backend("statevector_simulator"))
-        self.properties = {
-            "z1": ZFeatureMap(1),
-            "z2": ZFeatureMap(2),
-            "zz2": ZZFeatureMap(2),
-            "z4": ZFeatureMap(4),
-            "zz4": ZZFeatureMap(4),
-        }
-
-    def tearDown(self) -> None:
-        super().tearDown()
-        warnings.filterwarnings("always", category=DeprecationWarning)
-
-    @idata(
-        itertools.product(
-            ["z1", "z2", "zz2", "z4", "zz4"],
-            ["none", "off_diagonal", "all"],
-        )
-    )
-    @unpack
-    def test_new_vs_old(self, feature_map_name, duplicates):
-        """Test new versus old."""
-        feature_map = self.properties[feature_map_name]
-        features = algorithm_globals.random.random((10, feature_map.num_qubits))
-        # add some duplicates
-        features = np.concatenate((features, features[0, :].reshape(1, -1)))
-
-        new_qk = FidelityStatevectorKernel(
-            feature_map=feature_map,
-        )
-        old_qk = QuantumKernel(
-            feature_map,
-            quantum_instance=self.statevector_simulator,
-            evaluate_duplicates=duplicates,
-        )
-
-        new_matrix = new_qk.evaluate(features)
-        old_matrix = old_qk.evaluate(features)
-
-        np.testing.assert_almost_equal(new_matrix, old_matrix)
-
-        # test asymmetric case
-        unseen_features = algorithm_globals.random.random((5, feature_map.num_qubits))
-        # add some duplicates from the seen features
-        unseen_features = np.concatenate((unseen_features, features[0, :].reshape(1, -1)))
-
-        new_matrix = new_qk.evaluate(features, unseen_features)
-        old_matrix = old_qk.evaluate(features, unseen_features)
-
-        np.testing.assert_almost_equal(new_matrix, old_matrix)
diff --git a/test/kernels/test_qkernel.py b/test/kernels/test_qkernel.py
deleted file mode 100644
index d025a35d5..000000000
--- a/test/kernels/test_qkernel.py
+++ /dev/null
@@ -1,877 +0,0 @@
-# This code is part of a Qiskit project.
-#
-# (C) Copyright IBM 2021, 2023.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-""" Test QuantumKernel """
-
-import functools
-import unittest
-import warnings
-
-from test import QiskitMachineLearningTestCase
-
-import numpy as np
-from ddt import data, ddt, idata, unpack
-from qiskit import BasicAer, QuantumCircuit
-from qiskit.circuit import Parameter
-from qiskit.circuit.library import ZZFeatureMap, ZFeatureMap
-from qiskit.transpiler import PassManagerConfig
-from qiskit.transpiler.preset_passmanagers import level_1_pass_manager
-from qiskit.utils import QuantumInstance, algorithm_globals, optionals
-from sklearn.svm import SVC
-
-from qiskit_machine_learning.algorithms import QSVC
-from qiskit_machine_learning.exceptions import QiskitMachineLearningError
-from qiskit_machine_learning.kernels import QuantumKernel
-
-
-@ddt
-class TestQuantumKernelClassify(QiskitMachineLearningTestCase):
-    """Test QuantumKernel for Classification using SKLearn"""
-
-    def setUp(self):
-        super().setUp()
-        warnings.filterwarnings("ignore", category=DeprecationWarning)
-        algorithm_globals.random_seed = 10598
-
-        self.statevector_simulator = QuantumInstance(
-            BasicAer.get_backend("statevector_simulator"),
-            shots=1,
-            seed_simulator=algorithm_globals.random_seed,
-            seed_transpiler=algorithm_globals.random_seed,
-        )
-
-        self.feature_map = ZZFeatureMap(feature_dimension=2, reps=2)
-
-        self.sample_train = np.asarray(
-            [
-                [3.07876080, 1.75929189],
-                [6.03185789, 5.27787566],
-                [6.22035345, 2.70176968],
-                [0.18849556, 2.82743339],
-            ]
-        )
-        self.label_train = np.asarray([0, 0, 1, 1])
-
-        self.sample_test = np.asarray([[2.199114860, 5.15221195], [0.50265482, 0.06283185]])
-        self.label_test = np.asarray([0, 1])
-
-    def tearDown(self) -> None:
-        super().tearDown()
-        warnings.filterwarnings("always", category=DeprecationWarning)
-
-    def test_callable(self):
-        """Test callable kernel in sklearn"""
-        kernel = QuantumKernel(
-            feature_map=self.feature_map, quantum_instance=self.statevector_simulator
-        )
-
-        svc = SVC(kernel=kernel.evaluate)
-        svc.fit(self.sample_train, self.label_train)
-        score = svc.score(self.sample_test, self.label_test)
-
-        self.assertEqual(score, 0.5)
-
-    def test_precomputed(self):
-        """Test precomputed kernel in sklearn"""
-        kernel = QuantumKernel(
-            feature_map=self.feature_map, quantum_instance=self.statevector_simulator
-        )
-
-        kernel_train = kernel.evaluate(x_vec=self.sample_train)
-        kernel_test = kernel.evaluate(x_vec=self.sample_test, y_vec=self.sample_train)
-
-        svc = SVC(kernel="precomputed")
-        svc.fit(kernel_train, self.label_train)
-        score = svc.score(kernel_test, self.label_test)
-
-        self.assertEqual(score, 0.5)
-
-    # pylint: disable=no-member
-    @unittest.skipUnless(optionals.HAS_AER, "qiskit-aer is required to run this test")
-    @data("aer_simulator", "statevector_simulator")
-    def test_custom_pass_manager(self, backend_name):
-        """Test quantum kernel with a custom pass manager."""
-        if backend_name == "aer_simulator":
-            from qiskit_aer import AerSimulator
-
-            backend = AerSimulator()
-        else:
-            backend = BasicAer.get_backend(backend_name)
-
-        quantum_instance = QuantumInstance(
-            backend,
-            shots=100,
-            seed_simulator=algorithm_globals.random_seed,
-            seed_transpiler=algorithm_globals.random_seed,
-            pass_manager=level_1_pass_manager(PassManagerConfig(basis_gates=["u3", "cx"])),
-            bound_pass_manager=level_1_pass_manager(PassManagerConfig(basis_gates=["u3", "cx"])),
-        )
-
-        kernel = QuantumKernel(feature_map=self.feature_map, quantum_instance=quantum_instance)
-
-        svc = SVC(kernel=kernel.evaluate)
-        svc.fit(self.sample_train, self.label_train)
-        score = svc.score(self.sample_test, self.label_test)
-
-        self.assertEqual(score, 0.5)
-
-
-class TestQuantumKernelEvaluate(QiskitMachineLearningTestCase):
-    """Test QuantumKernel Evaluate Method"""
-
-    def setUp(self):
-        super().setUp()
-        warnings.filterwarnings("ignore", category=DeprecationWarning)
-
-        algorithm_globals.random_seed = 10598
-        self.shots = 12000
-
-        self.qasm_simulator = QuantumInstance(
-            BasicAer.get_backend("qasm_simulator"),
-            shots=self.shots,
-            seed_simulator=algorithm_globals.random_seed,
-            seed_transpiler=algorithm_globals.random_seed,
-        )
-        self.qasm_sample = QuantumInstance(
-            BasicAer.get_backend("qasm_simulator"),
-            shots=10,
-            seed_simulator=algorithm_globals.random_seed,
-            seed_transpiler=algorithm_globals.random_seed,
-        )
-        self.statevector_simulator = QuantumInstance(
-            BasicAer.get_backend("statevector_simulator"),
-            shots=1,
-            seed_simulator=algorithm_globals.random_seed,
-            seed_transpiler=algorithm_globals.random_seed,
-        )
-
-        self.feature_map = ZZFeatureMap(feature_dimension=2, reps=2)
-
-        self.sample_train = np.asarray(
-            [
-                [2.95309709, 2.51327412],
-                [3.14159265, 4.08407045],
-                [4.08407045, 2.26194671],
-                [4.46106157, 2.38761042],
-            ]
-        )
-
-        self.sample_test = np.asarray([[3.83274304, 2.45044227], [3.89557489, 0.31415927]])
-
-        self.sample_feature_dim = np.asarray([[1, 2, 3], [4, 5, 6]])
-        self.sample_more_dim = np.asarray([[[0, 0], [1, 1]]])
-
-        self.ref_kernel_train = {
-            "one_dim": np.array([[1.0]]),
-            "qasm": np.array(
-                [
-                    [1.000000, 0.856583, 0.120417, 0.358833],
-                    [0.856583, 1.000000, 0.113167, 0.449250],
-                    [0.120417, 0.113167, 1.000000, 0.671500],
-                    [0.358833, 0.449250, 0.671500, 1.000000],
-                ]
-            ),
-            "statevector": np.array(
-                [
-                    [1.00000000, 0.85342280, 0.12267747, 0.36334379],
-                    [0.85342280, 1.00000000, 0.11529017, 0.45246347],
-                    [0.12267747, 0.11529017, 1.00000000, 0.67137258],
-                    [0.36334379, 0.45246347, 0.67137258, 1.00000000],
-                ]
-            ),
-            "qasm_sample": np.array(
-                [
-                    [1.0, 0.9, 0.1, 0.4],
-                    [0.9, 1.0, 0.1, 0.6],
-                    [0.1, 0.1, 1.0, 0.9],
-                    [0.4, 0.6, 0.9, 1.0],
-                ]
-            ),
-            "qasm_sample_psd": np.array(
-                [
-                    [1.004036, 0.891664, 0.091883, 0.410062],
-                    [0.891664, 1.017215, 0.116764, 0.579220],
-                    [0.091883, 0.116764, 1.016324, 0.879765],
-                    [0.410062, 0.579220, 0.879765, 1.025083],
-                ]
-            ),
-        }
-
-        self.ref_kernel_test = {
-            "one_y_dim": np.array([[0.144395], [0.181701], [0.474796], [0.146918]]),
-            "one_xy_dim": np.array([[0.144395]]),
-            "qasm": np.array(
-                [
-                    [0.140667, 0.327833],
-                    [0.177750, 0.371750],
-                    [0.467833, 0.018417],
-                    [0.143333, 0.156750],
-                ]
-            ),
-            "statevector": np.array(
-                [
-                    [0.14439530, 0.33041779],
-                    [0.18170069, 0.37663733],
-                    [0.47479649, 0.02115561],
-                    [0.14691763, 0.16106199],
-                ]
-            ),
-        }
-
-    def tearDown(self) -> None:
-        super().tearDown()
-        warnings.filterwarnings("always", category=DeprecationWarning)
-
-    def test_qasm_symmetric(self):
-        """Test symmetric matrix evaluation using qasm simulator"""
-        qkclass = QuantumKernel(feature_map=self.feature_map, quantum_instance=self.qasm_simulator)
-
-        kernel = qkclass.evaluate(x_vec=self.sample_train)
-
-        np.testing.assert_allclose(kernel, self.ref_kernel_train["qasm"], rtol=1e-4)
-
-    def test_qasm_unsymmetric(self):
-        """Test unsymmetric matrix evaluation using qasm simulator"""
-        qkclass = QuantumKernel(feature_map=self.feature_map, quantum_instance=self.qasm_simulator)
-
-        kernel = qkclass.evaluate(x_vec=self.sample_train, y_vec=self.sample_test)
-
-        np.testing.assert_allclose(kernel, self.ref_kernel_test["qasm"], rtol=1e-4)
-
-    def test_sv_symmetric(self):
-        """Test symmetric matrix evaluation using state vector simulator"""
-        qkclass = QuantumKernel(
-            feature_map=self.feature_map, quantum_instance=self.statevector_simulator
-        )
-
-        kernel = qkclass.evaluate(x_vec=self.sample_train)
-
-        np.testing.assert_allclose(kernel, self.ref_kernel_train["statevector"], rtol=1e-4)
-
-    def test_sv_unsymmetric(self):
-        """Test unsymmetric matrix evaluation using state vector simulator"""
-        qkclass = QuantumKernel(
-            feature_map=self.feature_map, quantum_instance=self.statevector_simulator
-        )
-
-        kernel = qkclass.evaluate(x_vec=self.sample_train, y_vec=self.sample_test)
-
-        np.testing.assert_allclose(kernel, self.ref_kernel_test["statevector"], rtol=1e-4)
-
-    def test_qasm_nopsd(self):
-        """Test symmetric matrix qasm sample no positive semi-definite enforcement"""
-        qkclass = QuantumKernel(
-            feature_map=self.feature_map,
-            quantum_instance=self.qasm_sample,
-            enforce_psd=False,
-        )
-
-        kernel = qkclass.evaluate(x_vec=self.sample_train)
-
-        np.testing.assert_allclose(kernel, self.ref_kernel_train["qasm_sample"], rtol=1e-4)
-
-    def test_qasm_psd(self):
-        """Test symmetric matrix positive semi-definite enforcement qasm sample"""
-        qkclass = QuantumKernel(feature_map=self.feature_map, quantum_instance=self.qasm_sample)
-
-        kernel = qkclass.evaluate(x_vec=self.sample_train)
-
-        np.testing.assert_allclose(kernel, self.ref_kernel_train["qasm_sample_psd"], rtol=1e-4)
-
-    def test_x_one_dim(self):
-        """Test one x_vec dimension"""
-        qkclass = QuantumKernel(
-            feature_map=self.feature_map, quantum_instance=self.statevector_simulator
-        )
-
-        kernel = qkclass.evaluate(x_vec=self.sample_train[0])
-
-        np.testing.assert_allclose(kernel, self.ref_kernel_train["one_dim"], rtol=1e-4)
-
-    def test_y_one_dim(self):
-        """Test one y_vec dimension"""
-        qkclass = QuantumKernel(
-            feature_map=self.feature_map, quantum_instance=self.statevector_simulator
-        )
-
-        kernel = qkclass.evaluate(x_vec=self.sample_train, y_vec=self.sample_test[0])
-
-        np.testing.assert_allclose(kernel, self.ref_kernel_test["one_y_dim"], rtol=1e-4)
-
-    def test_xy_one_dim(self):
-        """Test one y_vec dimension"""
-        qkclass = QuantumKernel(
-            feature_map=self.feature_map, quantum_instance=self.statevector_simulator
-        )
-
-        kernel = qkclass.evaluate(x_vec=self.sample_train[0], y_vec=self.sample_test[0])
-
-        np.testing.assert_allclose(kernel, self.ref_kernel_test["one_xy_dim"], rtol=1e-4)
-
-    def test_no_backend(self):
-        """Test no backend provided"""
-        qkclass = QuantumKernel(feature_map=self.feature_map)
-
-        with self.assertRaises(QiskitMachineLearningError):
-            _ = qkclass.evaluate(x_vec=self.sample_train)
-
-    def test_x_more_dim(self):
-        """Test incorrect x_vec dimension"""
-        qkclass = QuantumKernel(feature_map=self.feature_map, quantum_instance=self.qasm_simulator)
-
-        with self.assertRaises(ValueError):
-            _ = qkclass.evaluate(x_vec=self.sample_more_dim)
-
-    def test_y_more_dim(self):
-        """Test incorrect y_vec dimension"""
-        qkclass = QuantumKernel(feature_map=self.feature_map, quantum_instance=self.qasm_simulator)
-
-        with self.assertRaises(ValueError):
-            _ = qkclass.evaluate(x_vec=self.sample_train, y_vec=self.sample_more_dim)
-
-    def test_y_feature_dim(self):
-        """Test incorrect y_vec feature dimension"""
-        qkclass = QuantumKernel(feature_map=self.feature_map, quantum_instance=self.qasm_simulator)
-
-        with self.assertRaises(ValueError):
-            _ = qkclass.evaluate(x_vec=self.sample_train, y_vec=self.sample_feature_dim)
-
-    def test_adjust_feature_map(self):
-        """Test adjust feature map"""
-        qkclass = QuantumKernel(
-            feature_map=ZZFeatureMap(feature_dimension=3), quantum_instance=self.qasm_simulator
-        )
-        _ = qkclass.evaluate(x_vec=self.sample_train, y_vec=self.sample_test)
-
-    def test_fail_adjust_feature_map(self):
-        """Test feature map adjustment failed"""
-        feature_map = QuantumCircuit(3)
-        qkclass = QuantumKernel(feature_map=feature_map, quantum_instance=self.qasm_simulator)
-        with self.assertRaises(ValueError):
-            _ = qkclass.evaluate(x_vec=self.sample_train, y_vec=self.sample_test)
-
-
-class TestQuantumKernelConstructCircuit(QiskitMachineLearningTestCase):
-    """Test QuantumKernel ConstructCircuit Method"""
-
-    def setUp(self):
-        super().setUp()
-        warnings.filterwarnings("ignore", category=DeprecationWarning)
-
-        self.x = [1, 1]
-        self.y = [2, 2]
-        self.z = [3]
-
-        self.feature_map = ZZFeatureMap(feature_dimension=2, reps=1)
-
-    def tearDown(self) -> None:
-        super().tearDown()
-        warnings.filterwarnings("always", category=DeprecationWarning)
-
-    def _check_circuit(self, qc: QuantumCircuit, check_measurements: bool, check_inverse: bool):
-        self.assertEqual(qc.num_qubits, self.feature_map.num_qubits)
-
-        # check that there are two feature maps
-        self.assertTrue(qc.data[0][0].name.startswith(self.feature_map.name))
-        self.assertTrue(qc.data[1][0].name.startswith(self.feature_map.name))
-
-        # check that there are measurement operations in the circuit
-        if check_measurements:
-            original_depth = qc.depth()
-            qc.remove_final_measurements()
-            self.assertNotEqual(original_depth, qc.depth())
-
-        # check that there are two feature maps: plain and plain dagger (inverse)
-        if check_inverse:
-            self.assertEqual(qc.data[1][0].definition, qc.data[0][0].definition.inverse())
-
-    def test_innerproduct(self):
-        """Test inner product"""
-        qkclass = QuantumKernel(feature_map=self.feature_map)
-        qc = qkclass.construct_circuit(self.x, self.y)
-        self._check_circuit(qc, check_measurements=True, check_inverse=False)
-
-    def test_selfinnerproduct(self):
-        """Test self inner product"""
-        qkclass = QuantumKernel(feature_map=self.feature_map)
-        qc = qkclass.construct_circuit(self.x)
-        self._check_circuit(qc, check_measurements=True, check_inverse=True)
-
-    def test_innerproduct_nomeasurement(self):
-        """Test inner product no measurement"""
-        qkclass = QuantumKernel(feature_map=self.feature_map)
-        qc = qkclass.construct_circuit(self.x, self.y, measurement=False)
-        self._check_circuit(qc, check_measurements=False, check_inverse=False)
-
-    def test_selfinnerprodect_nomeasurement(self):
-        """Test self inner product no measurement"""
-        qkclass = QuantumKernel(feature_map=self.feature_map)
-        qc = qkclass.construct_circuit(self.x, measurement=False)
-        self._check_circuit(qc, check_measurements=False, check_inverse=True)
-
-    def test_statevector(self):
-        """Test state vector simulator"""
-        qkclass = QuantumKernel(feature_map=self.feature_map)
-        qc = qkclass.construct_circuit(self.x, is_statevector_sim=True)
-
-        self.assertEqual(qc.num_qubits, self.feature_map.num_qubits)
-
-        # check that there's a feature map in the circuit
-        self.assertTrue(qc.data[0][0].name.startswith(self.feature_map.name))
-
-    def test_xdim(self):
-        """Test incorrect x dimension"""
-        qkclass = QuantumKernel(feature_map=self.feature_map)
-
-        with self.assertRaises(ValueError):
-            _ = qkclass.construct_circuit(self.z)
-
-    def test_ydim(self):
-        """Test incorrect y dimension"""
-        qkclass = QuantumKernel(feature_map=self.feature_map)
-
-        with self.assertRaises(ValueError):
-            _ = qkclass.construct_circuit(self.x, self.z)
-
-
-class TestQuantumKernelTrainingParameters(QiskitMachineLearningTestCase):
-    """Test QuantumKernel training parameter support"""
-
-    def setUp(self):
-        super().setUp()
-        warnings.filterwarnings("ignore", category=DeprecationWarning)
-
-        # Create an arbitrary 3-qubit feature map circuit
-        circ1 = ZZFeatureMap(3)
-        circ2 = ZZFeatureMap(3, parameter_prefix="θ")
-        training_params = circ2.parameters
-
-        self.feature_map = circ1.compose(circ2).compose(circ1)
-        self.training_parameters = training_params
-
-        self.statevector_simulator = QuantumInstance(
-            BasicAer.get_backend("statevector_simulator"),
-            shots=1,
-            seed_simulator=algorithm_globals.random_seed,
-            seed_transpiler=algorithm_globals.random_seed,
-        )
-
-        self.sample_train = np.asarray(
-            [
-                [3.07876080, 1.75929189],
-                [6.03185789, 5.27787566],
-                [6.22035345, 2.70176968],
-                [0.18849556, 2.82743339],
-            ]
-        )
-        self.label_train = np.asarray([0, 0, 1, 1])
-
-    def tearDown(self) -> None:
-        super().tearDown()
-        warnings.filterwarnings("always", category=DeprecationWarning)
-
-    def test_training_parameters(self):
-        """Test assigning/re-assigning user parameters"""
-
-        with self.subTest("check basic instantiation"):
-            # Ensure we can instantiate a QuantumKernel with user parameters
-            qkclass = QuantumKernel(
-                feature_map=self.feature_map, training_parameters=self.training_parameters
-            )
-            self.assertEqual(qkclass.training_parameters, self.training_parameters)
-
-        with self.subTest("test invalid parameter assignment"):
-            # Instantiate a QuantumKernel
-            qkclass = QuantumKernel(
-                feature_map=self.feature_map, training_parameters=self.training_parameters
-            )
-
-            # Try to set the user parameters using an incorrect number of values
-            training_param_values = [2.0, 4.0, 6.0, 8.0]
-            with self.assertRaises(ValueError):
-                qkclass.assign_training_parameters(training_param_values)
-
-            self.assertEqual(qkclass.get_unbound_training_parameters(), qkclass.training_parameters)
-
-        with self.subTest("test parameter assignment"):
-            # Assign params to some new values, and also test the bind_training_parameters interface
-            param_binds = {
-                self.training_parameters[0]: 0.1,
-                self.training_parameters[1]: 0.2,
-                self.training_parameters[2]: 0.3,
-            }
-            qkclass.bind_training_parameters(param_binds)
-
-            # Ensure the values are properly bound
-            self.assertEqual(
-                list(qkclass.training_parameter_binds.values()), list(param_binds.values())
-            )
-            self.assertEqual(qkclass.get_unbound_training_parameters(), [])
-            self.assertEqual(
-                list(qkclass.training_parameter_binds.keys()), qkclass.training_parameters
-            )
-
-        with self.subTest("test partial parameter assignment"):
-            # Assign params to some new values, and also test the bind_training_parameters interface
-            param_binds = {self.training_parameters[0]: 0.5, self.training_parameters[1]: 0.4}
-            qkclass.bind_training_parameters(param_binds)
-
-            # Ensure values were properly bound and param 2 was unchanged
-            self.assertEqual(list(qkclass.training_parameter_binds.values()), [0.5, 0.4, 0.3])
-            self.assertEqual(qkclass.get_unbound_training_parameters(), [])
-            self.assertEqual(
-                list(qkclass.training_parameter_binds.keys()), qkclass.training_parameters
-            )
-
-        with self.subTest("test unassign and assign to parameter expression"):
-            param_binds = {
-                self.training_parameters[0]: self.training_parameters[0],
-                self.training_parameters[1]: self.training_parameters[0]
-                + self.training_parameters[2],
-                self.training_parameters[2]: self.training_parameters[2],
-            }
-            qkclass.assign_training_parameters(param_binds)
-
-            # Ensure quantum kernel forgets unused param 1 and unbinds param 0 and 2
-            self.assertEqual(
-                list(qkclass.training_parameter_binds.keys()),
-                [self.training_parameters[0], self.training_parameters[2]],
-            )
-            self.assertEqual(
-                list(qkclass.training_parameter_binds.keys()),
-                list(qkclass.training_parameter_binds.values()),
-            )
-            self.assertEqual(
-                list(qkclass.training_parameter_binds.keys()), qkclass.training_parameters
-            )
-
-        with self.subTest("test immediate reassignment to parameter expression"):
-            # Create a new quantum kernel
-            qkclass = QuantumKernel(
-                feature_map=self.feature_map, training_parameters=self.training_parameters
-            )
-            # Create a new parameter
-            new_param = Parameter("0[n]")
-
-            # Create partial param binds with immediate reassignments to param expressions
-            param_binds = {
-                self.training_parameters[0]: new_param,
-                self.training_parameters[1]: self.training_parameters[0]
-                + self.training_parameters[2],
-            }
-            qkclass.assign_training_parameters(param_binds)
-
-            self.assertEqual(
-                list(qkclass.training_parameter_binds.keys()),
-                [new_param, self.training_parameters[0], self.training_parameters[2]],
-            )
-            self.assertEqual(
-                list(qkclass.training_parameter_binds.keys()),
-                list(qkclass.training_parameter_binds.values()),
-            )
-            self.assertEqual(
-                list(qkclass.training_parameter_binds.keys()), qkclass.training_parameters
-            )
-
-        with self.subTest("test bringing back old parameters"):
-            param_binds = {
-                new_param: self.training_parameters[1] * self.training_parameters[0]
-                + self.training_parameters[2]
-            }
-            qkclass.assign_training_parameters(param_binds)
-            self.assertEqual(
-                list(qkclass.training_parameter_binds.keys()),
-                [
-                    self.training_parameters[0],
-                    self.training_parameters[1],
-                    self.training_parameters[2],
-                ],
-            )
-            self.assertEqual(
-                list(qkclass.training_parameter_binds.keys()),
-                list(qkclass.training_parameter_binds.values()),
-            )
-            self.assertEqual(
-                list(qkclass.training_parameter_binds.keys()), qkclass.training_parameters
-            )
-
-        with self.subTest("test assign with immediate reassign"):
-            # Create a new quantum kernel
-            qkclass = QuantumKernel(
-                feature_map=self.feature_map, training_parameters=self.training_parameters
-            )
-            param_binds = {
-                self.training_parameters[0]: 0.9,
-                self.training_parameters[1]: self.training_parameters[0],
-                self.training_parameters[2]: self.training_parameters[1],
-            }
-            qkclass.assign_training_parameters(param_binds)
-            self.assertEqual(
-                list(qkclass.training_parameter_binds.keys()),
-                [self.training_parameters[0], self.training_parameters[1]],
-            )
-            self.assertEqual(
-                list(qkclass.training_parameter_binds.values()), [0.9, self.training_parameters[1]]
-            )
-            self.assertEqual(
-                list(qkclass.training_parameter_binds.keys()), qkclass.training_parameters
-            )
-
-        with self.subTest("test unordered assigns"):
-            # Create a new quantum kernel
-            qkclass = QuantumKernel(
-                feature_map=self.feature_map, training_parameters=self.training_parameters
-            )
-            param_binds = {
-                self.training_parameters[2]: self.training_parameters[1],
-                self.training_parameters[1]: self.training_parameters[0],
-                self.training_parameters[0]: 1.7,
-            }
-            qkclass.assign_training_parameters(param_binds)
-            self.assertEqual(
-                list(qkclass.training_parameter_binds.keys()), [self.training_parameters[0]]
-            )
-            self.assertEqual(list(qkclass.training_parameter_binds.values()), [1.7])
-            self.assertEqual(
-                list(qkclass.training_parameter_binds.keys()), qkclass.training_parameters
-            )
-
-    def test_unbound_parameters(self):
-        """Test unbound parameters."""
-        qc = QuantumCircuit(2)
-        parameters = [Parameter("x")]
-        qc.ry(parameters[0], 0)
-
-        qkernel = QuantumKernel(
-            qc, training_parameters=parameters, quantum_instance=self.statevector_simulator
-        )
-
-        qsvc = QSVC(quantum_kernel=qkernel)
-        self.assertRaises(ValueError, qsvc.fit, self.sample_train, self.label_train)
-
-
-class TestQuantumKernelBatching(QiskitMachineLearningTestCase):
-    """Test QuantumKernel circuit batching
-
-    Checks batching with both statevector simulator and QASM simulator.
-    Checks that the actual number of circuits being passed
-    to execute does not exceed the batch_size requested by the Quantum Kernel.
-    Checks that the sum of the batch sizes matches the total number of expected
-    circuits.
-    """
-
-    def count_circuits(self, func):
-        """Wrapper to record the number of circuits passed to QuantumInstance.execute.
-
-        Args:
-            func (Callable): execute function to be wrapped
-
-        Returns:
-            Callable: function wrapper
-        """
-
-        @functools.wraps(func)
-        def wrapper(*args, **kwds):
-            self.circuit_counts.append(len(args[0]))
-            return func(*args, **kwds)
-
-        return wrapper
-
-    def setUp(self):
-        super().setUp()
-        warnings.filterwarnings("ignore", category=DeprecationWarning)
-
-        algorithm_globals.random_seed = 10598
-
-        self.shots = 12000
-        self.batch_size = 3
-        self.circuit_counts = []
-
-        self.statevector_simulator = QuantumInstance(
-            BasicAer.get_backend("statevector_simulator"),
-            shots=1,
-            seed_simulator=algorithm_globals.random_seed,
-            seed_transpiler=algorithm_globals.random_seed,
-        )
-
-        # monkey patch the statevector simulator
-        self.statevector_simulator.execute = self.count_circuits(self.statevector_simulator.execute)
-
-        self.qasm_simulator = QuantumInstance(
-            BasicAer.get_backend("qasm_simulator"),
-            shots=self.shots,
-            seed_simulator=algorithm_globals.random_seed,
-            seed_transpiler=algorithm_globals.random_seed,
-        )
-
-        # monkey patch the qasm simulator
-        self.qasm_simulator.execute = self.count_circuits(self.qasm_simulator.execute)
-
-        self.feature_map = ZZFeatureMap(feature_dimension=2, reps=2)
-
-        # data generated using
-        # sample_train, label_train, _, _ = ad_hoc_data(training_size=4, test_size=2, n=2, gap=0.3)
-        self.sample_train = np.asarray(
-            [
-                [5.90619419, 1.25663706],
-                [2.32477856, 0.9424778],
-                [4.52389342, 5.0893801],
-                [3.58141563, 0.9424778],
-                [0.31415927, 3.45575192],
-                [4.83805269, 3.70707933],
-                [5.65486678, 6.09468975],
-                [5.46637122, 4.52389342],
-            ]
-        )
-        self.label_train = np.asarray([0, 0, 0, 0, 1, 1, 1, 1])
-
-    def tearDown(self) -> None:
-        super().tearDown()
-        warnings.filterwarnings("always", category=DeprecationWarning)
-
-    def test_statevector_batching(self):
-        """Test batching when using the statevector simulator"""
-
-        self.circuit_counts = []
-
-        kernel = QuantumKernel(
-            feature_map=self.feature_map,
-            batch_size=self.batch_size,
-            quantum_instance=self.statevector_simulator,
-        )
-
-        svc = SVC(kernel=kernel.evaluate)
-
-        svc.fit(self.sample_train, self.label_train)
-
-        for circuit_count in self.circuit_counts:
-            self.assertLessEqual(circuit_count, self.batch_size)
-
-        self.assertEqual(sum(self.circuit_counts), len(self.sample_train))
-
-    def test_qasm_batching(self):
-        """Test batching when using the QASM simulator"""
-
-        self.circuit_counts = []
-
-        kernel = QuantumKernel(
-            feature_map=self.feature_map,
-            batch_size=self.batch_size,
-            quantum_instance=self.qasm_simulator,
-        )
-
-        svc = SVC(kernel=kernel.evaluate)
-        svc.fit(self.sample_train, self.label_train)
-
-        for circuit_count in self.circuit_counts:
-            self.assertLessEqual(circuit_count, self.batch_size)
-
-        num_train = len(self.sample_train)
-        num_circuits = num_train * (num_train - 1) / 2
-
-        self.assertEqual(sum(self.circuit_counts), num_circuits)
-
-
-@ddt
-class TestQuantumKernelEvaluateDuplicates(QiskitMachineLearningTestCase):
-    """Test QuantumKernel for duplicate evaluation."""
-
-    def count_circuits(self, func):
-        """Wrapper to record the number of circuits passed to QuantumInstance.execute.
-
-        Args:
-            func (Callable): execute function to be wrapped
-
-        Returns:
-            Callable: function wrapper
-        """
-
-        @functools.wraps(func)
-        def wrapper(*args, **kwds):
-            self.circuit_counts += len(args[0])
-            return func(*args, **kwds)
-
-        return wrapper
-
-    def setUp(self):
-        super().setUp()
-        warnings.filterwarnings("ignore", category=DeprecationWarning)
-        algorithm_globals.random_seed = 10598
-        self.circuit_counts = 0
-
-        self.qasm_simulator = QuantumInstance(
-            BasicAer.get_backend("qasm_simulator"),
-            seed_simulator=algorithm_globals.random_seed,
-            seed_transpiler=algorithm_globals.random_seed,
-        )
-
-        # monkey patch the qasm simulator
-        self.qasm_simulator.execute = self.count_circuits(self.qasm_simulator.execute)
-
-        self.feature_map = ZFeatureMap(feature_dimension=2, reps=1)
-
-        self.properties = {
-            "no_dups": np.array([[1, 2], [2, 3], [3, 4]]),
-            "dups": np.array([[1, 2], [1, 2], [3, 4]]),
-            "y_vec": np.array([[0, 1], [1, 2]]),
-        }
-
-    def tearDown(self) -> None:
-        super().tearDown()
-        warnings.filterwarnings("always", category=DeprecationWarning)
-
-    @idata(
-        [
-            ("no_dups", "all", 6),
-            ("no_dups", "off_diagonal", 3),
-            ("no_dups", "none", 3),
-            ("dups", "all", 6),
-            ("dups", "off_diagonal", 3),
-            ("dups", "none", 2),
-        ]
-    )
-    @unpack
-    def test_evaluate_duplicates(self, dataset_name, evaluate_duplicates, expected_num_circuits):
-        """Tests symmetric quantum kernel evaluation with duplicate samples."""
-        self.circuit_counts = 0
-        qkernel = QuantumKernel(
-            feature_map=self.feature_map,
-            evaluate_duplicates=evaluate_duplicates,
-            quantum_instance=self.qasm_simulator,
-        )
-        qkernel.evaluate(self.properties.get(dataset_name))
-        self.assertEqual(self.circuit_counts, expected_num_circuits)
-
-    @idata(
-        [
-            ("no_dups", "all", 6),
-            ("no_dups", "off_diagonal", 6),
-            ("no_dups", "none", 5),
-        ]
-    )
-    @unpack
-    def test_evaluate_duplicates_not_symmetric(
-        self, dataset_name, evaluate_duplicates, expected_num_circuits
-    ):
-        """Tests non-symmetric quantum kernel evaluation with duplicate samples."""
-        self.circuit_counts = 0
-        qkernel = QuantumKernel(
-            feature_map=self.feature_map,
-            evaluate_duplicates=evaluate_duplicates,
-            quantum_instance=self.qasm_simulator,
-        )
-        qkernel.evaluate(self.properties.get(dataset_name), self.properties.get("y_vec"))
-        self.assertEqual(self.circuit_counts, expected_num_circuits)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/neural_networks/test_circuit_qnn.py b/test/neural_networks/test_circuit_qnn.py
deleted file mode 100644
index f2fad56c3..000000000
--- a/test/neural_networks/test_circuit_qnn.py
+++ /dev/null
@@ -1,475 +0,0 @@
-# This code is part of a Qiskit project.
-#
-# (C) Copyright IBM 2018, 2023.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-"""Test Circuit QNN."""
-import itertools
-import unittest
-import warnings
-
-from test import QiskitMachineLearningTestCase
-
-from ddt import ddt, data, idata, unpack
-
-import numpy as np
-
-from qiskit.circuit import QuantumCircuit, Parameter
-from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap
-from qiskit.utils import QuantumInstance, algorithm_globals, optionals
-from qiskit.providers.fake_provider import FakeToronto
-from qiskit.transpiler import PassManagerConfig
-from qiskit.transpiler.preset_passmanagers import level_1_pass_manager, level_2_pass_manager
-
-from qiskit_machine_learning import QiskitMachineLearningError
-from qiskit_machine_learning.neural_networks import CircuitQNN
-import qiskit_machine_learning.optionals as _optionals
-
-QASM = "qasm"
-STATEVECTOR = "statevector"
-CUSTOM_PASS_MANAGERS = "custom_pass_managers"
-
-SPARSE = [True, False]
-SAMPLING = [True, False]
-QUANTUM_INSTANCES = [STATEVECTOR, QASM, CUSTOM_PASS_MANAGERS]
-INTERPRET_TYPES = [0, 1, 2]
-BATCH_SIZES = [1, 2]
-
-
-@ddt
-class TestCircuitQNN(QiskitMachineLearningTestCase):
-    """Circuit QNN Tests."""
-
-    @unittest.skipUnless(optionals.HAS_AER, "qiskit-aer is required to run this test")
-    def setUp(self):
-        super().setUp()
-        warnings.filterwarnings("ignore", category=DeprecationWarning)
-        algorithm_globals.random_seed = 12345
-        from qiskit_aer import Aer, AerSimulator
-
-        # specify "run configuration"
-        self.quantum_instance_sv = QuantumInstance(
-            Aer.get_backend("aer_simulator_statevector"),
-            seed_simulator=algorithm_globals.random_seed,
-            seed_transpiler=algorithm_globals.random_seed,
-        )
-        # pylint: disable=no-member
-        self.quantum_instance_qasm = QuantumInstance(
-            AerSimulator(),
-            shots=100,
-            seed_simulator=algorithm_globals.random_seed,
-            seed_transpiler=algorithm_globals.random_seed,
-        )
-        self.quantum_instance_pm = QuantumInstance(
-            AerSimulator(),
-            shots=100,
-            seed_simulator=algorithm_globals.random_seed,
-            seed_transpiler=algorithm_globals.random_seed,
-            pass_manager=level_1_pass_manager(PassManagerConfig.from_backend(FakeToronto())),
-            bound_pass_manager=level_2_pass_manager(PassManagerConfig.from_backend(FakeToronto())),
-        )
-
-        # define feature map and ansatz
-        num_qubits = 2
-        feature_map = ZZFeatureMap(num_qubits, reps=1)
-        var_form = RealAmplitudes(num_qubits, reps=1)
-
-        # construct circuit
-        self.qc = QuantumCircuit(num_qubits)
-        self.qc.append(feature_map, range(2))
-        self.qc.append(var_form, range(2))
-
-        # store params
-        self.input_params = list(feature_map.parameters)
-        self.weight_params = list(var_form.parameters)
-
-        # define interpret functions
-        def interpret_1d(x):
-            return sum((s == "1" for s in f"{x:0b}")) % 2
-
-        self.interpret_1d = interpret_1d
-        self.output_shape_1d = 2  # takes values in {0, 1}
-
-        def interpret_2d(x):
-            return np.array([self.interpret_1d(x), 2 * self.interpret_1d(x)])
-
-        self.interpret_2d = interpret_2d
-        self.output_shape_2d = (
-            2,
-            3,
-        )  # 1st dim. takes values in {0, 1} 2nd dim in {0, 1, 2}
-
-    def tearDown(self) -> None:
-        super().tearDown()
-        warnings.filterwarnings("always", category=DeprecationWarning)
-
-    def _get_qnn(self, sparse, sampling, quantum_instance_type, interpret_id):
-        """Construct QNN from configuration."""
-
-        # get quantum instance
-        if quantum_instance_type == STATEVECTOR:
-            quantum_instance = self.quantum_instance_sv
-        elif quantum_instance_type == QASM:
-            quantum_instance = self.quantum_instance_qasm
-        elif quantum_instance_type == CUSTOM_PASS_MANAGERS:
-            quantum_instance = self.quantum_instance_pm
-        else:
-            quantum_instance = None
-
-        # get interpret setting
-        interpret = None
-        output_shape = None
-        if interpret_id == 1:
-            interpret = self.interpret_1d
-            output_shape = self.output_shape_1d
-        elif interpret_id == 2:
-            interpret = self.interpret_2d
-            output_shape = self.output_shape_2d
-
-        # construct QNN
-        qnn = CircuitQNN(
-            self.qc,
-            self.input_params,
-            self.weight_params,
-            sparse=sparse,
-            sampling=sampling,
-            interpret=interpret,
-            output_shape=output_shape,
-            quantum_instance=quantum_instance,
-        )
-        return qnn
-
-    def _verify_qnn(
-        self,
-        qnn: CircuitQNN,
-        quantum_instance_type: str,
-        batch_size: int,
-    ) -> None:
-        """
-        Verifies that a QNN functions correctly
-
-        Args:
-            qnn: a QNN to check
-            quantum_instance_type:
-            batch_size:
-
-        Returns:
-            None.
-        """
-        # pylint: disable=import-error
-        from sparse import SparseArray
-
-        input_data = np.zeros((batch_size, qnn.num_inputs))
-        weights = np.zeros(qnn.num_weights)
-
-        # if sampling and statevector, make sure it fails
-        if quantum_instance_type == STATEVECTOR and qnn.sampling:
-            with self.assertRaises(QiskitMachineLearningError):
-                qnn.forward(input_data, weights)
-        else:
-            # evaluate QNN forward pass
-            result = qnn.forward(input_data, weights)
-
-            # make sure forward result is sparse if it should be
-            if qnn.sparse and not qnn.sampling:
-                self.assertTrue(isinstance(result, SparseArray))
-            else:
-                self.assertTrue(isinstance(result, np.ndarray))
-
-            # check forward result shape
-            self.assertEqual(result.shape, (batch_size, *qnn.output_shape))
-
-            input_grad, weights_grad = qnn.backward(input_data, weights)
-            if qnn.sampling:
-                self.assertIsNone(input_grad)
-                self.assertIsNone(weights_grad)
-            else:
-                self.assertIsNone(input_grad)
-                self.assertEqual(
-                    weights_grad.shape, (batch_size, *qnn.output_shape, qnn.num_weights)
-                )
-
-            # verify that input gradients are None if turned off
-            qnn.input_gradients = True
-            input_grad, weights_grad = qnn.backward(input_data, weights)
-            if qnn.sampling:
-                self.assertIsNone(input_grad)
-                self.assertIsNone(weights_grad)
-            else:
-                self.assertEqual(input_grad.shape, (batch_size, *qnn.output_shape, qnn.num_inputs))
-                self.assertEqual(
-                    weights_grad.shape, (batch_size, *qnn.output_shape, qnn.num_weights)
-                )
-
-    @unittest.skipIf(not _optionals.HAS_SPARSE, "Sparse not available.")
-    @idata(itertools.product(SPARSE, SAMPLING, QUANTUM_INSTANCES, INTERPRET_TYPES, BATCH_SIZES))
-    @unpack
-    def test_circuit_qnn(
-        self, sparse: bool, sampling: bool, quantum_instance_type, interpret_type, batch_size
-    ):
-        """Circuit QNN Test."""
-        qnn = self._get_qnn(sparse, sampling, quantum_instance_type, interpret_type)
-        self._verify_qnn(qnn, quantum_instance_type, batch_size)
-
-    @data(
-        # sparse, sampling, quantum_instance_type, interpret (0=no, 1=1d, 2=2d), batch_size
-        (True, False, STATEVECTOR, 0, 1),
-        (True, False, STATEVECTOR, 0, 2),
-        (True, False, STATEVECTOR, 1, 1),
-        (True, False, STATEVECTOR, 1, 2),
-        (True, False, STATEVECTOR, 2, 1),
-        (True, False, STATEVECTOR, 2, 2),
-        (False, False, STATEVECTOR, 0, 1),
-        (False, False, STATEVECTOR, 0, 2),
-        (False, False, STATEVECTOR, 1, 1),
-        (False, False, STATEVECTOR, 1, 2),
-        (False, False, STATEVECTOR, 2, 1),
-        (False, False, STATEVECTOR, 2, 2),
-    )
-    def test_circuit_qnn_gradient(self, config):
-        """Circuit QNN Gradient Test."""
-
-        # get configuration
-        sparse, sampling, quantum_instance_type, interpret_id, batch_size = config
-        if sparse and not _optionals.HAS_SPARSE:
-            self.skipTest("sparse library is required to run this test")
-            return
-
-        # get QNN
-        qnn = self._get_qnn(sparse, sampling, quantum_instance_type, interpret_id)
-        qnn.input_gradients = True
-        input_data = np.ones((batch_size, qnn.num_inputs))
-        weights = np.ones(qnn.num_weights)
-        input_grad, weights_grad = qnn.backward(input_data, weights)
-
-        # test input gradients
-        eps = 1e-2
-        for k in range(qnn.num_inputs):
-            delta = np.zeros(input_data.shape)
-            delta[:, k] = eps
-
-            f_1 = qnn.forward(input_data + delta, weights)
-            f_2 = qnn.forward(input_data - delta, weights)
-            if sparse:
-                grad = (f_1.todense() - f_2.todense()) / (2 * eps)
-                input_grad_ = (
-                    input_grad.todense()
-                    .reshape((batch_size, -1, qnn.num_inputs))[:, :, k]
-                    .reshape(grad.shape)
-                )
-                diff = input_grad_ - grad
-            else:
-                grad = (f_1 - f_2) / (2 * eps)
-                input_grad_ = input_grad.reshape((batch_size, -1, qnn.num_inputs))[:, :, k].reshape(
-                    grad.shape
-                )
-                diff = input_grad_ - grad
-            self.assertAlmostEqual(np.max(np.abs(diff)), 0.0, places=3)
-
-        # test weight gradients
-        eps = 1e-2
-        for k in range(qnn.num_weights):
-            delta = np.zeros(weights.shape)
-            delta[k] = eps
-
-            f_1 = qnn.forward(input_data, weights + delta)
-            f_2 = qnn.forward(input_data, weights - delta)
-            if sparse:
-                grad = (f_1.todense() - f_2.todense()) / (2 * eps)
-                weights_grad_ = (
-                    weights_grad.todense()
-                    .reshape((batch_size, -1, qnn.num_weights))[:, :, k]
-                    .reshape(grad.shape)
-                )
-                diff = weights_grad_ - grad
-            else:
-                grad = (f_1 - f_2) / (2 * eps)
-                weights_grad_ = weights_grad.reshape((batch_size, -1, qnn.num_weights))[
-                    :, :, k
-                ].reshape(grad.shape)
-                diff = weights_grad_ - grad
-            self.assertAlmostEqual(np.max(np.abs(diff)), 0.0, places=3)
-
-    @unittest.skipIf(not _optionals.HAS_SPARSE, "Sparse not available.")
-    @idata(itertools.product(SPARSE, SAMPLING, QUANTUM_INSTANCES, INTERPRET_TYPES, BATCH_SIZES))
-    @unpack
-    def test_no_quantum_instance(
-        self,
-        sparse: bool,
-        sampling: bool,
-        quantum_instance_type: str,
-        interpret_type: int,
-        batch_size: int,
-    ):
-        """Circuit QNN Test with and without QuantumInstance."""
-        # get QNN with QuantumInstance
-        qnn_qi = self._get_qnn(sparse, sampling, quantum_instance_type, interpret_type)
-
-        # get QNN without QuantumInstance
-        qnn_no_qi = self._get_qnn(sparse, sampling, None, interpret_type)
-
-        with self.assertRaises(QiskitMachineLearningError):
-            qnn_no_qi.sample(input_data=None, weights=None)
-
-        with self.assertRaises(QiskitMachineLearningError):
-            qnn_no_qi.probabilities(input_data=None, weights=None)
-
-        with self.assertRaises(QiskitMachineLearningError):
-            qnn_no_qi.probability_gradients(input_data=None, weights=None)
-
-        if quantum_instance_type == STATEVECTOR:
-            quantum_instance = self.quantum_instance_sv
-        elif quantum_instance_type == QASM:
-            quantum_instance = self.quantum_instance_qasm
-        elif quantum_instance_type == CUSTOM_PASS_MANAGERS:
-            quantum_instance = self.quantum_instance_pm
-        else:
-            # must never happen
-            quantum_instance = None
-
-        qnn_no_qi.quantum_instance = quantum_instance
-
-        self.assertEqual(qnn_qi.output_shape, qnn_no_qi.output_shape)
-        self._verify_qnn(qnn_no_qi, quantum_instance_type, batch_size)
-
-    @data(
-        # interpret, output_shape, sparse, quantum_instance
-        (None, 1, False, "sv"),
-        (None, 1, True, "sv"),
-        (None, 1, False, "qasm"),
-        (None, 1, True, "qasm"),
-    )
-    def test_warning1_circuit_qnn(self, config):
-        """Circuit QNN with no sampling and input/output shape 1/1 ."""
-
-        interpret, output_shape, sparse, q_i = config
-        if sparse and not _optionals.HAS_SPARSE:
-            self.skipTest("sparse library is required to run this test")
-            return
-
-        if q_i == "sv":
-            quantum_instance = self.quantum_instance_sv
-        elif q_i == "qasm":
-            quantum_instance = self.quantum_instance_qasm
-        else:
-            raise ValueError("Unsupported quantum instance")
-
-        qc = QuantumCircuit(1)
-
-        # construct simple feature map
-        param_x = Parameter("x")
-        qc.ry(param_x, 0)
-
-        # construct simple feature map
-        param_y = Parameter("y")
-        qc.ry(param_y, 0)
-
-        # check warning when output_shape defined without interpret
-        with self.assertLogs(level="WARNING") as w_1:
-            CircuitQNN(
-                qc,
-                [param_x],
-                [param_y],
-                sparse=sparse,
-                sampling=False,
-                interpret=interpret,
-                output_shape=output_shape,
-                quantum_instance=quantum_instance,
-                input_gradients=True,
-            )
-            self.assertEqual(
-                w_1.output,
-                [
-                    "WARNING:qiskit_machine_learning.neural_networks.circuit_qnn:No "
-                    "interpret function given, output_shape will be automatically "
-                    "determined as 2^num_qubits."
-                ],
-            )
-
-    @data(
-        # interpret, output_shape, sparse, quantum_instance
-        (None, 1, False, "qasm"),
-        (None, 1, True, "qasm"),
-        (lambda x: np.sum(x) % 2, 2, True, "qasm"),
-        (lambda x: np.sum(x) % 2, 2, False, "qasm"),
-    )
-    def test_warning2_circuit_qnn(self, config):
-        """Torch Connector + Circuit QNN with sampling and input/output shape 1/1 ."""
-
-        interpret, output_shape, sparse, q_i = config
-        if q_i == "sv":
-            quantum_instance = self.quantum_instance_sv
-        elif q_i == "qasm":
-            quantum_instance = self.quantum_instance_qasm
-        else:
-            raise ValueError("Unsupported quantum instance")
-
-        qc = QuantumCircuit(2)
-
-        # construct simple feature map
-        param_x = Parameter("x")
-        qc.ry(param_x, 0)
-
-        # construct simple feature map
-        param_y = Parameter("y")
-        qc.ry(param_y, 0)
-
-        # check warning when sampling true
-        with self.assertLogs(level="WARNING") as w_2:
-            CircuitQNN(
-                qc,
-                [param_x],
-                [param_y],
-                sparse=sparse,
-                sampling=True,
-                interpret=interpret,
-                output_shape=output_shape,
-                quantum_instance=quantum_instance,
-                input_gradients=True,
-            )
-
-            self.assertEqual(
-                w_2.output,
-                [
-                    "WARNING:qiskit_machine_learning.neural_networks.circuit_qnn:"
-                    "In sampling mode, output_shape will be automatically inferred "
-                    "from the number of samples and interpret function, if provided."
-                ],
-            )
-
-    def test_delayed_gradient_initialization(self):
-        """Test delayed gradient initialization."""
-        qc = QuantumCircuit(1)
-        input_param = Parameter("x")
-        qc.ry(input_param, 0)
-
-        weight_param = Parameter("w")
-        qc.rx(weight_param, 0)
-
-        # define QNN
-        qnn = CircuitQNN(
-            qc, [input_param], [weight_param], quantum_instance=self.quantum_instance_sv
-        )
-        self.assertIsNone(qnn._gradient_circuit)
-
-        qnn.backward(np.asarray([1]), np.asarray([1]))
-        grad_qc1 = qnn._gradient_circuit
-        self.assertIsNotNone(grad_qc1)
-
-        qnn.input_gradients = True
-        self.assertIsNone(qnn._gradient_circuit)
-        qnn.backward(np.asarray([1]), np.asarray([1]))
-        grad_qc2 = qnn._gradient_circuit
-        self.assertIsNotNone(grad_qc1)
-        self.assertNotEqual(grad_qc1, grad_qc2)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/neural_networks/test_circuit_vs_sampler_qnn.py b/test/neural_networks/test_circuit_vs_sampler_qnn.py
deleted file mode 100644
index 4215ef1ae..000000000
--- a/test/neural_networks/test_circuit_vs_sampler_qnn.py
+++ /dev/null
@@ -1,118 +0,0 @@
-# This code is part of a Qiskit project.
-#
-# (C) Copyright IBM 2022, 2023.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-"""Test Sampler QNN vs Circuit QNN."""
-import warnings
-
-from test import QiskitMachineLearningTestCase
-
-import itertools
-import unittest
-import numpy as np
-from ddt import ddt, idata
-
-from qiskit import BasicAer
-from qiskit.algorithms.gradients import ParamShiftSamplerGradient
-from qiskit.circuit import QuantumCircuit
-from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap
-from qiskit.opflow import Gradient
-from qiskit.primitives import Sampler
-from qiskit.utils import QuantumInstance, algorithm_globals
-
-from qiskit_machine_learning.neural_networks import CircuitQNN, SamplerQNN
-import qiskit_machine_learning.optionals as _optionals
-
-SPARSE = [True, False]
-INPUT_GRADS = [True, False]
-
-
-@ddt
-class TestCircuitQNNvsSamplerQNN(QiskitMachineLearningTestCase):
-    """Circuit vs Sampler QNN Tests. To be removed once CircuitQNN is deprecated"""
-
-    def setUp(self):
-        super().setUp()
-        warnings.filterwarnings("ignore", category=DeprecationWarning)
-
-        algorithm_globals.random_seed = 10598
-
-        self.parity = lambda x: f"{x:b}".count("1") % 2
-        self.output_shape = 2  # this is required in case of a callable with dense output
-
-        # define feature map and ansatz
-        num_qubits = 2
-        feature_map = ZZFeatureMap(num_qubits, reps=1)
-        var_form = RealAmplitudes(num_qubits, reps=1)
-        # construct circuit
-        self.qc = QuantumCircuit(num_qubits)
-        self.qc.append(feature_map, range(2))
-        self.qc.append(var_form, range(2))
-
-        # store params
-        self.input_params = list(feature_map.parameters)
-        self.weight_params = list(var_form.parameters)
-
-        self.sampler = Sampler()
-
-    def tearDown(self) -> None:
-        super().tearDown()
-        warnings.filterwarnings("always", category=DeprecationWarning)
-
-    @unittest.skipIf(not _optionals.HAS_SPARSE, "Sparse not available.")
-    @idata(itertools.product(SPARSE, INPUT_GRADS))
-    def test_new_vs_old(self, config):
-        """Circuit vs Sampler QNN Test. To be removed once CircuitQNN is deprecated"""
-
-        sparse, input_grads = config
-        qi_sv = QuantumInstance(BasicAer.get_backend("statevector_simulator"))
-
-        circuit_qnn = CircuitQNN(
-            self.qc,
-            input_params=self.qc.parameters[:3],
-            weight_params=self.qc.parameters[3:],
-            sparse=sparse,
-            interpret=self.parity,
-            output_shape=self.output_shape,
-            quantum_instance=qi_sv,
-            gradient=Gradient("param_shift"),
-            input_gradients=input_grads,
-        )
-
-        sampler_qnn = SamplerQNN(
-            sampler=self.sampler,
-            circuit=self.qc,
-            input_params=self.qc.parameters[:3],
-            weight_params=self.qc.parameters[3:],
-            interpret=self.parity,
-            output_shape=self.output_shape,
-            gradient=ParamShiftSamplerGradient(self.sampler),
-            input_gradients=input_grads,
-        )
-
-        inputs = np.asarray(algorithm_globals.random.random(size=(3, circuit_qnn._num_inputs)))
-        weights = algorithm_globals.random.random(circuit_qnn._num_weights)
-
-        circuit_qnn_fwd = circuit_qnn.forward(inputs, weights)
-        sampler_qnn_fwd = sampler_qnn.forward(inputs, weights)
-
-        diff_fwd = circuit_qnn_fwd - sampler_qnn_fwd
-        self.assertAlmostEqual(np.max(np.abs(diff_fwd)), 0.0, places=3)
-
-        circuit_qnn_input_grads, circuit_qnn_weight_grads = circuit_qnn.backward(inputs, weights)
-        sampler_qnn_input_grads, sampler_qnn_weight_grads = sampler_qnn.backward(inputs, weights)
-
-        diff_weight = circuit_qnn_weight_grads - sampler_qnn_weight_grads
-        self.assertAlmostEqual(np.max(np.abs(diff_weight)), 0.0, places=3)
-
-        if input_grads:
-            diff_input = circuit_qnn_input_grads - sampler_qnn_input_grads
-            self.assertAlmostEqual(np.max(np.abs(diff_input)), 0.0, places=3)
diff --git a/test/neural_networks/test_effective_dimension.py b/test/neural_networks/test_effective_dimension.py
index 79073b7c8..5e2a3fc50 100644
--- a/test/neural_networks/test_effective_dimension.py
+++ b/test/neural_networks/test_effective_dimension.py
@@ -12,7 +12,6 @@
 """ Unit Tests for Effective Dimension Algorithm """
 
 import unittest
-import warnings
 
 from test import QiskitMachineLearningTestCase
 
@@ -21,13 +20,13 @@
 
 from qiskit.circuit import QuantumCircuit
 from qiskit.circuit.library import ZFeatureMap, RealAmplitudes
-from qiskit.utils import QuantumInstance, algorithm_globals, optionals
+from qiskit.utils import algorithm_globals
 
-from qiskit.opflow import PauliSumOp
-from qiskit_machine_learning.neural_networks import TwoLayerQNN, CircuitQNN
 from qiskit_machine_learning.neural_networks import (
     EffectiveDimension,
     LocalEffectiveDimension,
+    EstimatorQNN,
+    SamplerQNN,
 )
 from qiskit_machine_learning import QiskitMachineLearningError
 
@@ -36,26 +35,17 @@
 class TestEffectiveDimension(QiskitMachineLearningTestCase):
     """Test the Effective Dimension algorithm"""
 
-    @unittest.skipUnless(optionals.HAS_AER, "qiskit-aer is required to run this test")
     def setUp(self):
         super().setUp()
-        warnings.filterwarnings("ignore", category=DeprecationWarning)
 
         algorithm_globals.random_seed = 1234
-        from qiskit_aer import Aer
-
-        qi_sv = QuantumInstance(
-            Aer.get_backend("aer_simulator_statevector"),
-            seed_simulator=algorithm_globals.random_seed,
-            seed_transpiler=algorithm_globals.random_seed,
-        )
 
         # set up quantum neural networks
         num_qubits = 3
         feature_map = ZFeatureMap(feature_dimension=num_qubits, reps=1)
         ansatz = RealAmplitudes(num_qubits, reps=1)
 
-        # CircuitQNNs
+        # SamplerQNNs
         qc = QuantumCircuit(num_qubits)
         qc.append(feature_map, range(num_qubits))
         qc.append(ansatz, range(num_qubits))
@@ -63,51 +53,43 @@ def setUp(self):
         def parity(x):
             return f"{x:b}".count("1") % 2
 
-        circuit_qnn_1 = CircuitQNN(
-            qc,
+        sampler_qnn_1 = SamplerQNN(
+            circuit=qc,
             input_params=feature_map.parameters,
             weight_params=ansatz.parameters,
             interpret=parity,
             output_shape=2,
-            sparse=False,
-            quantum_instance=qi_sv,
         )
 
-        # qnn2 for checking result without parity
-        circuit_qnn_2 = CircuitQNN(
-            qc,
+        sampler_qnn_2 = SamplerQNN(
+            circuit=qc,
             input_params=feature_map.parameters,
             weight_params=ansatz.parameters,
-            sparse=False,
-            quantum_instance=qi_sv,
         )
 
-        # OpflowQNN
-        observable = PauliSumOp.from_list([("Z" * num_qubits, 1)])
-        opflow_qnn = TwoLayerQNN(
-            num_qubits,
-            feature_map=feature_map,
-            ansatz=ansatz,
-            observable=observable,
-            quantum_instance=qi_sv,
+        # EstimatorQNN
+        estimator_qnn = EstimatorQNN(
+            circuit=qc,
+            input_params=feature_map.parameters,
+            weight_params=ansatz.parameters,
         )
 
-        self.qnns = {"circuit1": circuit_qnn_1, "circuit2": circuit_qnn_2, "opflow": opflow_qnn}
+        self.qnns = {
+            "sampler_qnn_1": sampler_qnn_1,
+            "sampler_qnn_2": sampler_qnn_2,
+            "estimator_qnn": estimator_qnn,
+        }
 
         # define sample numbers
         self.n_list = [5000, 8000, 10000, 40000, 60000, 100000, 150000, 200000, 500000, 1000000]
         self.n = 5000
 
-    def tearDown(self) -> None:
-        super().tearDown()
-        warnings.filterwarnings("always", category=DeprecationWarning)
-
     @data(
         # qnn_name, num_inputs, num_weights, result
-        ("circuit1", 10, 10, 4.51202148),
-        ("circuit1", 1, 1, 1.39529449),
-        ("circuit1", 10, 1, 3.97371533),
-        ("circuit2", 10, 10, 5.90859124),
+        ("sampler_qnn_1", 10, 10, 4.51202148),
+        ("sampler_qnn_1", 1, 1, 1.39529449),
+        ("sampler_qnn_1", 10, 1, 3.97371533),
+        ("sampler_qnn_2", 10, 10, 5.90859124),
     )
     @unpack
     def test_alg_results(self, qnn_name, num_inputs, num_params, result):
@@ -120,11 +102,11 @@ def test_alg_results(self, qnn_name, num_inputs, num_params, result):
         self.assertAlmostEqual(effdim, result, 5)
 
     def test_qnn_type(self):
-        """Test that the results are equivalent for opflow and circuit qnn."""
+        """Test that the results are equivalent for EstimatorQNN and SamplerQNN."""
 
         num_input_samples, num_weight_samples = 1, 1
-        qnn1 = self.qnns["circuit1"]
-        qnn2 = self.qnns["opflow"]
+        qnn1 = self.qnns["sampler_qnn_1"]
+        qnn2 = self.qnns["estimator_qnn"]
 
         global_ed1 = EffectiveDimension(
             qnn=qnn1,
@@ -148,7 +130,7 @@ def test_multiple_data(self):
         """Test results for a list of sampling sizes."""
 
         num_input_samples, num_weight_samples = 10, 10
-        qnn = self.qnns["circuit1"]
+        qnn = self.qnns["sampler_qnn_1"]
 
         global_ed1 = EffectiveDimension(
             qnn=qnn,
@@ -164,7 +146,7 @@ def test_multiple_data(self):
     def test_inputs(self):
         """Test results for different input combinations."""
 
-        qnn = self.qnns["circuit1"]
+        qnn = self.qnns["sampler_qnn_1"]
 
         num_input_samples, num_weight_samples = 10, 10
         inputs = algorithm_globals.random.uniform(0, 1, size=(num_input_samples, qnn.num_inputs))
@@ -190,7 +172,7 @@ def test_inputs(self):
     def test_inputs_shapes(self):
         """Test results for different input combinations."""
 
-        qnn = self.qnns["circuit1"]
+        qnn = self.qnns["sampler_qnn_1"]
 
         num_inputs, num_params = 10, 10
         inputs_ok = algorithm_globals.random.uniform(0, 1, size=(num_inputs, qnn.num_inputs))
@@ -216,7 +198,7 @@ def test_inputs_shapes(self):
     def test_local_ed_params(self):
         """Test that QiskitMachineLearningError is raised for wrong parameters sizes."""
 
-        qnn = self.qnns["circuit1"]
+        qnn = self.qnns["sampler_qnn_1"]
 
         num_inputs, num_params = 10, 10
         inputs_ok = algorithm_globals.random.uniform(0, 1, size=(num_inputs, qnn.num_inputs))
diff --git a/test/neural_networks/test_effective_dimension_primitives.py b/test/neural_networks/test_effective_dimension_primitives.py
deleted file mode 100644
index 22292d547..000000000
--- a/test/neural_networks/test_effective_dimension_primitives.py
+++ /dev/null
@@ -1,230 +0,0 @@
-# This code is part of a Qiskit project.
-#
-# (C) Copyright IBM 2022, 2023.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-""" Unit Tests for Effective Dimension Algorithm """
-
-import unittest
-
-from test import QiskitMachineLearningTestCase
-
-import numpy as np
-from ddt import ddt, data, unpack
-
-from qiskit.circuit import QuantumCircuit
-from qiskit.circuit.library import ZFeatureMap, RealAmplitudes
-from qiskit.utils import algorithm_globals
-
-from qiskit_machine_learning.neural_networks import (
-    EffectiveDimension,
-    LocalEffectiveDimension,
-    EstimatorQNN,
-    SamplerQNN,
-)
-from qiskit_machine_learning import QiskitMachineLearningError
-
-
-@ddt
-class TestEffectiveDimension(QiskitMachineLearningTestCase):
-    """Test the Effective Dimension algorithm"""
-
-    def setUp(self):
-        super().setUp()
-
-        algorithm_globals.random_seed = 1234
-
-        # set up quantum neural networks
-        num_qubits = 3
-        feature_map = ZFeatureMap(feature_dimension=num_qubits, reps=1)
-        ansatz = RealAmplitudes(num_qubits, reps=1)
-
-        # CircuitQNNs
-        qc = QuantumCircuit(num_qubits)
-        qc.append(feature_map, range(num_qubits))
-        qc.append(ansatz, range(num_qubits))
-
-        def parity(x):
-            return f"{x:b}".count("1") % 2
-
-        sampler_qnn_1 = SamplerQNN(
-            circuit=qc,
-            input_params=feature_map.parameters,
-            weight_params=ansatz.parameters,
-            interpret=parity,
-            output_shape=2,
-        )
-
-        sampler_qnn_2 = SamplerQNN(
-            circuit=qc,
-            input_params=feature_map.parameters,
-            weight_params=ansatz.parameters,
-        )
-
-        # EstimatorQNN
-        estimator_qnn = EstimatorQNN(
-            circuit=qc,
-            input_params=feature_map.parameters,
-            weight_params=ansatz.parameters,
-        )
-
-        self.qnns = {
-            "sampler_qnn_1": sampler_qnn_1,
-            "sampler_qnn_2": sampler_qnn_2,
-            "estimator_qnn": estimator_qnn,
-        }
-
-        # define sample numbers
-        self.n_list = [5000, 8000, 10000, 40000, 60000, 100000, 150000, 200000, 500000, 1000000]
-        self.n = 5000
-
-    @data(
-        # qnn_name, num_inputs, num_weights, result
-        ("sampler_qnn_1", 10, 10, 4.51202148),
-        ("sampler_qnn_1", 1, 1, 1.39529449),
-        ("sampler_qnn_1", 10, 1, 3.97371533),
-        ("sampler_qnn_2", 10, 10, 5.90859124),
-    )
-    @unpack
-    def test_alg_results(self, qnn_name, num_inputs, num_params, result):
-        """Test that the algorithm results match the original code's."""
-        qnn = self.qnns[qnn_name]
-        global_ed = EffectiveDimension(qnn=qnn, weight_samples=num_params, input_samples=num_inputs)
-
-        effdim = global_ed.get_effective_dimension(self.n)
-
-        self.assertAlmostEqual(effdim, result, 5)
-
-    def test_qnn_type(self):
-        """Test that the results are equivalent for opflow and circuit qnn."""
-
-        num_input_samples, num_weight_samples = 1, 1
-        qnn1 = self.qnns["sampler_qnn_1"]
-        qnn2 = self.qnns["estimator_qnn"]
-
-        global_ed1 = EffectiveDimension(
-            qnn=qnn1,
-            weight_samples=num_weight_samples,
-            input_samples=num_input_samples,
-        )
-
-        global_ed2 = EffectiveDimension(
-            qnn=qnn2,
-            weight_samples=num_weight_samples,
-            input_samples=num_input_samples,
-        )
-
-        effdim1 = global_ed1.get_effective_dimension(self.n)
-        effdim2 = global_ed2.get_effective_dimension(self.n)
-
-        self.assertAlmostEqual(effdim1, 1.395, 3)
-        self.assertAlmostEqual(effdim1, effdim2, 5)
-
-    def test_multiple_data(self):
-        """Test results for a list of sampling sizes."""
-
-        num_input_samples, num_weight_samples = 10, 10
-        qnn = self.qnns["sampler_qnn_1"]
-
-        global_ed1 = EffectiveDimension(
-            qnn=qnn,
-            weight_samples=num_weight_samples,
-            input_samples=num_input_samples,
-        )
-
-        effdim1 = global_ed1.get_effective_dimension(self.n_list)
-        effdim2 = global_ed1.get_effective_dimension(np.asarray(self.n_list))
-
-        np.testing.assert_array_equal(effdim1, effdim2)
-
-    def test_inputs(self):
-        """Test results for different input combinations."""
-
-        qnn = self.qnns["sampler_qnn_1"]
-
-        num_input_samples, num_weight_samples = 10, 10
-        inputs = algorithm_globals.random.uniform(0, 1, size=(num_input_samples, qnn.num_inputs))
-        weights = algorithm_globals.random.uniform(0, 1, size=(num_weight_samples, qnn.num_weights))
-
-        global_ed1 = EffectiveDimension(
-            qnn=qnn,
-            weight_samples=num_weight_samples,
-            input_samples=num_input_samples,
-        )
-
-        global_ed2 = EffectiveDimension(
-            qnn=qnn,
-            weight_samples=weights,
-            input_samples=inputs,
-        )
-
-        effdim1 = global_ed1.get_effective_dimension(self.n_list)
-        effdim2 = global_ed2.get_effective_dimension(self.n_list)
-
-        np.testing.assert_array_almost_equal(effdim1, effdim2, 0.2)
-
-    def test_inputs_shapes(self):
-        """Test results for different input combinations."""
-
-        qnn = self.qnns["sampler_qnn_1"]
-
-        num_inputs, num_params = 10, 10
-        inputs_ok = algorithm_globals.random.uniform(0, 1, size=(num_inputs, qnn.num_inputs))
-        weights_ok = algorithm_globals.random.uniform(0, 1, size=(num_params, qnn.num_weights))
-
-        inputs_wrong = algorithm_globals.random.uniform(0, 1, size=(num_inputs, 1))
-        weights_wrong = algorithm_globals.random.uniform(0, 1, size=(num_params, 1))
-
-        with self.assertRaises(QiskitMachineLearningError):
-            EffectiveDimension(
-                qnn=qnn,
-                weight_samples=weights_ok,
-                input_samples=inputs_wrong,
-            )
-
-        with self.assertRaises(QiskitMachineLearningError):
-            EffectiveDimension(
-                qnn=qnn,
-                weight_samples=weights_wrong,
-                input_samples=inputs_ok,
-            )
-
-    def test_local_ed_params(self):
-        """Test that QiskitMachineLearningError is raised for wrong parameters sizes."""
-
-        qnn = self.qnns["sampler_qnn_1"]
-
-        num_inputs, num_params = 10, 10
-        inputs_ok = algorithm_globals.random.uniform(0, 1, size=(num_inputs, qnn.num_inputs))
-        weights_ok = algorithm_globals.random.uniform(0, 1, size=(1, qnn.num_weights))
-        weights_ok2 = algorithm_globals.random.uniform(0, 1, size=qnn.num_weights)
-        weights_wrong = algorithm_globals.random.uniform(0, 1, size=(num_params, qnn.num_weights))
-
-        LocalEffectiveDimension(
-            qnn=qnn,
-            weight_samples=weights_ok,
-            input_samples=inputs_ok,
-        )
-
-        LocalEffectiveDimension(
-            qnn=qnn,
-            weight_samples=weights_ok2,
-            input_samples=inputs_ok,
-        )
-
-        with self.assertRaises(QiskitMachineLearningError):
-            LocalEffectiveDimension(
-                qnn=qnn,
-                weight_samples=weights_wrong,
-                input_samples=inputs_ok,
-            )
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/neural_networks/test_estimator_qnn.py b/test/neural_networks/test_estimator_qnn.py
index f72d5c6fd..b1bcd810f 100644
--- a/test/neural_networks/test_estimator_qnn.py
+++ b/test/neural_networks/test_estimator_qnn.py
@@ -171,7 +171,7 @@
 
 
 class TestEstimatorQNN(QiskitMachineLearningTestCase):
-    """EstimatorQNN Tests. The correct references is obtained from OpflowQNN"""
+    """EstimatorQNN Tests. The correct references is obtained from EstimatorQNN"""
 
     def _test_network_passes(
         self,
diff --git a/test/neural_networks/test_opflow_qnn.py b/test/neural_networks/test_opflow_qnn.py
deleted file mode 100644
index 578a4cc1c..000000000
--- a/test/neural_networks/test_opflow_qnn.py
+++ /dev/null
@@ -1,357 +0,0 @@
-# This code is part of a Qiskit project.
-#
-# (C) Copyright IBM 2018, 2023.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-""" Test Opflow QNN """
-import warnings
-from typing import List
-
-from test import QiskitMachineLearningTestCase
-
-import unittest
-from ddt import ddt, data
-
-import numpy as np
-
-from qiskit.circuit import Parameter, QuantumCircuit
-from qiskit.opflow import PauliExpectation, Gradient, StateFn, PauliSumOp, ListOp
-from qiskit.utils import QuantumInstance, algorithm_globals, optionals
-
-
-from qiskit_machine_learning.neural_networks import OpflowQNN
-
-QASM = "qasm"
-STATEVECTOR = "sv"
-
-
-@ddt
-class TestOpflowQNN(QiskitMachineLearningTestCase):
-    """Opflow QNN Tests."""
-
-    @unittest.skipUnless(optionals.HAS_AER, "qiskit-aer is required to run this test")
-    def setUp(self):
-        super().setUp()
-        warnings.filterwarnings("ignore", category=DeprecationWarning)
-
-        algorithm_globals.random_seed = 12345
-        from qiskit_aer import Aer, AerSimulator
-
-        # specify quantum instances
-        self.sv_quantum_instance = QuantumInstance(
-            Aer.get_backend("aer_simulator_statevector"),
-            seed_simulator=algorithm_globals.random_seed,
-            seed_transpiler=algorithm_globals.random_seed,
-        )
-        # pylint: disable=no-member
-        self.qasm_quantum_instance = QuantumInstance(
-            AerSimulator(),
-            shots=100,
-            seed_simulator=algorithm_globals.random_seed,
-            seed_transpiler=algorithm_globals.random_seed,
-        )
-        np.random.seed(algorithm_globals.random_seed)
-
-    def tearDown(self) -> None:
-        super().tearDown()
-        warnings.filterwarnings("always", category=DeprecationWarning)
-
-    def validate_output_shape(self, qnn: OpflowQNN, test_data: List[np.ndarray]) -> None:
-        """
-        Asserts that the opflow qnn returns results of the correct output shape.
-
-        Args:
-            qnn: QNN to be tested
-            test_data: list of test input arrays
-
-        Raises:
-            QiskitMachineLearningError: Invalid input.
-        """
-
-        # get weights
-        weights = np.random.rand(qnn.num_weights)
-
-        # iterate over test data and validate behavior of model
-        for x in test_data:
-
-            # evaluate network
-            forward_shape = qnn.forward(x, weights).shape
-            input_grad, weights_grad = qnn.backward(x, weights)
-            if qnn.input_gradients:
-                backward_shape_input = input_grad.shape
-            backward_shape_weights = weights_grad.shape
-
-            # derive batch shape form input
-            batch_shape = x.shape[: -len(qnn.output_shape)]
-            if len(batch_shape) == 0:
-                batch_shape = (1,)
-
-            # compare results and assert that the behavior is equal
-            self.assertEqual(forward_shape, (*batch_shape, *qnn.output_shape))
-            if qnn.input_gradients:
-                self.assertEqual(
-                    backward_shape_input,
-                    (*batch_shape, *qnn.output_shape, qnn.num_inputs),
-                )
-            else:
-                self.assertIsNone(input_grad)
-            self.assertEqual(
-                backward_shape_weights,
-                (*batch_shape, *qnn.output_shape, qnn.num_weights),
-            )
-
-    @data(
-        (STATEVECTOR, True),
-        (STATEVECTOR, False),
-        (QASM, True),
-        (QASM, False),
-        (None, True),
-        (None, False),
-    )
-    def test_opflow_qnn_1_1(self, config):
-        """Test Opflow QNN with input/output dimension 1/1."""
-        q_i, input_grad_required = config
-
-        if q_i == STATEVECTOR:
-            quantum_instance = self.sv_quantum_instance
-        elif q_i == QASM:
-            quantum_instance = self.qasm_quantum_instance
-        else:
-            quantum_instance = None
-
-        # specify how to evaluate expected values and gradients
-        expval = PauliExpectation()
-        gradient = Gradient()
-
-        # construct parametrized circuit
-        params = [Parameter("input1"), Parameter("weight1")]
-        qc = QuantumCircuit(1)
-        qc.h(0)
-        qc.ry(params[0], 0)
-        qc.rx(params[1], 0)
-        qc_sfn = StateFn(qc)
-
-        # construct cost operator
-        cost_operator = StateFn(PauliSumOp.from_list([("Z", 1.0), ("X", 1.0)]))
-
-        # combine operator and circuit to objective function
-        op = ~cost_operator @ qc_sfn
-
-        # define QNN
-        qnn = OpflowQNN(
-            op,
-            [params[0]],
-            [params[1]],
-            expval,
-            gradient,
-            quantum_instance=quantum_instance,
-        )
-        qnn.input_gradients = input_grad_required
-
-        test_data = [
-            np.array(1),
-            np.array([1]),
-            np.array([[1], [2]]),
-            np.array([[[1], [2]], [[3], [4]]]),
-        ]
-
-        # test model
-        self.validate_output_shape(qnn, test_data)
-
-        # test the qnn after we set a quantum instance
-        if quantum_instance is None:
-            qnn.quantum_instance = self.qasm_quantum_instance
-            self.validate_output_shape(qnn, test_data)
-
-    @data(
-        (STATEVECTOR, True),
-        (STATEVECTOR, False),
-        (QASM, True),
-        (QASM, False),
-        (None, True),
-        (None, False),
-    )
-    def test_opflow_qnn_2_1(self, config):
-        """Test Opflow QNN with input/output dimension 2/1."""
-        q_i, input_grad_required = config
-
-        # construct QNN
-        if q_i == STATEVECTOR:
-            quantum_instance = self.sv_quantum_instance
-        elif q_i == QASM:
-            quantum_instance = self.qasm_quantum_instance
-        else:
-            quantum_instance = None
-
-        # specify how to evaluate expected values and gradients
-        expval = PauliExpectation()
-        gradient = Gradient()
-
-        # construct parametrized circuit
-        params = [
-            Parameter("input1"),
-            Parameter("input2"),
-            Parameter("weight1"),
-            Parameter("weight2"),
-        ]
-        qc = QuantumCircuit(2)
-        qc.h(0)
-        qc.ry(params[0], 0)
-        qc.ry(params[1], 1)
-        qc.rx(params[2], 0)
-        qc.rx(params[3], 1)
-        qc_sfn = StateFn(qc)
-
-        # construct cost operator
-        cost_operator = StateFn(PauliSumOp.from_list([("ZZ", 1.0), ("XX", 1.0)]))
-
-        # combine operator and circuit to objective function
-        op = ~cost_operator @ qc_sfn
-
-        # define QNN
-        qnn = OpflowQNN(
-            op,
-            params[:2],
-            params[2:],
-            expval,
-            gradient,
-            quantum_instance=quantum_instance,
-        )
-        qnn.input_gradients = input_grad_required
-
-        test_data = [np.array([1, 2]), np.array([[1, 2]]), np.array([[1, 2], [3, 4]])]
-
-        # test model
-        self.validate_output_shape(qnn, test_data)
-
-        # test the qnn after we set a quantum instance
-        if quantum_instance is None:
-            qnn.quantum_instance = self.qasm_quantum_instance
-            self.validate_output_shape(qnn, test_data)
-
-    @data(
-        (STATEVECTOR, True),
-        (STATEVECTOR, False),
-        (QASM, True),
-        (QASM, False),
-        (None, True),
-        (None, False),
-    )
-    def test_opflow_qnn_2_2(self, config):
-        """Test Opflow QNN with input/output dimension 2/2."""
-        q_i, input_grad_required = config
-
-        if q_i == STATEVECTOR:
-            quantum_instance = self.sv_quantum_instance
-        elif q_i == QASM:
-            quantum_instance = self.qasm_quantum_instance
-        else:
-            quantum_instance = None
-
-        # construct parametrized circuit
-        params_1 = [Parameter("input1"), Parameter("weight1")]
-        qc_1 = QuantumCircuit(1)
-        qc_1.h(0)
-        qc_1.ry(params_1[0], 0)
-        qc_1.rx(params_1[1], 0)
-        qc_sfn_1 = StateFn(qc_1)
-
-        # construct cost operator
-        h_1 = StateFn(PauliSumOp.from_list([("Z", 1.0), ("X", 1.0)]))
-
-        # combine operator and circuit to objective function
-        op_1 = ~h_1 @ qc_sfn_1
-
-        # construct parametrized circuit
-        params_2 = [Parameter("input2"), Parameter("weight2")]
-        qc_2 = QuantumCircuit(1)
-        qc_2.h(0)
-        qc_2.ry(params_2[0], 0)
-        qc_2.rx(params_2[1], 0)
-        qc_sfn_2 = StateFn(qc_2)
-
-        # construct cost operator
-        h_2 = StateFn(PauliSumOp.from_list([("Z", 1.0), ("X", 1.0)]))
-
-        # combine operator and circuit to objective function
-        op_2 = ~h_2 @ qc_sfn_2
-
-        op = ListOp([op_1, op_2])
-
-        qnn = OpflowQNN(
-            op,
-            [params_1[0], params_2[0]],
-            [params_1[1], params_2[1]],
-            quantum_instance=quantum_instance,
-        )
-        qnn.input_gradients = input_grad_required
-
-        test_data = [np.array([1, 2]), np.array([[1, 2], [3, 4]])]
-
-        # test model
-        self.validate_output_shape(qnn, test_data)
-
-        # test the qnn after we set a quantum instance
-        if quantum_instance is None:
-            qnn.quantum_instance = self.qasm_quantum_instance
-            self.validate_output_shape(qnn, test_data)
-
-    def test_composed_op(self):
-        """Tests OpflowQNN with ComposedOp as an operator."""
-        qc = QuantumCircuit(1)
-        param = Parameter("param")
-        qc.rz(param, 0)
-
-        h_1 = PauliSumOp.from_list([("Z", 1.0)])
-        h_2 = PauliSumOp.from_list([("Z", 1.0)])
-
-        h_op = ListOp([h_1, h_2])
-        op = ~StateFn(h_op) @ StateFn(qc)
-
-        # initialize QNN
-        qnn = OpflowQNN(op, [], [param])
-
-        # create random data and weights for testing
-        input_data = np.random.rand(2, qnn.num_inputs)
-        weights = np.random.rand(qnn.num_weights)
-
-        qnn.forward(input_data, weights)
-        qnn.backward(input_data, weights)
-
-    def test_delayed_gradient_initialization(self):
-        """Test delayed gradient initialization."""
-        qc = QuantumCircuit(1)
-        input_param = Parameter("x")
-        qc.ry(input_param, 0)
-
-        weight_param = Parameter("w")
-        qc.rx(weight_param, 0)
-
-        observable = StateFn(PauliSumOp.from_list([("Z", 1)]))
-        op = ~observable @ StateFn(qc)
-
-        # define QNN
-        qnn = OpflowQNN(op, [input_param], [weight_param])
-        self.assertIsNone(qnn._gradient_operator)
-
-        qnn.backward(np.asarray([1]), np.asarray([1]))
-        grad_op1 = qnn._gradient_operator
-        self.assertIsNotNone(grad_op1)
-
-        qnn.input_gradients = True
-        self.assertIsNone(qnn._gradient_operator)
-        qnn.backward(np.asarray([1]), np.asarray([1]))
-        grad_op2 = qnn._gradient_operator
-        self.assertIsNotNone(grad_op1)
-        self.assertNotEqual(grad_op1, grad_op2)
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/neural_networks/test_sampler_qnn.py b/test/neural_networks/test_sampler_qnn.py
index 29067bfab..593c2c30f 100644
--- a/test/neural_networks/test_sampler_qnn.py
+++ b/test/neural_networks/test_sampler_qnn.py
@@ -333,7 +333,7 @@ def test_no_parameters(self):
             self._verify_qnn(sampler_qnn, 1, input_data=[1, 2], weights=None)
 
         with self.subTest("no parameters"):
-            qc = qc.bind_parameters([1, 2])
+            qc = qc.assign_parameters([1, 2])
 
             sampler_qnn = SamplerQNN(
                 circuit=qc,
diff --git a/test/neural_networks/test_two_layer_qnn.py b/test/neural_networks/test_two_layer_qnn.py
deleted file mode 100644
index d1557b38e..000000000
--- a/test/neural_networks/test_two_layer_qnn.py
+++ /dev/null
@@ -1,171 +0,0 @@
-# This code is part of a Qiskit project.
-#
-# (C) Copyright IBM 2018, 2023.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-"""Test Two Layer QNN."""
-
-import unittest
-import warnings
-
-from test import QiskitMachineLearningTestCase
-
-import numpy as np
-
-from ddt import ddt, data
-from qiskit import QuantumCircuit
-from qiskit.circuit.library import RealAmplitudes, ZFeatureMap, ZZFeatureMap
-from qiskit.utils import QuantumInstance, algorithm_globals, optionals
-
-from qiskit_machine_learning import QiskitMachineLearningError
-from qiskit_machine_learning.neural_networks import TwoLayerQNN
-
-
-@ddt
-class TestTwoLayerQNN(QiskitMachineLearningTestCase):
-    """Two Layer QNN Tests."""
-
-    @unittest.skipUnless(optionals.HAS_AER, "qiskit-aer is required to run this test")
-    def setUp(self):
-        super().setUp()
-        warnings.filterwarnings("ignore", category=DeprecationWarning)
-        algorithm_globals.random_seed = 12345
-        from qiskit_aer import Aer
-
-        # specify "run configuration"
-        self.quantum_instance = QuantumInstance(
-            Aer.get_backend("aer_simulator_statevector"),
-            seed_simulator=algorithm_globals.random_seed,
-            seed_transpiler=algorithm_globals.random_seed,
-        )
-
-        # define QNN
-        num_qubits = 2
-        feature_map = ZZFeatureMap(num_qubits)
-        ansatz = RealAmplitudes(num_qubits, reps=1)
-        self.qnn = TwoLayerQNN(
-            num_qubits,
-            feature_map=feature_map,
-            ansatz=ansatz,
-            quantum_instance=self.quantum_instance,
-        )
-
-        self.qnn_no_qi = TwoLayerQNN(num_qubits, feature_map=feature_map, ansatz=ansatz)
-
-    def tearDown(self) -> None:
-        super().tearDown()
-        warnings.filterwarnings("always", category=DeprecationWarning)
-
-    @data(
-        ("qi", True),
-        ("no_qi", True),
-        ("qi", False),
-        ("no_qi", False),
-    )
-    def test_qnn_simple_new(self, config):
-        """Simple Opflow QNN Test for a specified neural network."""
-        qnn_type, input_grad_required = config
-
-        input_data = np.zeros(self.qnn.num_inputs)
-        weights = np.zeros(self.qnn.num_weights)
-
-        if qnn_type == "qi":
-            qnn = self.qnn
-        else:
-            qnn = self.qnn_no_qi
-        qnn.input_gradients = input_grad_required
-
-        # test forward pass
-        result = qnn.forward(input_data, weights)
-        self.assertEqual(result.shape, (1, *qnn.output_shape))
-
-        # test backward pass
-        result = qnn.backward(input_data, weights)
-        # batch dimension of 1
-        if qnn.input_gradients:
-            self.assertEqual(result[0].shape, (1, *qnn.output_shape, qnn.num_inputs))
-        else:
-            self.assertIsNone(result[0])
-
-        self.assertEqual(result[1].shape, (1, *qnn.output_shape, qnn.num_weights))
-
-    @data(
-        ("qi", True),
-        ("no_qi", True),
-        ("qi", False),
-        ("no_qi", False),
-    )
-    def _test_qnn_batch(self, config):
-        """Batched Opflow QNN Test for the specified network."""
-        qnn_type, input_grad_required = config
-
-        batch_size = 10
-
-        input_data = np.arange(batch_size * self.qnn.num_inputs).reshape(
-            (batch_size, self.qnn.num_inputs)
-        )
-        weights = np.zeros(self.qnn.num_weights)
-
-        if qnn_type == "qi":
-            qnn = self.qnn
-        else:
-            qnn = self.qnn_no_qi
-        qnn.input_gradients = input_grad_required
-
-        # test forward pass
-        result = qnn.forward(input_data, weights)
-        self.assertEqual(result.shape, (batch_size, *qnn.output_shape))
-
-        # test backward pass
-        result = qnn.backward(input_data, weights)
-        if qnn.input_gradients:
-            self.assertEqual(result[0].shape, (batch_size, *qnn.output_shape, qnn.num_inputs))
-        else:
-            self.assertIsNone(result[0])
-
-        self.assertEqual(result[1].shape, (batch_size, *qnn.output_shape, qnn.num_weights))
-
-    @data(1, 2)
-    def test_default_construction(self, num_features):
-        """Test the default construction for 1 feature and more than 1 feature."""
-        qnn = TwoLayerQNN(num_features)
-
-        with self.subTest(msg="Check ansatz"):
-            self.assertIsInstance(qnn.ansatz, RealAmplitudes)
-
-        with self.subTest(msg="Check feature map"):
-            expected_cls = ZZFeatureMap if num_features > 1 else ZFeatureMap
-            self.assertIsInstance(qnn.feature_map, expected_cls)
-
-    def test_circuit_extensions(self):
-        """Test TwoLayerQNN when the number of qubits is different compared to
-        the feature map/ansatz."""
-        num_qubits = 2
-        classifier = TwoLayerQNN(
-            num_qubits=num_qubits,
-            feature_map=ZFeatureMap(1),
-            ansatz=RealAmplitudes(1),
-            quantum_instance=self.quantum_instance,
-        )
-        self.assertEqual(classifier.feature_map.num_qubits, num_qubits)
-        self.assertEqual(classifier.ansatz.num_qubits, num_qubits)
-
-        qc = QuantumCircuit(1)
-        with self.assertRaises(QiskitMachineLearningError):
-            _ = TwoLayerQNN(
-                num_qubits=num_qubits,
-                feature_map=qc,
-                ansatz=qc,
-                quantum_instance=self.quantum_instance,
-            )
-
-
-if __name__ == "__main__":
-    unittest.main()
diff --git a/test/test_deprecation.py b/test/test_deprecation.py
deleted file mode 100644
index a37107216..000000000
--- a/test/test_deprecation.py
+++ /dev/null
@@ -1,517 +0,0 @@
-# This code is part of a Qiskit project.
-#
-# (C) Copyright IBM 2021, 2023.
-#
-# This code is licensed under the Apache License, Version 2.0. You may
-# obtain a copy of this license in the LICENSE.txt file in the root directory
-# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
-#
-# Any modifications or derivative works of this code must retain this
-# copyright notice, and modified files need to carry a notice indicating
-# that they have been altered from the originals.
-
-"""
-Test The deprecation methods
-"""
-
-import unittest
-import sys
-import inspect
-import warnings
-from typing import Tuple, Optional
-from test import QiskitMachineLearningTestCase
-from ddt import data, ddt
-from qiskit_machine_learning.deprecation import (
-    DeprecatedEnum,
-    DeprecatedEnumMeta,
-    DeprecatedType,
-    warn_deprecated,
-    warn_deprecated_same_type_name,
-    deprecate_function,
-    deprecate_property,
-    deprecate_method,
-    deprecate_arguments,
-    deprecate_values,
-)
-
-# pylint: disable=bad-docstring-quotes
-
-
-class EnumTest(DeprecatedEnum, metaclass=DeprecatedEnumMeta):
-    """Enumeration Test"""
-
-    ONE = "one"
-    TWO = "two"
-
-    def deprecate(self):
-        """show deprecate message"""
-        warn_deprecated(
-            "0.2.0", DeprecatedType.ENUM, self.__class__.__name__, new_name="NewEnum", stack_level=3
-        )
-
-
-@deprecate_function("0.1.1", DeprecatedType.CLASS, "some_class", "and more information")
-def func1(arg1: int) -> int:
-    """function 1"""
-    return arg1
-
-
-@deprecate_function("0.2.0", new_name="some_function2")
-def func2(arg2: int) -> int:
-    """function 2"""
-    return arg2
-
-
-@deprecate_arguments("0.1.2", {"old_arg": "new_arg"})
-def func3(new_arg: Optional[int] = None, old_arg: Optional[int] = None) -> Tuple[int, int]:
-    """function 3"""
-    return new_arg, old_arg
-
-
-class DeprecatedClass1:
-    """Deprecated Test class 1"""
-
-    def __init__(self):
-        warn_deprecated(
-            "0.3.0", DeprecatedType.CLASS, "DeprecatedClass1", DeprecatedType.CLASS, "NewClass"
-        )
-        self.value = 10
-
-
-class DeprecatedClass2:
-    """Deprecated Test class 2"""
-
-    def __init__(self):
-        warn_deprecated_same_type_name(
-            "0.3.0", DeprecatedType.CLASS, "DeprecatedClass2", "from package test2"
-        )
-        self.value = 10
-
-
-class DeprecatedClass3:
-    """Deprecated Test class 3"""
-
-    @deprecate_values("0.2.0", {"loss": {"l1": "absolute_error", "l2": "squared_error"}})
-    def __init__(self, arg1: int, loss: str = "squared_error") -> None:
-        self.value = arg1
-        self.loss = loss
-
-    @deprecate_values("0.2.0", {"loss": {"l1": "absolute_error", "l2": "squared_error"}})
-    def method1(self, arg1: int, loss: str = "squared_error") -> None:
-        """method 1"""
-        self.value = arg1
-        self.loss = loss
-
-
-class DeprecatedClass4:
-    """Deprecated Test class 4"""
-
-    def __init__(
-        self,
-    ) -> None:
-        self.status = 2
-
-    @deprecate_values("0.2.0", {"status": {3: 2, 4: 5}})
-    def method1(self, status: int = 2) -> None:
-        """method 1"""
-        self.status = status
-
-
-class TestClass:
-    """Test class with deprecation"""
-
-    def __init__(self):
-        self._value = 20
-
-    # Bug in mypy, if property decorator is used with another one
-    # https://github.com/python/mypy/issues/1362
-
-    @property
-    @deprecate_property("0.1.0")
-    def property1(self) -> int:
-        """property1 get"""
-        return self._value
-
-    @property1.setter
-    @deprecate_property(
-        "0.1.0", new_name="new_property", additional_msg="and some additional information"
-    )
-    def property1(self, value: int):
-        """property 1 set"""
-        self._value = value
-
-    @deprecate_method("0.1.0", new_name="some_method1", additional_msg="and additional information")
-    def method1(self, arg: int) -> int:
-        """method 1"""
-        return arg
-
-    @deprecate_method("0.2.0", new_name="some_method2")
-    def method2(self, arg: int) -> int:
-        """method 2"""
-        return arg
-
-    @deprecate_arguments("0.1.2", {"old_arg": "new_arg"})
-    def method3(
-        self, new_arg: Optional[int] = None, old_arg: Optional[int] = None
-    ) -> Tuple[int, int]:
-        """method3"""
-        return new_arg, old_arg
-
-
-@ddt
-class TestDeprecation(QiskitMachineLearningTestCase):
-    """Test deprecation methods"""
-
-    def setUp(self) -> None:
-        super().setUp()
-        self._source = inspect.getsource(sys.modules[self.__module__]).splitlines()
-
-    def _get_line_from_str(self, text: str) -> int:
-        for idx, line in enumerate(self._source):
-            if text in line:
-                return idx + 1
-        return -1
-
-    def test_enum_deprecation(self):
-        """test enumeration deprecation"""
-
-        msg_ref = (
-            "The EnumTest enum is deprecated as of version 0.2.0 "
-            "and will be removed no sooner than 3 months after the release. "
-            "Instead use the NewEnum enum."
-        )
-
-        # emit deprecation the first time it is used
-        with warnings.catch_warnings(record=True) as c_m:
-            warnings.simplefilter("always")
-            _ = EnumTest.ONE
-            msg = str(c_m[0].message)
-            self.assertEqual(msg, msg_ref)
-            self.assertTrue("test_deprecation.py" in c_m[0].filename, c_m[0].filename)
-            self.assertEqual(self._get_line_from_str("EnumTest.ONE"), c_m[0].lineno)
-
-        # trying again should not emit deprecation
-        with warnings.catch_warnings(record=True) as c_m:
-            warnings.simplefilter("always")
-            _ = EnumTest.TWO
-            self.assertListEqual(c_m, [])
-
-    @data(
-        (
-            "func1",
-            "The func1 function is deprecated as of version 0.1.1 "
-            "and will be removed no sooner than 3 months after the release. "
-            "Instead use the some_class class and more information.",
-        ),
-        (
-            "func2",
-            "The func2 function is deprecated as of version 0.2.0 "
-            "and will be removed no sooner than 3 months after the release. "
-            "Instead use the some_function2 function.",
-        ),
-    )
-    def test_function_deprecation(self, config):
-        """test function deprecation"""
-
-        function_name, msg_ref = config
-
-        # emit deprecation the first time it is used
-        with warnings.catch_warnings(record=True) as c_m:
-            warnings.simplefilter("always")
-            self.assertEqual(2, globals()[function_name](2))
-            msg = str(c_m[0].message)
-            self.assertEqual(msg, msg_ref)
-            self.assertTrue("test_deprecation.py" in c_m[0].filename, c_m[0].filename)
-            self.assertEqual(self._get_line_from_str("globals()[function_name](2)"), c_m[0].lineno)
-
-        # trying again should not emit deprecation
-        with warnings.catch_warnings(record=True) as c_m:
-            warnings.simplefilter("always")
-            globals()[function_name](None)
-            self.assertListEqual(c_m, [])
-
-    def test_class_deprecation1(self):
-        """test class deprecation 1"""
-
-        msg_ref = (
-            "The DeprecatedClass1 class is deprecated as of version 0.3.0 "
-            "and will be removed no sooner than 3 months after the release. "
-            "Instead use the NewClass class."
-        )
-
-        # emit deprecation the first time it is used
-        with warnings.catch_warnings(record=True) as c_m:
-            warnings.simplefilter("always")
-            obj = DeprecatedClass1()
-            self.assertEqual(obj.value, 10)
-            msg = str(c_m[0].message)
-            self.assertEqual(msg, msg_ref)
-            self.assertTrue("test_deprecation.py" in c_m[0].filename, c_m[0].filename)
-            self.assertEqual(self._get_line_from_str("DeprecatedClass1()"), c_m[0].lineno)
-
-        # trying again should not emit deprecation
-        with warnings.catch_warnings(record=True) as c_m:
-            warnings.simplefilter("always")
-            obj = DeprecatedClass1()
-            self.assertEqual(obj.value, 10)
-            self.assertListEqual(c_m, [])
-
-    def test_class_deprecation2(self):
-        """test class deprecation 2"""
-
-        msg_ref = (
-            "The DeprecatedClass2 class is deprecated as of version 0.3.0 "
-            "and will be removed no sooner than 3 months after the release. "
-            "Instead use the DeprecatedClass2 class from package test2."
-        )
-
-        # emit deprecation the first time it is used
-        with warnings.catch_warnings(record=True) as c_m:
-            warnings.simplefilter("always")
-            obj = DeprecatedClass2()
-            self.assertEqual(obj.value, 10)
-            msg = str(c_m[0].message)
-            self.assertEqual(msg, msg_ref)
-            self.assertTrue("test_deprecation.py" in c_m[0].filename, c_m[0].filename)
-            self.assertEqual(self._get_line_from_str("DeprecatedClass2()"), c_m[0].lineno)
-
-        # trying again should not emit deprecation
-        with warnings.catch_warnings(record=True) as c_m:
-            warnings.simplefilter("always")
-            obj = DeprecatedClass2()
-            self.assertEqual(obj.value, 10)
-            self.assertListEqual(c_m, [])
-
-    @data(
-        (
-            "l1",
-            'The loss argument value "l1" is deprecated as of version 0.2.0 '
-            "and will be removed no sooner than 3 months after the release. "
-            'Instead use the "absolute_error" value.',
-        ),
-        (
-            "l2",
-            'The loss argument value "l2" is deprecated as of version 0.2.0 '
-            "and will be removed no sooner than 3 months after the release. "
-            'Instead use the "squared_error" value.',
-        ),
-    )
-    def test_string_values_deprecation(self, config):
-        """test string values deprecation"""
-
-        loss, msg_ref = config
-
-        # emit deprecation the first time it is used
-        with warnings.catch_warnings(record=True) as c_m:
-            warnings.simplefilter("always")
-            obj = DeprecatedClass3(10, loss=loss)
-            self.assertEqual(obj.value, 10)
-            msg = str(c_m[0].message)
-            self.assertEqual(msg, msg_ref)
-            self.assertTrue("test_deprecation.py" in c_m[0].filename, c_m[0].filename)
-            self.assertEqual(
-                self._get_line_from_str("DeprecatedClass3(10, loss=loss)"), c_m[0].lineno
-            )
-
-        # trying again should not emit deprecation
-        with warnings.catch_warnings(record=True) as c_m:
-            warnings.simplefilter("always")
-            obj = DeprecatedClass3(10, loss=loss)
-            self.assertEqual(obj.value, 10)
-            self.assertListEqual(c_m, [])
-
-        # emit deprecation the first time it is used
-        with warnings.catch_warnings(record=True) as c_m:
-            warnings.simplefilter("always")
-            obj = DeprecatedClass3(5, loss=loss)
-            obj.method1(10, loss)
-            self.assertEqual(obj.value, 10)
-            msg = str(c_m[0].message)
-            self.assertEqual(msg, msg_ref)
-            self.assertTrue("test_deprecation.py" in c_m[0].filename, c_m[0].filename)
-            self.assertEqual(self._get_line_from_str("obj.method1(10, loss)"), c_m[0].lineno)
-
-        # trying again should not emit deprecation
-        with warnings.catch_warnings(record=True) as c_m:
-            warnings.simplefilter("always")
-            obj = DeprecatedClass3(5, loss=loss)
-            obj.method1(10, loss)
-            self.assertEqual(obj.value, 10)
-            self.assertListEqual(c_m, [])
-
-    @data(
-        (
-            3,
-            'The status argument value "3" is deprecated as of version 0.2.0 '
-            "and will be removed no sooner than 3 months after the release. "
-            'Instead use the "2" value.',
-        ),
-        (
-            4,
-            'The status argument value "4" is deprecated as of version 0.2.0 '
-            "and will be removed no sooner than 3 months after the release. "
-            'Instead use the "5" value.',
-        ),
-    )
-    def test_int_values_deprecation(self, config):
-        """test int values deprecation"""
-
-        status, msg_ref = config
-        obj = DeprecatedClass4()
-
-        # emit deprecation the first time it is used
-        with warnings.catch_warnings(record=True) as c_m:
-            warnings.simplefilter("always")
-            obj.method1(status)
-            msg = str(c_m[0].message)
-            self.assertEqual(msg, msg_ref)
-            self.assertTrue("test_deprecation.py" in c_m[0].filename, c_m[0].filename)
-            self.assertEqual(self._get_line_from_str("obj.method1(status)"), c_m[0].lineno)
-
-        # trying again should not emit deprecation
-        with warnings.catch_warnings(record=True) as c_m:
-            warnings.simplefilter("always")
-            obj.method1(status)
-            self.assertEqual(obj.status, status)
-            self.assertListEqual(c_m, [])
-
-    @data(
-        (
-            "method1",
-            "The method1 method is deprecated as of version 0.1.0 "
-            "and will be removed no sooner than 3 months after the release. "
-            "Instead use the some_method1 method and additional information.",
-        ),
-        (
-            "method2",
-            "The method2 method is deprecated as of version 0.2.0 "
-            "and will be removed no sooner than 3 months after the release. "
-            "Instead use the some_method2 method.",
-        ),
-    )
-    def test_method_deprecation(self, config):
-        """test method deprecation"""
-
-        method_name, msg_ref = config
-        method = getattr(TestClass(), method_name)
-
-        # emit deprecation the first time it is used
-        with warnings.catch_warnings(record=True) as c_m:
-            warnings.simplefilter("always")
-            self.assertEqual(3, method(3))
-            msg = str(c_m[0].message)
-            self.assertEqual(msg, msg_ref)
-            self.assertTrue("test_deprecation.py" in c_m[0].filename, c_m[0].filename)
-            self.assertEqual(self._get_line_from_str("method(3)"), c_m[0].lineno)
-
-        # trying again should not emit deprecation
-        with warnings.catch_warnings(record=True) as c_m:
-            warnings.simplefilter("always")
-            self.assertEqual(4, method(4))
-            self.assertListEqual(c_m, [])
-
-    def test_function_arguments_deprecation(self):
-        """test function arguments deprecation"""
-
-        msg_ref = (
-            "func3: the old_arg argument is deprecated as of version 0.1.2 "
-            "and will be removed no sooner than 3 months after the release. "
-            "Instead use the new_arg argument."
-        )
-        # both arguments at the same time should raise exception
-        with self.assertRaises(TypeError):
-            func3(new_arg="2222", old_arg="hello")
-
-        with warnings.catch_warnings(record=True) as c_m:
-            warnings.simplefilter("always")
-            self.assertEqual(("hello", None), func3(old_arg="hello"))
-            msg = str(c_m[0].message)
-            self.assertEqual(msg, msg_ref)
-            self.assertTrue("test_deprecation.py" in c_m[0].filename, c_m[0].filename)
-            self.assertEqual(self._get_line_from_str('func3(old_arg="hello")'), c_m[0].lineno)
-
-        # trying again should not emit deprecation
-        with warnings.catch_warnings(record=True) as c_m:
-            warnings.simplefilter("always")
-            self.assertEqual(("hello", None), func3(old_arg="hello"))
-            self.assertListEqual(c_m, [])
-
-    def test_method_arguments_deprecation(self):
-        """test method arguments deprecation"""
-
-        obj = TestClass()
-
-        msg_ref = (
-            "method3: the old_arg argument is deprecated as of version 0.1.2 "
-            "and will be removed no sooner than 3 months after the release. "
-            "Instead use the new_arg argument."
-        )
-        # both arguments at the same time should raise exception
-        with self.assertRaises(TypeError):
-            obj.method3(new_arg="2222", old_arg="hello")
-
-        with warnings.catch_warnings(record=True) as c_m:
-            warnings.simplefilter("always")
-            self.assertEqual(("hello", None), obj.method3(old_arg="hello"))
-            msg = str(c_m[0].message)
-            self.assertEqual(msg, msg_ref)
-            self.assertTrue("test_deprecation.py" in c_m[0].filename, c_m[0].filename)
-            self.assertEqual(self._get_line_from_str('obj.method3(old_arg="hello")'), c_m[0].lineno)
-
-        # trying again should not emit deprecation
-        with warnings.catch_warnings(record=True) as c_m:
-            warnings.simplefilter("always")
-            self.assertEqual(("hello", None), obj.method3(old_arg="hello"))
-            self.assertListEqual(c_m, [])
-
-    def test_property_deprecation(self):
-        """test property deprecation"""
-
-        obj = TestClass()
-
-        msg_ref = (
-            "The property1 property is deprecated as of version 0.1.0 "
-            "and will be removed no sooner than 3 months after the release."
-        )
-        # property get
-        # emit deprecation the first time it is used
-        with warnings.catch_warnings(record=True) as c_m:
-            warnings.simplefilter("always")
-            self.assertEqual(20, obj.property1)
-            msg = str(c_m[0].message)
-            self.assertEqual(msg, msg_ref)
-            self.assertTrue("test_deprecation.py" in c_m[0].filename, c_m[0].filename)
-            self.assertEqual(self._get_line_from_str("obj.property1"), c_m[0].lineno)
-
-        # trying again should not emit deprecation
-        with warnings.catch_warnings(record=True) as c_m:
-            warnings.simplefilter("always")
-            self.assertEqual(20, obj.property1)
-            self.assertListEqual(c_m, [])
-
-        msg_ref = (
-            "The property1 property is deprecated as of version 0.1.0 "
-            "and will be removed no sooner than 3 months after the release. "
-            "Instead use the new_property property and some additional information."
-        )
-        # property set
-        # emit deprecation the first time it is used
-        with warnings.catch_warnings(record=True) as c_m:
-            warnings.simplefilter("always")
-            obj.property1 = 0
-            self.assertEqual(0, obj.property1)
-            msg = str(c_m[0].message)
-            self.assertEqual(msg, msg_ref)
-            self.assertTrue("test_deprecation.py" in c_m[0].filename, c_m[0].filename)
-            self.assertEqual(self._get_line_from_str("obj.property1 = 0"), c_m[0].lineno)
-
-        # trying again should not emit deprecation
-        with warnings.catch_warnings(record=True) as c_m:
-            warnings.simplefilter("always")
-            obj.property1 = 0
-            self.assertEqual(0, obj.property1)
-            self.assertListEqual(c_m, [])
-
-
-if __name__ == "__main__":
-    unittest.main()