layers

layers

DEFAULT_LAYER_COMPILATION_RULES = {EmbeddingLayer: compile_embedding_layer, CategoricalLayer: compile_categorical_layer, BinomialLayer: compile_binomial_layer, GaussianLayer: compile_gaussian_layer, PolynomialLayer: compile_polynomial_layer, HadamardLayer: compile_hadamard_layer, KroneckerLayer: compile_kronecker_layer, SumLayer: compile_sum_layer, ConstantValueLayer: compile_constant_value_layer, EvidenceLayer: compile_evidence_layer} module-attribute

compile_binomial_layer(compiler, sl)

Source code in cirkit/backend/torch/rules/layers.py

def compile_binomial_layer(
    compiler: "TorchCompiler", sl: BinomialLayer
) -> TorchBinomialLayer:
    if sl.logits is None:
        assert sl.probs is not None
        probs = compiler.compile_parameter(sl.probs)
        logits = None
    else:
        assert sl.logits is not None
        logits = compiler.compile_parameter(sl.logits)
        probs = None
    return TorchBinomialLayer(
        torch.tensor(tuple(sl.scope)),
        sl.num_output_units,
        total_count=sl.total_count,
        probs=probs,
        logits=logits,
        semiring=compiler.semiring,
    )

compile_categorical_layer(compiler, sl)

Source code in cirkit/backend/torch/rules/layers.py

def compile_categorical_layer(
    compiler: "TorchCompiler", sl: CategoricalLayer
) -> TorchCategoricalLayer:
    if sl.logits is None:
        assert sl.probs is not None
        probs = compiler.compile_parameter(sl.probs)
        logits = None
    else:
        assert sl.logits is not None
        logits = compiler.compile_parameter(sl.logits)
        probs = None
    return TorchCategoricalLayer(
        torch.tensor(tuple(sl.scope)),
        sl.num_output_units,
        num_categories=sl.num_categories,
        probs=probs,
        logits=logits,
        semiring=compiler.semiring,
    )

compile_constant_value_layer(compiler, sl)

Source code in cirkit/backend/torch/rules/layers.py

def compile_constant_value_layer(
    compiler: "TorchCompiler", sl: ConstantValueLayer
) -> TorchConstantValueLayer:
    value = compiler.compile_parameter(sl.value)
    return TorchConstantValueLayer(
        sl.num_output_units,
        log_space=sl.log_space,
        value=value,
        semiring=compiler.semiring,
    )

compile_embedding_layer(compiler, sl)

Source code in cirkit/backend/torch/rules/layers.py

def compile_embedding_layer(
    compiler: "TorchCompiler", sl: EmbeddingLayer
) -> TorchEmbeddingLayer:
    weight = compiler.compile_parameter(sl.weight)
    return TorchEmbeddingLayer(
        torch.tensor(tuple(sl.scope)),
        sl.num_output_units,
        num_states=sl.num_states,
        weight=weight,
        semiring=compiler.semiring,
    )

compile_evidence_layer(compiler, sl)

Source code in cirkit/backend/torch/rules/layers.py

def compile_evidence_layer(
    compiler: "TorchCompiler", sl: EvidenceLayer
) -> TorchEvidenceLayer:
    layer = compiler.compile_layer(sl.layer)
    observation = compiler.compile_parameter(sl.observation)
    return TorchEvidenceLayer(
        cast(TorchInputLayer, layer),
        observation=observation,
        semiring=compiler.semiring,
    )

compile_gaussian_layer(compiler, sl)

Source code in cirkit/backend/torch/rules/layers.py

def compile_gaussian_layer(
    compiler: "TorchCompiler", sl: GaussianLayer
) -> TorchGaussianLayer:
    mean = compiler.compile_parameter(sl.mean)
    stddev = compiler.compile_parameter(sl.stddev)
    if sl.log_partition is not None:
        log_partition = compiler.compile_parameter(sl.log_partition)
    else:
        log_partition = None
    return TorchGaussianLayer(
        torch.tensor(tuple(sl.scope)),
        sl.num_output_units,
        mean=mean,
        stddev=stddev,
        log_partition=log_partition,
        semiring=compiler.semiring,
    )

compile_hadamard_layer(compiler, sl)

Source code in cirkit/backend/torch/rules/layers.py

def compile_hadamard_layer(
    compiler: "TorchCompiler", sl: HadamardLayer
) -> TorchHadamardLayer:
    return TorchHadamardLayer(
        sl.num_input_units, arity=sl.arity, semiring=compiler.semiring
    )

compile_kronecker_layer(compiler, sl)

Source code in cirkit/backend/torch/rules/layers.py

def compile_kronecker_layer(
    compiler: "TorchCompiler", sl: KroneckerLayer
) -> TorchKroneckerLayer:
    return TorchKroneckerLayer(
        sl.num_input_units, arity=sl.arity, semiring=compiler.semiring
    )

compile_polynomial_layer(compiler, sl)

Source code in cirkit/backend/torch/rules/layers.py

def compile_polynomial_layer(
    compiler: "TorchCompiler", sl: PolynomialLayer
) -> TorchPolynomialLayer:
    coeff = compiler.compile_parameter(sl.coeff)
    return TorchPolynomialLayer(
        torch.tensor(tuple(sl.scope)),
        sl.num_output_units,
        degree=sl.degree,
        coeff=coeff,
        semiring=compiler.semiring,
    )

compile_sum_layer(compiler, sl)

Source code in cirkit/backend/torch/rules/layers.py

def compile_sum_layer(compiler: "TorchCompiler", sl: SumLayer) -> TorchSumLayer:
    weight = compiler.compile_parameter(sl.weight)
    return TorchSumLayer(
        sl.num_input_units,
        sl.num_output_units,
        arity=sl.arity,
        weight=weight,
        semiring=compiler.semiring,
    )