Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Daftar jenis hasil
<a name="braket-result-types"></a>

Amazon Braket dapat mengembalikan berbagai jenis hasil ketika sirkuit diukur menggunakan `ResultType`. Sirkuit dapat mengembalikan jenis hasil berikut.
+  `AdjointGradient`mengembalikan gradien (turunan vektor) dari nilai ekspektasi dari observable yang disediakan. Observable ini bekerja pada target yang diberikan sehubungan dengan parameter yang ditentukan menggunakan metode diferensiasi adjoint. Anda hanya dapat menggunakan metode ini ketika shots=0.
+  `Amplitude`mengembalikan amplitudo keadaan kuantum tertentu dalam fungsi gelombang keluaran. Ini hanya tersedia di simulator lokal SV1 dan lokal.
+  `Expectation`mengembalikan nilai ekspektasi dari observable yang diberikan, yang dapat ditentukan dengan `Observable` kelas diperkenalkan nanti dalam chapter ini. Target yang qubits digunakan untuk mengukur yang dapat diamati harus ditentukan, dan jumlah target yang ditentukan harus sama dengan jumlah qubits tindakan yang dapat diamati. Jika tidak ada target yang ditentukan, observable harus beroperasi hanya pada 1 qubit dan diterapkan ke semua secara qubits paralel.
+  `Probability`mengembalikan probabilitas pengukuran keadaan basis komputasi. Jika target tidak ditentukan, `Probability` mengembalikan probabilitas mengukur semua keadaan dasar. Jika target ditentukan, hanya probabilitas marjinal dari vektor dasar pada yang ditentukan yang dikembalikan. qubits Simulator terkelola dan QPUs dibatasi hingga maksimum 15 qubit, dan simulator lokal terbatas pada ukuran memori sistem.
+  `Reduced density matrix`mengembalikan matriks kepadatan untuk subsistem target tertentu qubits dari sistem. qubits Untuk membatasi ukuran jenis hasil ini, Braket membatasi jumlah target qubits hingga maksimal 8.
+  `StateVector`mengembalikan vektor status penuh. Ini tersedia di simulator lokal.
+  `Sample`mengembalikan jumlah pengukuran dari qubit set target tertentu dan dapat diamati. Jika tidak ada target yang ditentukan, observable harus beroperasi hanya pada 1 qubit dan diterapkan ke semua secara qubits paralel. Jika target ditentukan, jumlah target yang ditentukan harus sama dengan jumlah qubits tindakan yang dapat diamati.
+  `Variance`mengembalikan varians (`mean([x-mean(x)]2)`) dari qubit set target yang ditentukan dan dapat diamati sebagai jenis hasil yang diminta. Jika tidak ada target yang ditentukan, observable harus beroperasi hanya pada 1 qubit dan diterapkan ke semua secara qubits paralel. Jika tidak, jumlah target yang ditentukan harus sama dengan jumlah qubits yang dapat diamati dapat diterapkan.

 **Jenis hasil yang didukung untuk penyedia yang berbeda:** 


|  |  |  |  |  |  |  |  |  | 
| --- |--- |--- |--- |--- |--- |--- |--- |--- |
|  |  Sim lokal  |   SV1   |   DM1   |   TN1   |   AQT   |   IonQ   |   IQM   |   Rigetti   | 
|  Gradien bersebelahan  |  T  |  Y  |  T  |  T  |  T  |  T  |  T  |  T  | 
|  Amplitudo  |  Y  |  Y  |  T  |  T  |  T  |  T  |  T  |  T  | 
|  Perkiraan  |  Y  |  Y  |  Y  |  Y  |  Y  |  Y  |  Y  |  Y  | 
|  probabilitas  |  Y  |  Y  |  Y  |  T  |  Y  |  Y  |  Y  |  Y  | 
|  Mengurangi matriks kepadatan  |  Y  |  T  |  Y  |  T  |  T  |  T  |  T  |  T  | 
|  Vektor keadaan  |  Y  |  T  |  T  |  T  |  T  |  T  |  T  |  T  | 
|  Sampel  |  Y  |  Y  |  Y  |  Y  |  Y  |  Y  |  Y  |  Y  | 
|  Varians  |  Y  |  Y  |  Y  |  Y  |  Y  |  Y  |  Y  |  Y  | 

Anda dapat memeriksa jenis hasil yang didukung dengan memeriksa properti perangkat, seperti yang ditunjukkan pada contoh berikut.

```
from braket.aws import AwsDevice

device = AwsDevice("arn:aws:braket:us-west-1::device/qpu/rigetti/Ankaa-3")

# Print the result types supported by this device
for iter in device.properties.action['braket.ir.openqasm.program'].supportedResultTypes:
    print(iter)
```

```
name='Sample' observables=['x', 'y', 'z', 'h', 'i'] minShots=10 maxShots=50000
name='Expectation' observables=['x', 'y', 'z', 'h', 'i'] minShots=10 maxShots=50000
name='Variance' observables=['x', 'y', 'z', 'h', 'i'] minShots=10 maxShots=50000
name='Probability' observables=None minShots=10 maxShots=50000
```

Untuk memanggil a`ResultType`, tambahkan ke sirkuit, seperti yang ditunjukkan pada contoh berikut.

```
from braket.circuits import Circuit, Observable

circ = Circuit().h(0).cnot(0, 1).amplitude(state=["01", "10"])
circ.probability(target=[0, 1])
circ.probability(target=0)
circ.expectation(observable=Observable.Z(), target=0)
circ.sample(observable=Observable.X(), target=0)
circ.state_vector()
circ.variance(observable=Observable.Z(), target=0)

# Print one of the result types assigned to the circuit
print(circ.result_types[0])
```

**catatan**  
Perangkat kuantum yang berbeda memberikan hasil dalam berbagai format. Misalnya, Rigetti perangkat mengembalikan pengukuran, sementara IonQ perangkat memberikan probabilitas. Amazon Braket SDK menawarkan properti pengukuran untuk semua hasil. Namun, untuk perangkat yang mengembalikan probabilitas, pengukuran ini dihitung pasca-perhitungan dan berdasarkan probabilitas, karena pengukuran per tembakan tidak tersedia. Untuk menentukan apakah suatu hasil telah dihitung setelah dihitung, periksa `measurements_copied_from_device` pada objek hasil. Operasi ini dirinci dalam file [gate\$1model\$1quantum\$1task\$1result.py di repositori](https://github.com/aws/amazon-braket-sdk-python/blob/ca5b08dada4839ca31c012ff50aa20b656fd1879/src/braket/tasks/gate_model_quantum_task_result.py#L70-L72) SDK GitHub Amazon Braket.

## Hasil pengamatan
<a name="braket-result-types-observables"></a>

`Observable`Kelas Amazon Braket memungkinkan Anda mengukur pengamatan tertentu. 

Anda hanya dapat menerapkan satu non-identitas unik yang dapat diamati untuk masing-masing. qubit Terjadi kesalahan Jika Anda menentukan dua atau lebih yang dapat diamati non-identitas yang berbeda untuk hal yang sama. qubit Untuk tujuan ini, setiap faktor produk tensor dihitung sebagai individu yang dapat diamati. Ini berarti Anda dapat memiliki beberapa produk tensor yang samaqubit, selama faktor-faktor yang bekerja pada itu qubit tetap sama.

Observable dapat diskalakan dan menambahkan observable lainnya (diskalakan atau tidak). Ini menciptakan `Sum` yang dapat digunakan dalam tipe `AdjointGradient` hasil.

`Observable`Kelas ini mencakup observable berikut.

```
import numpy as np

Observable.I()
Observable.H()
Observable.X()
Observable.Y()
Observable.Z()

# Get the eigenvalues of the observable
print("Eigenvalue:", Observable.H().eigenvalues)
# Or rotate the basis to be computational basis
print("Basis rotation gates:", Observable.H().basis_rotation_gates)

# Get the tensor product of the observable for the multi-qubit case
tensor_product = Observable.Y() @ Observable.Z()
# View the matrix form of an observable by using
print("The matrix form of the observable:\n", Observable.Z().to_matrix())
print("The matrix form of the tensor product:\n", tensor_product.to_matrix())

# Factorize an observable in the tensor form
print("Factorize an observable:", tensor_product.factors)

# Self-define observables, given it is a Hermitian
print("Self-defined Hermitian:", Observable.Hermitian(matrix=np.array([[0, 1], [1, 0]])))

print("Sum of other (scaled) observables:", 2.0 * Observable.X() @ Observable.X() + 4.0 * Observable.Z() @ Observable.Z())
```

```
Eigenvalue: [ 1. -1.]
Basis rotation gates: (Ry('angle': -0.7853981633974483, 'qubit_count': 1),)
The matrix form of the observable:
 [[ 1.+0.j  0.+0.j]
 [ 0.+0.j -1.+0.j]]
The matrix form of the tensor product:
 [[ 0.+0.j  0.+0.j  0.-1.j  0.+0.j]
 [ 0.+0.j -0.+0.j  0.+0.j  0.+1.j]
 [ 0.+1.j  0.+0.j  0.+0.j  0.+0.j]
 [ 0.+0.j  0.-1.j  0.+0.j -0.+0.j]]
Factorize an observable: (Y('qubit_count': 1), Z('qubit_count': 1))
Self-defined Hermitian: Hermitian('qubit_count': 1, 'matrix': [[0.+0.j 1.+0.j], [1.+0.j 0.+0.j]])
Sum of other (scaled) observables: Sum(TensorProduct(X('qubit_count': 1), X('qubit_count': 1)), TensorProduct(Z('qubit_count': 1), Z('qubit_count': 1)))
```

## Parameter
<a name="braket-result-types-parameters"></a>

Sirkuit dapat menggabungkan parameter gratis. Parameter gratis ini hanya perlu dibangun sekali untuk dijalankan beberapa kali, dan dapat digunakan untuk menghitung gradien. 

Setiap parameter gratis menggunakan nama yang disandikan string yang digunakan untuk: 
+ Tetapkan nilai parameter
+ Identifikasi parameter mana yang akan digunakan

```
from braket.circuits import Circuit, FreeParameter, observables
from braket.parametric import FreeParameter

theta = FreeParameter("theta")
phi = FreeParameter("phi")
circ = Circuit().h(0).rx(0, phi).ry(0, phi).cnot(0, 1).xx(0, 1, theta)
```

## Gradien bersebelahan
<a name="braket-result-types-adjoint-gradient"></a>

SV1Perangkat menghitung gradien berdampingan dari nilai ekspektasi yang dapat diamati, termasuk Hamiltonian multi-term. Untuk membedakan parameter, tentukan namanya (dalam format string) atau dengan referensi langsung.

```
from braket.aws import AwsDevice
from braket.devices import Devices

device = AwsDevice(Devices.Amazon.SV1)

circ.adjoint_gradient(observable=3 * Observable.Z(0) @ Observable.Z(1) - 0.5 * observables.X(0), parameters = ["phi", theta])
```

Melewati nilai parameter tetap sebagai argumen ke sirkuit berparameter akan menghapus parameter bebas. Menjalankan sirkuit ini dengan `AdjointGradient` menghasilkan kesalahan, karena parameter bebas tidak ada lagi. Contoh kode berikut menunjukkan penggunaan yang benar dan salah:

```
# Will error, as no free parameters will be present
#device.run(circ(0.2), shots=0)

# Will succeed
device.run(circ, shots=0, inputs={'phi': 0.2, 'theta': 0.2})
```