# s=ArgParseSettings()

**URL:** <https://discourse.julialang.org/t/s-argparsesettings/16343>\
**Category:** General Usage\
**Tags:** question\
**Created:** [October 15, 2018, 1:30pm UTC](https://discourse.julialang.org/t/s-argparsesettings/16343 "2018-10-15T13:30:43Z")\
**Posts on this page:** 2\
**Page:** 1

<div class="post-metadata">

**Author:** ![lannisite110](https://avatars.discourse-cdn.com/v4/letter/l/df705f/32.png) [@lannisite110](https://discourse.julialang.org/u/lannisite110)\
**Post date:** [October 15, 2018, 1:30pm UTC](https://discourse.julialang.org/t/s-argparsesettings/16343/1 "2018-10-15T13:30:43Z")

</div>

julia VGGforw\_up.jl  
Testing vgg’s code on RGB-D dataset  
Dict{String,Any}(“epochs”=\>5,“lr”=\>1.0e-5,“nbatch”=\>100,“seed”=\>42,“gcheck”=\>0)  
ERROR: LoadError: UndefVarError: symbol not defined  
Stacktrace:  
[1] macro expansion at /home/users/xdlan/.julia/packages/ArgParse/iJFzR/src/ArgParse.jl:776 [inlined]  
[2] Knettest(::Array{String,1}) at /home/users/xdlan/myexperiment/VGG3D/rgbd-convnet-master/VGG3D/VGGforw\_up.jl:82  
[3] top-level scope at none:0  
[4] include at ./boot.jl:317 [inlined]  
[5] include\_relative(::Module, ::String) at ./loading.jl:1038  
[6] include(::Module, ::String) at ./sysimg.jl:29  
[7] exec\_options(::Base.JLOptions) at ./client.jl:229  
[8] \_start() at ./client.jl:421  
in expression starting at /home/users/xdlan/myexperiment/VGG3D/rgbd-convnet-master/VGG3D/VGGforw\_up.jl:278

this is the original file

# Implementing a test for the RGB-d dataset

# 148x148 - one layer

using Pkg; for p in (“Knet”,“ArgParse”); haskey(Pkg.installed(),p) || Pkg.add(p); end  
#using CUDArt  
using CUDAdrv  
#device(3)

#CUDNN-\>CuArrays  
using Knet, MAT, ArgParse, CuArrays

function cbf(x;f=:relu, w = Xavier(), b = Constant(0) , p= 1, out = 0, oparams…)  
v = par(; oparams… , init = w, out=out)  
y = conv(v,x; padding = p, mode = CUDNN\_CROSS\_CORRELATION)  
z = bias4(y; binit=b, outDim = out, oparams…)  
return f(z; oparams…)  
end

function bias4(x; binit=Constant(0), outDim = 0, oparams…)  
b = par(; oparams…, init=binit)  
return b+x  
end

function cb(x;w = Xavier(), b = Constant(0) , p= 0, s = 1, oparams…)  
v = par(; oparams… , init = w)  
y = conv(v,x; padding = p, stride = s, mode = CUDNN\_CROSS\_CORRELATION)  
return bias4(y; binit =b,oparams…)  
end

function cbfp(x; f=:relu, cwindow=0, pwindow=0, oparams…)  
y = wconv(x; oparams…, window=cwindow)  
z = bias4(y; oparams…)  
return f(z; oparams…)  
end

function vgg\_model(x0;weights=0)

```
x1 = cbf(x0; w = map(Float32,weights["w1_1"]), b = reshape(map(Float32,weights["b1_1"]) ,1,1,size(weights["b1_1"],1),1), out=64)

x2 = cbf(x1; w = map(Float32,weights["w1_2"]), b = reshape(map(Float32,weights["b1_2"]) ,1,1,size(weights["b1_2"],1),1), out=64)

x3 = pool(x2; window = 2)

x4 = cbf(x3; w = map(Float32,weights["w2_1"]), b = reshape(map(Float32,weights["b2_1"]) ,1,1,size(weights["b2_1"],1),1), out=128)

x5 = cbf(x4; w = map(Float32,weights["w2_2"]), b = reshape(map(Float32,weights["b2_2"]) ,1,1,size(weights["b2_2"],1),1), out=128)

x6 = pool(x5; window = 2)

x7 = cbf(x6; w = map(Float32,weights["w3_1"]), b = reshape(map(Float32,weights["b3_1"]) ,1,1,size(weights["b3_1"],1),1), out=256)

x8 = cbf(x7; w = map(Float32,weights["w3_2"]), b = reshape(map(Float32,weights["b3_2"]) ,1,1,size(weights["b3_2"],1),1), out=256)

x9 = cbf(x8; w = map(Float32,weights["w3_3"]), b = reshape(map(Float32,weights["b3_3"]) ,1,1,size(weights["b3_3"],1),1), out=256)

x10 = pool(x9; window = 2)

x11 = cbf(x10; w = map(Float32,weights["w4_1"]), b = reshape(map(Float32,weights["b4_1"]) ,1,1,size(weights["b4_1"],1),1), out=512)

x12 = cbf(x11; w = map(Float32,weights["w4_2"]), b = reshape(map(Float32,weights["b4_2"]) ,1,1,size(weights["b4_2"],1),1), out=512)

x13 = cbf(x12; w = map(Float32,weights["w4_3"]), b = reshape(map(Float32,weights["b4_3"]) ,1,1,size(weights["b4_3"],1),1), out=512)

x14 = pool(x13; window = 2)

x15 = cbf(x14;w = map(Float32,weights["w5_1"]), b = reshape(map(Float32,weights["b5_1"]) ,1,1,size(weights["b5_1"],1),1), out=512)

x16 = cbf(x15; w = map(Float32,weights["w5_2"]), b = reshape(map(Float32,weights["b5_2"]) ,1,1,size(weights["b5_2"],1),1), out=512)

x17 = cbf(x16; w = map(Float32,weights["w5_3"]), b = reshape(map(Float32,weights["b5_3"]) ,1,1,size(weights["b5_3"],1),1), out=512)

x18 = pool(x17; window = 2)

```

return cbf(x18;w = map(Float32,weights[“w6”]), b = reshape(map(Float32,weights[“b6”]) ,1,1,size(weights[“b6”],1),1), f=:relu, p=0)

```
#x20 = cbf(x19; w= w77, b=b77, f=:relu, out=4096, p=0)
#return wbf(x20; out = 51, f=:soft)

```

end

function Knettest(args=ARGS)  
println(“Testing vgg’s code on RGB-D dataset”)  
s = ArgParseSettings()  
@add\_arg\_table s begin  
(“–seed”; arg\_type=Int; default=42)  
(“–nbatch”; arg\_type=Int; default=100)  
(“–lr”; arg\_type=Float64; default=0.00001)  
(“–epochs”; arg\_type=Int; default=5)  
(“–gcheck”; arg\_type=Int; default=0)  
end  
isa(args, AbstractString) && (args=split(args))  
opts = parse\_args(args, s)  
println(opts)  
for (k,v) in opts; @eval ($(symbol(k))=$v); end  
seed \> 0 && setseed(seed)

```
xtrnFile = matopen("Train3DSplit1Reshaped.mat")
xtrn = read(xtrnFile,"Train3DSplit1Reshaped")
xtrn = map(Float32,xtrn)
println(size(xtrn))

xtstFile = matopen("Test3DSplit1Reshaped.mat")
xtst = read(xtstFile,"Test3DSplit1Reshaped")
xtst = map(Float32,xtst)
println(size(xtst))

#xdevFile = matopen("DevRGBSplit1.mat")
#xdev = read(xdevFile,"DevRGBSplit1")
#xdev = map(Float32,xdev)
#println(size(xdev))

ytrnFile = matopen("Train3DSplit1LabelsMat.mat")
ytrn = read(ytrnFile,"Train3DSplit1LabelsMat")
ytrn = map(Float32,ytrn)

ytstFile = matopen("Test3DSplit1LabelsMat.mat")
ytst = read(ytstFile,"Test3DSplit1LabelsMat")
ytst = map(Float32,ytst)

#ydevFile = matopen("DevRGBSplit1LabelsMat.mat")
#ydev = read(ydevFile,"DevRGBSplit1LabelsMat")
#ydev = map(Float32,ydev)

file = matread("vgg-verydeep-16.mat")

rxtrn = mean(xtrn[:,:,1,:]);
gxtrn = mean(xtrn[:,:,2,:]);
bxtrn = mean(xtrn[:,:,3,:]);

println(rxtrn);
println(gxtrn);
println(bxtrn);

xtrn[:,:,1,:] = xtrn[:,:,1,:] - rxtrn;
xtrn[:,:,2,:] = xtrn[:,:,2,:] - gxtrn;
xtrn[:,:,3,:] = xtrn[:,:,3,:] - bxtrn;

xtst[:,:,1,:] = xtst[:,:,1,:] - rxtrn;
xtst[:,:,2,:] = xtst[:,:,2,:] - gxtrn;
xtst[:,:,3,:] = xtst[:,:,3,:] - bxtrn;

global dtrn = minibatch(xtrn, ytrn, nbatch)
global dtst = minibatch(xtst, ytst, nbatch)

global vgg = compile(:vgg_model; weights=file)
#tic()
dim = 1;fmaps = 4096;
xtrnsize =size(xtrn,4)
xtrnzerosize = xtrnsize + nbatch - xtrnsize%nbatch;#map(Int64, (xtrnsize/nbatch +1)*nbatch);
println(xtrnzerosize)
xtrnZeroPad = zeros(size(xtrn,1),size(xtrn,2),size(xtrn,3),xtrnzerosize)
for x=1:size(xtrn,4)
	xtrnZeroPad[:,:,:,x] = xtrn[:,:,:,x]
end
println(size(xtrn))
println(size(xtrnZeroPad))
xtrnZeroPad = map(Float32, xtrnZeroPad)
xtrnFeatures = zeros(dim,dim,fmaps,xtrnzerosize)
for item = 1:nbatch:size(xtrn,4)
	ypred = forw(vgg, xtrnZeroPad[:,:,:,item:item+nbatch-1])
	xtrnFeatures[:,:,:,item:item+nbatch-1] = to_host(ypred)
end

xtrnFeatures = xtrnFeatures[:,:,:,1:xtrnsize]

filetrn = matopen("TrainRGBSplit1Features1.mat", "w")
write(filetrn, "TrainRGBSplit1Features1", xtrnFeatures)
close(filetrn)

xtrnFeatures = 0;
xtrnZeroPad = 0;
gc();

xtstsize =size(xtst,4)
xtstzerosize = xtstsize + nbatch - xtstsize%nbatch;#map(Int64,(xtstsize/nbatch +1)*nbatch);
println(xtrnzerosize)
xtstZeroPad = zeros(size(xtst,1),size(xtst,2),size(xtst,3),xtstzerosize)
for x=1:size(xtst,4)
	xtstZeroPad[:,:,:,x] = xtst[:,:,:,x]
end

println(size(xtst))
println(size(xtstZeroPad))
xtstZeroPad = map(Float32, xtstZeroPad)
xtstFeatures = zeros(dim,dim,fmaps,xtstzerosize)
for item = 1:nbatch:size(xtst,4)
	ypred = forw(vgg, xtstZeroPad[:,:,:,item:item+nbatch-1])
	xtstFeatures[:,:,:,item:item+nbatch-1] = to_host(ypred)
end

xtstFeatures = xtstFeatures[:,:,:,1:xtstsize]

println(size(xtstFeatures))
println(size(xtrnFeatures))
filetst = matopen("TestRGBSplit1Features1.mat", "w")
write(filetst, "TestRGBSplit1Features1", xtstFeatures)
close(filetst)

#xdevZeroPad = zeros(size(xdev,1),size(xdev,2),size(xdev,3),7040)
#for x=1:size(xdev,4)
#	xdevZeroPad[:,:,:,x] = xdev[:,:,:,x]
#end

#xdevFeatures = zeros(dim,dim,fmaps,7040)
#for item = 1:nbatch:size(xdev,4)
#	ypred = forw(vgg, xdevZeroPad[:,:,:,item:item+nbatch-1]; trn=false)
#	xdevFeatures[:,:,:,item:item+nbatch-1] = to_host(ypred)
#end

#xdevFeatures = xdevFeatures[:,:,:,1:6982]

#filedev = matopen("DevRGBSplit1Features1.mat", "w")
#write(filedev, "DevRGBSplit1Features1", xdevFeatures)
#close(filedev)
#println(toc())
setp(vgg; lr=lr)

#l=zeros(2); m=zeros(2)
#for epoch=1:epochs
#	tic();
# train(vgg,dtrn,softloss; losscnt=fill!(l,0), maxnorm=fill!(m,0))
# atrn = 1-test(vgg,dtrn,zeroone)
# atst = 1-test(vgg,dtst,zeroone)
# println((epoch, atrn, atst, l[1]/l[2], m...))
# println(toc())
# gcheck > 0 && gradcheck(vgg, f->getgrad(f,dtrn,softloss), f->getloss(f,dtrn,softloss); gcheck=gcheck)
#end
#return (l[1]/l[2],m...)

```

end

function train(f, data, loss; losscnt=nothing, maxnorm=nothing)  
for (x,ygold) in data  
ypred = forw(f, x)  
#println(to\_host(size(ypred)))  
back(f, ygold, loss)  
update!(f)  
losscnt[1] += loss(ypred, ygold); losscnt[2] += 1  
w=wnorm(f); w \> maxnorm[1] && (maxnorm[1]=w)  
g=gnorm(f); g \> maxnorm[2] && (maxnorm[2]=g)  
end  
end

function test(f, data, loss)  
sumloss = numloss = 0  
for (x,ygold) in data  
ypred = forw(f, x)  
sumloss += loss(ypred, ygold)  
numloss += 1  
end  
sumloss / numloss  
end

function minibatch(x, y, batchsize)  
data = Any  
for i=1:batchsize:ccount(x)-batchsize+1  
j=i+batchsize-1  
push!(data, (cget(x,i:j), cget(y,i:j)))  
end  
return data  
end

function getgrad(f, data, loss)  
(x,ygold) = first(data)  
ypred = forw(f, x)  
back(f, ygold, loss)  
loss(ypred, ygold)  
end

function getloss(f, data, loss)  
(x,ygold) = first(data)  
ypred = forw(f, x)  
loss(ypred, ygold)  
end

#!isinteractive() && !isdefined(:load\_only) && Knettest(ARGS)  
endswith(string(PROGRAM\_FILE), “VGGforw\_up.jl”) && Knettest(ARGS)

---

<div class="post-metadata">

**Author:** ![Sukera](https://avatars.discourse-cdn.com/v4/letter/s/ce7236/32.png) [@Sukera](https://discourse.julialang.org/u/Sukera)\
**Post date:** [October 15, 2018, 1:37pm UTC](https://discourse.julialang.org/t/s-argparsesettings/16343/2 "2018-10-15T13:37:07Z")

</div>

[Please make it easier to help you - provide a minimal working example and format your code for display](https://discourse.julialang.org/t/psa-make-it-easier-to-help-you/14757). For example, I’m quite certain we can’t just run your code as it seems to open and read files local to your environment.