Recortar

class TrimPolicy(*, trim_ratio=0.1, carryover_threshold=0.0001, carryover_ratio=0.1, max_strings_per_trim=None, max_carryover=None)

Bases: object

Un SubspacePolicy que clasifica lotes no coincidentes.

En cada iteración se diagonaliza cada lote, se conservan las cadenas de CI con mayor peso de cada uno, se fusionan y se lleva a cabo una nueva diagonalización sobre el subespacio fusionado. La energía de esa diagonalización es la que indica la iteración, y sus propias cadenas de CI recortadas sirven de base para la siguiente.

Pasa una instancia como argumento policy de diagonalize_fermionic_hamiltonian():

result = diagonalize_fermionic_hamiltonian(
    hcore,
    eri,
    bit_array,
    samples_per_batch=300,
    norb=norb,
    nelec=nelec,
    num_batches=5,
    policy=TrimPolicy(trim_ratio=0.1),
)

El coste de una iteración corresponde a las diagonalizaciones num_batches + 1 , en lugar de a num_batches, y el subespacio fusionado está limitado por lo que conservan los lotes.

Los lotes se extraen como un único conjunto de cadenas samples_per_batch * num_batches de bits repartidas entre ellos, de modo que ninguna cadena de bits aparezca en más de uno. La selección se realiza entre los lotes, por lo que su utilidad depende de hasta qué punto difieran dichos lotes: si los lotes se extrajeran de forma independiente, se solaparían en gran medida, lo que reduciría el conjunto de candidatos distintos y daría a una cadena de bits que apareciera en varios lotes varias oportunidades de superar el proceso de selección. Dado que eso se deriva del funcionamiento de esta programación, no es algo que haya que configurar.

Lo que hace que sean independientes son las configuraciones. Las matrices de cadenas de CI por giro derivadas de ellas pueden seguir compartiendo cadenas entre lotes, ya que dos configuraciones pueden coincidir en una de sus mitades.

Inicializar la política.

Esta política realiza dos tipos de recorte, y cada uno de ellos tiene sus propios límites. Los recortes de selección reducen cada lote de la primera ronda, una vez por lote; el recorte de arrastre reduce el subespacio fusionado hasta obtener las semillas que dan lugar a la siguiente iteración. El carryover aplica el mismo umbral de amplitud que StandardPolicy, y luego una fracción de lo que supera dicho umbral.

Parámetros

• trim_ratio (float) – La proporción de cadenas CI de cada lote, por sector de espín, que superan el filtrado y pasan al subespacio fusionado. Clasificado según la suma de los cuadrados de la amplitud con respecto al otro sector de espín.

• carryover_threshold (float) – Límite de amplitud para las cadenas de CI que sirven de base para la siguiente iteración, aplicado exactamente igual que lo StandardPolicy hace, con el mismo valor por defecto. Esto limita el peso descartado, en lugar del número de cadenas que se conservan.

• carryover_ratio (float) – La fracción de las cadenas que sobreviven y carryover_threshold que sirven de semilla para la siguiente iteración, ordenadas según la suma de los cuadrados de la amplitud en el otro sector de espín. El corte se aplica primero y la fracción reduce lo que queda, por lo que ambos abarcan cosas diferentes: el corte, el peso descartado; la fracción, el recuento.

• max_strings_per_trim (int | None) –

  Límite máximo del número de cadenas de CI, por sector de giro, que puede conservar cada ciclo de cribado. Allí donde se ata, reduce la relación efectiva, por lo que un ajuste mantiene las cuerdas min(ceil(trim_ratio * len(strings)), max_strings_per_trim) en cada sector. El valor por defecto es None, dejando trim_ratio que decida.

  Úsalo cuando un ratio retenga más de lo previsto: symmetrize_spin fusiona los dos sectores de spin en una sola lista y, de este modo, duplica aproximadamente lo que ofrece cada lote; un «large» samples_per_batch hace lo mismo.

  Esto no es un límite de un subespacio. Se aplica una vez por lote y las aportaciones se fusionan, por lo que el subespacio fusionado puede albergar hasta veces num_batches más cadenas por sector; en la práctica, la cifra se acerca a esa cifra, ya que los lotes tienen poco en común. El argumento max_dim de es diagonalize_fermionic_hamiltonian() lo que delimita un subespacio.

• max_carryover (int | None) – Límite máximo del número de cadenas de CI, por sector de giro, que sirven de base para la siguiente iteración, aplicado junto con carryover_ratio a la clasificación por peso marginal de lo que haya sobrevivido carryover_threshold. A diferencia de esto max_strings_per_trim , rige un único recorte del subespacio fusionado, por lo que limita el traspaso en su conjunto.

Subidas

ValueError : una relación no estaba en (0, 1], o un límite superior era inferior a uno.

Parámetros

• trim_ratio (float)
• carryover_threshold (float)
• carryover_ratio (float)
• max_strings_per_trim (int | None)
• max_carryover (int | None)

prepare_subspaces

refine

select_carryover

select_result