ltntorch 0.1.0

data/examples/4_semi_supervised_pattern_recognition.rb

@@ -0,0 +1,249 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Mauro Tortonesi.
+# Ported from LTNtorch's examples/4-semi-supervised_pattern_recognition.ipynb, copyright 2021-2024 by
+# Tommaso Carraro.
+
+# Semi-supervised pattern recognition: MNIST digit addition, from the LTN
+# paper. The training data are pairs of MNIST images labeled with the sum of
+# their digits only, never with the digits themselves; a digit classifier
+# Digit(x, d) is learned from the knowledge base
+#
+#   forall diag(x, y, n): exists d1, d2 with d1 + d2 = n: Digit(x, d1) and Digit(y, d2)
+#
+# In the multi-digit task, each operand is a two-digit number (two images),
+# and the guard becomes 10 d1 + d2 + 10 d3 + d4 = n.
+#
+# Like LTNtorch's notebook, the models initialize their weights with
+# Kaiming/Xavier and their biases with N(0, 1) (#init_weights). With that
+# initialization, single-digit addition reaches about 48% test accuracy
+# after 20 epochs, in LTNtorch as here (checked against LTNtorch with the
+# same settings: 46.5% vs 46.4% after one epoch, 48.4% vs 48.3% after 20).
+# With PyTorch's default initialization (skipping the init_weights calls),
+# LTNtorch reaches about 98%, as reported in the LTN paper: pass
+# `--default-init` to train that way.
+#
+# The first run downloads MNIST (about 11 MB) into examples/datasets/MNIST.
+# Training follows LTNtorch's settings (20 epochs on 30,000 additions), which
+# takes a while on a CPU; set EPOCHS to train for fewer epochs, and pass
+# `multi` to run the multi-digit task instead of the single-digit one.
+#
+#   bundle exec ruby examples/4_semi_supervised_pattern_recognition.rb [single|multi] [--default-init]
+
+require_relative "support/example"
+require_relative "support/mnist"
+
+module LTNExamples
+  class SemiSupervisedPatternRecognition
+    # Convolutional embeddings of MNIST images.
+    class MNISTConv < Torch::NN::Module
+      # @parameter init_weights [Boolean] whether to initialize the weights as
+      #   LTNtorch's example does (see #init_weights), or keep PyTorch's defaults.
+      def initialize(conv_channels_sizes: [1, 6, 16], kernel_sizes: [5, 5], linear_layers_sizes: [256, 100],
+        init_weights: true)
+        super()
+        @conv_layers = Torch::NN::ModuleList.new(
+          conv_channels_sizes.each_cons(2).zip(kernel_sizes).map { |(input, output), kernel| Torch::NN::Conv2d.new(input, output, kernel) }
+        )
+        @relu = Torch::NN::ReLU.new
+        @tanh = Torch::NN::Tanh.new
+        @maxpool = Torch::NN::MaxPool2d.new([2, 2])
+        @linear_layers = Torch::NN::ModuleList.new(
+          linear_layers_sizes.each_cons(2).map { |input, output| Torch::NN::Linear.new(input, output) }
+        )
+        @batch_norm_layers = Torch::NN::ModuleList.new(
+          linear_layers_sizes.drop(1).map { |size| Torch::NN::BatchNorm1d.new(size) }
+        )
+        self.init_weights if init_weights
+      end
+
+      def forward(x)
+        @conv_layers.each { |conv| x = @maxpool.call(@relu.call(conv.call(x))) }
+        x = Torch.flatten(x, start_dim: 1)
+        @linear_layers.to_a.zip(@batch_norm_layers.to_a).each do |linear, batch_norm|
+          x = @tanh.call(batch_norm.call(linear.call(x)))
+        end
+        x
+      end
+
+      # Kaiming (convolutions) and Xavier (linear layers) weights, and N(0, 1) biases.
+      def init_weights
+        @conv_layers.each do |layer|
+          Torch::NN::Init.kaiming_uniform!(layer.weight)
+          Torch::NN::Init.normal!(layer.bias)
+        end
+        @linear_layers.each do |layer|
+          Torch::NN::Init.xavier_uniform!(layer.weight)
+          Torch::NN::Init.normal!(layer.bias)
+        end
+      end
+    end
+
+    # Returns the logits of the ten digits for an MNIST image.
+    class SingleDigitClassifier < Torch::NN::Module
+      # @parameter init_weights [Boolean] as for MNISTConv.
+      def initialize(layers_sizes: [100, 84, 10], init_weights: true)
+        super()
+        @mnistconv = MNISTConv.new(init_weights: init_weights)
+        @tanh = Torch::NN::Tanh.new
+        @linear_layers = Torch::NN::ModuleList.new(
+          layers_sizes.each_cons(2).map { |input, output| Torch::NN::Linear.new(input, output) }
+        )
+        @batch_norm_layers = Torch::NN::ModuleList.new(
+          layers_sizes.drop(1).map { |size| Torch::NN::BatchNorm1d.new(size) }
+        )
+        self.init_weights if init_weights
+      end
+
+      def forward(x)
+        x = @mnistconv.call(x)
+        linear_layers = @linear_layers.to_a
+        linear_layers[0...-1].each_with_index do |layer, i|
+          x = @tanh.call(@batch_norm_layers.to_a[i].call(layer.call(x)))
+        end
+        linear_layers.last.call(x)
+      end
+
+      # Xavier weights and N(0, 1) biases for the linear layers.
+      def init_weights
+        @linear_layers.each do |layer|
+          Torch::NN::Init.xavier_uniform!(layer.weight)
+          Torch::NN::Init.normal!(layer.bias)
+        end
+      end
+    end
+
+    # The truth value of Digit(x, d): the softmax probability of digit d for image x.
+    class LogitsToPredicate < Torch::NN::Module
+      def initialize(logits_model)
+        super()
+        @logits_model = logits_model
+        @softmax = Torch::NN::Softmax.new(dim: 1)
+      end
+
+      def forward(x, d)
+        Torch.gather(@softmax.call(@logits_model.call(x)), 1, d)
+      end
+    end
+
+    TASKS = {
+      single: {operands: 2, train_examples: 30_000, test_examples: 5_000},
+      multi: {operands: 4, train_examples: 15_000, test_examples: 2_500}
+    }.freeze
+
+    # @parameter task [Symbol] :single (one-digit operands) or :multi (two-digit operands).
+    # @parameter data [Hash, nil] {train: [images, labels], test: [images, labels]}, with images
+    #   as uint8 n x 28 x 28 tensors; by default, MNIST.
+    # @parameter init_weights [Boolean] true to initialize the classifier as LTNtorch's example
+    #   does (about 48% test accuracy), false for PyTorch's defaults (about 98%).
+    def initialize(task: :single, seed: 2020, output: $stdout, data: nil, init_weights: true)
+      @task = task
+      @output = output
+      LTNExamples.seed(seed)
+
+      data ||= {train: MNIST.load(:train), test: MNIST.load(:test)}
+      settings = TASKS.fetch(task)
+      @train = additions(*data[:train], settings[:operands], settings[:train_examples])
+      @test = additions(*data[:test], settings[:operands], settings[:test_examples])
+
+      @digits = (1..settings[:operands]).map { |i| LTN::Variable.new("d_#{i}", Torch.arange(10)) }
+      @cnn = SingleDigitClassifier.new(init_weights: init_weights)
+      @digit = LTN::Predicate.new(LogitsToPredicate.new(@cnn))
+      @and = LTN::Connective.new(LTN::FuzzyOps::AndProd.new)
+      @exists = LTN::Quantifier.new(LTN::FuzzyOps::AggregPMean.new(p: 2), :exists)
+      @forall = LTN::Quantifier.new(LTN::FuzzyOps::AggregPMeanError.new(p: 2), :forall)
+    end
+
+    def run(epochs: 20, batch_size: 32)
+      optimizer = Torch::Optim::Adam.new(@digit.parameters, lr: 0.001)
+      metrics = nil
+
+      epochs.times do |epoch|
+        # The exponent of the existential quantifier grows during training.
+        p = case epoch
+        when 0...4 then 1
+        when 4...8 then 2
+        when 8...12 then 4
+        else 6
+        end
+
+        train = LTNExamples.batches(@train, batch_size: batch_size, shuffle: true).map do |images, labels|
+          optimizer.zero_grad
+          sat = satisfaction(images, labels, p)
+          loss = 1.0 - sat
+          loss.backward
+          optimizer.step
+          [loss.item, sat.item, accuracy(images, labels)]
+        end
+        test = LTNExamples.batches(@test, batch_size: batch_size, shuffle: false).map do |images, labels|
+          Torch.no_grad do
+            sat = satisfaction(images, labels, p)
+            [1.0 - sat.item, sat.item, accuracy(images, labels)]
+          end
+        end
+
+        train_loss, train_sat, train_acc = train.transpose.map { |values| values.sum / values.size }
+        test_loss, test_sat, test_acc = test.transpose.map { |values| values.sum / values.size }
+        metrics = {train_sat: train_sat, test_sat: test_sat, train_accuracy: train_acc, test_accuracy: test_acc}
+        @output.puts format(" epoch %d | Train loss %.4f | Train Sat %.4f | Train Acc %.4f | Test loss %.4f | " \
+          "Test Sat %.4f | Test Acc %.4f", epoch, train_loss, train_sat, train_acc, test_loss, test_sat, test_acc)
+      end
+
+      metrics
+    end
+
+    def satisfaction(images, labels, p)
+      operands = images.shape[1].times.map { |i| LTN::Variable.new("x#{i + 1}", images[0.., i]) }
+      z = LTN::Variable.new("z", labels)
+      # diag must come first: it changes the labels of the variables, so the
+      # formulas built from them below pair the operands with their sum.
+      quantified = LTN.diag(*operands, z)
+      digits = operands.zip(@digits).map { |x, d| @digit.call(x, d) }
+      @forall.call(
+        quantified,
+        @exists.call(@digits, digits.reduce { |a, b| @and.call(a, b) },
+          cond_vars: @digits + [z], cond_fn: ->(*ds, n) { number(ds.map(&:value)).eq(n.value) }, p: p)
+      ).value
+    end
+
+    # Accuracy of the predicted sums.
+    def accuracy(images, labels)
+      Torch.no_grad do
+        predictions = images.shape[1].times.map { |i| Torch.argmax(@cnn.call(images[0.., i]), dim: 1) }
+        LTNExamples.accuracy(number(predictions), labels)
+      end
+    end
+
+    private
+
+    # The sum the digits stand for: d1 + d2, or (10 d1 + d2) + (10 d3 + d4).
+    def number(digits)
+      (@task == :single) ? digits[0] + digits[1] : digits[0] * 10 + digits[1] + digits[2] * 10 + digits[3]
+    end
+
+    # Groups consecutive slices of the images into additions, as LTNtorch does:
+    # operand i of example j is image i * examples + j. With fewer images than
+    # needed, makes as many additions as they allow.
+    def additions(images, labels, operands, examples)
+      examples = [examples, images.shape[0] / operands].min
+      images = images.float / 255.0
+      slices = (0...operands).map { |i| (i * examples)...((i + 1) * examples) }
+      inputs = Torch.stack(slices.map { |range| images[range].unsqueeze(1) }, dim: 1)
+      digits = slices.map { |range| labels[range] }
+      [inputs, number(digits)]
+    end
+  end
+end
+
+if File.expand_path($PROGRAM_NAME) == File.expand_path(__FILE__)
+  unknown = ARGV - %w[single multi --default-init]
+  abort "Unknown arguments: #{unknown.join(" ")}\nUsage: #{$PROGRAM_NAME} [single|multi] [--default-init]" if unknown.any?
+
+  example = LTNExamples::SemiSupervisedPatternRecognition.new(
+    task: ARGV.include?("multi") ? :multi : :single,
+    init_weights: !ARGV.include?("--default-init")
+  )
+  LTNExamples.main(example, __FILE__)
+end

data/examples/5_regression.rb

@@ -0,0 +1,103 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Mauro Tortonesi.
+# Ported from LTNtorch's examples/5-regression.ipynb, copyright 2021-2024 by Tommaso Carraro.
+
+# Regression on the Real estate valuation dataset: learn a function f(x)
+# predicting the price per unit area of a house from its features, from the
+# knowledge base
+#
+#   forall diag(x, y): Eq(f(x), y)
+#
+# where Eq(u, v) = exp(-alpha * ||u - v||) is a smooth equality, and diag
+# pairs each house x with its own price y (diagonal quantification).
+#
+#   bundle exec ruby examples/5_regression.rb
+
+require_relative "support/example"
+
+module LTNExamples
+  class Regression
+    # A multi-layer perceptron with a linear output.
+    class MLP < Torch::NN::Module
+      def initialize(layer_sizes = [6, 8, 8, 1])
+        super()
+        @elu = Torch::NN::ELU.new
+        @linear_layers = Torch::NN::ModuleList.new(
+          layer_sizes.each_cons(2).map { |input, output| Torch::NN::Linear.new(input, output) }
+        )
+      end
+
+      def forward(x)
+        @linear_layers.to_a[0...-1].each { |layer| x = @elu.call(layer.call(x)) }
+        @linear_layers.to_a.last.call(x)
+      end
+    end
+
+    FEATURES = ["X1 transaction date", "X2 house age", "X3 distance to the nearest MRT station",
+      "X4 number of convenience stores", "X5 latitude", "X6 longitude"].freeze
+    TARGET = "Y house price of unit area"
+    ALPHA = 0.05
+
+    def initialize(seed: 2020, output: $stdout)
+      @output = output
+      LTNExamples.seed(seed)
+
+      header, rows = LTNExamples.read_table("real-estate.csv")
+      rows = rows.values_at(*Torch.randperm(rows.size).to_a) # shuffle, as LTNtorch does
+      x = Torch.tensor(rows.map { |row| FEATURES.map { |column| Float(row[header.index(column)]) } })
+      y = Torch.tensor(rows.map { |row| [Float(row[header.index(TARGET)])] })
+      @train = [x[0...330], y[0...330]]
+      @test = [x[330..], y[330..]]
+
+      @f = LTN::Function.new(MLP.new)
+      @eq = LTN::Predicate.new { |u, v| Torch.exp(Torch.sqrt(Torch.sum(Torch.square(u - v), dim: 1)) * -ALPHA) }
+      @forall = LTN::Quantifier.new(LTN::FuzzyOps::AggregPMeanError.new(p: 2), :forall)
+    end
+
+    def run(epochs: 500, log_every: 50)
+      optimizer = Torch::Optim::Adam.new(@f.parameters, lr: 0.0005)
+
+      epochs.times do |epoch|
+        train_loss = 0.0
+        batches = LTNExamples.batches(@train, batch_size: 64, shuffle: true)
+        batches.each do |x_data, y_data|
+          optimizer.zero_grad
+          loss = 1.0 - satisfaction(x_data, y_data)
+          loss.backward
+          optimizer.step
+          train_loss += loss.item
+        end
+        next unless (epoch % log_every).zero?
+
+        @output.puts format(" epoch %d | loss %.4f | Train Sat %.3f | Test Sat %.3f | Train RMSE %.3f | Test RMSE %.3f",
+          epoch, train_loss / batches.size, sat_level(*@train), sat_level(*@test), rmse(*@train), rmse(*@test))
+      end
+
+      {train_sat: sat_level(*@train), test_sat: sat_level(*@test), train_rmse: rmse(*@train), test_rmse: rmse(*@test)}
+    end
+
+    def satisfaction(x_data, y_data)
+      x = LTN::Variable.new("x", x_data)
+      y = LTN::Variable.new("y", y_data)
+      @forall.call(LTN.diag(x, y), @eq.call(@f.call(x), y)).value
+    end
+
+    # LTNtorch averages over batches of 64; the whole set is a single batch for the test set.
+    def sat_level(x_data, y_data)
+      batches = LTNExamples.batches([x_data, y_data], batch_size: 64, shuffle: false)
+      Torch.no_grad { batches.sum { |x, y| satisfaction(x, y).item } / batches.size }
+    end
+
+    def rmse(x_data, y_data)
+      batches = LTNExamples.batches([x_data, y_data], batch_size: 64, shuffle: false)
+      Torch.no_grad do
+        batches.sum { |x, y| Torch.sqrt(Torch.mean(Torch.square(@f.model.call(x) - y))).item } / batches.size
+      end
+    end
+  end
+end
+
+LTNExamples.main(LTNExamples::Regression.new, __FILE__)

data/examples/6_clustering.rb

@@ -0,0 +1,126 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Mauro Tortonesi.
+# Ported from LTNtorch's examples/6-clustering.ipynb, copyright 2021-2024 by Tommaso Carraro.
+
+# Clustering, without labels: learn a predicate C(x, c), "point x belongs to
+# cluster c", for four clusters of points, from the knowledge base
+#
+#   forall x: exists c: C(x, c)                          every point is in some cluster
+#   forall c: exists x: C(x, c)                          no cluster is empty
+#   forall c, x, y with dist(x, y) < 0.2: C(x, c) <-> C(y, c)     close points share clusters
+#   forall c, x, y with dist(x, y) > 1.0: not (C(x, c) and C(y, c))  distant points do not
+#
+# The last two axioms use guarded quantification.
+#
+#   bundle exec ruby examples/6_clustering.rb
+
+require_relative "support/example"
+
+module LTNExamples
+  class Clustering
+    # The probability, from a softmax over the clusters, that point x belongs
+    # to cluster c (one-hot).
+    class MLP < Torch::NN::Module
+      def initialize(layer_sizes = [2, 16, 16, 16, 4])
+        super()
+        @elu = Torch::NN::ELU.new
+        @softmax = Torch::NN::Softmax.new(dim: 1)
+        @linear_layers = Torch::NN::ModuleList.new(
+          layer_sizes.each_cons(2).map { |input, output| Torch::NN::Linear.new(input, output) }
+        )
+      end
+
+      def forward(x, c)
+        @linear_layers.to_a[0...-1].each { |layer| x = @elu.call(layer.call(x)) }
+        Torch.sum(@softmax.call(@linear_layers.to_a.last.call(x)) * c, dim: 1)
+      end
+    end
+
+    CLUSTERS = 4
+    POINTS_PER_CLUSTER = 50
+    CLOSE_THRESHOLD = 0.2
+    DISTANT_THRESHOLD = 1.0
+    MARGIN = 0.2
+
+    attr_reader :data, :c
+
+    def initialize(seed: 2020, output: $stdout)
+      @output = output
+      LTNExamples.seed(seed)
+
+      # One cluster per quadrant of [-1, 1]^2, its mean drawn uniformly within
+      # the quadrant (minus a margin), its points normally around the mean
+      # with standard deviation 0.1.
+      quadrants = [[-1, -1], [0, -1], [-1, 0], [0, 0]]
+      @data = Torch.cat(quadrants.map do |low|
+        low = Torch.tensor(low, dtype: :float32) + MARGIN
+        mean = low + Torch.rand(2) * (1 - 2 * MARGIN)
+        mean + Torch.randn(POINTS_PER_CLUSTER, 2) * 0.1
+      end)
+
+      @cluster = LTN::Predicate.new(MLP.new)
+      @c = LTN::Variable.new("c", Torch.eye(CLUSTERS))
+      @x = LTN::Variable.new("x", @data)
+      @y = LTN::Variable.new("y", @data)
+      @th_close = LTN::Constant.new(Torch.tensor(CLOSE_THRESHOLD))
+      @th_distant = LTN::Constant.new(Torch.tensor(DISTANT_THRESHOLD))
+
+      @and = LTN::Connective.new(LTN::FuzzyOps::AndProd.new)
+      @not = LTN::Connective.new(LTN::FuzzyOps::NotStandard.new)
+      @equiv = LTN::Connective.new(LTN::FuzzyOps::Equiv.new(LTN::FuzzyOps::AndProd.new,
+        LTN::FuzzyOps::ImpliesReichenbach.new))
+      @exists = LTN::Quantifier.new(LTN::FuzzyOps::AggregPMean.new(p: 1), :exists)
+      @forall = LTN::Quantifier.new(LTN::FuzzyOps::AggregPMeanError.new(p: 4), :forall)
+      @sat_agg = LTN::FuzzyOps::SatAgg.new
+    end
+
+    def run(epochs: 1000, log_every: 100)
+      optimizer = Torch::Optim::Adam.new(@cluster.parameters, lr: 0.001)
+      sat = nil
+
+      epochs.times do |epoch|
+        optimizer.zero_grad
+        sat = satisfaction(p_exists: (epoch <= 100) ? 1 : 6)
+        loss = 1.0 - sat
+        loss.backward
+        optimizer.step
+        @output.puts format(" epoch %d | loss %.4f | Train Sat %.3f", epoch, loss.item, sat.item) if (epoch % log_every).zero?
+      end
+
+      {train_sat: sat.item, clusters_used: assignments.to_a.uniq.size}
+    end
+
+    def satisfaction(p_exists:)
+      dist = ->(u, v) { Torch.norm(u - v, 2, dim: 1).unsqueeze(1) }
+      @sat_agg.call(
+        @forall.call(@x, @exists.call(@c, @cluster.call(@x, @c), p: p_exists)),
+        @forall.call(@c, @exists.call(@x, @cluster.call(@x, @c), p: p_exists)),
+        @forall.call([@c, @x, @y], @equiv.call(@cluster.call(@x, @c), @cluster.call(@y, @c)),
+          cond_vars: [@x, @y]) { |x, y| dist.call(x.value, y.value).lt(@th_close.value) },
+        @forall.call([@c, @x, @y], @not.call(@and.call(@cluster.call(@x, @c), @cluster.call(@y, @c))),
+          cond_vars: [@x, @y]) { |x, y| dist.call(x.value, y.value).gt(@th_distant.value) }
+      )
+    end
+
+    # The most likely cluster of each point.
+    def assignments
+      Torch.no_grad do
+        probabilities = (0...CLUSTERS).map do |i|
+          @cluster.model.call(@data, Torch.eye(CLUSTERS)[i].unsqueeze(0).expand(@data.shape[0], CLUSTERS))
+        end
+        Torch.argmax(Torch.stack(probabilities, dim: 1), dim: 1)
+      end
+    end
+  end
+end
+
+LTNExamples.main(LTNExamples::Clustering.new, __FILE__) do |example|
+  markers = %w[o + x *]
+  assigned = example.assignments
+  series = markers.each_with_index.to_h { |marker, i| ["cluster #{i}", [marker, example.data[assigned.eq(i)]]] }
+  puts
+  puts LTNExamples.scatter(series, title: "Learned clusters", xlim: [-1.0, 1.0], ylim: [-1.0, 1.0])
+end

data/examples/7_learning_embeddings_with_ltn.rb

@@ -0,0 +1,166 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Mauro Tortonesi.
+# Ported from LTNtorch's examples/7-learning_embeddings_with_LTN.ipynb, copyright 2021-2024 by Tommaso Carraro.
+
+# Learning embeddings: the "smokers, friends and cancer" problem. Fourteen
+# people, in two groups (a-h and i-n), are grounded as trainable constants
+# (embeddings) learned together with three predicates: Smokes(x),
+# Cancer(x) and Friends(x, y). The knowledge base contains:
+#
+# - facts: some friendships, who smokes, and who has cancer (the latter only
+#   for the first group); all other friendships within a group are false;
+# - rules: friendship is irreflexive and symmetric, everybody has a friend,
+#   friends of smokers smoke, smoking causes cancer, and not smoking
+#   prevents it.
+#
+# After training, the script queries two formulas the knowledge base does
+# not state:
+#
+#   phi1: forall p: Cancer(p) -> Smokes(p)
+#   phi2: forall p, q: (Cancer(p) or Cancer(q)) -> Friends(p, q)
+#
+#   bundle exec ruby examples/7_learning_embeddings_with_ltn.rb
+
+require_relative "support/example"
+
+module LTNExamples
+  class LearningEmbeddings
+    # A multi-layer perceptron over the concatenation of its arguments.
+    class MLP < Torch::NN::Module
+      def initialize(layer_sizes)
+        super()
+        @elu = Torch::NN::ELU.new
+        @sigmoid = Torch::NN::Sigmoid.new
+        @linear_layers = Torch::NN::ModuleList.new(
+          layer_sizes.each_cons(2).map { |input, output| Torch::NN::Linear.new(input, output) }
+        )
+      end
+
+      def forward(*inputs)
+        x = (inputs.size == 1) ? inputs.first : Torch.cat(inputs, dim: 1)
+        @linear_layers.to_a[0...-1].each { |layer| x = @elu.call(layer.call(x)) }
+        @sigmoid.call(@linear_layers.to_a.last.call(x))
+      end
+    end
+
+    EMBEDDING_SIZE = 5
+    GROUP1 = ("a".."h").to_a.freeze
+    GROUP2 = ("i".."n").to_a.freeze
+    FRIENDS = [%w[a b], %w[a e], %w[a f], %w[a g], %w[b c], %w[c d], %w[e f], %w[g h],
+      %w[i j], %w[j m], %w[k l], %w[m n]].freeze
+    SMOKES = %w[a e f g j n].freeze
+    CANCER = %w[a e].freeze
+
+    attr_reader :people
+
+    def initialize(seed: 2020, output: $stdout)
+      @output = output
+      LTNExamples.seed(seed)
+
+      @people = (GROUP1 + GROUP2).to_h { |person| [person, LTN::Constant.new(Torch.rand(EMBEDDING_SIZE), trainable: true)] }
+
+      @cancer = LTN::Predicate.new(MLP.new([5, 16, 16, 1]))
+      @smokes = LTN::Predicate.new(MLP.new([5, 16, 16, 1]))
+      @friends = LTN::Predicate.new(MLP.new([10, 16, 16, 1]))
+
+      @and = LTN::Connective.new(LTN::FuzzyOps::AndProd.new)
+      @or = LTN::Connective.new(LTN::FuzzyOps::OrProbSum.new)
+      @not = LTN::Connective.new(LTN::FuzzyOps::NotStandard.new)
+      @implies = LTN::Connective.new(LTN::FuzzyOps::ImpliesReichenbach.new)
+      @exists = LTN::Quantifier.new(LTN::FuzzyOps::AggregPMean.new(p: 2), :exists)
+      @forall = LTN::Quantifier.new(LTN::FuzzyOps::AggregPMeanError.new(p: 2), :forall)
+      @sat_agg = LTN::FuzzyOps::SatAgg.new
+    end
+
+    def run(epochs: 1000, log_every: 20)
+      parameters = @smokes.parameters + @friends.parameters + @cancer.parameters + @people.values.map(&:value)
+      optimizer = Torch::Optim::Adam.new(parameters, lr: 0.001)
+      sat = nil
+
+      epochs.times do |epoch|
+        optimizer.zero_grad
+        sat = satisfaction(p_exists: (epoch <= 200) ? 1 : 6)
+        loss = 1.0 - sat
+        loss.backward
+        optimizer.step
+        next unless (epoch % log_every).zero?
+
+        @output.puts format(" epoch %d | loss %.4f | Train Sat %.3f | Phi1 Sat %.3f | Phi2 Sat %.3f",
+          epoch, loss.item, sat.item, phi1, phi2)
+      end
+
+      {train_sat: sat.item, phi1: phi1, phi2: phi2}
+    end
+
+    def satisfaction(p_exists:)
+      g = @people
+      # The embeddings change at each step, so the variables are rebuilt from them.
+      x = LTN::Variable.new("x", Torch.stack(g.values.map(&:value)))
+      y = LTN::Variable.new("y", Torch.stack(g.values.map(&:value)))
+      not_friends = [GROUP1, GROUP2].flat_map do |group|
+        group.combination(2).reject { |pair| FRIENDS.include?(pair) }
+          .map { |a, b| @not.call(@friends.call(g[a], g[b])) }
+      end
+
+      @sat_agg.call(
+        @sat_agg.call(*FRIENDS.map { |a, b| @friends.call(g[a], g[b]) }),
+        @sat_agg.call(*not_friends),
+        @sat_agg.call(*SMOKES.map { |a| @smokes.call(g[a]) }),
+        @sat_agg.call(*(g.keys - SMOKES).map { |a| @not.call(@smokes.call(g[a])) }),
+        @sat_agg.call(*CANCER.map { |a| @cancer.call(g[a]) }),
+        @sat_agg.call(*(GROUP1 - CANCER).map { |a| @not.call(@cancer.call(g[a])) }),
+        @forall.call(x, @not.call(@friends.call(x, x)), p: 5),
+        @forall.call([x, y], @implies.call(@friends.call(x, y), @friends.call(y, x)), p: 5),
+        @forall.call(x, @exists.call(y, @friends.call(x, y), p: p_exists)),
+        @forall.call([x, y], @implies.call(@and.call(@friends.call(x, y), @smokes.call(x)), @smokes.call(y))),
+        @forall.call(x, @implies.call(@smokes.call(x), @cancer.call(x))),
+        @forall.call(x, @implies.call(@not.call(@smokes.call(x)), @not.call(@cancer.call(x))))
+      )
+    end
+
+    def phi1
+      Torch.no_grad do
+        p = LTN::Variable.new("p", Torch.stack(@people.values.map(&:value)))
+        @forall.call(p, @implies.call(@cancer.call(p), @smokes.call(p)), p: 5).value.item
+      end
+    end
+
+    def phi2
+      Torch.no_grad do
+        p = LTN::Variable.new("p", Torch.stack(@people.values.map(&:value)))
+        q = LTN::Variable.new("q", Torch.stack(@people.values.map(&:value)))
+        @forall.call([p, q], @implies.call(@or.call(@cancer.call(p), @cancer.call(q)), @friends.call(p, q)), p: 5)
+          .value.item
+      end
+    end
+
+    # The learned truth values: Smokes and Cancer for each person, and Friends for each pair.
+    def truth_values
+      Torch.no_grad do
+        p = LTN::Variable.new("p", Torch.stack(@people.values.map(&:value)))
+        q = LTN::Variable.new("q", Torch.stack(@people.values.map(&:value)))
+        {smokes: @smokes.call(p).value, cancer: @cancer.call(p).value, friends: @friends.call(p, q).value}
+      end
+    end
+  end
+end
+
+LTNExamples.main(LTNExamples::LearningEmbeddings.new, __FILE__) do |example|
+  names = example.people.keys
+  values = example.truth_values
+  puts "\n     Smokes Cancer   (facts: smokes #{LTNExamples::LearningEmbeddings::SMOKES.join}, " \
+    "cancer #{LTNExamples::LearningEmbeddings::CANCER.join}, unknown for #{LTNExamples::LearningEmbeddings::GROUP2.join})"
+  names.each_with_index do |name, i|
+    puts format("  %s    %.2f   %.2f", name, values[:smokes][i].item, values[:cancer][i].item)
+  end
+  [LTNExamples::LearningEmbeddings::GROUP1, LTNExamples::LearningEmbeddings::GROUP2].each do |group|
+    puts "\nFriends(row, column):"
+    puts "     " + group.map { |name| name.center(5) }.join
+    group.each do |row|
+      puts "  #{row}  " + group.map { |column| format("%5.2f", values[:friends][names.index(row), names.index(column)].item) }.join
+    end
+  end
+end