Live Math
Mix.install([
{:nx, "~> 0.5"},
{:exla, "~> 0.5"},
{:kino, "~> 0.8"},
{:stb_image, "~> 0.6"},
{:vega_lite, "~> 0.1"},
{:kino_vega_lite, "~> 0.1"}
])
Main
# Setting EXLA to be default backend
Nx.default_backend(EXLA.Backend)
# Demo of Vectors
a = Nx.tensor([1, 2, 3])
b = Nx.tensor([4.0, 5.0, 6.0])
c = Nx.tensor([1, 0, 1], type: {:u, 8})
IO.inspect a, label: :a
IO.inspect b, label: :b
IO.inspect c, label: :c
# Ex: A stock is a vector, made up of a vector of stock properties
goog_current_price = 2677.32
goog_pe = 23.86
goog_mrk_cap = 1760
goog = Nx.tensor([goog_current_price, goog_pe, goog_mrk_cap])
# Example of Scalar
i_am_a_scalar = Nx.tensor(5)
i_am_also_a_scalar = 5
# Expanding into Matrix Example
meta_current_price = 133.93
meta_pe = 11.10
meta_mkt_cap = 360
stocks_matrix = Nx.tensor([
[goog_current_price, goog_pe, goog_mrk_cap],
[meta_current_price, meta_pe, meta_mkt_cap]
])
IO.inspect stocks_matrix
# Vector Addition
sales_day_1 = Nx.tensor([32, 10, 14])
sales_day_2 = Nx.tensor([10, 24, 21])
total_sales = Nx.add(sales_day_1, sales_day_2)
# Scalar Multiplication
sales_day_1 = Nx.tensor([32, 10, 24])
sales_day_2 = Nx.tensor([10, 24, 21])
total_sales = Nx.add(sales_day_1, sales_day_2)
keep_rate = 0.9
unreturned_sales = Nx.multiply(keep_rate, total_sales)
price_per_product = Nx.tensor([9.95, 10.95, 5.99])
revenue_per_product = Nx.multiply(unreturned_sales, price_per_product)
# Transpose to flip Rows and Columns
sales_matrix = Nx.tensor([
[32, 10, 14],
[10, 24, 21]
])
Nx.transpose(sales_matrix)
# Identity Operation only when Vector is 1 Dimensional
vector = Nx.tensor([1, 2, 3])
Nx.transpose(vector)
# Invert Colors of an Image
invert_color_channels = Nx.tensor([
[-1, 0, 0],
[0, -1, 0],
[0, 0, -1]
])
""
|> StbImage.read_file!()
|> StbImage.resize(256, 256)
|> StbImage.to_nx()
|> Nx.dot(invert_color_channels)
|> Nx.as_type({:u, 8})
|> Kino.Image.new()
# Matrix Multiplication
vector = Nx.dot(Nx.tensor([1, 2, 3]), Nx.tensor([1, 2, 3]))
vector_matrix = Nx.dot(Nx.tensor([1, 2]), Nx.tensor([[1], [2]]))
matrix_matrix = Nx.dot(Nx.tensor([[1, 2]]), Nx.tensor([[3], [4]]))
vector |> IO.inspect(label: :vector)
vector_matrix |> IO.inspect(label: :vector_matrix)
matrix_matrix |> IO.inspect(label: :martix_matrix)
# Probability Example
simulation = fn key ->
{value, key} = Nx.Random.uniform(key)
if Nx.to_number(value) < 0.5, do: {0, key}, else: {1, key}
end
key = Nx.Random.key(42)
for n <- [10, 100, 1000, 10000] do
Enum.map_reduce(1..n, key, fn _, key -> simulation.(key) end)
|> elem(0)
|> Enum.sum()
|> IO.inspect()
end
# Derivatives
defmodule BerryFarm do
import Nx.Defn
defn profits(trees) do
trees
|> Nx.subtract(1)
|> Nx.pow(4)
|> Nx.negate()
|> Nx.add(Nx.pow(trees, 3))
|> Nx.add(Nx.pow(trees, 2))
end
end
# Derivatives Visualization
trees = Nx.linspace(0, 4, n: 100)
profits = BerryFarm.profits(trees)
alias VegaLite, as: Vl
Vl.new(title: "Berry Profits", width: 1440, height: 1080)
|> Vl.data_from_values(%{
trees: Nx.to_flat_list(trees),
profits: Nx.to_flat_list(profits)
})
|> Vl.mark(:line, interpolate: :basis)
|> Vl.encode_field(:x, "trees", type: :quantitative)
|> Vl.encode_field(:y, "profits", type: :quantitative)
# Profit Change
defmodule BerryFarmProfit do
import Nx.Defn
defn profits(trees) do
-((trees - 1) ** 4) + (trees ** 3) + trees ** 2
end
defn profits_derivative(trees) do
grad(trees, &profits/1)
end
end
# Visualization of Profit Change
trees = Nx.linspace(0, 4, n: 100)
profits = BerryFarmProfit.profits(trees)
profits_derivative = BerryFarmProfit.profits_derivative(trees)
alias VegaLite, as: Vl
title = "Berry Profits and Profits Rate of Change"
Vl.new(title: title, width: 1440, height: 1080)
|> Vl.data_from_values(%{
trees: Nx.to_flat_list(trees),
profits: Nx.to_flat_list(profits),
profits_derivative: Nx.to_flat_list(profits_derivative)
})
|> Vl.layers([
Vl.new()
|> Vl.mark(:line, interpolate: :basis)
|> Vl.encode_field(:x, "trees", type: :quantitative)
|> Vl.encode_field(:y, "profits", type: :quantitative),
Vl.new()
|> Vl.mark(:line, interpolate: :basis)
|> Vl.encode_field(:x, "trees", type: :quantitative)
|> Vl.encode_field(:y, "profits_derivative", type: :quantitative)
|> Vl.encode(:color, value: "#ff0000")
])
# Automatic Differentiation
defmodule GradFun do
import Nx.Defn
defn my_function(x) do
x
|> Nx.cos()
|> Nx.exp()
|> Nx.sum()
|> print_expr()
end
defn grad_my_function(x) do
grad(x, &my_function/1) |> print_expr()
end
end