Skip to content

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 
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
def compile_binomial_layer(compiler: "TorchCompiler", sl: BinomialLayer) -> TorchBinomialLayer:
    if sl.logits is None:
        probs = compiler.compile_parameter(sl.probs)
        logits = None
    else:
        probs = None
        logits = compiler.compile_parameter(sl.logits)
    return TorchBinomialLayer(
        torch.tensor(tuple(sl.scope)),
        sl.num_output_units,
        num_channels=sl.num_channels,
        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 
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
def compile_categorical_layer(
    compiler: "TorchCompiler", sl: CategoricalLayer
) -> TorchCategoricalLayer:
    if sl.logits is None:
        probs = compiler.compile_parameter(sl.probs)
        logits = None
    else:
        probs = None
        logits = compiler.compile_parameter(sl.logits)
    return TorchCategoricalLayer(
        torch.tensor(tuple(sl.scope)),
        sl.num_output_units,
        num_channels=sl.num_channels,
        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 
135
136
137
138
139
140
141
142
143
144
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 
34
35
36
37
38
39
40
41
42
43
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_channels=sl.num_channels,
        num_states=sl.num_states,
        weight=weight,
        semiring=compiler.semiring,
    )

compile_evidence_layer(compiler, sl) ¤

Source code in cirkit/backend/torch/rules/layers.py 
147
148
149
150
151
152
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 
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
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,
        num_channels=sl.num_channels,
        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 
116
117
def compile_hadamard_layer(compiler: "TorchCompiler", sl: KroneckerLayer) -> 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 
120
121
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 
102
103
104
105
106
107
108
109
110
111
112
113
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,
        num_channels=sl.num_channels,
        degree=sl.degree,
        coeff=coeff,
        semiring=compiler.semiring,
    )

compile_sum_layer(compiler, sl) ¤

Source code in cirkit/backend/torch/rules/layers.py 
124
125
126
127
128
129
130
131
132
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,
    )