バックプロパゲーション中のパウリ項の切り捨て

このガイドでは、 qiskit_addon_obp.utils.truncating モジュールが提供するパウリ項の切り捨てメカニズムの設定方法について説明します。

演算子バックプロパゲーション（OBP）を用いることで、観測量の複雑さを増すことを代償として、量子回路の深さを減らすことができる。 OBPから有意義な結果を得るためには、通常、観測可能変数から項を切り捨て、その規模が過度に大きくなるのを防ぐ必要があります。演算子のサイズが過度に大きくなるのを防ぎつつ、回路内でのバックプロパゲーションをより深く行うための方法の一つは、係数の小さい項を演算子に加えるのではなく、それらを切り捨てることです。項を切り捨てると、実行すべき量子回路の数が減る可能性があるが、その一方で、最終的な期待値の計算において、切り捨てられた項の係数の大きさに比例する誤差が生じる。

バックプロパゲーション手法では、オプションの TruncationErrorBudget を受け取ります。これは、各スライスのバックプロパゲーションが正常に完了した後、各観測量について重みの小さいパウリ項の切り捨てを設定するものです。切り捨てられる項の数は、ユーザーが指定したさまざまな設定パラメータによって決まります。現時点では、利用可能な切り捨て戦略は「 truncate_binary_search 」メソッドのみです。ある観測量と予算が与えられると、その観測量に含まれるパウリ項および係数に対して二分探索を行い、切り捨てられた係数の和が最大となるが、予算を下回るような最適な閾値を見つけ出します。

注：デフォルトでは、切り捨て誤差の評価および上限の算出には L1 ノルムが使用されますが、この設定 p_norm を有効にすると、使用するLpノルムを指定できるようになります。この設定の使用方法の詳細については、「パウリ項の切り捨てに異なるLpノルムを使用する」ガイドを参照してください。

以下の例は、付属のsetup _budget 関数を使用して TruncationErrorBudget を構築するさまざまな方法を示しています。

例となる回路を組み立てる

このガイドでは、以下の回路スライスを使用しています：

import rustworkx.generators
from qiskit.synthesis import LieTrotter
from qiskit_addon_utils.problem_generators import (
    PauliOrderStrategy,
    generate_time_evolution_circuit,
    generate_xyz_hamiltonian,
)
from qiskit_addon_utils.slicing import combine_slices, slice_by_gate_types

# Generate a linear chain of 10 qubits
linear_chain = rustworkx.generators.path_graph(10)

# Use an arbitrary XY model
hamiltonian = generate_xyz_hamiltonian(
    linear_chain,
    coupling_constants=(0.05, 0.02, 0.0),
    ext_magnetic_field=(0.02, 0.08, 0.0),
    pauli_order_strategy=PauliOrderStrategy.InteractionThenColor,
)
# Evolve for some time
circuit = generate_time_evolution_circuit(
    hamiltonian, synthesis=LieTrotter(reps=3), time=2.0
)
# slice the circuit by gate type
slices = slice_by_gate_types(circuit)

# for visualization purposes, recombine the slices with barriers between them and draw the resulting circuit
combine_slices(slices, include_barriers=True).draw("mpl", fold=50, scale=0.6)

Output:

ここでは、1つの単純な観測量について見ていきます：

from qiskit.quantum_info import SparsePauliOp

obs = SparsePauliOp("IIIIIZIIII")

最も単純なケース：各スライスごとに固定の切り捨て予算を設定する場合

パウリ項の切り捨てに割り当てられる予算は、バックプロパゲーションの各ステップごとに異なる場合があります。この仕組みを理解するために、まず、ユーザーが指定した固定の切り捨て予算という最も単純なケースについて見ていきます。

切り捨ての許容範囲を指定する最も簡単な方法は、``引数 max_error_per_slice を使用することです。実際、「演算子によるバックプロパゲーションを用いた回路の深さの削減」というチュートリアルでは、まさにこの手法が用いられています。を max_error_per_slice に設定すると float 、各スライスにその値に等しい予算が割り当てられます。以下の例では、この値をに設定しています。 0.001 これにより、18個のスライスすべてに対してバックプロパゲーションが行われた場合 0.018、暗黙の切り捨て誤差が以下に抑えられることが保証されます。

なお、スライスのバックプロパゲーションを行い、係数の小さい項を切り捨てた後に残った誤差許容範囲は、常に次のスライスの誤差許容範囲に加算されることに注意してください。

from qiskit_addon_obp.utils.truncating import setup_budget

truncation_error_budget = setup_budget(max_error_per_slice=0.001)
print(truncation_error_budget)

Output:

TruncationErrorBudget(per_slice_budget=[0.001], max_error_total=inf, p_norm=1)

from qiskit_addon_obp import backpropagate
from qiskit_addon_obp.utils.simplify import OperatorBudget

op_budget = OperatorBudget(max_qwc_groups=10)
bp_obs, remaining_slices, metadata = backpropagate(
    obs,
    slices,
    operator_budget=op_budget,
    truncation_error_budget=truncation_error_budget,
)
reduced_circuit = combine_slices(remaining_slices)
print(f"Backpropagated {len(slices) - len(remaining_slices)} circuit slices.")
print(
    f"New observable contains {len(bp_obs)} terms and {len(bp_obs.group_commuting(qubit_wise=True))} commuting groups."
)

Output:

Backpropagated 11 circuit slices.
New observable contains 29 terms and 10 commuting groups.

次に、 OBPMetadata インスタンスと可視化モジュールが提供するツールを使用して、バックプロパゲーションのプロセスを可視化します。

左上のグラフから、 3番目のスライスのバックプロパゲーションを終えた時点で、観測可能な項の切り捨てを開始するのに十分な予算があることがわかります。 3番目のスライスからは、各スライスごとにバックプロパゲーションを行う際、少なくとも1つの項が切り捨てられることが分かっています。これは、各スライスの後に何らかの切り捨て誤差が生じているためです。
右上のグラフは、 3番目のスライス .003 において誤差予算がまで増加することを示している。残りの予算が急激に減少していることが確認され、これは観測データから条件が切り捨てられたことを意味します。これは、左上の図から推測した内容と一致しています。
左下のグラフは、観測可能な項を順次切り捨てていくにつれて、累積誤差が単調増加していることを示しています。このグラフからも、3番目のスライスのバックプロパゲーションが完了するまでは、どの項も切り捨てられていなかったことが確認できる。
右下の図から、我々の観測量におけるコミューティング・パウリ群の数が、指定された限界値であるまで増加していることがわかる 10。このグラフからは、黒線と赤線が交差しているところからもわかるように、バックプロパゲーションをもう1層行うと、観測値が指定された範囲を超えてしまうことも示されています。

なお、これらのグラフすべてにおいて、x軸はバックプロパゲーションされたスライスを列挙したものですが、OBPは回路の末端で動作するため、 slice 1 は最も最後のスライス、はその前のスライス、というように続きます slice 2 。

from matplotlib import pyplot as plt
from qiskit_addon_obp.utils.visualization import (
    plot_accumulated_error,
    plot_left_over_error_budget,
    plot_num_qwc_groups,
    plot_slice_errors,
)

fig, axes = plt.subplots(2, 2, figsize=(20, 10))
plot_slice_errors(metadata, axes[(0, 0)])
plot_left_over_error_budget(metadata, axes[(0, 1)])
plot_accumulated_error(metadata, axes[(1, 0)])
plot_num_qwc_groups(metadata, axes[(1, 1)])

Output:

スライスの予算を明示的に指定する

バックプロパゲーションのパフォーマンスが最適化されるように、各スライスに予算を割り当てる方法をご存知であれば、各スライスに明示的に予算を割り当てることを検討するとよいでしょう。説明のために、最初の3つのスライスには予算をゼロとし、残りのスライスにはスライス .001 ごとにの予算を割り当てます。

# Zero out the first 3 slices' budgets
max_error_per_slice = [0.0] * 3 + [0.001] * (len(slices) - 3)

truncation_error_budget = setup_budget(
    max_error_per_slice=max_error_per_slice
)
print(truncation_error_budget)

Output:

TruncationErrorBudget(per_slice_budget=[0.0, 0.0, 0.0, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001, 0.001], max_error_total=inf, p_norm=1)

bp_obs, remaining_slices, metadata = backpropagate(
    obs,
    slices,
    operator_budget=op_budget,
    truncation_error_budget=truncation_error_budget,
)
reduced_circuit = combine_slices(remaining_slices)
print(f"Backpropagated {len(slices) - len(remaining_slices)} circuit slices.")
print(
    f"New observable contains {len(bp_obs)} terms and {len(bp_obs.group_commuting(qubit_wise=True))} commuting groups."
)

Output:

Backpropagated 11 circuit slices.
New observable contains 32 terms and 10 commuting groups.

最初の3つのレイヤーから予算を削除したところ、4番目のレイヤー以降になるまで、どの用語も切り捨てられることはなかった。これは、これらのプロットのうち3つで確認できる。少々意外に思えるかもしれないのは、4番目のスライスには残りの予算が割り当てられていなかったにもかかわらず、割り当てられた予算 .001 が使用された結果、1つの期間が切り詰められてしまったという点だ。これは左上のグラフから明らかですが、 右上のグラフでも、スライス3と4の間で残りの予算曲線が横ばいになっていることから確認できます。もう1つ注目すべき点は、前の例と同様に、この時点から少なくとも1つの項が切り捨てられたことです。

重要なポイントは、2番目の例では一部のスライスの予算をゼロにしたため切り捨て誤差は少なくなったものの、バックプロパゲーションの対象となるスライスの数は同じであり、観測可能量に含まれるコミューティング・パウリ群の数も同様であったということです。 左下のグラフを確認することで、2番目の例の方が誤差の上限が小さいことが確認できます。

fig, axes = plt.subplots(2, 2, figsize=(20, 10))
plot_slice_errors(metadata, axes[(0, 0)])
plot_left_over_error_budget(metadata, axes[(0, 1)])
plot_accumulated_error(metadata, axes[(1, 0)])
plot_num_qwc_groups(metadata, axes[(1, 1)])

Output:

予算を周期的に設定する

トロッター回路など、繰り返しパターンがある回路の場合、その繰り返しされるスライスのサブセットに対して予算を指定し、その後のそのスライスのすべての繰り返しに対してその予算が適用されるようにしたい場合があります。

より具体的に言えば、今回使用している例示回路には6つのスライスが3回繰り返されており、合計で18個のスライスがあります。単一量子ビット層および各層 RYY には、予算をゼロと任意に設定し、各層 RXX にはそれぞれ予算 .003 を割り当てます。予算を length-6 のシーケンスとして指定すると、18枚すべてのスライスに予算が周期的に適用される様子を確認します。

繰り返しになりますが、スライスは逆順（つまり、最後から順に）でバックプロパゲーションが行われる点に注意してください。したがって、循環予算の最初のエントリは実際には最後のスライスに割り当てられ、2番目のエントリはその前のスライスに割り当てられ、というように続きます。

# Specify a length-6 per-slice budget.
# This will be cycled over three times to be applied to the 18 slices
max_error_per_slice = [0.0] * 4 + [0.003] * 2

truncation_error_budget = setup_budget(
    max_error_per_slice=max_error_per_slice
)
print(truncation_error_budget)

Output:

TruncationErrorBudget(per_slice_budget=[0.0, 0.0, 0.0, 0.0, 0.003, 0.003], max_error_total=inf, p_norm=1)

op_budget = OperatorBudget(max_qwc_groups=20)
bp_obs, remaining_slices, metadata = backpropagate(
    obs,
    slices,
    operator_budget=op_budget,
    truncation_error_budget=truncation_error_budget,
)
reduced_circuit = combine_slices(remaining_slices)
print(f"Backpropagated {len(slices) - len(remaining_slices)} circuit slices.")
print(
    f"New observable contains {len(bp_obs)} terms and {len(bp_obs.group_commuting(qubit_wise=True))} commuting groups."
)

Output:

Backpropagated 13 circuit slices.
New observable contains 49 terms and 14 commuting groups.

左上および左下の画像に見られるように、最初の4つのスライスにはエラーバジェットが割り当てられていなかったため、切り捨ては行われませんでした。第5および第6のスライスでは、予算が確保されたことに伴い、一部の用語が省略されました。

左上の画像に見られるように、スライス7には予算が割り当てられていなかったにもかかわらず、そのスライスのバックプロパゲーション後に比較的大きな誤差が生じました。これは、スライス5と6に割り当てられた .006 総予算のうち .002 、約しか使用されなかったため、残りの部分がスライス7に振り替えられ、 右上の画像にあるように、その大部分が支出されたためです。

左上と右上の画像から、わずかに残っていた予算がスライス8～10の間に使い切られ、予想通りスライス11で新たな予算が利用可能になることがわかります。左上、右上、および左下の図はすべて、引数の長さがスライスの数より少ない場合の、その引 max_error_per_slice 数の周期的な挙動を示しています。この周期的な挙動はすべてのスライスにわたって続いたはずですが、 右下の画像にあるように、13スライスのバックプロパゲーションを行った後に停止 max_qwc_groups 基準に達しました。

また興味深いのは、スライス11で第2ラウンドの予算が確保された後、パウリ群の数が実際に減少することだ。これは、スライス11のバックプロパゲーション後に予算が増えるまで切り捨てることができなかった係数の小さいグループが存在したため、それらが数回の反復にわたって観測可能量に蓄積されたからである。また、この事例は、アルゴリズムが終了するためには、が*超え *max_qwc_groups なければならないことを浮き彫りにしている。

fig, axes = plt.subplots(2, 2, figsize=(20, 10))
plot_slice_errors(metadata, axes[(0, 0)])
plot_left_over_error_budget(metadata, axes[(0, 1)])
plot_accumulated_error(metadata, axes[(1, 0)])
plot_num_qwc_groups(metadata, axes[(1, 1)])

Output:

エラーの合計に上限を設ける

スライスごとの誤差許容範囲を指定することに加え、切り捨てによって生じる誤差の最大許容値も指定することができます。その制限に達すると、それ以上の切り捨ては行われませんが、観測値が過大になり、停止基準のいずれかが満たされるまで、バックプロパゲーションは継続されます。

次に、スライス7のバックプロパゲーション後にエラーバジェットが使い果たされる max_error_total ように、に上限を設定して、上記の実験を再度実行する。

# Specify a length-6 per-slice budget.
# This will be cycled over 3 times to be applied to the 18 slices
max_error_per_slice = [0.0] * 4 + [0.003] * 2

truncation_error_budget = setup_budget(
    max_error_per_slice=max_error_per_slice, max_error_total=0.006
)
print(truncation_error_budget)

Output:

TruncationErrorBudget(per_slice_budget=[0.0, 0.0, 0.0, 0.0, 0.003, 0.003], max_error_total=0.006, p_norm=1)

bp_obs, remaining_slices, metadata = backpropagate(
    obs,
    slices,
    operator_budget=op_budget,
    truncation_error_budget=truncation_error_budget,
)
reduced_circuit = combine_slices(remaining_slices)
print(f"Backpropagated {len(slices) - len(remaining_slices)} circuit slices.")
print(
    f"New observable contains {len(bp_obs)} terms and {len(bp_obs.group_commuting(qubit_wise=True))} commuting groups."
)

Output:

Backpropagated 10 circuit slices.
New observable contains 67 terms and 20 commuting groups.

予想通り、切り捨て誤差は（ .006** 左下の**グラフ）で上限に達しています。今回の実行では、スライス11のバックプロパゲーションを行うことができなかった点が注目に値する。これは、項を切り捨てるための予算が足りず、 右下の図に示されているように 20、通勤するパウリ群の数がの限界を超えてしまったためです。

fig, axes = plt.subplots(2, 2, figsize=(20, 10))
plot_slice_errors(metadata, axes[(0, 0)])
plot_left_over_error_budget(metadata, axes[(0, 1)])
plot_accumulated_error(metadata, axes[(1, 0)])
plot_num_qwc_groups(metadata, axes[(1, 1)])

Output:

全体予算に上限を設けるだけで、具体的な金額を指定しない max_error_total 方が望ましい場合もある max_error_per_slice。

truncation_error_budget = setup_budget(max_error_total=0.018)
print(truncation_error_budget)

Output:

TruncationErrorBudget(per_slice_budget=[0.018], max_error_total=0.018, p_norm=1)

上のセルの出力は、がに設定 per_slice_budget されているため、少し意外に思えるかもしれません max_error_total。これは、利用可能な予算の全額が貪欲に使い尽くされることを示している。次のように考えてみてください。各スライスには予算全体が割り当てられます（ because we loop over the per_slice_budget）。ただし、すでに消費済みの予算は、アルゴリズムのその時点で利用可能な予算から差し引かれます。

op_budget = OperatorBudget(max_qwc_groups=10)
bp_obs, remaining_slices, metadata = backpropagate(
    obs,
    slices,
    operator_budget=op_budget,
    truncation_error_budget=truncation_error_budget,
)
reduced_circuit = combine_slices(remaining_slices)
print(f"Backpropagated {len(slices) - len(remaining_slices)} circuit slices.")
print(
    f"New observable contains {len(bp_obs)} terms and {len(bp_obs.group_commuting(qubit_wise=True))} commuting groups."
)

Output:

Backpropagated 9 circuit slices.
New observable contains 25 terms and 9 commuting groups.

右上の図は、 .018 エラーバジェット全体が最初のスライスに割り当てられる様子を示しています。 3番目のスライスまでは切り捨てが行われないため、残りの予算は一定のままとなります。予算は、バックプロパゲーションされた各スライスに全予算が割り当てられ、それが使い果たされるまで、単調に減少していきます。

注目すべきは、この実験では、このノートブック内の最初の実験（ほぼ同一の内容）と比較して、バックプロパゲーションが適用されたスライスの数が2つ少なかったという点である。これは、問題によっては、予算を均等に配分することが最適である可能性があることを示している。その他の問題については、スライスが予算を貪欲に使い切ることを許可した方が、パフォーマンスが向上する可能性があります。

fig, axes = plt.subplots(2, 2, figsize=(20, 10))
plot_slice_errors(metadata, axes[(0, 0)])
plot_left_over_error_budget(metadata, axes[(0, 1)])
plot_accumulated_error(metadata, axes[(1, 0)])
plot_num_qwc_groups(metadata, axes[(1, 1)])

Output:

バックプロパゲーションの対象となるスライスの数と総誤差を合わせて上限を設定する

エラーバジェットを回路全体に分散させたくないが、かといって無駄に消費したくもない場合は、バックプロパゲーションを行うスライスの数 (num_slices) と、総エラーバジェット (max_error_total) を指定することができます。これにより、エラーバジェットは（それに応じて p_norm）入力スライス全体に均等に分散されます。

ここでは、バックプロパゲーションの対象となるスライスの数をで上限設定し 12、総誤差予算はそのまま維持します。

num_slices = 12

truncation_error_budget = setup_budget(
    max_error_total=0.018, num_slices=num_slices, p_norm=1
)
print(truncation_error_budget)

Output:

TruncationErrorBudget(per_slice_budget=[0.0014999999999999998], max_error_total=0.018, p_norm=1)

それでは、前のステップで予算を割り当てた12のスライスについて、バックプロパゲーションを試みてみましょう。これを行うには、回路の最後の12スライスをそのまま渡すだけです。の場合 p_norm=1、12のスライスそれぞれに、利用可能な予算ががあります 0.018 / num_slices = 0.0015。

bp_obs, remaining_slices, metadata = backpropagate(
    obs,
    slices[-num_slices:],
    operator_budget=op_budget,
    truncation_error_budget=truncation_error_budget,
)

（コード内の slices[-num_slices:]）スライスの一部をに渡したため backpropagate、バックプロパゲーション後に残ったスライスと、バックプロパゲーション用に送信されなかったスライス（コード内の） slices[:-num_slices]とを結合する必要があります。

残りのスライスをすべて結合したら、 combine_slices を使用して、深さが削減された QuantumCircuit を生成できます。次に、バックプロパゲーションが行われたスライスの数と、観測可能変数の大きさがどのように変化したかを調べます。

# Recombine the slices remaining after backprop with the rest of the original circuit
reduced_circuit = combine_slices(slices[:-num_slices] + remaining_slices)

print(f"Backpropagated {num_slices - len(remaining_slices)} circuit slices.")
print(
    f"New observable contains {len(bp_obs)} terms and {len(bp_obs.group_commuting(qubit_wise=True))} commuting groups."
)

Output:

Backpropagated 12 circuit slices.
New observable contains 29 terms and 9 commuting groups.

これらのプロットから、観測可能量を10個の可換パウリ群以内に収めつつ、12個のスライスすべてに対してバックプロパゲーションを正常に実行できたことがわかります。また、とを併用 num_slices すると、各スライスに予算が配分 max_error_total され、未使用の予算は再び次のスライスに繰り越されることもわかります。これは右上のグラフで最も顕著に見られ、バックプロパゲーションの過程を通じて、予算が消費されると同時に補充されていることがわかります。

注目すべきは、この誤差の分散方法が、このノートブックでの最初の実験や、この直前の例と比較して、最良の結果（バックプロパゲーションされたスライスの数が多い）をもたらした点である。これらの例はすべて .018 エラーバジェットを割り当てていましたが、そのバジェットの配分方法によって、バックプロパゲーションの挙動は異なっていました。

fig, axes = plt.subplots(2, 2, figsize=(20, 10))
plot_slice_errors(metadata, axes[(0, 0)])
plot_left_over_error_budget(metadata, axes[(0, 1)])
plot_accumulated_error(metadata, axes[(1, 0)])
plot_num_qwc_groups(metadata, axes[(1, 1)])

Output:

複数のオブザーバブルを扱う

このメソッド qiskit_addon_obp.backpropagate では、オブザーバブルのシーケンスを引数として渡すことができます。これにより、複数のターゲットオブザーバブルを扱う際のワークフローが簡素化されます。

ここでは、切り捨て戦略がこのようなケースをどのように処理するかを説明するために、あえてこの点について言及しています。この例のために、これまで使用してきたオブザーバブルに、もう1つオブザーバブルを追加します：

obs = [SparsePauliOp("IIIIIZIIII"), SparsePauliOp("IIIIIXIIII")]

最後に、このチュートリアルの最初の実験をもう一度行いますしかし、バックプロパゲーションを行う対象となる観測量が2つある。

この例では、これはバックプロパゲーションの対象となるスライスの数には影響しません。しかし、これら2つの観測量では、パウリ項の数や可換群が異なっていることがわかる。

truncation_error_budget = setup_budget(max_error_per_slice=0.001)
print(truncation_error_budget)

Output:

TruncationErrorBudget(per_slice_budget=[0.001], max_error_total=inf, p_norm=1)

bp_obs, remaining_slices, metadata = backpropagate(
    obs,
    slices,
    operator_budget=op_budget,
    truncation_error_budget=truncation_error_budget,
)
reduced_circuit = combine_slices(remaining_slices)
print(f"Backpropagated {len(slices) - len(remaining_slices)} circuit slices.")
print(
    f"The new first observable contains {len(bp_obs[0])} terms and {len(bp_obs[0].group_commuting(qubit_wise=True))} commuting groups."
)
print(
    f"The new second observable contains {len(bp_obs[1])} terms and {len(bp_obs[1].group_commuting(qubit_wise=True))} commuting groups."
)

Output:

Backpropagated 11 circuit slices.
The new first observable contains 29 terms and 10 commuting groups.
The new second observable contains 23 terms and 8 commuting groups.

以下の図は、バックプロパゲーションアルゴリズムが複数の観測変数をどのように扱うかを示すものです。

まず、左上、右上、および左下のグラフから、項を切り捨てるための予算が、観測変数ごとに個別に設定されていることがわかります。つまり、どちらの観測量も、バックプロパゲーションされたスライス 0.001 ごとにの誤差があると仮定して、項を切り捨てる能力を持っている。観測可能な項目の性質が異なるため、その結果、予算の消費量も異なってきます。この例では、両者に多くの重複が見られますが、必ずしもそうなるわけではありません。

右下の図は、がすべての観測量を考慮に入 max_qwc_groups れていることを示している。つまり、すべての観測可能量の項をまとめて、クビットごとの可換群の最終的な個数を算出し、それをと比較する max_qwc_paulis。しきい max_paulis 値についても同様の処理が行われます（このノートブックでは詳しく説明しません）。これにより、すべての観測量にわたるパウリ項の数を制限することができます。

fig, axes = plt.subplots(2, 2, figsize=(20, 10))
plot_slice_errors(metadata, axes[(0, 0)])
plot_left_over_error_budget(metadata, axes[(0, 1)])
plot_accumulated_error(metadata, axes[(1, 0)])
plot_num_qwc_groups(metadata, axes[(1, 1)])

Output:

このページは役に立ちましたか？

バグや誤字の報告、またはコンテンツの要求はGitHubで行ってください。