Merge pull request #52 from DrChainsaw/renamepackage

Rename package to ONNXNaiveNASflux

Author: DrChainsaw

Project.toml

@@ -1,5 +1,5 @@
-name = "ONNXmutable"
-uuid = "cf2a63a0-f8ae-421c-82b7-306ecfceaf66"
+name = "ONNXNaiveNASflux"
+uuid = "2e935253-ba83-4645-9154-13ffeb13a688"
 authors = ["DrChainsaw"]
 version = "0.1.0"
 

README.md

@@ -1,29 +1,29 @@
-# ONNXmutable
+# ONNXNaiveNASflux
 
-[![Build status](https://github.com/DrChainsaw/ONNXmutable.jl/workflows/CI/badge.svg?branch=master)](https://github.com/DrChainsaw/ONNXmutable.jl/actions)
-[![Build Status](https://ci.appveyor.com/api/projects/status/github/DrChainsaw/ONNXmutable.jl?svg=true)](https://ci.appveyor.com/project/DrChainsaw/ONNXmutable-jl)
-[![Codecov](https://codecov.io/gh/DrChainsaw/ONNXmutable.jl/branch/master/graph/badge.svg)](https://codecov.io/gh/DrChainsaw/ONNXmutable.jl)
+[![Build status](https://github.com/DrChainsaw/ONNXNaiveNASflux.jl/workflows/CI/badge.svg?branch=master)](https://github.com/DrChainsaw/ONNXNaiveNASflux.jl/actions)
+[![Build Status](https://ci.appveyor.com/api/projects/status/github/DrChainsaw/ONNXNaiveNASflux.jl?svg=true)](https://ci.appveyor.com/project/DrChainsaw/ONNXNaiveNASflux-jl)
+[![Codecov](https://codecov.io/gh/DrChainsaw/ONNXNaiveNASflux.jl/branch/master/graph/badge.svg)](https://codecov.io/gh/DrChainsaw/ONNXNaiveNASflux.jl)
 
 [ONNX](https://onnx.ai) import and export for [Flux](https://github.com/FluxML/Flux.jl).
 
 Models are imported as [NaiveNASflux](https://github.com/DrChainsaw/NaiveNASflux.jl) graphs, meaning that things like removing/inserting layers and pruning pre-trained models is a breeze.
 
-Model export does not require the model to have any particular format. Almost any julia function can be exported as long as the primitives are recognized by ONNXmutable. 
+Model export does not require the model to have any particular format. Almost any julia function can be exported as long as the primitives are recognized by ONNXNaiveNASflux. 
 
 ## Basic usage
 
 ```julia
-Pkg.add(url="https://github.com/DrChainsaw/ONNXmutable.jl")
+Pkg.add(url="https://github.com/DrChainsaw/ONNXNaiveNASflux.jl")
 ```
 
 Exporting is done using the `onnx` function which accepts a filename `String` or an `IO` as first argument:
 
 ```julia
 # Save model as model.onnx where inputshapes are tuples with sizes of input.
-onnx("model.onnx", model, inputshapes...)
+save("model.onnx", model, inputshapes...)
 
 # Load model as a CompGraph
-graph = CompGraph("model.onnx", inputshapes...)
+graph = load("model.onnx", inputshapes...)
 ```
 Input shapes can be omitted in which case an attempt to infer the shapes will be made. If supplied, one tuple with size as the dimensions of the corresponding input array (including batch dimension) is expected. 
 
@@ -37,7 +37,7 @@ Names can be attached to inputs by providing a `Pair` where the first element is
 More elaborate example with a model defined as a plain Julia function:
 
 ```julia
-using ONNXmutable, Test, Statistics
+using ONNXNaiveNASflux, Test, Statistics
 
 l1 = Conv((3,3), 2=>3, relu)
 l2 = Dense(3, 4, elu)
@@ -54,20 +54,20 @@ end
 io = PipeBuffer()
 x_shape = (:W, :H, 2, :Batch)
 y_shape = (4, :Batch)
-onnx(io, f, x_shape, y_shape)
+save(io, f, x_shape, y_shape)
 
 # Deserialize as a NaiveNASflux CompGraph
-g = CompGraph(io)
+g = load(io)
 
 x = ones(Float32, 5,4,2,3)
 y = ones(Float32, 4, 3)
 @test g(x,y) ≈ f(x,y)
 
 # Serialization of CompGraphs does not require input shapes to be provided as they can be inferred.
 io = PipeBuffer()
-onnx(io, g)
+save(io, g)
 
-g = CompGraph(io)
+g = load(io)
 @test g(x,y) ≈ f(x,y)
 ```
 
@@ -112,7 +112,7 @@ To map the function `myfun(args::SomeType....)` to an ONNX operation one just de
 This function typically looks something like this:
 
 ```julia
-import ONNXmutable: AbstractProbe, recursename, nextname, newfrom, add!, name
+import ONNXNaiveNASflux: AbstractProbe, recursename, nextname, newfrom, add!, name
 function myfun(probes::AbstractProbe...)
     p = probes[1] # select any probe
     optype = "MyOpType"
@@ -138,7 +138,7 @@ See [serialize.jl](src/serialize/serialize.jl) for existing operations.
 Deserialization is done by simply mapping operation types to functions in a dictionary. This allows for both easy extension as well as overwriting of existing mappings with own implementations:
 
 ```julia
-import ONNXmutable: actfuns
+import ONNXNaiveNASflux: actfuns
 
 # All inputs which are not output from another node in the graph are provided in the method call
 actfuns[:SomeOp] = (params, α, β) -> x -> x^α + β
@@ -147,9 +147,9 @@ actfuns[:AnotherOp] = function(params)
     α = get(params, :alpha, 1)
     return x -> α / x
 end
-ONNXmutable.refresh()
+ONNXNaiveNASflux.refresh()
 ```
-Note: After adding/changing an operation mapping one needs to call `ONNXmutable.refresh()` for it to take effect.
+Note: After adding/changing an operation mapping one needs to call `ONNXNaiveNASflux.refresh()` for it to take effect.
 See [ops.jl](src/deserialize/ops.jl) for existing operations.
 
 

src/ONNXmutable.jl src/ONNXNaiveNASflux.jlsrc/ONNXmutable.jl renamed to src/ONNXNaiveNASflux.jl

@@ -1,4 +1,4 @@
-module ONNXmutable
+module ONNXNaiveNASflux
 
 include("baseonnx/BaseOnnx.jl")
 
@@ -13,7 +13,7 @@ import Pkg
 import JuMP: @variable, @constraint
 import NaiveNASflux.NaiveNASlib: compconstraint!, all_in_Δsize_graph
 
-export onnx, CompGraph
+export load, save
 
 include("shapes.jl")
 include("validate.jl")

src/deserialize/deserialize.jl

@@ -15,16 +15,10 @@ NaiveNASlib.name(n::ONNX.NodeProto) = n.name
 NaiveNASlib.name(vip::ONNX.ValueInfoProto) = vip.name
 NaiveNASlib.name(tp::ONNX.TensorProto) = tp.name
 
-"""
-   CompGraph(filename::String, insizes...)
-
-Return a [`CompGraph`](@ref) loaded from the given file.
-
-Argument insizes and be either size tuples or name => tuple pairs indicating the size for each model input.
-"""
-NaiveNASlib.CompGraph(filename::String, insizes...; vfun = create_vertex_default) = open(io -> CompGraph(io, insizes...; vfun), filename)
-NaiveNASlib.CompGraph(io::IO, insizes...; vfun = create_vertex_default) = CompGraph(extract(io), insizes...; vfun)
-NaiveNASlib.CompGraph(m::ONNX.ModelProto, insizes...; vfun = create_vertex_default) = CompGraph(m.graph, insizes...; vfun)
+load(filename::String, insizes...; vfun = create_vertex_default) = open(io -> load(io, insizes...; vfun), filename)
+load(io::IO, insizes...; vfun = create_vertex_default) = load(extract(io), insizes...; vfun)
+load(m::ONNX.ModelProto, insizes...; vfun = create_vertex_default) = load(m.graph, insizes...; vfun)
+load(g::ONNX.GraphProto, insizes...; vfun = create_vertex_default) = CompGraph(g, insizes...; vfun)
 NaiveNASlib.CompGraph(g::ONNX.GraphProto, insizes...; vfun = create_vertex_default) = CompGraph(CompGraphBuilder(g, insizes...); vfun)
 function NaiveNASlib.CompGraph(gb::CompGraphBuilder; vfun = create_vertex_default)
    outputs::Vector{AbstractVertex} = vertex.(gb, node.(name.(gb.g.output), gb), vfun)

src/serialize/serialize.jl

@@ -1,23 +1,23 @@
 
 """
-    onnx(filename::AbstractString, f, args...; kwargs...)
-    onnx(io::IO, f, args...; kwargs...)
+    save(filename::AbstractString, f, args...; kwargs...)
+    save(io::IO, f, args...; kwargs...)
 
 Serialize the result of `modelproto(f, args...; kwargs...)` to a file with path `filename` or to `io`.
 
 See [`modelproto`](@ref) for description of arguments.
 """
-onnx(filename::AbstractString, f, args...; modelname=filename, kwargs...) = onnx(filename, modelproto(f, args...; modelname=modelname, kwargs...))
-onnx(io::IO, f, args...; kwargs...) = onnx(io, modelproto(f, args...; kwargs...))
+save(filename::AbstractString, f, args...; modelname=filename, kwargs...) = save(filename, modelproto(f, args...; modelname=modelname, kwargs...))
+save(io::IO, f, args...; kwargs...) = save(io, modelproto(f, args...; kwargs...))
 
 """
-    onnx(filename::AbstractString, mp::ONNX.ModelProto)
-    onnx(io::IO, mp::ONNX.ModelProto)
+    save(filename::AbstractString, mp::ONNX.ModelProto)
+    save(io::IO, mp::ONNX.ModelProto)
 
 Serialize the given [`ONNX.ModelProto`](@ref) to a file with path `filename` or to `io`.
 """
-onnx(filename::AbstractString, mp::ONNX.ModelProto) = open(io -> onnx(io, mp), filename, "w")
-onnx(io::IO, mp::ONNX.ModelProto) = ONNX.writeproto(io, mp)
+save(filename::AbstractString, mp::ONNX.ModelProto) = open(io -> save(io, mp), filename, "w")
+save(io::IO, mp::ONNX.ModelProto) = ONNX.writeproto(io, mp)
 
 
 """
@@ -92,7 +92,7 @@ infer_shape(::Type{<:AbstractArray{T,N}}) where {T,N} = ntuple(i -> missing, N)
 modelproto(;kwargs...) = ONNX.ModelProto(;
     ir_version=6,
     opset_import=[ONNX.OperatorSetIdProto(version=11)],
-    producer_name="ONNXmutable.jl",
+    producer_name="ONNXNaiveNASflux.jl",
     producer_version=string(Pkg.Types.Context().env.project.version), # TODO: Ugh....
     kwargs...)
 
@@ -429,7 +429,7 @@ argpermswith(t, n::Integer, args...) = (a for a in argpermutations(n, t, args...
 
 function gen_broadcastable_elemwise(f, optype, n=2)
     fs = Symbol(f)
-    fm = which(ONNXmutable, fs)
+    fm = which(ONNXNaiveNASflux, fs)
     generate_elemwise(fm, fs, optype, argpermswith(AbstractProbe, n, nothing))
     override_broadcast(f, argpermswith(Base.RefValue{<:AbstractProbe}, n, AbstractArray))
 end

test/Project.toml

@@ -1,5 +1,7 @@
 [deps]
 Conda = "8f4d0f93-b110-5947-807f-2305c1781a2d"
+Downloads = "f43a241f-c20a-4ad4-852c-f6b1247861c6"
+ONNXNaiveNASflux = "2e935253-ba83-4645-9154-13ffeb13a688"
 Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
 PyCall = "438e738f-606a-5dbb-bf0a-cddfbfd45ab0"
 Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"

test/baseonnx/readwrite.jl

@@ -1,5 +1,5 @@
 @testset "Read and write" begin
-    import ONNXmutable.BaseOnnx
+    import ONNXNaiveNASflux.BaseOnnx
 
     function serdeser(p::T) where T
         iob = PipeBuffer();

test/deserialize/constraints.jl

@@ -1,13 +1,13 @@
 
 @testset "Constraints" begin
-    using ONNXmutable.NaiveNASflux
-    import ONNXmutable: SizePseudoTransparent
+    using ONNXNaiveNASflux.NaiveNASflux
+    import ONNXNaiveNASflux: SizePseudoTransparent
 
     dv(name, invertex, outsize) = mutable(name, Dense(nout(invertex), outsize), invertex)
     cv(name, invertex, outsize) = mutable(name, Conv((3,3), nout(invertex) => outsize, pad=(1,1)), invertex)
 
     @testset "Reshape" begin
-        import ONNXmutable: Reshape
+        import ONNXNaiveNASflux: Reshape
 
         rv(name, invertex, outsize, dims) = absorbvertex(Reshape(dims), outsize, invertex; traitdecoration=t -> NamedTrait(SizePseudoTransparent(t), name))
 
@@ -203,7 +203,7 @@
 
 
     @testset "Flatten" begin
-        import ONNXmutable: Flatten
+        import ONNXNaiveNASflux: Flatten
         fv(name, invertex, outsize, dim) = absorbvertex(Flatten(dim), outsize, invertex; traitdecoration=t -> NamedTrait(SizePseudoTransparent(t), name))
 
         function tg(outsize, dim)

test/deserialize/deserialize.jl

@@ -1,11 +1,11 @@
-import ONNXmutable: fluxlayers, sources, actfuns, invariantops, pseudotransparentops, optype, nodes
-using ONNXmutable.NaiveNASflux
+import ONNXNaiveNASflux: fluxlayers, sources, actfuns, invariantops, pseudotransparentops, optype, nodes
+using ONNXNaiveNASflux.NaiveNASflux
 
 # Logging to avoid travis timeouts
 @info "  Test padding and sources"
 
 @testset "Read padding" begin
-    import ONNXmutable: prev
+    import ONNXNaiveNASflux: prev
 
     @test prev(2) == 2
     @test prev([1,2]) == [1,2]
@@ -29,15 +29,15 @@ end
     end
 
     @testset "$(tc.name) graph" begin
-        cg = CompGraph(model)
+        cg = load(model)
         res = cg()
         @test size(res) == size(outputs[1])
         @test res ≈ outputs[1]
 
         # Also test that it we get the same thing by serializing and then deserializing
         io = PipeBuffer()
-        onnx(io, cg)
-        cg = CompGraph(io)
+        save(io, cg)
+        cg = load(io)
         res = cg()
         @test size(res) == size(outputs[1])
         @test res ≈ outputs[1]
@@ -116,15 +116,15 @@ end
     end
 
     @testset "$(tc.name) graph" begin
-        cg = CompGraph(model)
+        cg = load(model)
         res = cg(Float32.(inputs[1]))
         @test size(res) == size(outputs[1])
         @test res ≈ outputs[1]
 
         # Also test that it we get the same thing by serializing and then deserializing
         io = PipeBuffer()
-        onnx(io, cg)
-        cg = CompGraph(io)
+        save(io, cg)
+        cg = load(io)
         res = cg(Float32.(inputs[1]))
         @test size(res) == size(outputs[1])
         @test res ≈ outputs[1]
@@ -213,15 +213,15 @@ end
     end
 
     @testset "$(tc.name) graph" begin
-        cg = CompGraph(model)
+        cg = load(model)
         res = cg(inputs[1])
         @test size(res) == size(outputs[1])
         @test res ≈ outputs[1]
 
         # Also test that it we get the same thing by serializing and then deserializing
         io = PipeBuffer()
-        onnx(io, cg)
-        cg = CompGraph(io)
+        save(io, cg)
+        cg = load(io)
         res = cg(inputs[1])
         @test size(res) == size(outputs[1])
         @test res ≈ outputs[1]
@@ -250,15 +250,15 @@ end
     model, gb, inputs, outputs = prepare_node_test(tc.name, tc.ninputs, tc.noutputs)
 
     @testset "$(tc.name) graph" begin
-        cg = CompGraph(model)
+        cg = load(model)
         res = cg(inputs[1:length(cg.inputs)]...)
         @test size(res) == size(outputs[1])
         @test res ≈ outputs[1]
 
         # Also test that it we get the same thing by serializing and then deserializing
         io = PipeBuffer()
-        onnx(io, cg)
-        cg = CompGraph(io)
+        save(io, cg)
+        cg = load(io)
         res = cg(inputs[1:length(cg.inputs)]...)
         @test size(res) == size(outputs[1])
         @test res ≈ outputs[1]
@@ -271,29 +271,29 @@ end
         ivs = inputvertex.(["in1", "in2"], 4, Ref(FluxDense())) 
         g_org = CompGraph(ivs, "out" >> ivs[1] + ivs[2])
         pb = PipeBuffer()
-        onnx(pb, g_org, "in1" => missing, "in2" => missing)
+        save(pb, g_org, "in1" => missing, "in2" => missing)
         return pb
     end
 
-    insize(t::Tuple) = ONNXmutable.int_size(t[NaiveNASflux.actdim(length(t))])
+    insize(t::Tuple) = ONNXNaiveNASflux.int_size(t[NaiveNASflux.actdim(length(t))])
     insize(p::Pair) = p |> last |> insize
     @testset "Input format $inshapes" for inshapes in (
         ((4,1), (4,1)),
         ("in1" => (4,1), "in2" => (4,1)),
         ((4,missing), (4, :B)),
         ((:I, 3), (:I, 4))
     ) 
-        g_new = CompGraph(sumgraph(), inshapes...)
+        g_new = load(sumgraph(), inshapes...)
         @test nout.(g_new.inputs) == insize.(inshapes) |> collect
         @test layertype.(g_new.inputs) == [FluxDense(), FluxDense()]
     end
 
-    inshape(t::Tuple) = t |> length |> ONNXmutable.guess_layertype
+    inshape(t::Tuple) = t |> length |> ONNXNaiveNASflux.guess_layertype
     @testset "Mixshape format $inshapes" for inshapes in (
         ((1,1,5,1), (5,1)),
         ((5,1), (1,1,5,1)),
     )
-        g_new = CompGraph(sumgraph(), inshapes...)
+        g_new = load(sumgraph(), inshapes...)
         @test nout.(g_new.inputs) == [5, 5]
         @test layertype.(g_new.inputs) == inshape.(inshapes |> collect)
     end
@@ -303,15 +303,15 @@ end
         ("in1" => (4,1), "in2" => (4,1), "in2" => (4,1)),
         ("in1" => (4,1), "notin2" => (4,1))
     )
-        @test_throws AssertionError CompGraph(sumgraph(), inshapes...)
+        @test_throws AssertionError load(sumgraph(), inshapes...)
     end
 end
 
 @testset "Deserialize with merging" begin
     function remodel(f, args...) 
         pb = PipeBuffer()
-        onnx(pb, f, args...)
-        return CompGraph(pb, args...)
+        save(pb, f, args...)
+        return load(pb, args...)
     end
 
 
@@ -322,8 +322,8 @@ end
     end
 
     @testset "Merge Reshape and $gp" for gp in (
-        ONNXmutable.globalmeanpool,
-        ONNXmutable.globalmaxpool
+        ONNXNaiveNASflux.globalmeanpool,
+        ONNXNaiveNASflux.globalmaxpool
     ) 
         m = remodel(Chain(
             Conv((3,3), 3 => 3),