updated readme related packages and typos

Author: njericha

README.md

@@ -33,15 +33,15 @@ Here is an example of an order-3 Tucker-1 factorization.
 
 <img width="500" height="526" alt="tucker_1_example" src="https://github.com/user-attachments/assets/120224d1-f7a9-4566-b416-73917a614ff1" />
 
-Say you've collected your data into an order-3 tensor `Y`. You can use `randn` from `Random.jl` to simulate this.
+Say you've collected your data into an order-3 tensor `Y`. (We'll use `randn` from `Random.jl` to simulate this.)
 
 ```julia
 using Random
 
 Y = randn(100,100,100)
 ```
 
-Then you can call `factorize` with a number of keywords. The main keywords you many want to specify are the `model` and `rank`. This lets `factorize` know they type and size of the decomposition. See [Decomposition Models](@ref) for a complete list of avalible models, and how to define your own custom decomposition.
+Then you can call `factorize` with a number of [keywords](https://mpf-optimization-laboratory.github.io/BlockTensorFactorization.jl/dev/reference/functions/#BlockTensorFactorization.Core.default_kwargs-Tuple{Any}). The main keywords you many want to specify are the `model` and `rank`. This lets `factorize` know they type and size of the decomposition. See [Decomposition Models](https://mpf-optimization-laboratory.github.io/BlockTensorFactorization.jl/dev/tutorial/decompositionmodels/) for a complete list of available models, and how to define your own custom decomposition.
 
 ```julia
 using BlockTensorFactorization
@@ -112,21 +112,21 @@ stats[end, :ObjectiveValue] # Final objective value
 stats[:, :ObjectiveValue] # Objective value at every iteration
 ```
 
-You may also want to see every stat at a particular iteration which can be accessed in the following way. Note that the initilization is stored in the first row, so the nth row stores the stats right *before* the nth iteration, not after.
+You may also want to see every stat at a particular iteration which can be accessed in the following way. Note that the initialization is stored in the first row, so the nth row stores the stats right *before* the nth iteration, not after.
 
 ```julia
 stats[begin, :] # Every stat at the initialization
 stats[4, :] # Every stat right *before* the 4th iteration
 stats[end, :] # Every stat at the final iteration
 ```
 
-See the `DataFrames.jl` package for more data handeling.
+See the [`DataFrames.jl`](https://dataframes.juliadata.org/stable/) package for more data handling.
 
 ## Output keyword arguments
 
-Since there are many options and a complicated handeling of defaults arguments, the `factorize` function also outputs all the keyword arguments as a `NamedTuple`. This allows you to check what keywords you set, along with the default values that were substituted for the keywords you did not provide.
+Since there are many options and a complicated handling of defaults arguments, the `factorize` function also outputs all the keyword arguments as a `NamedTuple`. This allows you to check what keywords you set, along with the default values that were substituted for the keywords you did not provide.
 
-You can access the values by getting the relevent field, or index (as a `Symbol`). In our running example, this would look like the following.
+You can access the values by getting the relevant field, or index (as a `Symbol`). In our running example, this would look like the following.
 
 ```julia
 kwargs.rank == 5
@@ -148,12 +148,12 @@ Naomi Graham, Nicholas Richardson, Michael P. Friedlander, and Joel Saylor. Trac
 
 # Related Packages
 
-## For decomposing tensors
+## For decomposing/factorizing tensors
 
-- [TensorDecompositions.jl](https://github.com/yunjhongwu/TensorDecompositions.jl): Supports the decompositions; high-order SVD, CP & Tucker (and nonnegative version), symmetric rank-1, and Tensor-CUR. Most models support one or two algorithms (usually alternating methods). No customizability of constraints.
+- [TensorDecompositions.jl](https://github.com/yunjhongwu/TensorDecompositions.jl): Supports the decompositions; high-order SVD, CP & Tucker (and nonnegative versions), symmetric rank-1, and Tensor-CUR. Most models support one or two algorithms (usually alternating methods). No customizability of constraints.
 - [NTFk.jl](https://github.com/SmartTensors/NTFk.jl): Only nonnegative Tucker and CP decompositions supported
-- [GCPDecompositions.jl](https://github.com/dahong67/GCPDecompositions.jl): Only LBFGSB or ALS algorithms for CPDecompositions
-- [NMF.jl](https://github.com/JuliaStats/NMF.jl): Multiple algorithms supported for nonnegative matrix factorizations
+- [GCPDecompositions.jl](https://github.com/dahong67/GCPDecompositions.jl): Only LBFGSB or ALS algorithms for CP Decompositions
+- [NMF.jl](https://github.com/JuliaStats/NMF.jl): Multiple algorithms supported for only nonnegative matrix factorizations
 - [TensorFactorizations.jl](https://github.com/mhauru/TensorFactorizations.jl): Eigenvalue and singular value decompositions of tensors
 
 ## For working with tensors and some basic decompositions

docs/src/index.md

@@ -5,7 +5,7 @@
 
 (Coming Soon) The package also supports user defined models and constraints provided the operations for combining factor into a tensor, and projecting/applying the constraint are given. It is also a longer term goal to support other optimization objective beyond minimizing the least-squares (Frobenius norm) between the input tensor and model.
 
-The general scheme for computing the decomposition is a generalization of Xu and Yin's Block Coordinate Descent Method (2013) that cyclicaly updates each factor in a model with a proximal gradient descent step. Note for convex constraints, the proximal operation would be a Euclidean projection onto the constraint set, but we find some improvment with a hybrid approach of a partial Euclidean projection followed by a rescaling step. In the case of a simplex constraint on one factor, this looks like: dividing the constrained factor by the sum of entries, and multiplying another factor by this sum to preserve the product.
+The general scheme for computing the decomposition is a generalization of Xu and Yin's Block Coordinate Descent Method (2013) that cyclically updates each factor in a model with a proximal gradient descent step. Note for convex constraints, the proximal operation would be a Euclidean projection onto the constraint set, but we find some improvement with a hybrid approach of a partial Euclidean projection followed by a rescaling step. In the case of a simplex constraint on one factor, this looks like: dividing the constrained factor by the sum of entries, and multiplying another factor by this sum to preserve the product.
 
 
 ```@contents

docs/src/quickguide.md

@@ -4,15 +4,15 @@
 
 The main feature of this package is to factorize an array. This is accomplished with the `factorize` function.
 
-Say you've collected your data into an order-$3$ tensor `Y`. You can use `randn` from `Random.jl` to simulate this.
+Say you've collected your data into an order-$3$ tensor `Y`. (We will use `randn` from `Random.jl` to simulate this.)
 
 ```julia
 using Random
 
 Y = randn(100,100,100)
 ```
 
-Then you can call `factorize` with a number of keywords. The main keywords you many want to specify are the `model` and `rank`. This lets `factorize` know they type and size of the decomposition. See [Decomposition Models](@ref) for a complete list of avalible models, and how to define your own custom decomposition.
+Then you can call `factorize` with a number of [keywords](https://mpf-optimization-laboratory.github.io/BlockTensorFactorization.jl/dev/reference/functions/#BlockTensorFactorization.Core.default_kwargs-Tuple{Any}). The main keywords you many want to specify are the `model` and `rank`. This lets `factorize` know they type and size of the decomposition. See [Decomposition Models](@ref) for a complete list of available models, and how to define your own custom decomposition.
 
 ```julia
 using BlockTensorFactorization
@@ -83,21 +83,21 @@ stats[end, :ObjectiveValue] # Final objective value
 stats[:, :ObjectiveValue] # Objective value at every iteration
 ```
 
-You may also want to see every stat at a particular iteration which can be accessed in the following way. Note that the initilization is stored in the first row, so the nth row stores the stats right *before* the nth iteration, not after.
+You may also want to see every stat at a particular iteration which can be accessed in the following way. Note that the initialization is stored in the first row, so the nth row stores the stats right *before* the nth iteration, not after.
 
 ```julia
 stats[begin, :] # Every stat at the initialization
 stats[4, :] # Every stat right *before* the 4th iteration
 stats[end, :] # Every stat at the final iteration
 ```
 
-See the `DataFrames.jl` package for more data handeling.
+See the `DataFrames.jl` package for more data handling.
 
 ## Output keyword arguments
 
-Since there are many options and a complicated handeling of defaults arguments, the `factorize` function also outputs all the keyword arguments as a `NamedTuple`. This allows you to check what keywords you set, along with the default values that were substituted for the keywords you did not provide.
+Since there are many options and a complicated handling of defaults arguments, the `factorize` function also outputs all the keyword arguments as a `NamedTuple`. This allows you to check what keywords you set, along with the default values that were substituted for the keywords you did not provide.
 
-You can access the values by getting the relevent field, or index (as a `Symbol`). In our running example, this would look like the following.
+You can access the values by getting the relevant field, or index (as a `Symbol`). In our running example, this would look like the following.
 
 ```julia
 kwargs.rank == 5

src/Core/constraint.jl

@@ -75,7 +75,7 @@ end
 
 # Need to separate inner and outer into two lines
 # since (C.outer ∘ C.inner) would apply f=C.outer to the output of g=C.inner.
-# This is not nessesarily the mutated A.
+# This is not necessarily the mutated A.
 # For example, g = l1scale! would divide A by the 1-norm of A,
 # and return the 1-norm of A, not A itself.
 function (C::ComposedConstraint)(A::AbstractArray)
@@ -91,7 +91,7 @@ Base.:∘(f::AbstractConstraint, g::AbstractConstraint) = ComposedConstraint(f,
 # function Base.:∘(f::AbstractConstraint, g::AbstractConstraint)
 #     # Need to separate f.apply and g.apply into two lines
 #     # since (f.apply ∘ g.apply) would apply f to the output of g.
-#     # This is not nessesarily the result of g.apply.
+#     # This is not necessarily the result of g.apply.
 #     # For example, g = l1scale! would divide X by the 1-norm of X,
 #     # and return the 1-norm of X, not X itself.
 #     function composition(X::AbstractArray)
@@ -119,7 +119,7 @@ Base.:∘(f::AbstractConstraint, g::AbstractConstraint) = ComposedConstraint(f,
 #     g::Function
 # end
 
-# (F::BoolFunctionAnd)(x) = F.f(x) & F.g(x) # No short curcit to ensure any warnings are shown from both checks
+# (F::BoolFunctionAnd)(x) = F.f(x) & F.g(x) # No short circuit to ensure any warnings are shown from both checks
 
 # bool_function_and(f::Function, g::Function) = BoolFunctionAnd(f, g)
 
@@ -327,7 +327,7 @@ normalizations_to_whats_normalized = [
 # Generate the constraints
 
 """List of symbols of the built-in constraint functions."""
-const BUILT_IN_CONSTRAINTS = Symbol[] # const means constant type, not an unmutable
+const BUILT_IN_CONSTRAINTS = Symbol[] # const means constant type, not an immutable
 
 for (type, pattern) in constraint_types
     for c in constraint_set

src/Core/decomposition.jl

@@ -1,5 +1,5 @@
 """
-Low level code defining the verious decomposition types like Tucker and CP
+Low level code defining the various decomposition types like Tucker and CP
 """
 
 """
@@ -378,7 +378,7 @@ contractions(_::Tucker1) = ((×₁),)
 rankof(T::Tucker) = map(x -> size(x, 2), matrix_factors(T))
 rankof(T::Tucker1) = size(core(T), 1)
 
-# Essentialy zero index tucker factors so the core is the 0th factor, and the nth factor
+# Essentially zero index tucker factors so the core is the 0th factor, and the nth factor
 # is the matrix factor in the nth dimension
 function factor(D::AbstractTucker, n::Integer)
     if n == 0

src/Core/factorize.jl

@@ -192,7 +192,7 @@ function default_kwargs(Y; kwargs...)
 	get!(kwargs, :constrain_output) do
 		isnothing(kwargs[:final_constraints]) ? false : true
 	end
-	# the rest of the constraint parsing is handled later, once the decomposition is initalized
+	# the rest of the constraint parsing is handled later, once the decomposition is initialized
 
 	# Stats
 	get!(kwargs, :stats) do

src/Core/tensorproducts.jl

@@ -56,7 +56,7 @@ function mtt(A::AbstractMatrix, B::AbstractArray)
     #Cmat = A * Bmat
     #C = reshape(Cmat, size(A, 1), sizeB[2:end]...)
 
-    # Slightly faster implimentation
+    # Slightly faster implementation
     C = zeros(size(A, 1), sizeB[2:end]...)
     Cmat = reshape(C, size(A, 1), prod(sizeB[2:end]))
     mul!(Cmat, A, Bmat)

src/Core/utils.jl

@@ -148,7 +148,7 @@ function mat(A::AbstractArray, n::Integer)
     N = ndims(A)
     1 <= n && n <= N || throw(ArgumentError("n=$n is not a valid dimension to matricize"))
     dims = ((1:n-1)..., (n+1:N)...) # all axis, skipping n
-    return cat(eachslice(A; dims)...; dims=2) # TODO Idealy return a view/SubArray
+    return cat(eachslice(A; dims)...; dims=2) # TODO Ideally return a view/SubArray
 end
 
 #fullouter(v...) = reshape(kron(reverse(vec.(v))...),tuple(vcat(collect.(size.(v))...)...))
@@ -260,7 +260,7 @@ end
 """
     abs_randn(x...)
 
-Folded normal or more specificly the half-normal initialization.
+Folded normal or more specifically the half-normal initialization.
 """
 abs_randn(x...) = abs.(randn(x...))
 

test/runtests.jl

@@ -248,7 +248,7 @@ const VERBOSE = true
         @test_broken check(c!, v) # Only nonnegativity is satisfied. Entries do not sum to 1
     end
 
-    @testset "Convertion" begin
+    @testset "Conversion" begin
         @test ProjectedNormalization(l1scale!) == l1normalize!
         @test ScaledNormalization(l1normalize!) == l1scale!
     end
@@ -343,7 +343,7 @@ end
     @test_throws ArgumentError Tucker((G, A)) # Can handle auto conversion to TuckerN in the future??
 
     G = Tucker1((10,11,12), 5);
-    Y = Tucker1((10,11,12), 5; init=abs_randn); # check if other initilizations work
+    Y = Tucker1((10,11,12), 5; init=abs_randn); # check if other initializations work
 
     @test isfrozen(G, 0) == false # the core is not frozen
     @test isfrozen(G, 1) == false # the matrix factor A is not frozen