caffe

package module
v0.3.1-0...-4043f67 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Jul 31, 2019 License: NCSA Imports: 24 Imported by: 2

README

MLModelScope Caffe Agent

Build Status Build Status Go Report Card License

This is the Caffe agent for MLModelScope, an open-source framework and hardware agnostic, extensible and customizable platform for evaluating and profiling ML models across datasets / frameworks / systems, and within AI application pipelines.

Currently it has most of the vison models from Caffe Model Zoo built in. More built-in models are comming. One can evaluate the ~40 models on any systems of insterest with either local Caffe installation or Caffe docker images.

Check out MLModelScope and welcome to contribute.

Installation

Install go if you have not done so. Please follow Go Installation.

Download and install the MLModelScope Caffe Agent:

go get -v github.com/rai-project/caffe

The agent requires The Caffe C library and other Go packages.

Go packages

You can install the dependency through go get.

cd $GOPATH/src/github.com/rai-project/caffe
go get -u -v ./...

Or use Dep.

dep ensure -v

This installs the dependency in vendor/.

Note: The CGO interface passes go pointers to the C API. This is an error by the CGO runtime. Disable the error by placing

export GODEBUG=cgocheck=0

in your ~/.bashrc or ~/.zshrc file and then run either source ~/.bashrc or source ~/.zshrc

The Caffe C library

The Caffe C library is required.

If you use Caffe Docker Images (e.g. NVIDIA GPU CLOUD (NGC)), skip this step.

Refer to go-caffe for caffe installation.

External services

Refer to External services.

Use within Caffe Docker Images

Refer to Use within TensorFlow Docker Images.

Usage

Refer to Usage

Documentation

Overview

Package caffe is a generated protocol buffer package.

It is generated from these files:

caffe.proto

It has these top-level messages:

BlobShape
BlobProto
BlobProtoVector
Datum
FillerParameter
NetParameter
SolverParameter
SolverState
NetState
NetStateRule
ParamSpec
LayerParameter
TransformationParameter
LossParameter
AccuracyParameter
ArgMaxParameter
ConcatParameter
BatchNormParameter
BiasParameter
ContrastiveLossParameter
ConvolutionParameter
CropParameter
DataParameter
DropoutParameter
DummyDataParameter
EltwiseParameter
ELUParameter
EmbedParameter
ExpParameter
FlattenParameter
HDF5DataParameter
HDF5OutputParameter
HingeLossParameter
ImageDataParameter
InfogainLossParameter
InnerProductParameter
InputParameter
LogParameter
LRNParameter
MemoryDataParameter
MVNParameter
ParameterParameter
PoolingParameter
PowerParameter
PythonParameter
RecurrentParameter
ReductionParameter
ReLUParameter
ReshapeParameter
ScaleParameter
SigmoidParameter
SliceParameter
SoftmaxParameter
TanHParameter
TileParameter
ThresholdParameter
WindowDataParameter
SPPParameter
V1LayerParameter
V0LayerParameter
PReLUParameter

Index

Constants

View Source
const Default_AccuracyParameter_Axis int32 = 1
View Source
const Default_AccuracyParameter_TopK uint32 = 1
View Source
const Default_ArgMaxParameter_OutMaxVal bool = false
View Source
const Default_ArgMaxParameter_TopK uint32 = 1
View Source
const Default_BatchNormParameter_Eps float32 = 1e-05
View Source
const Default_BatchNormParameter_MovingAverageFraction float32 = 0.999
View Source
const Default_BiasParameter_Axis int32 = 1
View Source
const Default_BiasParameter_NumAxes int32 = 1
View Source
const Default_BlobProto_Channels int32 = 0
View Source
const Default_BlobProto_Height int32 = 0
View Source
const Default_BlobProto_Num int32 = 0
View Source
const Default_BlobProto_Width int32 = 0
View Source
const Default_ConcatParameter_Axis int32 = 1
View Source
const Default_ConcatParameter_ConcatDim uint32 = 1
View Source
const Default_ContrastiveLossParameter_LegacyVersion bool = false
View Source
const Default_ContrastiveLossParameter_Margin float32 = 1
View Source
const Default_ConvolutionParameter_Axis int32 = 1
View Source
const Default_ConvolutionParameter_BiasTerm bool = true
View Source
const Default_ConvolutionParameter_ForceNdIm2Col bool = false
View Source
const Default_ConvolutionParameter_Group uint32 = 1
View Source
const Default_ConvolutionParameter_PadH uint32 = 0
View Source
const Default_ConvolutionParameter_PadW uint32 = 0
View Source
const Default_CropParameter_Axis int32 = 2
View Source
const Default_DataParameter_CropSize uint32 = 0
View Source
const Default_DataParameter_ForceEncodedColor bool = false
View Source
const Default_DataParameter_Mirror bool = false
View Source
const Default_DataParameter_Prefetch uint32 = 4
View Source
const Default_DataParameter_RandSkip uint32 = 0
View Source
const Default_DataParameter_Scale float32 = 1
View Source
const Default_Datum_Encoded bool = false
View Source
const Default_DropoutParameter_DropoutRatio float32 = 0.5
View Source
const Default_ELUParameter_Alpha float32 = 1
View Source
const Default_EltwiseParameter_StableProdGrad bool = true
View Source
const Default_EmbedParameter_BiasTerm bool = true
View Source
const Default_ExpParameter_Base float32 = -1
View Source
const Default_ExpParameter_Scale float32 = 1
View Source
const Default_ExpParameter_Shift float32 = 0
View Source
const Default_FillerParameter_Max float32 = 1
View Source
const Default_FillerParameter_Mean float32 = 0
View Source
const Default_FillerParameter_Min float32 = 0
View Source
const Default_FillerParameter_Sparse int32 = -1
View Source
const Default_FillerParameter_Std float32 = 1
View Source
const Default_FillerParameter_Type string = "constant"
View Source
const Default_FillerParameter_Value float32 = 0
View Source
const Default_FlattenParameter_Axis int32 = 1
View Source
const Default_FlattenParameter_EndAxis int32 = -1
View Source
const Default_HDF5DataParameter_Shuffle bool = false
View Source
const Default_ImageDataParameter_BatchSize uint32 = 1
View Source
const Default_ImageDataParameter_CropSize uint32 = 0
View Source
const Default_ImageDataParameter_IsColor bool = true
View Source
const Default_ImageDataParameter_Mirror bool = false
View Source
const Default_ImageDataParameter_NewHeight uint32 = 0
View Source
const Default_ImageDataParameter_NewWidth uint32 = 0
View Source
const Default_ImageDataParameter_RandSkip uint32 = 0
View Source
const Default_ImageDataParameter_Scale float32 = 1
View Source
const Default_ImageDataParameter_Shuffle bool = false
View Source
const Default_InnerProductParameter_Axis int32 = 1
View Source
const Default_InnerProductParameter_BiasTerm bool = true
View Source
const Default_InnerProductParameter_Transpose bool = false
View Source
const Default_LRNParameter_Alpha float32 = 1
View Source
const Default_LRNParameter_Beta float32 = 0.75
View Source
const Default_LRNParameter_K float32 = 1
View Source
const Default_LRNParameter_LocalSize uint32 = 5
View Source
const Default_LogParameter_Base float32 = -1
View Source
const Default_LogParameter_Scale float32 = 1
View Source
const Default_LogParameter_Shift float32 = 0
View Source
const Default_MVNParameter_AcrossChannels bool = false
View Source
const Default_MVNParameter_Eps float32 = 1e-09
View Source
const Default_MVNParameter_NormalizeVariance bool = true
View Source
const Default_NetParameter_DebugInfo bool = false
View Source
const Default_NetParameter_ForceBackward bool = false
View Source
const Default_NetState_Level int32 = 0
View Source
const Default_PReLUParameter_ChannelShared bool = false
View Source
const Default_ParamSpec_DecayMult float32 = 1
View Source
const Default_ParamSpec_LrMult float32 = 1
View Source
const Default_PoolingParameter_GlobalPooling bool = false
View Source
const Default_PoolingParameter_Pad uint32 = 0
View Source
const Default_PoolingParameter_PadH uint32 = 0
View Source
const Default_PoolingParameter_PadW uint32 = 0
View Source
const Default_PoolingParameter_Stride uint32 = 1
View Source
const Default_PowerParameter_Power float32 = 1
View Source
const Default_PowerParameter_Scale float32 = 1
View Source
const Default_PowerParameter_Shift float32 = 0
View Source
const Default_PythonParameter_ShareInParallel bool = false
View Source
const Default_ReLUParameter_NegativeSlope float32 = 0
View Source
const Default_RecurrentParameter_DebugInfo bool = false
View Source
const Default_RecurrentParameter_ExposeHidden bool = false
View Source
const Default_RecurrentParameter_NumOutput uint32 = 0
View Source
const Default_ReductionParameter_Axis int32 = 0
View Source
const Default_ReductionParameter_Coeff float32 = 1
View Source
const Default_ReshapeParameter_Axis int32 = 0
View Source
const Default_ReshapeParameter_NumAxes int32 = -1
View Source
const Default_ScaleParameter_Axis int32 = 1
View Source
const Default_ScaleParameter_BiasTerm bool = false
View Source
const Default_ScaleParameter_NumAxes int32 = 1
View Source
const Default_SliceParameter_Axis int32 = 1
View Source
const Default_SliceParameter_SliceDim uint32 = 1
View Source
const Default_SoftmaxParameter_Axis int32 = 1
View Source
const Default_SolverParameter_AverageLoss int32 = 1
View Source
const Default_SolverParameter_ClipGradients float32 = -1
View Source
const Default_SolverParameter_DebugInfo bool = false
View Source
const Default_SolverParameter_Delta float32 = 1e-08
View Source
const Default_SolverParameter_DeviceId int32 = 0
View Source
const Default_SolverParameter_IterSize int32 = 1
View Source
const Default_SolverParameter_Momentum2 float32 = 0.999
View Source
const Default_SolverParameter_RandomSeed int64 = -1
View Source
const Default_SolverParameter_RegularizationType string = "L2"
View Source
const Default_SolverParameter_Snapshot int32 = 0
View Source
const Default_SolverParameter_SnapshotAfterTrain bool = true
View Source
const Default_SolverParameter_SnapshotDiff bool = false
View Source
const Default_SolverParameter_TestComputeLoss bool = false
View Source
const Default_SolverParameter_TestInitialization bool = true
View Source
const Default_SolverParameter_TestInterval int32 = 0
View Source
const Default_SolverParameter_Type string = "SGD"
View Source
const Default_SolverState_CurrentStep int32 = 0
View Source
const Default_ThresholdParameter_Threshold float32 = 0
View Source
const Default_TileParameter_Axis int32 = 1
View Source
const Default_TransformationParameter_CropSize uint32 = 0
View Source
const Default_TransformationParameter_ForceColor bool = false
View Source
const Default_TransformationParameter_ForceGray bool = false
View Source
const Default_TransformationParameter_Mirror bool = false
View Source
const Default_TransformationParameter_Scale float32 = 1
View Source
const Default_V0LayerParameter_Alpha float32 = 1
View Source
const Default_V0LayerParameter_Beta float32 = 0.75
View Source
const Default_V0LayerParameter_Biasterm bool = true
View Source
const Default_V0LayerParameter_ConcatDim uint32 = 1
View Source
const Default_V0LayerParameter_Cropsize uint32 = 0
View Source
const Default_V0LayerParameter_DetBgThreshold float32 = 0.5
View Source
const Default_V0LayerParameter_DetContextPad uint32 = 0
View Source
const Default_V0LayerParameter_DetCropMode string = "warp"
View Source
const Default_V0LayerParameter_DetFgFraction float32 = 0.25
View Source
const Default_V0LayerParameter_DetFgThreshold float32 = 0.5
View Source
const Default_V0LayerParameter_DropoutRatio float32 = 0.5
View Source
const Default_V0LayerParameter_Group uint32 = 1
View Source
const Default_V0LayerParameter_K float32 = 1
View Source
const Default_V0LayerParameter_LocalSize uint32 = 5
View Source
const Default_V0LayerParameter_Mirror bool = false
View Source
const Default_V0LayerParameter_NewChannels int32 = 0
View Source
const Default_V0LayerParameter_NewHeight int32 = 0
View Source
const Default_V0LayerParameter_NewNum int32 = 0
View Source
const Default_V0LayerParameter_NewWidth int32 = 0
View Source
const Default_V0LayerParameter_Pad uint32 = 0
View Source
const Default_V0LayerParameter_RandSkip uint32 = 0
View Source
const Default_V0LayerParameter_Scale float32 = 1
View Source
const Default_V0LayerParameter_ShuffleImages bool = false
View Source
const Default_V0LayerParameter_Stride uint32 = 1
View Source
const Default_WindowDataParameter_BgThreshold float32 = 0.5
View Source
const Default_WindowDataParameter_CacheImages bool = false
View Source
const Default_WindowDataParameter_ContextPad uint32 = 0
View Source
const Default_WindowDataParameter_CropMode string = "warp"
View Source
const Default_WindowDataParameter_CropSize uint32 = 0
View Source
const Default_WindowDataParameter_FgFraction float32 = 0.25
View Source
const Default_WindowDataParameter_FgThreshold float32 = 0.5
View Source
const Default_WindowDataParameter_Mirror bool = false
View Source
const Default_WindowDataParameter_Scale float32 = 1

Variables

View Source
var (
	// CTX is a context for webdav vfs
	CTX = context.Background()

	// FS is a virtual memory file system
	FS = webdav.NewMemFS()

	// Handler is used to server files through a http handler
	Handler *webdav.Handler

	// HTTP is the http file system
	HTTP http.FileSystem = new(HTTPFS)
)
View Source
var (
	ErrInvalidLengthCaffe = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowCaffe   = fmt.Errorf("proto: integer overflow")
)
View Source
var (
	Version   = "0.3.0"
	BuildDate = "undefined"
	GitCommit = "undefined"
)

Version ...

View Source
var ConvolutionParameter_Engine_name = map[int32]string{
	0: "DEFAULT",
	1: "CAFFE",
	2: "CUDNN",
}
View Source
var ConvolutionParameter_Engine_value = map[string]int32{
	"DEFAULT": 0,
	"CAFFE":   1,
	"CUDNN":   2,
}
View Source
var DataParameter_DB_name = map[int32]string{
	0: "LEVELDB",
	1: "LMDB",
}
View Source
var DataParameter_DB_value = map[string]int32{
	"LEVELDB": 0,
	"LMDB":    1,
}
View Source
var EltwiseParameter_EltwiseOp_name = map[int32]string{
	0: "PROD",
	1: "SUM",
	2: "MAX",
}
View Source
var EltwiseParameter_EltwiseOp_value = map[string]int32{
	"PROD": 0,
	"SUM":  1,
	"MAX":  2,
}
View Source
var FileBVLCAlexNetYml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x04\xff\x8c\x56\x5b\x6f\xe3\xba\x11\x7e\xd7\xaf\x18\xc0\x58\x20\xdb\x5a\x57\x5f\xe2\xa8\x40\xd1\x36\xed\x43\x81\x36\x0f\xed\x9e\xf3\xb2\x58\x04\x23\x72\x64\x71\x43\x91\x02\x49\x39\xf1\xfe\xfa\x83\xa1\x64\xcb\x59\x60\xf7\x9c\x3c\x38\x22\xe7\xfe\xcd\x8d\x06\x7b\xaa\xe1\x1f\xbf\xfe\xe7\x31\xfd\xbb\xa6\xb7\x27\x0a\xb0\x02\xbe\x04\xdb\xc2\xd9\x8e\x0e\x7a\x2b\x49\x27\xad\xc3\x9e\x5e\xad\x7b\xa9\x13\x88\xf4\x1a\x1e\xb1\x6d\x09\x56\x70\x25\x41\x6b\x1d\x84\x8e\x66\x11\x80\x13\x39\xaf\xac\xa9\xa1\xcc\x8a\x77\x8c\x33\x01\x84\x35\xc1\xa1\x32\x21\x99\x6f\x2e\xac\xf3\x11\x94\x69\xad\xeb\x31\x28\xcb\xdf\xe0\xa9\x47\x13\x94\xb8\xd2\x27\x6a\xc2\x7a\x50\x19\x72\x35\xac\xa2\xd2\x78\xf0\x30\x7a\x92\x10\x2c\x0c\xe4\x98\x73\x72\x0c\x06\x47\x52\x09\xd6\x99\xc0\xf2\xb7\x82\x7e\xd4\x41\x0d\x9a\x60\xd0\x18\x98\xdf\x83\x40\x03\x0d\x81\x1f\x48\xa8\x56\x91\x4c\x00\xb0\x97\xfb\x2d\xa3\x00\x70\x1c\xc6\x1a\x1c\xaa\xc1\xd9\xaf\x24\x42\x2e\xd0\xf5\x3a\x15\x8c\x4b\x1d\xd9\x52\x31\x8c\xd1\x86\xf8\x5d\xce\x63\xe4\x1c\x06\xb1\xdf\x6a\x9a\xd4\xff\x4c\x68\x66\x9c\xc5\x7e\xee\xca\x2d\xaf\x24\x2f\x9c\x1a\x38\xf8\x1a\xfe\x9a\x00\x7c\xea\x94\x9f\x71\x51\x1e\x10\x1c\x0d\x5a\x89\x09\x71\xdb\x2e\xe9\x84\x49\xb2\x21\x09\xca\xc4\xeb\x4b\xbd\x0c\x63\x73\x91\xc8\x12\x80\x7f\xaa\xb6\x25\x47\x46\x90\xaf\xc1\xd8\x00\x31\xc3\xca\x1c\xe1\x55\x85\x2e\x4a\x3a\xd2\xea\xd8\x05\xbe\x93\x18\x30\xc5\xf1\xd8\x93\x09\xd1\xe8\x5f\x12\x00\x65\x54\x50\xa8\xd5\x37\xe6\x30\xd6\xa4\xdf\xc8\x59\x68\x14\x7a\xf2\x9c\xce\x22\x2b\x41\x19\x1f\x08\x25\xfb\x58\xc2\x5d\x6b\x47\x23\xc1\x90\x20\xef\xd1\x9d\xb9\x2e\xae\x76\xd7\x80\x7e\x51\x19\x8d\xb0\x92\x12\x8e\x78\x22\x68\x35\x06\xd0\xd6\xfb\x8f\xec\xfc\xa7\x8e\xa0\x19\x8d\xd4\x24\x17\x50\xb8\xa4\x55\x20\x37\x89\x6e\xf6\xc5\xba\x28\x0a\xf0\x06\x07\xdf\xd9\x90\x4d\x42\xe4\x03\x9c\x50\x2b\x19\xb9\x12\xb8\xd4\x1c\x1a\x41\x20\x47\xc7\xa1\x2c\x48\xb0\x47\x8b\xc6\xdd\x21\x6a\x8c\xf8\x2c\x3a\x00\x85\x18\x1d\x8a\x73\x02\xb0\xbb\xcf\xaa\xdd\xe1\x03\xa0\x91\xd1\x59\x28\xb3\xc3\xe6\x61\x7b\x60\xe3\xd7\xfc\xd9\x86\xeb\x9e\x93\x18\xec\x90\x96\x57\x79\x96\x2e\x27\x59\x4c\x20\x12\x77\x0b\xf1\x50\x64\xd5\x07\xb0\x53\x4e\x6f\xac\x7b\x0a\x6b\x18\x3d\xfb\xfd\x75\xf4\x21\xa2\x20\xc8\x04\x72\x20\x9c\x1d\x18\xad\xbb\x5f\x22\x99\xf1\xc1\x13\x39\x3c\xc6\xa9\x51\x16\x91\xc1\xaf\xe1\x6e\x0b\x7f\x86\x72\x96\xfa\x08\x7f\x82\x0a\x7a\xe5\x9c\x75\x6b\xf0\x9d\x1d\xb5\x9c\x5d\xe6\xae\x82\x46\x05\xe8\xd4\xb1\x23\x77\xf5\x2d\xfb\xf8\xbe\x40\x19\xb6\x88\x21\x49\x68\xce\xf0\xaf\x13\x1a\xf8\x7f\x47\xba\xc3\x9e\x1c\xfc\xcd\x5f\x3e\x13\x47\x4b\x09\xae\x60\x39\x71\xde\x07\x1c\xc8\x79\xc8\xe1\x95\x1a\xaf\x02\xf1\x27\x05\x91\x65\x97\x0a\xe7\x88\x39\xa4\x69\xf0\x01\xa4\xd0\x85\x30\xf8\x3a\xcf\x8f\x2a\x74\x63\x93\x09\xdb\xe7\x3c\x31\xf3\xd8\xe9\x79\x70\x44\x79\x8f\x3e\x90\xcb\xa3\x8c\xcf\x9b\x93\x16\xcf\xa8\xe9\xcd\x50\xf8\x03\x1a\x5e\xd5\x8b\xca\xff\xcb\x73\xd6\xa7\x97\xa4\xa7\xd6\xa4\xff\xee\xf1\x48\x4f\x14\xd2\xaa\x28\xab\xf4\x84\xfa\xaa\xab\xce\xf3\x29\x8e\xcc\xa8\xc1\x67\x42\x4c\xc7\x7c\x7b\xa8\xb6\xa9\x62\x31\x43\x21\x15\x1a\xbd\x57\xed\xdc\xce\xe9\xab\x0a\x5d\x2a\x89\x86\x54\x58\x73\xb2\x7a\xe4\x29\x80\x3a\x35\x34\xba\xf8\x2f\xf0\x80\xf7\xd9\x20\xdb\x64\x05\x5a\x09\x32\x3e\x66\x74\x41\x63\xbe\xac\x61\x34\x8e\x7c\x70\x4a\x04\x92\xc9\x0a\x94\x19\xc6\x10\xe1\x5d\x78\xa7\x3b\x1e\x65\x2b\x68\x95\xf3\x61\xe2\x82\x70\x1e\x68\x6a\xd0\x9b\x55\x91\xc6\xeb\x1a\xa2\xef\x71\x64\xae\xe6\x7c\xc4\x59\xc5\x6d\xce\xec\x37\x7a\x22\xd3\x34\x94\x22\x4b\x1d\x19\xa2\xd1\x1b\x2d\x03\xf2\xe2\x0a\xe4\x3c\xaf\x86\x68\x7a\xb9\x8a\x2a\x00\xa4\xea\xc9\xf0\xa2\xf2\x35\x7c\xde\xac\xa1\xaa\xee\xe3\xcf\x97\x99\xde\x13\x9a\x1a\x3e\x97\xd5\x66\x0d\x65\x79\xbf\x86\xb2\xd8\x7e\x49\xec\x18\x86\x31\x4c\xe1\xb1\x6b\x51\xf7\x3c\x31\x27\x1a\xf7\xda\x79\xa0\x1a\x5a\xc2\x30\x3a\x0e\x6b\x05\x78\xeb\xf3\x7b\xfe\xc5\xb3\x04\x6e\xb9\xa6\xc8\x26\x9d\xa0\xb1\x21\xae\x83\x25\x0a\x76\x01\x60\x35\x39\xb0\x5c\x47\xe7\x67\xcb\xfe\x79\x74\xba\x8e\x75\x5c\xe7\x39\xcf\xdc\x4c\xf6\x5a\x64\xbd\xce\x7b\xae\xd1\x4b\xdd\x46\xf4\x0d\x85\xdc\x9f\x8d\xa7\x90\x85\x37\x0e\x02\x16\x35\xa2\x23\xf1\xe2\xc7\xbe\x86\xad\xac\x36\xdb\x66\x77\xd8\x6c\x50\xe0\x76\xfb\x50\x1d\x8a\xfd\x0e\xcb\x43\x21\x9b\x4d\x51\xee\x31\x89\xad\xc0\xa0\x5f\x96\xe7\x65\xcd\x1c\x1d\x0e\x5d\x9c\x64\xaf\xc4\x6b\xc0\x83\x23\x6f\x47\x27\x88\x7d\x8e\xd4\xe7\x01\x43\x37\xf9\xcb\x7d\xe7\xf0\x35\x9b\x7a\x6f\xf4\xe4\x78\xd9\x93\x09\xdf\xb7\xe1\x8f\x3b\x30\x97\x34\x68\x7b\xce\x06\x67\x83\x9d\x42\x9a\x2d\xdf\xd8\x61\x5c\x74\x16\x3b\x3a\x6b\xc8\xbd\x90\xa6\xf3\x49\x71\x55\x64\xd6\x1d\xdf\x75\xf4\xc4\x15\xe3\xe3\x65\xe5\x9f\xd1\x89\x4e\x9d\x38\xd1\xa8\x3d\x3f\x89\x54\x3b\x8d\xcf\xd0\xd1\x34\x57\x1b\xf4\xc4\x39\x98\x76\xec\xe8\x34\x4f\x22\x34\x30\x4b\xc6\x5c\x7d\xff\xb7\x62\xf1\x1b\x3c\x6e\x21\x8b\x8e\x33\xdd\x80\x24\x63\x03\xf1\xf7\x0f\xb4\xb4\x4a\x53\x7c\xb2\xf9\x4b\xb9\x45\x8c\x6f\xd5\xc5\xd5\x33\xaf\xf5\xc5\xa5\xc8\x76\x93\xf2\x56\x36\xbb\x6a\x87\x02\xf1\x20\x37\xb2\x29\xda\xc3\xbd\xd8\xed\xee\xef\x1f\x8a\xb2\xdd\x6d\x88\xed\x5f\x70\x5d\xea\xa4\x7a\xa0\x66\xfb\xb0\x6b\xca\x72\x5f\x6e\x0e\xd5\x4e\x94\x0f\x45\xb1\x39\x54\xed\xae\x3a\xec\x1f\xf6\x9b\x04\x43\x70\xaa\x19\x03\x3f\x17\x56\x40\x6f\xc1\x21\x98\x69\x14\xc1\x42\x4b\x00\x5e\x94\x91\x35\x3c\x3e\x3d\xcd\xc8\xf0\x99\x23\x9a\xc6\xd7\x55\xe6\xee\xf1\xe9\x69\x0d\xff\xe3\x9f\x2c\x8b\x1b\x24\xae\x0c\x65\x8e\xcf\x5c\xf8\x9e\x42\x0d\x97\xc1\xca\x43\x06\x03\xdf\x5d\x9f\x8a\xf1\x0d\xcb\x6f\x52\x65\x8e\x09\x40\x8f\x46\xb5\xe4\xc3\x33\x8e\xa1\xb3\xae\x06\x6c\xe4\xa8\x65\xf2\x5b\x00\x00\x00\xff\xff\x86\x41\x2d\x07\x38\x0b\x00\x00")

FileBVLCAlexNetYml is "/BVLC-AlexNet.yml"

View Source
var FileBVLCGoogLeNetYml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x04\xff\x84\x56\xdf\x6f\xe3\xb8\x11\x7e\xd7\x5f\x31\x58\x63\x81\x6c\xeb\xc8\x92\xad\x38\x8a\x0a\x14\xed\xe5\xd0\x43\xd1\x43\x1e\x7a\xd7\xf6\xe1\x70\x08\x46\xe4\x48\xe2\x85\x22\x55\xfe\xb0\xe3\xfd\xeb\x8b\xa1\xe4\xd8\xd9\x6e\xb7\x7e\x30\x44\xf2\xe3\x70\xe6\x9b\x8f\x33\x34\x38\x52\x03\xdf\xfd\xf3\xc7\xc7\xdb\x1f\xac\xed\x7f\xa4\x27\x0a\xb0\x02\x9e\x06\xdb\xc1\xc9\x46\x07\xa3\x95\xa4\xb3\xce\xe1\x48\x47\xeb\x5e\x9a\x0c\xd2\x7a\x03\x8f\xd8\x75\x04\x2b\x78\x5b\x82\xce\x3a\x08\x03\x2d\x5b\x00\x0e\xe4\xbc\xb2\xa6\x81\x32\x2f\xde\x01\x97\x05\x10\xd6\x04\x87\xca\x84\x6c\x99\x39\x43\x97\x21\x28\xd3\x59\x37\x62\x50\x96\xbf\xc1\xd3\x88\x26\x28\xf1\xb6\x3e\xaf\x66\x6c\x07\x95\x21\xd7\xc0\x2a\x19\x4d\x03\x0f\xd1\x93\x84\x60\x61\x22\xc7\xc8\xd9\x31\x98\x1c\x49\x25\xd8\x66\x06\x97\xdf\x0a\xc6\xa8\x83\x9a\x34\xc1\xa4\x31\x30\xde\x83\x40\x03\x2d\x81\x9f\x48\xa8\x4e\x91\xcc\x00\x70\x94\xfb\x8a\x59\x00\xe8\xa7\xd8\x80\x43\x35\x39\xfb\x1b\x89\xb0\x11\xe8\x46\x7d\x2b\x98\x97\x26\xc1\x6e\xc5\x14\xd3\x19\xe2\xff\x22\xfb\x84\x9c\x26\xb1\xaf\x34\xcd\xe6\xbf\xb5\x69\x01\x2e\xdb\xbe\xed\xca\x35\x56\x92\x17\x4e\x4d\x1c\x7c\x03\x7f\xcc\x00\x7e\x1e\x94\x5f\x78\x51\x1e\x10\x1c\x4d\x5a\x89\x99\x71\xdb\x5d\xd2\x09\xf3\xce\x96\x24\x28\x93\xa6\x59\x31\x3a\x29\x66\x8a\xed\x79\x4f\x0e\xff\x22\x38\xda\xa8\x25\x68\xf5\x42\x4c\x7e\x18\xd0\xbc\xc0\xe3\xe0\x94\x0f\x0a\x0d\xfc\xf4\x99\x7a\x92\x27\xce\x1d\xa0\xd6\xc0\x0e\x0c\xa4\xa7\xb3\x5d\xf7\xde\x83\xcb\x31\x49\x89\x79\x06\xf0\xbd\xea\x3a\x72\x64\x04\x79\x66\xca\xd8\x00\x49\x46\xca\xf4\x70\x54\x61\x48\xee\x39\xd2\xaa\x1f\x02\xcf\x49\x0c\x78\x8b\xb1\x1f\xc9\x84\x14\xd9\x1f\x58\xc4\x5f\xdd\xe5\x05\x6a\x02\xeb\x00\x39\xe7\xe1\xd6\x31\xfe\xeb\x06\xa2\x27\x0f\x1f\x5e\xf1\xa0\xc8\x7d\xe0\x40\x95\x51\x41\xa1\x56\x9f\x29\x39\x70\x24\x3e\xdf\x83\x32\x3e\x10\x4a\x66\xf3\x43\x8f\xd1\x7b\x85\xe6\x03\x7b\xf0\xef\xa8\xc4\xcb\xb3\xb7\xfa\x40\x2e\x9f\x9c\x0d\x36\xbc\x86\xd9\x2c\x82\x5c\x62\x0c\xa0\x09\x5d\x0a\xcd\x61\x20\x90\x24\xf0\x04\x93\xd5\x4a\x9c\x12\xb5\xe9\x2c\xeb\x54\xaf\x0c\x6a\xf8\xc2\xda\x9a\x21\x81\x69\xb6\x47\xce\xee\x18\xc5\x00\x1d\xfa\x40\xee\x42\xd9\xcd\xbe\x00\x9a\xac\x18\x3c\x1c\x3c\x6c\xef\xce\xa3\x4f\xec\xe4\xcf\x03\x41\x1b\x8d\xd4\x24\xe7\x04\xb0\x4c\xf8\x92\xab\x40\x89\x1c\x03\xdb\x75\x55\x14\xeb\xa2\x28\xc0\x1b\x9c\xfc\x60\xc3\x95\xc9\x4f\x10\x3d\xe7\xe0\xab\xc1\x9e\xf5\xf7\xfe\x00\xdb\xf2\xfd\x65\x77\x83\x9d\x6e\x4b\x40\x21\xa2\x43\x71\x82\x7d\x9d\xdf\x7f\x84\x9b\x5d\x99\xef\x3e\x02\x39\x67\xdd\x27\x40\x23\x01\x81\x81\x77\x17\x60\x5d\xe7\x0f\x1f\xe1\xa6\x2c\xf3\xf2\x0d\x68\x67\xa6\x0e\xa8\x95\xe4\xa4\x72\x35\x09\xeb\xc5\xbb\xdf\xa2\x0f\x29\x2a\x41\x86\xb9\x11\xce\x4e\xac\xb4\x9b\x7f\x24\xe7\x39\x5e\x3c\x90\xc3\x3e\xd5\xc5\xb2\x48\x00\xbf\x86\x9b\x0a\x7e\x0f\xe5\xb2\xeb\x13\xfc\x0e\xb6\x30\x2a\x76\x6c\x0d\x7e\x48\xb7\x60\x0e\x06\x10\x5a\x15\x60\x50\xfd\x40\xee\xcd\xcf\xfc\x13\x13\xa0\x46\x65\x7a\x9f\xae\x43\x7b\xd0\xe2\xb9\xb7\xb6\xd7\x64\x28\xcc\x5a\x16\xf1\xfb\xa7\xa7\xc5\xcd\x16\x83\x18\x9e\xbd\xfa\x4c\x4d\xb9\xad\x39\x24\x84\xbf\x55\x85\xe0\x5b\xf0\xe7\xc5\xbf\xbf\x58\x77\x44\x27\x61\x42\xef\x1b\xb8\xdb\x6f\xf3\xba\x2a\x61\xf4\x1c\xce\x19\xf3\x1d\x8a\x97\x2b\x50\x59\x6e\x77\x79\x5d\x7d\x01\x5a\x0c\xdd\x9e\xc1\x0d\x94\xfb\xba\xce\xeb\x05\x76\x55\x38\x8e\xe8\x67\x35\x91\x84\xf6\x04\x3f\x91\xeb\x95\x85\x1f\x22\x4a\x74\x0e\x47\x84\x3f\xf9\x9e\x07\x99\xa3\xb7\x7b\x0b\x2b\xb8\x8c\xf8\xf6\x4c\x38\x91\xf3\xb0\x81\x23\xb5\x5e\x05\xe2\x4f\x0a\x22\xcf\xcf\x95\x87\x55\xc4\x89\x48\x65\x20\x03\xb8\x85\x21\x84\xc9\x37\x9b\x4d\xaf\xc2\x10\xdb\x5c\xd8\x71\xc3\xbd\x6c\x93\x2a\xf0\x26\x38\xa2\xcd\x98\xb4\xbe\x49\x7b\xfc\xe6\x3d\xbf\xef\x6c\xa0\x7b\x55\x87\xdc\xba\x7e\x83\xad\xdf\x94\x55\xf1\x90\x57\x75\xb5\xcd\x56\xa0\x95\x20\xe3\x53\xe2\x2f\xc7\x2f\x93\x0d\x44\xe3\xc8\x07\xa7\x44\x20\x99\xad\x40\x99\x29\x86\x14\xcf\x05\x3b\xcf\x71\x8e\x56\xd0\x29\xe7\xc3\x8c\x82\x70\x9a\x28\xa5\xfd\x02\xe5\xa8\x78\xba\x01\x35\x62\x4f\xa9\x77\xac\x16\x02\x52\xd1\xe6\x2a\xc2\xf0\x2b\x3b\x09\x34\x57\xe7\x04\x69\x12\x20\x1d\x7a\x65\x65\x42\xee\xe0\x81\x9c\x67\xea\xf9\x8c\xab\xa9\x64\x02\x40\xaa\x91\x0c\x77\x6c\xdf\xc0\x2f\xbb\x35\x6c\xb7\x55\xfa\xfb\x75\x59\x1f\x09\x4d\x03\xbf\x94\xdb\xdd\x1a\xca\xf2\x7e\x0d\x65\x51\xfd\x9a\xd9\x18\xa6\x18\xe6\xf0\xd8\xb5\x64\x7b\x69\x1d\xf3\x5a\x06\x69\xb2\x81\x8e\x30\x44\xc7\x61\xad\xb8\xc4\xd1\x5b\x2f\x7a\x8f\xbf\x78\x96\xc1\x7f\x47\x36\xdb\x04\x8d\x2d\xb1\x0c\xae\x02\x4b\x6e\xae\xd2\x59\x57\xd3\x69\x76\x39\xd9\x3f\x47\xa7\x9b\x24\x9c\x66\xb3\xe1\xbe\x90\xcb\x51\x8b\x7c\xd4\x9b\xf1\xd5\x50\x38\x0b\x25\xb1\xcf\x63\x7f\x32\x9e\x42\x1e\x5e\x39\x08\xb8\x98\x11\x03\x89\x17\x1f\xc7\x06\x2a\xb9\xdd\x55\xed\x5d\xbd\xdb\xa1\xc0\xaa\x7a\xd8\xd6\xc5\xfe\x0e\xcb\xba\x90\xed\xae\x28\xf7\x98\x25\xed\x31\xe9\xdc\x51\xf8\x15\x71\xee\xb7\xbd\xc3\x69\x00\x2e\x60\xe7\x56\xe1\xc8\xdb\xe8\x04\xb1\xcf\x69\xf5\x79\xc2\x30\xcc\xfe\xb2\xd0\x1d\x1e\xf3\x59\xec\xd1\x93\xe3\x57\x0f\x99\xf0\xa5\xee\xbf\x25\xf9\x8d\xa4\x49\xdb\xd3\x5b\xb7\xc9\xe0\x7c\xf6\xd5\x49\xcc\x8c\xce\xd3\x25\xca\x5b\x72\x2f\xa4\xe9\x74\x50\xac\x8b\x74\x3f\xde\x5f\xa2\x19\x97\x62\xcc\x00\x94\x7f\x46\x27\x06\x75\xe0\x64\xa3\xf6\xfc\x3e\x54\x1d\x78\x4a\x9d\x88\xe6\x12\xdc\xa2\x27\xce\x03\x77\x12\x84\xe8\x34\x5f\x7f\x34\xb0\xec\x4c\xf9\xfa\xf2\xb7\x4a\xd2\xba\x70\x72\x4d\x5b\x72\x9d\xd7\x0d\x48\x32\x36\xa4\xf6\xfb\x3f\xac\x74\x4a\x53\x7a\xbf\xfa\xb3\xe4\x92\xcd\x6b\x73\xa9\xec\x2e\x6f\x9c\x8b\x4b\x09\x76\x9d\x76\xbc\xdf\xd6\xe5\x7d\x55\xcb\x87\xb2\x7d\xd8\x17\x2d\xd6\x7b\xb9\xaf\xcb\xa2\x2c\x64\x85\xb8\xbd\x62\xf6\xa2\x15\x29\x8a\xbb\xfd\x7d\xd9\x15\x55\xb5\xbb\x2f\x6a\x89\x65\x5b\xc8\x02\xa9\xa0\x42\x3c\x08\x94\x19\x86\xe0\x54\x1b\x03\x79\x16\x0c\xbd\x06\x87\x60\x28\xf0\xc3\x1b\x2e\x6b\x19\xc0\x8b\x32\xb2\x81\xc7\xa7\xa7\x85\x19\x1e\x73\x44\x86\xa2\x43\xfd\xb6\xe7\xe6\xf1\xe9\x69\x0d\x7f\xe7\xbf\x3c\x4f\xed\xe6\xfc\x50\x7a\x66\xf1\x7b\x0a\x0d\xfc\x95\x2b\xcd\xfc\xf0\x5f\xe6\xf8\x0d\x22\x39\x29\xe9\x41\xcf\x0f\x74\x65\xfa\x0c\x60\x44\xa3\x3a\xf2\xe1\x19\x63\x18\xac\x6b\x00\x5b\x19\xb5\xcc\xfe\x13\x00\x00\xff\xff\x9e\xd1\xb0\xdd\x47\x0c\x00\x00")

FileBVLCGoogLeNetYml is "/BVLC-GoogLeNet.yml"

View Source
var FileBVLCReferenceCaffeNetYml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x04\xff\x8c\x56\x4b\x8f\xe3\xb8\x11\xbe\xeb\x57\x14\x60\x2c\xd0\x93\xd8\x92\xe5\x77\x2b\x40\x90\xa4\xf7\xb2\x41\xd0\x87\xc5\x24\x97\xc1\xa0\x41\x91\x25\x8b\xd3\x14\x29\x90\xc5\x76\x3b\xbf\x3e\x28\x52\x7e\xf4\x00\x33\x59\x1f\x6c\x93\xf5\x55\xf1\xab\x27\x69\xc5\x80\x0d\xfc\xe3\x3f\xff\x7a\x5a\xfc\x8e\x1d\x7a\xb4\x12\x17\x4f\xa2\xeb\xf0\x19\x09\x66\xc0\x72\x70\x1d\x9c\x5d\xf4\x30\x38\x85\xa6\xe8\xbc\x18\xf0\xe4\xfc\x6b\x53\x40\x92\x37\x90\x14\x60\x06\x57\x11\x74\xce\x03\xf5\x38\xa9\x00\xbc\xa1\x0f\xda\xd9\x06\xea\x72\xf9\x01\x38\x09\x40\x3a\x4b\x5e\x68\x4b\xc5\xb4\x73\x81\x4e\x4b\xd0\xb6\x73\x7e\x10\xa4\x1d\xff\x87\x80\x83\xb0\xa4\xe5\x55\x9e\xa5\x05\xdb\x11\xda\xa2\x6f\x60\x96\x8c\xa6\x45\x80\x18\x50\x01\x39\x18\xd1\x33\x32\x13\x83\xd1\xa3\xd2\x92\x6d\x16\x70\xfb\xcc\x60\x88\x86\xf4\x68\x10\x46\x23\x88\xf1\x01\xa4\xb0\xd0\x22\x84\x11\xa5\xee\x34\xaa\x02\x40\x0c\x6a\xb7\xe1\x28\x00\x1c\xc7\xd8\x80\x17\x7a\xf4\xee\x1b\x4a\xaa\xa4\xf0\x83\x59\x48\x0e\x64\x93\x60\x0b\x39\xc6\x74\x86\xfc\xbf\xc8\x63\x42\x8e\xa3\xdc\x6d\x0c\x66\xf3\x3f\x53\x9a\x80\x93\xda\xcf\xa9\xdc\x63\x15\x06\xe9\xf5\xc8\xce\x37\xf0\xd7\x02\xe0\x73\xaf\xc3\x14\x17\x1d\x52\xf6\x3c\x86\x68\x88\xf3\xdf\x39\x63\xdc\x49\xdb\x63\xda\xcf\xf9\xfe\x6d\x10\xc7\x54\x26\xa9\x2e\x20\xa5\x8f\x11\xda\x06\xf2\x31\x45\x35\x94\xf0\x1b\xb1\x35\x01\x1e\x47\xa3\x65\xce\x9f\xeb\x92\x99\xac\x97\x79\xb4\xa8\x40\xdb\xb4\xfd\x77\x83\xef\x5c\x7d\x63\x6c\xaf\x1a\x27\x4d\x3d\x04\x37\x20\x28\xdd\x4d\x75\x1a\xca\x02\xe0\xd7\xdb\x92\x43\x65\x1d\xdd\x88\x24\x25\xae\x42\x8f\x46\x1f\x7b\x62\x72\x4a\x90\x58\x88\x78\x1c\xd0\x52\x22\xf3\x97\x02\x12\xc6\x79\x85\x9e\x99\x8d\xce\x19\x46\x0a\xab\xc0\x72\xc9\x19\xfd\xdf\x84\x04\x23\xce\xe8\x03\xbb\x13\x4e\x9a\x64\x8f\x0a\x1e\xb4\xcd\xd1\x78\x46\x9a\x5f\x55\x75\x00\xe5\x2c\x42\x8b\x9d\xf3\xf8\xd1\xca\x27\x66\xfd\x31\xd4\xc1\x8a\x31\xf4\x2e\x05\x5a\x13\xfa\x7c\xda\xba\x5e\xce\x97\xcb\x65\x09\x9f\x7b\xb6\x14\x08\xde\x84\xd1\x2a\x0b\xa7\x32\x16\x56\x22\xa8\xe8\x99\xef\x35\xfe\x27\x11\x3e\x98\x59\xb3\x99\x1c\x8c\x3b\x0b\x42\xca\xe8\x85\x3c\xc3\x76\x5f\x6e\xea\xd5\x2f\xc0\xfe\x1a\x17\x02\xd4\xe5\x61\xb5\x5e\x1d\xbe\xe3\xe9\x5a\x6e\xa5\x00\x02\xc8\x8d\x8b\xfa\xa3\x7e\xd6\xce\xa2\xed\x4d\x74\x58\x96\x9b\x5f\xc0\xe5\xb4\xde\x9d\x1d\x38\x58\x31\x30\xeb\x6f\x31\x10\x70\x8e\x24\x5a\x42\x0f\xd2\xbb\x91\x4f\x7e\xf8\x77\x12\xb3\x44\xbc\xa1\x17\xc7\x34\x86\xea\x65\x02\x84\x39\x3c\x6c\xe0\xcf\x50\x4f\x5a\x9f\xe0\x4f\xb0\x82\x41\x7b\xef\xfc\x1c\x42\xef\xa2\x51\x13\x61\x10\xd0\x6a\x82\x5e\x1f\x7b\xf4\x37\x66\x81\xb4\x31\xe5\xa7\x8f\x55\xcf\x81\x4b\x51\x44\x05\xed\x19\xfe\x89\x5d\x07\xbf\x3a\x2b\xfa\x88\xf0\xb7\x6f\xd8\x75\x2a\x2f\x0a\x7f\x19\x95\x81\xa7\xcc\x6d\x95\x06\x8c\x18\xb9\x48\x2a\x38\x61\x1b\x34\x61\x80\x0a\x90\x64\x59\x5e\x0a\x9d\xbd\x66\xb7\x52\xf5\x17\x00\x0b\xe8\x89\xc6\xd0\x54\xd5\x51\x53\x1f\xdb\x52\xba\xa1\xe2\x89\x5c\xa5\xf1\x51\x91\x47\xac\x06\x11\x08\x7d\x95\x74\x42\xd5\xbe\x19\xf9\x72\x3d\xf6\x25\xe1\x2c\xd2\xd5\x58\x53\x55\x99\x46\x69\xf5\x18\x4a\x29\xf3\xb2\xda\x1c\x56\x9b\x85\xe6\xb6\xb5\x48\x0b\x69\x44\x08\xba\x9b\x9a\x72\x71\xd2\xd4\x2f\x14\xe2\xb8\x90\xce\xbe\x39\x13\x79\x32\x08\xb3\xb0\x18\x7d\xfa\x21\x1e\xfa\xa1\x1c\x55\x57\xcc\xc0\x68\x89\x36\xa4\xa4\xdc\x9c\x99\x36\x1b\x88\xd6\x63\x20\xaf\x25\xa1\x2a\x66\xa0\xed\x18\x29\x45\xe7\x86\xcd\x7b\xdc\xb3\x33\xe8\xb4\x0f\x94\x51\x40\xe7\x11\x79\x98\xdf\x41\x39\x46\xbc\xdd\x40\xe2\x9e\xc6\xe8\x6c\x0a\x67\x9a\x5f\xdc\xb6\x6c\xf9\xce\x4e\x02\xe5\xd1\x92\x20\x4d\x02\xa4\x43\xef\xac\x8c\x82\x2f\x33\x42\x9f\x12\xc9\x67\xdc\x6d\x25\x13\x00\x4a\x0f\x68\xf9\xf2\x0a\x0d\x7c\x59\xcf\x61\xb5\xda\xa7\xaf\xaf\x93\x7c\x40\x61\x1b\xf8\x52\xaf\xd6\x73\xa8\xeb\xfd\x1c\xea\xe5\xe6\x6b\xe1\x22\x8d\x91\xb2\x7b\x4c\x2d\xd9\x9e\xe6\x5e\x96\xf1\xdc\x39\x8f\xd8\x40\x87\x82\xa2\x67\xb7\x66\x20\xee\x39\x7f\xc4\xdf\x98\x15\x70\x8f\xca\x9e\x65\x9b\x60\x44\x8b\x5c\x54\x77\x8e\x25\x9a\xb3\x4c\xe0\xb6\x9d\x76\xa7\x93\xc3\x4b\xf4\xa6\x49\x65\xd8\x54\x15\x4f\xc8\x52\x0d\x46\x96\x83\xa9\x86\x77\x8b\x74\x29\xbb\x14\x7d\x5e\x87\xb3\x0d\x48\x25\xbd\xb3\x13\x70\x33\x23\x7b\x94\xaf\x21\x0e\x0d\x6c\xd4\x6a\xbd\x69\xb7\x87\xf5\x5a\x48\xb1\xd9\x3c\xae\x0e\xcb\xdd\x56\xd4\x87\xa5\x6a\xd7\xcb\x7a\x27\x8a\x54\xc9\xdc\x3d\x97\x0b\xf5\x72\xf5\x1c\xbd\x18\xfb\x34\x8c\x4e\xc8\x43\x3b\xf0\x2d\xe4\xa2\x97\xc8\x9c\x93\xf4\x65\x14\xd4\x67\xbe\xdc\x36\x5e\x9c\xca\xdc\x3a\x31\xa0\xe7\x07\x00\x5a\xfa\xbe\x8b\xfe\x50\x03\x55\x0a\x47\xe3\xce\xe5\xe8\x1d\xb9\xec\xdd\x44\xe2\xee\x48\x0e\x91\x29\x53\xcf\x95\x2d\xfa\x57\x34\x78\x7e\xd3\x5c\x20\xa5\xf3\xc7\x1f\xf5\x66\x56\x48\x5e\x17\x05\x80\x0e\x2f\xc2\xcb\x5e\xbf\x71\xfe\x85\x09\xfc\x7a\xd2\x5d\x1e\x8c\xd4\x63\x9e\x98\xad\x08\xc8\xa9\xe1\xfb\x44\x40\xf4\x86\xe7\x8b\xb0\x30\x69\xa6\x14\x7e\xff\x99\xb1\xfa\x5d\x98\xee\x23\x99\x9c\x60\xb9\x05\x85\xd6\x11\xf2\xff\x1f\x58\xe9\xb4\xc1\xf4\xba\x0b\x97\x2a\x4c\xa1\xbf\x37\x97\xae\x94\xe9\xce\xbe\x51\x4a\xb0\xbb\x4a\x78\xdc\x6e\x97\xdb\x5a\xd5\x35\x6e\x36\xad\x5a\x3d\x2a\x75\xd8\x8b\xd5\x56\xa9\xfd\x6e\x87\x72\xb5\x2e\x00\x2e\x31\xbe\x95\x8f\xe8\x76\xfb\x43\xb7\x6c\xd5\x5a\x2a\xb5\xda\xac\xf7\xb8\xde\xee\xf6\x8f\xea\x70\xd8\xed\xb6\xf5\x7e\x59\x08\x22\xaf\xdb\x48\x79\x02\xe3\x3b\x79\x01\x36\x4f\x28\xb8\xc9\x0a\x80\x57\x6d\x55\x03\x4f\xcf\xcf\x53\x64\x78\xcd\x1e\xe5\xa9\x76\xd5\x79\x78\x7a\x7e\x9e\xc3\xef\xfc\x55\x96\xe9\x5e\x48\x17\x81\xb6\xc7\x17\xee\x87\x80\xd4\xdc\xde\x3b\xb3\xf4\x8a\x08\x48\xd7\x57\x65\x7a\xee\xf2\xf3\x55\xdb\x63\x01\x30\x08\xab\x3b\x0c\xf4\x22\x22\xf5\xce\x37\x20\x5a\x15\x8d\x2a\xfe\x17\x00\x00\xff\xff\xec\x0c\x22\xbd\x6e\x0b\x00\x00")

FileBVLCReferenceCaffeNetYml is "/BVLC-Reference-CaffeNet.yml"

View Source
var FileBVLCReferenceRCNNILSVRC13Yml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x04\xff\x8c\x56\x4d\x6f\xe3\x36\x10\xbd\xeb\x57\x0c\xe0\x4b\x0b\xc4\x52\xe4\x8f\x38\xd6\xa1\x28\x36\x40\x8b\x05\xb6\x3e\x64\x8b\xbd\x14\x85\x31\xa2\x46\x16\xd7\x12\x49\x0c\x29\x3b\xfe\xf7\xc5\x50\xb2\xad\x14\x68\xba\x3e\x18\x22\x39\x1f\x8f\x6f\xde\x8c\x64\xb0\xa3\x02\x3e\x7d\xfb\xf2\x32\x7f\xa5\x9a\x98\x8c\xa2\xf9\xeb\xcb\x6e\x37\xff\xfc\xe5\xeb\xb7\xd7\x97\x7c\x09\x33\x30\xd8\x11\xd8\x1a\x2e\xb6\x67\xe8\x6c\x45\x6d\x52\x33\x76\x74\xb6\x7c\x2c\x12\x00\x13\x83\xbc\x60\x5d\x13\xcc\xe0\x76\x04\xb5\x65\x08\x0d\xc1\xe0\x02\x70\x22\xf6\xda\x9a\x02\xf2\xf4\xf1\x9d\xe1\x78\x00\xca\x9a\xc0\xa8\x4d\x48\xc6\x9d\xab\xe9\xb8\x04\x6d\x6a\xcb\x1d\x06\x6d\xe5\x19\x3c\x75\x68\x82\x56\xb7\xf3\xe1\x34\x91\x38\xa8\x0d\x71\x01\xb3\x18\x34\x2e\x3c\xf4\x9e\x2a\x08\x16\x1c\xb1\x58\x0e\xc0\xc0\x31\x55\x5a\x49\xcc\x04\xee\xbf\x19\x74\x7d\x1b\xb4\x6b\x09\x5c\x8b\x41\xec\x3d\x28\x34\x50\x12\x78\x47\x4a\xd7\x9a\xaa\x04\x00\xbb\xea\x69\x55\x44\xcf\x83\xeb\x0b\x60\xd4\x8e\xed\x77\x52\x21\x53\xc8\x5d\x3b\x57\xc2\x4b\x11\xcd\xe6\xca\xf5\xd1\x52\xfd\xaf\xe5\x21\x5a\x3a\xa7\x9e\x56\x2d\x0d\xe1\x3f\x72\x1a\x0d\x47\x37\xf8\x10\xca\xd4\xb6\x22\xaf\x58\x3b\xb9\x7c\x01\xbf\x24\x00\x7f\x36\x04\xae\x67\x1a\xcb\xa9\x8d\x0f\x42\xf1\x40\xb9\xad\x63\x3d\x5f\xe7\x2f\xbb\xdd\x48\x9e\xd4\xf8\x26\x95\x8a\x02\x45\x22\xd3\x18\x49\xfb\xd1\xe8\x8c\x1e\x3a\xac\x08\xca\x0b\x04\x46\xe3\x5d\x2b\x41\xcd\x61\x12\xee\xeb\xb7\x3f\x40\xb5\xe8\xbd\x10\xcb\x1e\xb4\x09\x16\x10\x6a\x35\x67\x65\xcc\xed\x48\x0d\x48\x5a\xbc\x10\x3f\x80\x63\x7b\xd2\x15\x55\xd0\x10\x13\xa0\x07\x34\x60\xeb\x7a\x1e\x1a\x9a\xfb\x86\xda\x1a\x06\x55\x0e\xc0\x2c\x47\x5c\x7c\x89\x69\x87\x3d\x51\x12\xbd\x61\x27\x75\x0e\x16\x3c\x11\xe8\x00\xda\x00\xde\x2e\xb2\x4b\x3f\xa5\xf0\x9b\x65\x60\xf2\x84\xac\x1a\x21\xc8\x59\x4f\xfe\x01\x3a\x3c\x92\xc8\x0a\x46\x6a\x6c\x5d\x6b\xa5\xb1\x1d\x39\x72\xa8\x8e\x78\x20\x40\x53\x81\xb1\x01\x82\x70\x32\xa6\x8b\x58\x64\x1d\xdb\x23\x72\x14\xc5\x4f\x95\xd0\xf4\x6a\xbd\x87\xdf\x35\xfb\x46\xab\x23\xfc\xca\xe5\x61\x7c\x4e\xf8\xda\xa7\x5e\xd4\x7d\x5f\x09\x7c\x87\x4e\xb8\xcb\xe0\x4c\xa5\xd7\x81\x3c\x64\x40\x41\xa5\x29\x0c\x85\x2e\xaf\x9c\xc7\x9c\x09\xc0\x1c\x9a\x10\x9c\x2f\xb2\xec\xa0\x43\xd3\x97\xa9\xb2\x5d\x26\xe3\x20\x8b\xb2\xcd\x02\x13\x65\x1d\xfa\x40\x9c\x45\x1f\x9f\x95\xa7\x56\xed\x6f\x69\xf7\x52\x9d\xbd\x6e\xfd\x89\x55\xbe\x7c\x17\x11\xf9\x4d\x9f\x52\xcb\x87\x0c\x4b\x9f\xe5\xcb\x3c\x4f\x17\xeb\xc5\xea\x66\x53\x64\x99\x29\x4f\x9a\xce\xc4\xe9\xf7\xde\x5d\x02\x71\xb4\x1e\x90\x4c\x51\x94\xad\x2d\xaf\x28\x46\xf6\x7c\x76\xab\x5f\xaa\xdd\xc5\x94\xc9\x0c\x5a\xad\xc8\xf8\x5b\x2d\x22\xde\x64\xdc\x2c\xa0\x37\x4c\x3e\xb0\x56\x81\xaa\x64\x06\xda\xb8\x3e\x44\xd2\xee\x23\x6a\xd8\x93\x6e\x9b\x41\xad\xd9\x8b\x10\x5c\x1f\x20\x5c\x1c\x45\xa5\xdf\x4d\x85\x3a\xd9\x2e\x40\x77\x78\xa0\xd8\xd5\xb3\x91\xe5\xd8\x4e\x57\x45\x4c\xe2\x44\xa3\xa1\x10\xd1\xa4\x88\xf1\x62\xd2\x49\x14\x87\x8c\x1d\x05\xe2\x58\x5f\xc9\x31\xd9\x8a\x21\x00\x2a\xdd\x91\x91\x59\xea\x0b\xf8\x6b\xf9\x00\x8b\xc5\x26\xfe\xfd\x9d\xd8\x3e\xb8\x3e\x0c\x57\x10\xb4\xd1\xff\x2a\xce\x78\x96\x40\xdc\x2c\xa0\x26\x0c\x3d\x0b\xf4\x19\xe0\x14\xd7\x7b\xfb\x7b\xf6\x04\xa6\x56\x03\xfa\x21\x26\xb4\x58\x92\xe8\x69\x02\x3e\x42\x9d\xc5\x5c\x93\xed\xb8\x3b\x66\xf6\xfb\x9e\xdb\xe2\xa6\x40\xc6\x73\x3a\xd4\xbe\xf7\xc4\x32\xc3\xc9\x84\x28\x48\x46\x3d\x7f\x3f\x54\x63\x6d\xfd\x55\x13\x15\x06\xcc\x46\x0d\x2e\x44\x18\x7b\x7f\x31\x9e\xc2\xfe\x6c\xb9\xf2\x69\x78\x93\x4b\xc3\x3d\xad\x6a\x48\x1d\x7d\xdf\x09\x07\x8f\x35\x2d\x97\xa5\x7a\x56\xe5\xe3\x26\xaf\x9f\x15\x6e\x96\x8f\x9b\x65\xb5\xdd\x6c\x37\x4b\xf5\x94\xc4\x44\xd2\x68\xd7\x99\x7f\x9d\x69\x07\x46\xd7\xc4\xc6\x3e\x93\x3e\x34\xc1\xcb\x78\xb0\x3d\x2b\x92\x3b\xc6\xd3\xbd\xc3\xd0\xfc\xc8\xfd\x26\x0d\xf7\xe3\xbd\x96\x55\xe4\x5a\x7b\x49\x1d\xdb\x60\x87\x2b\x8e\x48\x26\x79\x8b\x2c\xab\xda\x34\xf6\x72\x5a\x12\x1f\xa9\xa5\xcb\x49\x8b\x72\x62\xab\x7d\xd4\xcb\x83\x57\xbc\x7f\x02\xa0\xfd\x5e\x46\x9f\x3e\x89\x70\xb0\xf5\xf2\xa6\xd7\x35\x78\x0a\x0f\xa2\x33\x23\x7f\x50\xa2\x27\xa9\x29\x68\x0f\x08\x3d\xb7\x32\x93\xd0\xc0\xe8\x19\x6b\xff\xef\xdf\x2c\x7a\xde\xf9\x9a\x52\x1a\x2f\x22\xe7\x06\x2a\x32\x36\x90\x3c\xff\x47\x94\x5a\xb7\x14\xbf\x54\xfc\x55\xbe\x31\xe6\x34\x1c\x9c\x75\x68\xf4\x00\xf5\x0e\x29\x9a\x4d\x24\xb1\x7a\xde\x2c\xb6\xab\xe7\x3c\xdf\x6e\x36\xe5\x36\xaf\x10\x17\xb8\xa6\xed\xe6\x69\x9d\x97\xe5\xf3\x5a\x25\x00\x57\x9e\xef\x3a\x5a\x2d\x54\xbe\x5e\x3f\x55\x8b\x6a\xb5\xc1\x6d\xbe\x78\x56\x2b\xdc\x3e\xd2\x23\x6e\xd5\x7a\xb9\xca\x55\x82\x21\xb0\x2e\xfb\x30\x4c\x6d\x7a\x0b\x8c\x60\x28\x9c\x2d\x1f\xe1\x7e\x96\x00\x1c\xb5\xa9\x0a\x90\x17\xec\xc0\x8c\xac\xe5\x46\x86\x7a\xc6\xf6\xe6\xf3\xd3\xcb\x6e\xf7\x00\xaf\xf2\x97\xa6\xe9\xcf\xd2\xd4\xf2\xe5\xa4\xcd\x61\x2f\xdd\xe0\x29\x14\xf0\x59\x26\xd3\x8e\x82\x0c\x26\x0c\xb2\x27\xaf\xaa\xf8\x05\x24\xaf\xed\xab\x43\x02\xd0\xa1\xd1\x35\xf9\xb0\xc7\x3e\x34\x96\x0b\xc0\xb2\xea\xdb\x2a\xf9\x27\x00\x00\xff\xff\x3d\xf6\xc7\xf0\x1f\x0a\x00\x00")

FileBVLCReferenceRCNNILSVRC13Yml is "/BVLC-Reference-RCNN-ILSVRC13.yml"

View Source
var FileDPN68Yml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x04\xff\xac\x56\x4d\x6f\xe3\x36\x10\xbd\xeb\x57\x3c\xc4\x97\x16\x48\x24\xdb\xb2\xbd\x8a\x0e\x05\xda\xe4\x52\xa0\x35\x82\x45\x51\x14\x58\x14\x06\x45\x8e\x24\x76\x29\x52\x20\xa9\x64\xd3\x5f\x5f\x0c\x25\xc7\xde\x45\xbb\xed\xa1\x3e\xc8\xe2\xcc\xe3\x0c\xdf\x7c\x51\x56\x0c\x54\xe3\xf1\xe9\x78\xa8\xb0\x02\xaf\xe0\x5a\xbc\xba\xc9\x63\x70\x8a\x4c\xd6\x7a\x31\xd0\x8b\xf3\x1f\xeb\x0c\x49\x5f\xe3\x41\xb4\x2d\x61\x85\x37\x15\x5a\xe7\x11\x7b\x5a\xb6\x00\xcf\xe4\x83\x76\xb6\xc6\x26\x5f\x7f\x06\x5c\x14\x90\xce\x46\x2f\xb4\x8d\xd9\x22\x39\x43\x97\x25\xb4\x6d\x9d\x1f\x44\xd4\x8e\xdf\x11\x68\x10\x36\x6a\xf9\xa6\x9f\xb5\x19\xdb\x11\xda\x92\xaf\xb1\x4a\x46\xd3\x22\x60\x0a\xa4\x10\x1d\x46\xf2\x8c\x9c\x0f\x86\xd1\x93\xd2\x92\x6d\x66\xb8\xfc\x56\x18\x26\x13\xf5\x68\x08\xa3\x11\x91\xf1\x01\x52\x58\x34\x84\x30\x92\xd4\xad\x26\x95\x01\x62\x50\x87\x1d\x47\x01\xe8\xc6\xa9\x86\x17\x7a\xf4\xee\x0f\x92\xb1\x90\xc2\x0f\xe6\x4e\x72\x5c\xea\x04\xbb\x93\xe3\x94\x7c\xc8\x7f\x45\x76\x09\x39\x8e\xf2\xb0\x33\x34\x9b\xff\xda\xa6\x05\xb8\x6c\xfb\xfa\x51\xae\xb1\x8a\x82\xf4\x7a\x64\xf2\x35\xbe\xcb\x80\xc7\x49\x18\x3c\x89\xd8\xe3\x48\x91\x13\x1c\x20\x3c\xa1\xd7\x5d\x6f\x5e\x41\x6d\xab\xa5\x26\x1b\x61\xcf\xda\x97\x5e\xcb\x1e\xd2\x0d\x8d\xb6\x94\xd2\x1d\xa2\x27\xdb\xc5\x9e\x4b\xa6\x71\xb1\xc7\x7b\x0a\x47\xfa\x2d\xe2\xfb\xae\xf3\xd4\x89\x48\x8a\x45\x5a\xb1\xab\x5f\xbc\xb0\x81\x83\x9b\x92\x1a\x32\x70\x0e\xf1\x48\x34\xe2\x48\x93\x17\xe6\xea\x1c\x56\xe1\x91\x6c\xa0\x23\xc5\x30\xbf\x99\x57\x3c\x38\x6b\x49\xb2\xcd\x07\x67\x9f\x9d\x99\x98\xcb\xd5\xb6\x3c\xf3\xd4\x92\x27\x2b\x29\x70\x39\x5c\x56\xa9\x12\xc4\x48\x3e\xa0\xc0\x0b\x35\x41\x47\xe2\x57\x8a\x32\xcf\x31\x47\xa6\xd1\xb6\x4b\xa4\xe6\xb2\x07\xee\xd0\xc7\x38\x86\xba\x28\x3a\x1d\xfb\xa9\xc9\xa5\x1b\x8a\xe0\x48\x3c\x93\x2f\x52\xaa\xef\x12\xb4\x88\x9e\xa8\x18\x44\x88\x2c\x37\x4c\xec\x6f\xb7\xca\xd7\xf1\xa5\x78\x7c\x3a\x86\x6c\x05\xa3\x25\xd3\xe3\xb8\x5d\xda\x66\x11\xd6\x98\xac\xa7\x10\xbd\x66\xae\xd9\x0a\xda\x8e\x53\x4c\x1c\x2e\xd8\x59\xc6\xd5\xb2\x42\xab\x7d\x88\x33\x0a\xf1\x75\xa4\x14\xd7\x0b\x94\x99\xb0\xb8\x86\x1e\x44\x47\xa9\x2a\x57\x0b\xe9\x54\x0e\xe7\x53\x5c\xd9\x49\xa0\x39\x2e\x09\x52\x27\x7b\xc9\xe9\x95\x95\x51\xf0\x6c\x88\xe4\x53\xb8\xd9\xc7\x95\x28\x99\x00\x94\x1e\xc8\xf2\x2c\x08\x35\x3e\x94\xb7\xd8\x6e\x77\xe9\xf1\xfb\xa2\x1f\x48\xd8\x1a\x1f\x36\xdb\x5d\xbe\xbe\xc5\x66\xf3\x2e\xfd\xad\x77\xf9\xfa\x8c\x08\x52\x18\xaa\xb1\xbf\xcf\xab\x6a\xbd\x2d\xef\xf7\xdb\x4d\xe6\xa6\x38\x4e\x71\xa6\xcf\x4c\x93\x6f\xd7\xa6\xf7\x59\x97\x21\x09\x6b\xb4\x24\xe2\xe4\x99\xf6\x0a\xe2\x9a\xd3\xe7\xf8\xcb\xc9\x33\x5c\xa3\x66\xe6\xb3\x4d\x18\xd1\x90\xc9\x70\xc1\xa6\x0c\x00\xab\xe4\xeb\x4a\x9c\xc8\x2d\x9e\xc3\x69\xf2\xa6\x4e\xc5\x54\x17\x45\x28\x73\x31\x88\x3f\x9d\x15\x2f\x61\xae\xa8\xe8\x3c\xe5\x69\x80\xe4\xce\x77\x45\x78\xb5\x81\x62\x28\x52\xb2\x2c\xc5\x45\x90\xc7\x4f\xcc\x09\x17\xab\xb2\x27\xf9\x31\x4c\x43\x8d\x9d\xda\x96\xbb\x66\x5f\x95\xa5\x90\x62\xb7\xbb\xdf\x56\xeb\xc3\x5e\x6c\xaa\xb5\x6a\xca\xf5\xe6\x20\xb2\x54\xa7\xdc\x12\xe7\x71\x16\xe6\x2a\x47\xe7\xc5\xd8\x83\xdb\xed\x85\x74\xd7\xc7\x00\x4f\xc1\x4d\x5e\x12\x53\x48\xda\xd3\x28\x62\xff\xdf\x8f\x9f\x5c\x85\xb9\x3f\x0a\x35\xda\x43\x55\x28\x1a\x8d\x7b\x3d\xa5\xc5\x1d\x7d\x8a\x5e\x9c\xac\x3b\x49\xd2\xe6\xc4\xe8\x7c\xf4\x2e\xba\x99\xde\x72\x8a\xff\xc1\x27\x7b\x9e\x9d\xe5\xa9\x57\xd9\x13\xa7\x4e\x87\x93\xf0\xb2\xd7\xcf\x5c\x1a\xc2\x04\xbe\xc7\x74\x8b\x40\xf1\x96\xab\xc7\xf2\x03\x8d\x08\xc4\x59\x83\x0e\x10\x98\xbc\xe1\x01\x22\x2c\x96\x9d\x29\xbb\x5f\xfe\x56\x69\xe7\x25\x64\xd7\x51\x4d\x7c\x58\x6f\xa1\xc8\xba\x98\xa6\xe7\x3f\x58\x69\xb5\xa1\x74\xcf\x86\x73\x81\x26\x9b\xd7\xe6\xf0\xa2\x63\xaf\xe7\xa3\x5e\x8e\x94\x60\x57\x55\xa1\x9a\xad\xda\x97\x8d\x3a\xc8\x72\xb3\x96\x1b\xda\xb6\x55\x29\xa8\xdc\x95\xbb\xcd\xe6\x50\x89\x6d\x06\x9c\xc3\x7d\x29\x25\x55\xdd\xdf\x6f\xa5\xac\xee\x77\xdb\x6a\xff\xae\x52\x87\x7d\x7b\x5f\xae\xa5\x92\x87\x76\xbf\x95\xd5\x26\x13\x31\x7a\xdd\x4c\x71\x1e\xb1\x29\x9b\xe7\x1b\x02\x17\x5d\x06\x7c\xd4\x56\xd5\x78\x38\x1e\x97\xc8\xf0\x9a\x19\x59\x4a\xb3\x7e\xb9\x55\xf0\xcd\xc3\xf1\x78\x8b\xf7\xfc\xc8\xf3\xfc\x5b\x6e\x5b\xfe\x2e\xd0\xb6\x3b\x29\x11\x45\xa0\x58\xe3\x47\x9e\x5b\x47\x8a\x3c\xb6\x66\xd9\xdb\xfd\x9e\x3e\x3c\x96\x0d\x19\x30\x08\xab\x5b\x0a\xf1\x24\xa6\xd8\x3b\x5f\x43\x34\x6a\x32\x3c\x44\x7b\xad\x14\x71\x37\xfb\x89\x53\xfe\x33\x85\x20\x3a\x9a\xfb\xf6\x26\x55\x48\xfe\xe4\x9c\xd1\xb6\x7b\x3a\x4f\xb5\x1b\xf4\x22\xc0\x3a\xb4\x9a\x8c\x4a\x39\x51\xb8\x79\xab\xdb\x9b\x6c\x95\x9a\xfa\x8b\x1b\xe2\x87\x5f\x7f\x7a\x58\xca\x7f\x9c\x8c\x29\xca\xf5\xfe\x5d\xd1\x6a\x43\x21\xfb\x2b\x00\x00\xff\xff\x00\x40\x2f\x59\x6c\x09\x00\x00")

FileDPN68Yml is "/DPN68.yml"

View Source
var FileDPN92Yml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x04\xff\xac\x56\xcb\x6e\xe4\xb6\x12\xdd\xeb\x2b\x0e\xdc\x9b\x7b\x01\x5b\xea\xf7\x43\x8b\x0b\xdc\xd8\x9b\x00\x49\xc3\x18\x04\x41\x80\x41\xd0\xa8\xa6\x4a\x12\x33\x14\x29\x90\x94\x3d\xce\xd7\x07\x45\xa9\xdd\x3d\x83\x64\x92\x45\x7a\xa1\x16\xab\x0e\xab\x78\xea\x45\x59\xea\xb8\xc4\xd3\xf3\xf1\xb0\xc4\x0c\xb2\x82\xab\xf1\xe6\x06\x8f\xce\x55\x6c\xb2\xda\x53\xc7\xaf\xce\x7f\x2a\x33\x24\x7d\x89\x47\xaa\x6b\xc6\x0c\xef\x2a\xd4\xce\x23\xb6\x3c\x6d\x01\x5e\xd8\x07\xed\x6c\x89\x45\x3e\xff\x02\x38\x29\xa0\x9c\x8d\x9e\xb4\x8d\xd9\x24\xb9\x40\xa7\x25\xb4\xad\x9d\xef\x28\x6a\x27\xef\x08\xdc\x91\x8d\x5a\xbd\xeb\x47\x6d\x26\x76\x48\x5b\xf6\x25\x66\xc9\x68\x5a\x04\x0c\x81\x2b\x44\x87\x9e\xbd\x20\xc7\x83\xa1\xf7\x5c\x69\x25\x36\x33\x5c\x7f\x33\x74\x83\x89\xba\x37\x8c\xde\x50\x14\x7c\x80\x22\x8b\x33\x23\xf4\xac\x74\xad\xb9\xca\x00\xea\xaa\xed\x5a\xa2\x00\x34\xfd\x50\xc2\x93\xee\xbd\xfb\x8d\x55\x2c\x14\xf9\xce\x3c\x28\x89\x4b\x99\x60\x0f\xaa\x1f\x92\x0f\xf5\xb7\xc8\x26\x21\xfb\x5e\x6d\xd7\x86\x47\xf3\xdf\xda\x34\x01\xa7\x6d\xdf\x3e\xca\x2d\xb6\xe2\xa0\xbc\xee\x85\x7c\x89\xff\x65\xc0\xd3\x40\x06\xcf\x14\x5b\x1c\x39\x4a\x82\x03\xc8\x33\x5a\xdd\xb4\xe6\x0d\x5c\xd7\x5a\x69\xb6\x11\xf6\xa2\x7d\x6d\xb5\x6a\xa1\x5c\x77\xd6\x96\x53\xba\x43\xf4\x6c\x9b\xd8\x4a\xc9\x9c\x5d\x6c\xf1\x81\xc3\x91\x7f\x89\xf8\x7f\xd3\x78\x6e\x28\x72\x25\x22\x5d\x89\xab\x9f\x3c\xd9\x20\xc1\x4d\x49\x0d\x19\x24\x87\x78\x62\xee\x71\xe4\xc1\x93\xb9\x39\x87\xad\xf0\xc4\x36\xf0\x91\x63\x18\xdf\xcc\x1b\x1e\x9d\xb5\xac\xc4\xe6\xa3\xb3\x2f\xce\x0c\xc2\xe5\x66\x5b\x9e\x79\xae\xd9\xb3\x55\x1c\xa4\x1c\xae\xab\x54\x09\xd4\xb3\x0f\x28\xf0\xca\xe7\xa0\x23\xcb\x2b\x47\x95\xe7\x18\x23\x73\xd6\xb6\x49\xa4\xc6\xb2\x07\x1e\xd0\xc6\xd8\x87\xb2\x28\x1a\x1d\xdb\xe1\x9c\x2b\xd7\x15\xc1\x31\xbd\xb0\x2f\x52\xaa\x1f\x12\xb4\x88\x9e\xb9\xe8\x28\x44\x91\x1b\x21\xf6\xa7\x5b\xd5\x5b\xff\x5a\x3c\x3d\x1f\x43\x36\x83\xd1\x4a\xe8\x49\xdc\xae\x6d\x33\x09\x4b\x0c\xd6\x73\x88\x5e\x0b\xd7\x6c\x06\x6d\xfb\x21\x26\x0e\x57\xec\x28\x93\x6a\x99\xa1\xd6\x3e\xc4\x11\x85\xf8\xd6\x73\x8a\xeb\x15\x2a\x4c\x44\x5c\x42\x77\xd4\x70\xaa\xca\xd9\x44\x3a\x95\xc3\xe5\x14\x37\x76\x12\x68\x8c\x4b\x82\x94\xc9\x5e\x72\x7a\x63\xa5\x27\x99\x0d\x91\x7d\x0a\xb7\xf8\xb8\x11\x25\x13\x40\xa5\x3b\xb6\x32\x0b\x42\x89\x8f\xab\x7b\x2c\x97\xeb\xf4\xf8\x75\xd2\x77\x4c\xb6\xc4\xc7\xc5\x72\x9d\xcf\xef\xb1\x58\xec\xd2\xdf\x7c\x9d\xcf\x2f\x88\xa0\xc8\x70\x89\xcd\x21\xdf\xef\xe7\xcb\xd5\x61\xb3\x5c\x64\x6e\x88\xfd\x10\x47\xfa\xc2\x34\xf9\x76\x75\x7a\x1f\x75\x19\x92\xb0\x44\xcd\x14\x07\x2f\xb4\x67\xa0\x5b\x4e\x5f\xe2\xaf\x27\xcf\x70\x8b\x1a\x99\x8f\x36\x61\xe8\xcc\x26\xc3\x15\x9b\x32\x00\xcc\x92\xaf\x1b\x71\x22\x37\x79\x0e\xa7\xc1\x9b\x32\x15\x53\x59\x14\x61\x95\x53\x47\xbf\x3b\x4b\xaf\x61\xac\xa8\xe8\x3c\xe7\x69\x80\xe4\xce\x37\x45\x78\xb3\x81\x63\x28\x52\xb2\x2c\xc7\x49\x90\xc7\xcf\xc2\x09\x57\xab\xaa\x65\xf5\x29\x0c\x5d\x89\x75\xb5\x5c\xad\xcf\x9b\xfd\x6a\x45\x8a\xd6\xeb\xc3\x72\x3f\xdf\x6e\x68\xb1\x9f\x57\xe7\xd5\x7c\xb1\xa5\x2c\xd5\xa9\xb4\xc4\x65\x9c\x85\xb1\xca\xd1\x78\xea\x5b\x48\xbb\xbd\xb2\x6e\xda\x18\xe0\x39\xb8\xc1\x2b\x16\x0a\x49\x7b\xea\x29\xb6\xff\xfc\xf8\xc9\x55\x18\xfb\xa3\xa8\x7a\x7b\x58\x16\x15\xf7\xc6\xbd\x9d\xd2\xe2\x64\xdd\x49\xb1\x36\x27\xc1\xe5\xbd\x77\xd1\x8d\xc4\x26\xff\xff\x82\x37\xf1\x99\xa7\xfe\x14\x1f\x92\x2e\x1d\x4e\xe4\x55\xab\x5f\xa4\x1c\xc8\x04\xb9\xbb\x74\x8d\xc0\xf1\x5e\x2a\xc6\xca\x03\x67\x0a\x2c\x99\x82\x0e\x20\x0c\xde\xc8\xd0\x20\x8b\x69\x67\xca\xe8\xd7\xbf\x59\xda\x79\x0d\xd3\x6d\x24\x13\x13\xd1\x5b\x54\x6c\x5d\x4c\x13\xf3\x2f\xac\xd4\xda\x70\xba\x5b\xc3\xa5\x28\x93\xcd\x5b\x73\x78\xd5\xb1\xd5\xe3\x51\xaf\x47\x4a\xb0\x9b\x4a\x58\xaa\xed\x62\xb1\x5d\x6c\xf7\xdb\xc3\x52\xed\x79\xb5\xab\xb6\xab\xcd\x61\xb1\x5e\x54\xab\x03\xd7\xb4\xcb\x80\x4b\xa0\xaf\xe5\xb3\xa7\x6a\xb7\xa4\xcd\x6a\xb1\x5f\x6d\xeb\x5d\xbd\x53\xcb\x1d\xaf\xeb\x6d\xb5\x56\x9b\xcd\xe6\xbc\xdf\x64\x14\xa3\xd7\xe7\x21\x8e\x63\x95\x3f\x47\x4f\x97\x5b\x01\x57\x5d\x06\x7c\xd2\xb6\x2a\xf1\x78\x3c\x4e\x91\x91\xb5\x30\xb2\x9c\xe6\xfb\x74\x93\xe0\x3f\x8f\xc7\xe3\x3d\x3e\xc8\x23\xcf\xf3\xff\x4a\xab\xca\xb7\x80\xb6\xcd\xa9\xa2\x48\x81\x63\x89\xef\x65\x56\x1d\x39\xca\xa8\x1a\x65\xef\x77\x7a\xfa\xd8\x98\x36\x64\x40\x47\x56\xd7\x1c\xe2\x89\x86\xd8\x3a\x5f\x82\xce\xd5\x60\x64\x70\xb6\xba\xaa\x58\x3a\xd8\x0f\x92\xf2\x1f\x39\x04\x6a\x78\xec\xd5\xbb\x54\x21\xf9\xb3\x73\x46\xdb\xe6\xf9\x32\xc9\xee\xd0\x52\x80\x75\xa8\x35\x9b\x2a\xe5\xa4\xc2\xdd\x7b\xc5\xde\x65\xb3\xd4\xc8\x5f\xdd\x0a\xdf\xfd\xfc\xc3\xe3\x54\xf2\xfd\x60\x4c\xb1\x9a\x6f\x76\x45\xad\x0d\x87\xec\x8f\x00\x00\x00\xff\xff\xb3\x78\x5f\x97\x60\x09\x00\x00")

FileDPN92Yml is "/DPN92.yml"

View Source
var FileInceptionBN21KYml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x04\xff\xac\x55\x4d\x8f\xdb\x36\x10\xbd\xeb\x57\x3c\xc0\x97\x16\x58\x4b\xeb\x2f\xd9\xd6\xa1\x87\x6c\x2f\x41\x5b\x07\x28\x8a\x1e\x1a\x04\x8b\x11\x35\xb4\x59\x4b\xa4\x40\x52\x71\xb6\xbf\xbe\xe0\x48\x6b\x3b\x41\x93\xf6\x50\x1d\x08\x71\xe6\xcd\x27\xdf\x90\x96\x3a\xae\xf0\xd6\x2a\xee\xa3\x71\xf6\xcd\x61\xbe\x5c\xfc\x84\x19\x92\x1c\x4e\xe3\xc5\x0d\x1e\x9d\x6b\xb8\xcd\xb4\xa7\x8e\x2f\xce\x9f\xab\x0c\xa2\xaf\xf0\x44\x5a\x33\x66\xb8\xaa\xa0\x9d\x47\x3c\xf1\x64\x02\x7c\x64\x1f\x8c\xb3\x15\x16\xf9\xe3\x67\xc0\x49\x01\xe5\x6c\xf4\x64\x6c\xcc\x26\x49\x85\xa5\x40\xa7\x2d\x8c\xd5\xce\x77\x94\xb2\x83\xb1\x08\xdc\x91\x8d\x46\x5d\xf5\xa3\x36\x4b\x7e\xc8\x58\xf6\x15\x66\xe2\x54\x36\x01\x43\xe0\x06\xd1\xa1\x67\x9f\x90\x63\x62\xe8\x3d\x37\x46\x25\x9f\x19\x6e\xdf\x0c\xdd\xd0\x46\xd3\xb7\x8c\xbe\xa5\x98\xf0\x01\x8a\x2c\x6a\x46\xe8\x59\x19\x6d\xb8\xc9\x00\xea\x9a\x72\x9d\xba\x00\x1c\xfb\xa1\x82\x27\xd3\x7b\xf7\x27\xab\x58\x28\xf2\x5d\x3b\x57\xa9\x2f\x95\xc0\xe6\xaa\x1f\x24\x86\xfa\x57\xe4\x51\x90\x7d\xaf\xca\x75\xcb\xa3\xfb\x6f\x19\x4d\xc0\xc9\xec\xdb\xa9\xdc\x63\x1b\x0e\xca\x1b\x39\xee\x0a\x3f\x64\xc0\x6f\xef\x7e\x7c\x97\x79\xd6\xec\xd9\x2a\x0e\xa9\x81\xb7\x9d\xf4\x8e\x7a\xf6\x01\x05\x2e\x5c\x07\x13\x39\xfd\x72\x54\x79\x8e\xd1\x57\x6d\xec\xf1\xb3\x53\x9f\xe3\x14\x63\x1f\xaa\xa2\x38\x9a\x78\x1a\xea\x5c\xb9\xae\xe8\xd9\xc7\x21\x50\xf1\x05\xd9\xe6\xda\xf9\xb9\x10\x29\xc3\x3f\x1b\xbe\xf9\xfd\xe7\xa7\x42\x5a\x5a\x5c\xcc\xd9\x14\xbf\x24\x3a\xce\xff\x70\xee\x6b\x06\x4d\xd7\xaa\xa2\xfb\x64\x39\xce\x85\xba\xf3\x23\xb5\x2d\xfb\x97\xa2\x6e\x5d\x5d\x74\x14\x22\xfb\xc2\x74\x74\xe4\x04\x59\x2e\xce\x73\xf3\x3a\x00\x79\xd7\x64\x33\xb4\x46\xb1\x0d\x32\x00\x37\x32\x4f\xc2\x0a\x83\xf5\x1c\xa2\x37\x2a\x72\x02\x1b\xdb\x0f\x51\xfa\x74\xc3\x8e\xb2\x74\x86\x33\x68\xe3\x43\x1c\x51\x88\x2f\x3d\x27\xc6\xde\x41\x53\xd1\x49\x5c\x41\x32\x12\xae\xcc\xa6\xc6\xca\x21\xa5\x31\x4c\x9e\xef\xfc\x08\x68\xec\xbd\x40\x2a\x01\x48\xd0\x3b\x2f\x3d\xa5\x89\x8d\xec\xe5\x48\x53\x8c\x3b\x91\xb8\x00\x1a\xd3\xb1\x4d\x13\x1a\x2a\xbc\x5f\x3d\x60\xb9\x5c\xcb\xf2\x61\xd2\x77\x4c\xb6\xc2\xfb\xc5\x62\xfb\x80\xd7\xe5\x43\xe6\x86\xd8\x0f\x71\x2c\x2f\xa5\x26\xbe\x9d\x96\xff\x51\x97\x41\x84\x15\x34\x53\x1c\x7c\x2a\x6b\x06\xba\xcf\xf9\x73\xfc\x2d\xb3\x0c\xf7\xa8\xb1\xb2\xd1\x27\x5a\xaa\xb9\xcd\x70\xc3\x4a\x87\x81\x99\xc4\xba\x13\x4b\xf2\x53\xe4\xf0\x3c\xf8\xb6\x12\x42\x56\x45\x11\x56\x39\x75\xf4\x97\xb3\x74\x09\xc2\xca\x10\x9d\xe7\x5c\xc6\x36\x77\xfe\x58\x84\x17\x1b\x38\x86\x2b\x3d\x26\x41\x62\x49\x1e\x3f\xa5\xba\x70\xf3\xac\x4e\xac\xce\x61\xe8\x2a\xec\x36\x8b\xba\xe6\xc7\x72\xbd\xdf\x2b\xbd\x59\x69\x2a\xf5\x4e\xd7\xdb\x25\x35\xe5\x82\xf7\x8f\x65\x26\x44\x4c\xa3\xf5\x7a\x91\x84\xe9\x2a\x3a\x7a\xea\x4f\x20\xdb\xe0\xc2\xe6\x78\x8a\x01\x9e\x83\x1b\xbc\xe2\x54\x86\x68\x9f\x7b\x8a\xa7\xff\x5e\x82\x84\x0a\xd3\xc4\x5c\x99\x5d\xdb\x54\x43\xd1\x70\xdf\xba\x97\xbc\xf7\x2e\xba\xb1\x9e\x29\xec\xff\x19\xe4\x3a\xe2\xcb\xc5\x39\x97\xc9\x95\x9c\x32\xc0\x84\x67\xf2\xea\x64\x3e\x26\x6a\x50\x1b\xd2\xeb\x61\x34\x02\xc7\x87\xc4\x1e\x9b\x16\xd4\x14\x38\x9d\x1a\x4c\x00\x61\xf0\x6d\xba\x84\xc8\x62\xb2\x94\xd3\xfd\xf2\x9b\x89\xe5\xad\x5d\xf7\x1d\x95\xd2\x92\xde\xa2\x61\xeb\x22\xa7\xff\xaf\x78\xd1\xa6\x65\x79\xdd\xc2\x2b\x41\xc5\xe7\xbd\x3b\x5c\x4c\x3c\x99\x31\xd5\x5b\x4a\x02\xbb\x63\xc4\x6a\xbf\x2b\x37\x7a\xbb\x6b\x1e\xf5\x7e\x4d\xd4\xac\x56\xaa\xac\xd5\x8e\xb6\xdb\xbd\xd6\xab\xf5\x2a\x03\x5e\x3b\x7f\xa3\x51\x59\xeb\x72\xb3\xd8\x95\x8a\xf9\x71\x57\xaf\xb7\x35\x95\xb4\x2d\xb7\x7a\x43\x1b\xb5\x53\xbc\xc8\x28\x46\x6f\xea\x21\x8e\xd7\x34\x7f\x8a\x9e\x60\x39\xa6\x67\x19\x37\x5d\x06\x9c\x8d\x6d\x2a\x3c\x1d\x0e\x53\x67\xd2\x3e\x55\x64\x79\xf0\xd4\x5e\x6d\xbe\x7b\x3a\x1c\x1e\xf0\x6b\x5a\xf2\x3c\xff\x3e\x8d\x6d\x7a\x8d\x8d\x3d\x3e\x37\x14\x29\x70\xac\xf0\x36\xdd\x94\x07\x8e\xe9\x5a\x1a\x65\xd7\x57\x55\x9e\xfb\xc9\x20\x03\x3a\xb2\x46\x73\x88\xcf\x34\xc4\x93\xf3\x15\xa8\x6e\x86\xb6\xc9\xfe\x0e\x00\x00\xff\xff\x5c\x5f\x78\xcb\x66\x08\x00\x00")

FileInceptionBN21KYml is "/InceptionBN-21K.yml"

View Source
var FileInceptionResNetV2Yml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x04\xff\xac\x56\x3d\x8f\xe3\x36\x13\xee\xf5\x2b\x06\x50\xf3\xbe\xc0\x5a\xb2\xe5\x6f\x16\x69\x2e\xcd\x35\x7b\xc0\x21\xdd\x21\x30\x46\xd4\xc8\x66\x4e\x22\x09\xce\x68\xbd\x9b\x5f\x1f\x90\x92\x57\xda\x20\xb9\xa4\x88\x0b\x41\x9a\x79\xe6\x99\x6f\xd2\x16\x7b\x52\xf0\xd9\x6a\xf2\x62\x9c\x5d\x7d\x25\x7e\x26\x81\x1c\xa2\x02\x5c\x0b\x6f\x6e\x08\xd0\xbb\x86\xba\xac\x0d\xd8\xd3\xdd\x85\xef\x2a\x83\xa4\x57\xf0\x09\xdb\x96\x20\x87\x77\x15\xb4\x2e\x80\xdc\x68\x32\x01\x78\xa1\xc0\xc6\x59\x05\x9b\x62\xfd\x01\x38\x29\x40\x3b\x2b\x01\x8d\x95\x6c\x92\x28\xa8\x12\x74\xfa\x04\x63\x5b\x17\x7a\x8c\xe1\x81\xb1\xc0\xd4\xa3\x15\xa3\xdf\xf5\xa3\x36\x8b\x3c\x68\x2c\x05\x05\x79\x22\x4d\x1f\x0c\x03\x53\x03\xe2\xc0\x53\x88\xc8\x31\x30\xf0\x81\x1a\xa3\x23\x67\x06\xf3\x2f\x87\x7e\xe8\xc4\xf8\x8e\xc0\x77\x28\x11\xcf\xa0\xd1\x42\x4d\xc0\x9e\xb4\x69\x0d\x35\x19\x00\xf6\xcd\x61\x17\xab\x00\x70\xf5\x83\x82\x80\xc6\x07\xf7\x1b\x69\x29\x35\x86\xbe\x5b\xe9\x58\x17\x95\x60\x2b\xed\x87\xe4\x43\xff\x23\xf2\x9a\x90\xde\xeb\xc3\xae\xa3\x91\xfe\x47\x46\x13\x70\x32\xfb\x71\x28\x4b\x6c\x43\xac\x83\x49\xfd\x56\xf0\x53\x06\xf0\xcb\x97\x9f\xbf\x64\x81\x5a\x0a\x64\x35\x71\x2c\xe0\xfc\x95\x6a\x87\x9e\x02\x43\x09\x77\xaa\xd9\x08\xc5\x57\x12\x5d\x14\x30\x72\xd5\xc6\x5e\x3f\x74\x7d\x05\x37\x11\xcf\xaa\x2c\xaf\x46\x6e\x43\x5d\x68\xd7\x97\xec\x08\x5f\x28\x94\xa9\x38\xab\x34\x53\xa5\x04\xa2\xb2\x47\x96\x28\xef\x38\x83\x85\x29\x86\x57\xf3\x52\xb8\x70\x2d\xb1\xe6\x72\x73\x58\x57\xc5\xfa\x58\x1d\x36\x1f\x40\x0b\x7e\x21\xcb\x2e\xb4\x9d\xbb\x97\x89\x9c\xcb\xba\x73\xf5\x83\x3d\x10\x13\x06\x7d\x2b\xb9\x33\x7d\xe9\x03\xf9\xe0\x34\x31\x1b\x7b\x2d\xcd\x63\xfe\x2f\x1f\xe4\x85\x7f\xcb\x72\xe8\x8c\x26\xcb\x69\x19\xe6\xc1\x9e\x84\x0a\x06\x1b\x88\x25\x18\x2d\xd4\x64\x39\x18\xeb\x07\x49\x35\x9b\xb1\xa3\x2c\xf6\x33\x87\xd6\x04\x96\x11\x05\xf2\xe6\x29\x4e\xef\x02\x1a\xd3\x8f\x62\x05\xa6\xc7\x2b\xa5\xb9\xc9\xa7\x22\xa7\x86\xc5\x95\x8c\xcc\x0b\x9e\x04\x1a\xfb\x90\x20\x2a\x01\x92\xd3\x05\x8b\xc7\xb8\xbd\x42\x21\xb5\x37\xfa\x58\x88\x12\x05\x40\x63\x7a\xb2\x71\x5b\x59\xc1\xb7\xed\x13\x54\xe7\x73\x7a\xfc\x3a\xe9\x7b\x42\xab\xe0\xdb\xa6\x3a\x3d\xc1\xe3\xf1\xd0\xb1\xc6\x8e\x54\x14\x67\x6e\x10\x3f\xc8\x98\x6f\x8c\x35\x39\x73\x6d\x7a\x1f\x75\x19\x24\xa1\x82\x96\x50\x86\x10\xf3\xcc\x01\x97\x49\x7c\xc4\xcf\xa1\x66\xb0\x44\x8d\xa9\x8e\x9c\xd0\x61\x4d\x5d\x06\x33\x36\x95\x1c\x20\x4f\xbe\x16\xe2\x94\xcd\xe4\x99\x2f\x43\xe8\x54\x9a\x56\x55\x96\xbc\x2d\xb0\xc7\xdf\x9d\xc5\x3b\x8f\x23\x2b\x2e\x50\x91\x76\x3a\x0d\x22\xbf\x59\x26\xe1\x32\x75\xc7\x92\x4c\x82\x42\x5e\x63\x4e\x30\xb3\xea\x1b\xe9\xef\x3c\xf4\x0a\x76\x4d\xb5\xdd\xd5\xfb\xd3\x76\x8b\x1a\x77\xbb\x73\x75\x5a\x1f\xf6\xb8\x39\xad\x9b\x7a\xbb\xde\x1c\x30\x4b\xb3\x1a\x77\xee\x71\xc2\xf0\x74\x46\x5d\x03\xfa\x1b\xa0\x6d\xe0\x4e\xe6\x7a\x13\x86\x40\xec\x86\xa0\x29\xa6\x90\xb4\x17\x8f\x72\xfb\xf7\xe1\x27\x57\x3c\x2e\xe0\x3c\xf4\xab\x40\x6c\x49\x56\x2f\x55\xd9\x90\xef\xdc\xdb\xe5\x7d\x1f\x66\x55\xe1\x83\x13\x37\xe6\x39\x85\xf3\x5f\x3b\xff\x2b\xaf\xe9\xac\x48\x61\x67\x00\x86\x2f\x71\x83\xcd\x4b\x9c\x1c\xec\x98\x20\x07\xd3\x02\x93\x3c\xc5\xe1\xb2\xf1\x01\x35\x32\xc5\xa6\x82\x61\x40\x18\x42\x17\x0f\x30\xb4\x30\x59\xa6\xe6\xff\xf9\x97\x27\xcb\xb9\xa2\xcb\xa2\xa7\x2c\xa3\xde\x42\x43\xd6\x09\xc5\xf7\xbf\x61\x69\x4d\x47\xe9\x66\xe4\xc7\xfc\x26\xce\x25\x1d\xdc\x8d\xdc\xcc\x18\xea\x1c\x52\x82\x2d\x86\xa6\xdd\xd5\xad\x6e\xf7\xc7\x7a\x73\xde\x1d\xd7\xfb\x6d\xa5\xf5\xb6\xae\x76\x3b\x24\x7d\xdc\xee\x69\x9b\x01\x3c\x9a\x30\x4f\xda\x41\x37\x78\xac\x49\x63\x75\xac\xeb\xb5\x3e\xd3\xf9\xb4\xd1\x54\x6d\x9a\x7d\x5b\x1d\xeb\xcd\x29\x43\x91\x60\xea\x41\xc6\x23\x9e\x5e\x25\x20\x58\x92\x78\xa5\xc3\xac\xcb\x00\xbe\x1b\xdb\x28\xf8\xf4\xfc\x3c\x55\x26\x7e\xc7\x8c\x2c\x0d\x01\xbb\x77\x9b\xff\x7d\x7a\x7e\x7e\x82\xaf\xf1\x51\x14\xc5\xff\xe3\x56\xc7\x9b\xdc\xd8\xeb\xa5\x41\x41\x26\x51\xf0\x39\x9e\x63\xe3\x5f\x8a\x49\xf6\x7e\x23\xa7\xbf\x0a\x93\x41\x06\xd0\xa3\x35\x2d\xb1\x5c\x70\x90\x9b\x0b\x0a\xb0\x6e\x86\xae\xc9\xfe\x08\x00\x00\xff\xff\xee\x30\x57\xe3\xa3\x08\x00\x00")

FileInceptionResNetV2Yml is "/Inception-ResNet-v2.yml"

View Source
var FileInceptionV3Yml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x04\xff\xac\x56\xbd\x8e\xe3\x36\x10\xee\xf5\x14\x83\x75\x93\x00\xb6\xe4\x9f\xb5\xd7\xab\x22\xcd\x5e\x73\x40\xb0\xc5\x21\x48\x91\x43\x60\x8c\xa8\xa1\xc5\x2c\x45\x0a\x1c\xca\x5e\xe7\xe9\x83\xa1\x64\xcb\x1b\xe4\x2e\x29\xe2\x42\xb0\x66\xbe\xf9\xff\x86\xa2\xc3\x96\x4a\xf8\xec\x14\x75\xd1\x78\x07\x33\x10\x09\x78\x0d\x17\xdf\x07\x68\x7d\x4d\x36\xd3\x01\x5b\x3a\xfb\xf0\x56\x66\x90\xf4\x25\xbc\xa0\xd6\x04\x33\xb8\xa9\x40\xfb\x00\xb1\xa1\xd1\x04\xe0\x44\x81\x8d\x77\x25\xac\xf2\xe5\x07\xe0\xa8\x00\xe5\x5d\x0c\x68\x5c\xcc\x46\x49\x09\x9b\x04\x1d\x5f\xc1\x38\xed\x43\x8b\x29\x2f\xe3\x80\xa9\x45\x17\x8d\xba\xe9\x07\x6d\x26\x7e\xd0\x38\x0a\x25\xcc\x92\xd3\xf4\xc2\xd0\x33\xd5\x10\x3d\x74\x14\x04\x39\x24\x06\x5d\xa0\xda\x28\xf1\x99\xc1\xf4\x9b\x41\xdb\xdb\x68\x3a\x4b\xd0\x59\x8c\x82\x67\x50\xe8\xa0\x22\xe0\x8e\x94\xd1\x86\xea\x0c\x00\xdb\x7a\xf7\x28\x5d\x00\x38\x76\x7d\x09\x01\x4d\x17\xfc\x1f\xa4\x62\xa1\x30\xb4\x76\xa1\xa4\x2f\x65\x82\x2d\x54\xd7\xa7\x18\xea\x5f\x91\xc7\x84\xec\x3a\xb5\x7b\xb4\x34\xb8\xff\x9e\xd1\x08\x1c\xcd\xbe\x9f\xca\x3d\xb6\x26\x56\xc1\xa4\x41\x97\xf0\x53\x06\xd3\xdc\x17\xa7\x0d\x18\x86\x34\x0f\xaa\xa5\xb3\x69\x96\x9f\x5b\x3c\xd2\x2b\x45\xf8\x19\xc3\x91\xe0\x57\xc3\x3d\x5a\xf8\x42\xca\x1f\x9d\x91\x1e\xc2\x4b\x83\xd6\x92\x3b\x12\xf4\x6c\xdc\x31\x59\xd5\x18\x11\x74\xf0\x2d\xac\x97\xab\x75\x9e\x01\xfc\xd2\x18\x16\xff\x08\x1c\xd1\xd5\x18\x6a\x88\xc8\x6f\x32\x55\xe5\xdb\xae\x8f\x14\xe0\x64\x84\x2e\x73\x38\x37\x14\x46\x16\x49\x42\x17\x19\xa1\xb2\xc8\x6c\xf4\x05\xc8\x45\x13\x08\x8c\xe4\xc5\x60\x5c\xf4\xb0\x5a\x2e\x97\x03\x80\x78\x0e\xd6\xbc\x11\x3c\xfc\x46\x55\xc0\x87\x39\x3c\x7c\x42\x2b\x04\x42\xf7\x30\x07\x74\x35\x3c\x7c\x32\xdc\x9c\x91\x1b\x0a\x0f\x79\x16\x48\x53\x20\xa7\x88\x85\x3a\xd3\x9b\x84\xec\xb0\xa3\xc0\x50\xc0\x99\x2a\x36\x91\xe4\x2f\x45\x95\xe7\x30\x74\xb1\xba\x56\x3b\xac\x08\xc0\x02\x9a\x18\x3b\x2e\x8b\xe2\x68\x62\xd3\x57\xb9\xf2\x6d\xc1\x9e\xf0\x44\xa1\x48\xb4\x58\x24\x68\x11\x03\x51\xd1\x22\x47\x91\x5b\xfe\x96\x69\xdd\x5a\x55\xb4\xef\x8e\xe2\x60\xb7\x38\x4a\xa7\xc3\xa5\xa8\xac\xaf\xae\xf6\xa9\x11\x02\x59\xbd\x2d\xcc\x75\x89\x17\xa7\x4d\xde\x0a\x5b\xff\x31\xa5\x48\x8e\x7d\xd0\xd6\x9f\x8b\x94\x0f\x7f\x70\x18\x88\x09\x83\x6a\x0a\xb6\xa6\x2d\xba\x40\x5d\xf0\x8a\x58\x66\x5b\xdc\x02\x1c\x3e\xc8\xf3\xee\x92\xcd\xc0\x1a\x45\x8e\xd3\xc9\x31\x9d\x02\xa3\xb0\x84\xde\x05\xe2\x18\x8c\x8a\x54\x67\x33\x30\xae\xeb\x63\x6a\xf3\x84\x1d\x64\x42\xfe\x19\x68\x13\x38\x0e\x28\x88\x97\x8e\x6e\x84\x4c\x19\xa7\x8e\x89\xb8\x1c\x88\x90\x96\x6c\x36\xce\x25\xb1\x5b\xce\x2f\xf1\x7c\xe7\x27\x81\x86\xd1\x25\x48\x99\x00\x29\xe8\x9d\x97\x0e\xe5\xa8\x8b\x14\x12\x23\x24\xc6\x9d\x28\xb9\x00\xa8\x4d\x4b\x4e\xb8\xca\x25\x7c\xdd\xcc\x61\xfd\xfc\x9c\x1e\xbf\x8f\xfa\x96\xd0\x95\xf0\x75\xb5\xde\xcf\xe1\xfa\xb8\xea\x58\xa1\xa5\x52\xc4\x99\xef\x63\xd7\xc7\xa1\x5e\xc9\x35\x05\xf3\x3a\xfd\x1f\x74\x19\x24\x61\x09\x9a\x30\xf6\x41\xea\x9c\x01\xde\x17\xf1\x11\x3f\xa5\x9a\xc1\x3d\x6a\x28\x75\xf0\x09\x16\x2b\x92\x0e\xde\x55\x9a\xf2\x9e\xa5\x58\x77\xe2\x24\x1d\x23\xf3\xa1\x0f\xb6\x4c\x04\x2f\x8b\x82\x37\x39\xb6\xf8\xa7\x77\x78\xe6\x81\xe5\xd1\x07\xca\xd3\x01\x98\xfb\x70\x2c\xf8\xe2\x98\x22\xdf\xd8\x39\x0a\x64\x53\xf3\xf8\x2e\x75\xc1\xe4\x59\x35\xa4\xde\xb8\x6f\x4b\x78\xda\xac\xb6\x6a\xad\xf6\x95\xd6\x75\xb5\xdb\x2f\x95\xde\xab\x6d\xbd\xc6\x27\xf5\xb8\x55\x9b\xdd\x26\x4b\xd3\x97\x55\xbd\x1e\xc9\x3c\x10\x02\x8e\x01\xbb\x26\x2d\xf8\x99\xcc\xb1\x89\x0c\x81\xd8\xf7\x41\x91\x94\x91\xb4\x87\x0e\x63\xf3\xdf\x4b\x48\xa1\x78\xd8\xdb\x89\xf8\x8b\xd3\xa6\xa8\xa9\xb3\xfe\x72\xb8\x2d\x83\x6c\x5b\x17\x7c\xf4\x43\x65\x63\x02\xff\x5b\xb8\x0f\x71\xd2\x31\x92\x52\xcb\x00\x0c\x1f\x64\x53\xcd\x49\x18\x82\x96\xe5\x73\x6c\x34\x30\xc5\xb9\x90\xc8\xc9\x03\x2a\x64\x92\xe1\x0d\xa7\x6f\x1f\xac\x9c\x6d\xe8\x60\xb4\x4c\x43\xfe\xfb\x6f\x96\x2c\xa7\xae\xdd\x37\x36\xd5\x25\x7a\x07\x35\x39\x1f\x49\xfe\x7f\xc3\x8b\x36\x96\xd2\x75\x81\xaf\x3c\x4d\x3e\xef\xdd\xc1\xd9\xc4\xc6\x0c\xa9\x4e\x29\x25\xd8\x1d\x31\xf4\x6e\xbd\x59\x57\xdb\xdd\xaa\x5a\x6b\x5d\xad\xb4\x5e\xd7\x4f\xea\x51\xeb\xdd\xf3\xf6\x49\xef\x76\x55\x06\x70\x6d\xfb\xc4\xa6\xe5\x76\xb5\x53\x5b\xac\x97\xdb\x6a\xbb\xd4\x3b\xf5\xb4\xc2\xfd\xfe\x79\x85\x4b\x55\xed\xd4\x23\xed\x33\x8c\x31\x98\xaa\x8f\xc3\xe9\x4f\xef\x31\x20\x38\x8a\x72\xcf\x81\x49\x97\x01\xbc\x19\x57\x97\xf0\xf2\xfa\x3a\x76\x46\xde\xa5\x22\x47\x7d\x40\x7b\xb3\xf9\xe1\xe5\xf5\x75\x0e\x5f\xe4\x91\xe7\xf9\x8f\xb2\xbd\x72\xbd\x31\xee\x78\x90\x2f\x22\x53\x2c\xa7\x0f\xea\x2c\x7d\x25\x99\xe2\xed\x9a\x92\xee\x4f\xa3\x41\x06\xd0\xa2\x33\x9a\x38\x1e\xb0\x8f\x8d\x0f\x25\x60\x55\xf7\xb6\xce\xfe\x0a\x00\x00\xff\xff\x66\x61\xeb\x6d\xb1\x09\x00\x00")

FileInceptionV3Yml is "/Inception-v3.yml"

View Source
var FileInceptionV4Yml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x04\xff\xac\x56\x3d\x8f\xa4\x46\x13\xce\xf9\x15\x25\x4d\xf2\xbe\xd2\x0e\xcc\x07\xf3\xb1\x04\x4e\x2e\xba\x64\x03\x07\x4e\x4e\xd6\xa8\x68\x8a\xa1\xbd\xd0\x8d\xba\x8a\x99\x5b\xff\x7a\xab\x1a\x76\x60\x2c\xf9\xec\xe0\x08\x10\x54\x3d\xfd\xd4\x77\x81\xc3\x8e\x0a\xf8\xea\x0c\xf5\x62\xbd\x83\x15\xa8\x04\x7c\x0d\x1f\x7e\x08\xd0\xf9\x8a\xda\xa4\x0e\xd8\xd1\xdd\x87\xf7\x22\x81\xa8\x2f\xe0\x0b\xd6\x35\xc1\x0a\x1e\x2a\xa8\x7d\x00\x69\x68\x3a\x02\x70\xa3\xc0\xd6\xbb\x02\xb6\xe9\xe6\x09\x38\x29\xc0\x78\x27\x01\xad\x93\x64\x92\x14\x90\x47\xe8\xf4\x0a\xd6\xd5\x3e\x74\x18\xfd\xb2\x0e\x98\x3a\x74\x62\xcd\x43\x3f\x6a\x13\xe5\x41\xeb\x28\x14\xb0\x8a\xa4\xf1\x85\x61\x60\xaa\x40\x3c\xf4\x14\x14\x39\x3a\x06\x7d\xa0\xca\x1a\xe5\x4c\x60\xbe\x56\xd0\x0d\xad\xd8\xbe\x25\xe8\x5b\x14\xc5\x33\x18\x74\x50\x12\x70\x4f\xc6\xd6\x96\xaa\x04\x00\xbb\xea\x98\x6b\x16\x00\xae\xfd\x50\x40\x40\xdb\x07\xff\x07\x19\xc9\x0c\x86\xae\x5d\x1b\xcd\x4b\x11\x61\x6b\xd3\x0f\xd1\x86\xf9\x57\xe4\x35\x22\xfb\xde\x1c\xf3\x96\x46\xfa\x1f\x1d\x9a\x80\xd3\xb1\x1f\xbb\xb2\xc4\x56\xc4\x26\xd8\x58\xe8\x02\x7e\x49\xe6\xb2\xaf\x6f\x39\xdc\x1b\x6b\x1a\x68\x90\x01\xa1\xf3\x81\x60\x70\x56\xf3\x00\x6c\xbb\xbe\x8d\x09\x00\x0c\xa6\xb1\x42\x46\x86\x40\x80\xae\x1a\x81\xf6\xd1\x3d\x9d\xaf\x86\x96\x18\xa4\x41\xb7\x64\xdf\xa7\x49\xa0\x9a\x02\x39\x43\xac\x65\x9a\xdf\x62\x85\xb0\xa7\xc0\x90\xc1\x9d\x4a\xb6\x42\xfa\x48\x62\xd2\x14\x46\x8f\x4b\xeb\xae\x4f\xbd\xb5\x86\x46\xa4\xe7\x22\xcb\xae\x56\x9a\xa1\x4c\x8d\xef\x32\xf6\x84\x37\x0a\x59\x2c\xc1\x3a\x76\x6e\x26\x81\x28\xeb\x90\x45\xe5\x2d\x27\xb0\x38\x8a\xe1\xbb\xbd\xa5\x3e\x5c\x33\x2c\x39\xdb\x1e\x37\xbb\x74\x73\xda\x1d\xb7\x4f\xa0\x05\xbf\x90\x63\x1f\xea\xd6\xdf\xb3\x48\xce\x59\xd9\xfa\xf2\x93\x3d\x10\x93\xa6\x27\xe3\xd6\x76\x99\x23\xe1\xec\x91\x97\xcb\x2d\x4f\xfb\x8f\x9f\xc1\xdb\x07\xea\x83\x37\xc4\x6c\xdd\x75\x61\xe0\x49\xfe\x03\x5b\xef\xe4\x84\x7d\xd7\x51\xc8\xde\x29\x20\xaf\x1f\x3e\xfe\x96\x67\x96\x79\x20\xce\x0e\xc9\x0a\x5a\x6b\xc8\x71\xdc\x03\xf3\x4c\x4f\xc2\x02\x06\x17\x88\x25\x58\x23\x54\x25\x2b\xb0\xae\x1f\x24\x16\x72\xc6\x8e\x32\x6d\xe5\x15\xd4\x36\xb0\x8c\x28\x90\x8f\x9e\x74\x70\x17\x50\xad\x89\x8a\x0b\xb0\x1d\x5e\x29\x8e\xcc\x6a\xaa\x7c\xec\x55\xdd\x46\xca\xbc\xe0\x89\xa0\xb1\x39\x22\xa4\x88\x80\x68\x74\xc1\xd2\xa3\x2e\x2e\xa1\x10\x7b\x4e\x6d\x2c\x44\x91\x02\xa0\xb2\x1d\x39\x5d\x54\x5c\xc0\xb7\xfd\x0b\xec\x5e\x5f\xe3\xed\xf7\x49\xdf\x11\xba\x02\xbe\x6d\x77\xe7\x17\xf8\xbc\x7d\xea\xd8\x60\x4b\x85\x8a\x13\x3f\x48\x3f\xc8\x18\xaf\xfa\x1a\x8d\xf9\x3a\x3e\x8f\xba\x04\xa2\xb0\x80\x9a\x50\xe7\x27\x01\x58\x01\x2e\x83\x78\xc6\xcf\xae\x26\xb0\x44\x8d\xa1\x8e\x9c\xd0\x62\x49\x6d\x02\x33\x36\xa6\x5c\x99\xa3\x03\x73\x02\x62\x34\x93\x65\xbe\x0c\xa1\x2d\xe2\x08\x15\x59\xc6\xfb\x14\x3b\xfc\xd3\x3b\xbc\xf3\x38\x47\xe2\x03\xa5\x71\x9d\xc5\xe9\xe0\x0f\xc7\xb1\x9d\xb5\x3a\x8e\x64\x12\xa4\xf2\x5d\x63\x82\x99\xd5\x34\x64\xde\x79\xe8\x0a\xc8\xab\xdd\x3e\x2f\x0f\xe7\xfd\x1e\x0d\xe6\xf9\xeb\xee\xbc\x39\x1e\x70\x7b\xde\x54\xe5\x7e\xb3\x3d\x62\x12\x07\x48\x17\xc1\xe7\x72\x65\xdd\x1d\xd4\xc2\x35\x60\xdf\xc4\xd5\x72\x27\x7b\x6d\x84\x21\x10\xfb\x21\x18\xd2\x10\xa2\xf6\xd2\xa3\x34\xff\xdd\xfd\x68\x8a\xc7\xad\x30\x4f\xcc\xfa\x96\x67\x15\xf5\xad\xff\xb8\x3c\x46\x60\xad\x63\x1a\xbc\xf8\x31\xb2\xc9\x81\x9f\x66\xee\xc9\x4e\x5c\x52\xd1\xb5\x04\xc0\xf2\x45\x57\x87\xbd\x69\x77\x60\xcb\xfa\x61\xb5\x35\x30\xc9\x8b\x36\x90\xd3\x1b\x94\xc8\xa4\x85\x03\xab\x1b\x7a\x08\xad\x6e\x4e\x74\x30\x9d\x8c\x05\xfe\xfb\xb5\x8a\x27\xe7\xac\x2d\x13\x1b\xe3\x52\xbd\x83\x8a\x9c\x17\xd2\xe7\x7f\x60\xa9\x6d\x4b\xf1\xc3\xcf\x9f\x3d\x1a\x39\x97\x74\x70\xb7\xd2\xd8\xd1\xd5\xd9\xa5\x08\x5b\x34\xc6\xa9\xda\x9d\x0f\x78\xdc\x1e\x5e\x0f\xa7\xed\xc1\x54\xa7\x6a\x83\x87\xcd\xde\x9c\xaa\x7a\x5b\xd2\x66\x97\x00\x7c\xa6\x7d\xee\x26\x73\x2a\xab\x1d\x9d\x72\xda\x60\xb9\x3f\x1d\x8f\xa7\x2d\xd6\x47\xb3\x3f\x9f\xeb\xe3\x6e\x47\xe7\x4d\x82\x22\xc1\x96\x83\x8c\xdf\x16\xfa\x2e\x01\xc1\x91\xe8\x1f\x0b\xcc\xba\x04\xe0\xdd\xba\xaa\x80\x2f\x6f\x6f\x53\x66\xf4\x5d\x23\x72\x34\x04\x6c\x1f\x67\xfe\xf7\xe5\xed\xed\x05\x7e\xd5\x5b\x9a\xa6\xff\xd7\xc9\xd5\x1f\x15\xeb\xae\x97\x0a\x05\x99\xa4\x80\xaf\x3a\x0d\x6f\x24\xba\xaa\x46\xd9\xe3\x87\x23\xfe\x09\x4d\x07\x12\x80\x0e\x9d\xad\x89\xe5\x82\x83\x34\x3e\x14\x80\x65\x35\xb4\x55\xf2\x57\x00\x00\x00\xff\xff\xf2\x96\xc4\x58\x7b\x09\x00\x00")

FileInceptionV4Yml is "/Inception-v4.yml"

View Source
var FileNINYml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x04\xff\x94\x55\x4b\x8b\xe4\x36\x10\xbe\xfb\x57\x7c\xd0\x04\x12\x98\xf6\xbb\x7b\xdc\x3e\x04\xc2\x9c\x16\xc2\x1c\x76\x97\xbd\x2c\xcb\x50\x96\xcb\x6d\x65\x6d\xc9\x48\xf2\x3c\xf2\xeb\x83\x64\x77\xbb\x67\x21\x1b\xd2\x87\x46\xae\xfa\xea\xab\x97\xaa\xa4\x68\xe4\x1a\x8f\xec\x5e\xb4\xf9\x0e\xa9\xae\xc7\x1d\xbc\x0a\xba\xc3\x9b\x9e\x0d\x46\xdd\xf2\x10\x75\x86\x46\xf6\xc8\x3a\x42\xd0\xd7\x78\xa0\xae\x63\xec\x70\x55\xa1\xd3\x06\xae\xe7\xd5\x04\x78\x66\x63\xa5\x56\x35\xb2\x38\x7d\x07\x5c\x15\x10\x5a\x39\x43\x52\xb9\x68\x95\x5c\xa0\xeb\x27\xa4\xea\xb4\x19\xc9\x49\xed\xcf\xb0\x3c\x92\x72\x52\x5c\xf5\x8b\x36\xf2\x3c\x24\x15\x9b\x1a\xbb\x40\x1a\x3e\x2c\x66\xcb\x2d\x9c\xc6\xc4\xc6\x23\x97\xc0\x30\x19\x6e\xa5\xf0\x9c\x11\xb6\xdf\x0e\xe3\x3c\x38\x39\x0d\x8c\x69\x20\xe7\xf1\x16\x82\x14\x1a\x86\x9d\x58\xc8\x4e\x72\x1b\x01\x34\xb6\xc7\xd2\x57\x01\x38\x4f\x73\x0d\x43\x72\x32\xfa\x2f\x16\x2e\x11\x64\xc6\x61\x3f\xbe\x2a\x76\x75\x80\xed\xc5\x34\x07\x1f\xe2\x3f\x91\xe7\x80\x9c\x26\x71\x2c\x07\x5e\xe8\x7f\x66\xb4\x02\x57\xb3\x9f\x87\x72\x8b\x6d\xd9\x0a\x23\x27\x9f\x7c\x8d\xdf\x23\xe0\x73\x2f\xed\x5a\x17\x69\x41\xbe\x38\xa1\x25\xdc\xae\x52\xad\xf0\xe1\xcf\x4f\x5f\x3e\x3e\xe4\x69\x96\x7f\xcd\xbe\xa1\x25\x47\x96\x5d\x1c\x01\x1f\x5c\x30\x6a\x06\xf6\x55\x26\xd1\x4b\x7e\x66\x1c\xaa\xb8\xfa\x05\x9f\xf5\xb4\xcf\xf0\x87\x10\xb3\x21\xf1\x06\x52\x2d\xaa\x2c\x2e\x16\xc5\x01\x74\x51\xbc\xe3\xdf\x7f\xa1\x41\xb6\x4b\xbf\x3f\x79\x1f\x86\x3b\x36\xac\x04\x5b\xdf\xda\xed\xcb\xfb\x9b\x68\x62\x63\x91\xe0\x85\x1b\x2b\x1d\xfb\x23\x3b\x11\xc7\x58\xb2\x6c\xa4\x3a\xbf\xbb\x8f\x7b\xf4\xce\x4d\xb6\x4e\x92\xb3\xb4\x2e\x3e\x4b\xd7\xcf\x4d\x2c\xf4\x98\x8c\xf4\xcc\x6a\x90\x2a\x69\xab\x34\xa7\x43\x55\x9e\x5a\x2e\x4e\x79\x7e\x68\x84\x38\x46\xb8\xb1\x24\xf3\x2a\x9f\x63\x6d\xce\x09\x35\x36\xc9\x8a\x2c\x8f\xcb\x32\x4d\xa3\x1d\x06\x29\x58\xd9\x30\x38\xdb\x10\xac\xc2\x1a\x4a\xab\xbd\xd0\xe3\xc8\x46\x48\x1a\xa2\x1d\xa4\x9a\x66\x17\xf2\xd8\xd0\x8b\xcc\x77\x7f\x87\x4e\x1a\xeb\x16\x14\xdc\xdb\xc4\xf8\x71\xba\xf6\x41\x5c\x43\x8e\x74\xe6\x70\xcb\x76\x6b\xe2\xa1\xbd\x7e\x80\x3d\xf3\x0d\x4f\x00\x2d\xb5\x09\x90\x3a\x00\x82\xd3\x1b\x96\x89\xfc\xac\x3b\x36\xa1\xe4\xc1\xf5\x26\x0a\x14\x40\x2b\x47\x56\x7e\xb6\x6d\x8d\xaf\xc5\x1d\xf2\xbc\x0c\x7f\xdf\x56\xfd\xc8\xa4\x6a\x7c\xcd\xf2\xe2\x0e\x59\x76\x7f\x87\x2c\x2d\xbf\x45\x7a\x76\xd3\xec\x96\xf4\x7c\x68\x81\x5b\x77\xe1\xbc\xe8\x22\x04\x61\x8d\x8e\xc9\xcd\xc6\xa7\xb5\x03\xdd\xc6\xfc\x1e\xbf\x45\x16\xe1\x16\xb5\x64\xb6\x70\x62\xa0\x86\x87\x08\x1b\x36\x54\x18\xd8\x05\x5f\x37\xe2\x10\xfc\xea\xd9\x3e\xcd\x66\xa8\xc3\x85\xa9\x93\xc4\x16\x31\x8d\xf4\xb7\x56\xf4\x62\xc3\x85\xb1\x4e\x1b\x8e\xc3\xc0\x87\xcb\x60\xdf\x94\x65\x67\x93\xd0\x0c\xc5\x6e\x15\xc4\xee\xd5\xe7\x84\x8d\x55\xf4\x2c\xbe\xdb\x79\xac\x51\xb6\x79\x51\x36\x87\xaa\x28\x48\x50\x59\x9e\xf2\x2a\x3d\x1e\x28\xab\xd2\xb6\x29\xd2\xec\x48\x51\xd8\xbc\xfe\xda\x5f\xd6\xcf\x65\x50\xcf\x86\xa6\x3e\x4c\xd4\x0b\xcb\x73\xef\x2c\x0c\x5b\x3d\x1b\xc1\x3e\x85\x86\x2c\xff\xbf\xe0\x83\x23\x9b\x08\xbf\xd0\x13\x25\xfd\x5a\x0c\x2e\x9e\x26\x72\x7d\x8d\x96\xa7\x41\xbf\xc5\x93\xd1\x4e\x2f\xf9\xac\x6e\x57\xbd\x92\xea\xe9\x92\x77\x1c\x48\x02\x61\x04\x48\xfb\x44\x46\xf4\xf2\xd9\x77\x94\x06\xeb\x9f\x0b\xd9\xc1\xb2\xbb\xf3\x4d\x57\xfe\xef\x1a\x6f\x58\x25\x98\xcd\xe0\x67\x9b\x14\x56\xcb\xd0\x94\x1f\x7f\xbb\x60\xb9\x05\x79\x5b\x8c\x10\x95\xd7\x2b\xb4\xac\xb4\x63\x7f\xfe\x17\x96\x4e\x0e\x1c\x9e\x33\x7b\xb9\x57\x81\xf3\x96\x0e\x2f\xd2\xf5\x72\x09\x75\x0b\x29\xc0\x6e\x9a\x59\x89\xfb\xf2\x94\x1e\x8e\x9c\x89\xa2\xac\x32\xce\xb2\xaa\xbd\xcf\x4e\x54\x14\x65\xc9\x87\x53\x1a\x01\x97\xa2\x6d\x37\xa0\x39\x1c\xab\xd3\xa1\x12\x69\x2b\xba\xac\x3d\xdd\x8b\x46\x74\x5d\x29\xf2\xbc\x49\x73\xca\x1b\x8e\xc8\x39\x23\x9b\xd9\x2d\xdb\x8f\x5f\x9d\x21\xa8\xf5\xc5\xde\x74\x11\xf0\x5d\xaa\xb6\xc6\xc3\xe3\xe3\x5a\x19\xff\xed\x33\x52\x3c\x1b\x1a\xae\x36\xbf\x3e\x3c\x3e\xde\xe1\xa3\xff\x8b\xe3\xf8\x37\x3f\x6d\xfe\xf9\x95\xea\xfc\xb4\x6e\xf5\x1a\x1f\xfc\x3a\x79\x64\xe7\xb7\xc9\xb2\xe9\xaf\xcf\x68\xd8\x40\xab\x41\x04\x8c\xa4\x64\xc7\xd6\x3d\xd1\xec\x7a\x6d\x6a\x50\xd3\xce\x43\x1b\xfd\x13\x00\x00\xff\xff\x60\x55\x08\x74\x5a\x08\x00\x00")

FileNINYml is "/NIN.yml"

View Source
var FileResNeXt10132x4dYml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x04\xff\xac\x56\xcd\x6e\xe4\xb8\x11\xbe\xeb\x29\x0a\xee\xcb\x0c\xd0\x96\xfa\xdf\xb6\x0e\x01\x12\x67\x0e\x01\x32\xce\x60\x10\x04\x01\x06\x41\xa3\x44\x96\x24\xc6\x14\x29\x90\x25\xb7\x7b\x4e\xf3\x20\xc9\xcb\xcd\x93\x04\x45\xc9\xdd\x6d\x67\x77\x76\x17\x58\x1d\x04\x89\x55\xac\xdf\xef\x2b\xd2\x61\x47\x25\x7c\xa6\xf8\x40\xff\xe4\xe5\x62\x79\xbd\x5e\x3d\x6f\x34\xcc\x40\x04\xe0\x6b\x38\xfa\x21\x40\xe7\x35\xd9\xac\x0e\xd8\xd1\xc1\x87\xc7\x32\x83\x24\x2f\xe1\x1e\xeb\x9a\x60\x06\x27\x11\xd4\x3e\x00\xb7\x34\x6d\x01\x78\xa2\x10\x8d\x77\x25\x2c\xf3\xc5\x2b\xc5\x49\x00\xca\x3b\x0e\x68\x1c\x67\xd3\xca\x8b\xea\xf4\x0b\xc6\xd5\x3e\x74\xc8\xc6\xcb\x37\x44\xea\xd0\xb1\x51\x27\xf9\x28\xcd\xc4\x0e\x1a\x47\xa1\x84\x59\x32\x9a\x7e\x22\x0c\x91\x34\xb0\x87\x9e\x82\x68\x8e\x81\x41\x1f\x48\x1b\x25\x36\x33\x38\x3f\x33\xe8\x06\xcb\xa6\xb7\x04\xbd\x45\x16\xfd\x08\x0a\x1d\x54\x04\xb1\x27\x65\x6a\x43\x3a\x03\xc0\x4e\xef\x36\x52\x05\x80\xa6\x1f\x4a\x08\x68\xfa\xe0\xff\x4d\x8a\x0b\x85\xa1\xb3\xd7\x4a\xea\x52\x26\xb5\x6b\xd5\x0f\xc9\x87\xfa\x45\xcd\x26\x69\xf6\xbd\xda\x6d\x2c\x8d\xe6\x7f\xb4\x69\x52\x9c\xb6\xfd\x38\x94\x4b\x5d\x4d\x51\x05\xd3\x4b\xf2\x25\xfc\x21\x83\x97\xf6\x83\x89\x80\x10\x4d\xd7\x5b\x9a\x43\x6b\x9a\xd6\x1e\xa5\x5c\x83\xc5\x60\xbe\x92\x06\x47\x2c\xed\x07\x0c\xaa\x35\x4c\x8a\x87\x40\x52\x7e\x30\x1d\x36\x04\xca\x62\x8c\xa6\x36\x2a\xf5\x2a\x87\xbf\x0d\xe1\xb4\xc5\x44\xe9\x49\xe4\x30\x28\x26\x0d\xd5\x11\x02\xf5\x84\x6c\x5c\x23\xf5\x84\x6a\x30\x56\x1b\xd7\x40\x65\xbd\x7a\x04\x6e\x91\x01\x9b\x26\x50\x83\x4c\x29\x2c\x62\x81\x23\x07\x74\x51\xfa\x92\x7c\x44\x38\x18\x6e\x13\xde\x22\x76\x04\xec\x7b\x6f\x7d\x73\x1c\x7d\x8f\x99\x80\xa6\x68\x1a\x07\x81\xe2\x60\x39\x82\x71\x80\xd0\xfa\xce\x37\xe4\xc8\x0f\x71\x9e\xc1\xd8\xf5\xeb\x2a\xa0\x53\xed\xeb\xec\x52\x20\x2d\x46\xf0\xce\x1e\x01\xa1\xa6\x03\xb4\xc7\x9e\xc2\x75\x8f\x01\x3b\x62\x0a\x51\xd0\x15\x89\x73\xf8\x7b\x6b\x22\x44\x0e\xc8\xd4\x1c\x81\x9e\x7b\x1f\x53\xec\x8e\x0e\xa0\x4d\x47\x4e\x98\x30\x87\x43\x6b\x54\x0b\x07\x02\x85\xd6\x66\x00\xdf\xbf\xfd\x47\x61\xd0\xc6\xa1\x35\x7c\xfc\xfe\xed\xbf\xf0\x4e\x18\x14\xcd\xd7\xc4\xc0\xf4\xfd\x93\xd9\xbf\x9f\x03\x46\x40\x07\x14\x23\x39\x36\x68\xa1\x46\xc5\x3e\xa4\x24\xb5\x36\xd2\x62\x89\x4e\x4c\x9c\x02\x88\x52\x47\x4d\x3d\xb7\x80\x4e\xc3\xc1\x68\x6e\xf3\x2c\x50\x4d\x81\x9c\xa2\x28\xfc\x39\xff\xc9\xf6\x1e\x7b\x49\xb3\x80\x03\x55\xd1\x48\x3f\x0a\x20\x56\x79\x2e\xb5\x55\xc1\x54\xd2\x38\xf1\x31\xce\x09\x80\x6b\x68\x99\xfb\x58\x16\x45\x63\xb8\x1d\xaa\x5c\xf9\xae\x88\x9e\xf0\x89\x42\x91\xb8\x71\x9d\x54\x0b\x0e\x44\x45\x87\x91\x65\xdd\xc6\x9f\xdb\x5a\xa3\xa2\xca\xfb\xc7\x40\x91\x04\x7c\xc5\x34\xb0\x7e\xab\x7e\x51\x59\x5f\xbd\xf8\xd3\xc8\x18\x89\x63\xf1\xf9\xc3\x1f\xff\xfc\xf1\x43\xde\xe9\x6c\x06\xd6\x28\x72\xf1\x54\xf7\x14\x65\x36\x2d\x96\x30\xb8\x40\x91\x83\x11\x0c\x67\x33\x30\xae\x1f\x38\x55\xe8\x9c\xfc\xb8\x26\xe4\x9d\x41\x6d\x42\xe4\x51\x0b\xf8\xd8\x8f\x5c\x39\xab\x4a\x9d\x64\xb9\x1c\xf9\x93\x86\xc4\x6c\x2a\x69\x62\xa7\x34\x4a\xd4\x2f\xec\x24\xa5\x57\x04\x16\x85\xe4\xf4\xc2\xca\x19\x9b\xd2\x4c\xf1\x71\xb1\x94\x4c\xc0\x05\x1e\x4a\xf8\xb2\x9e\xc3\x6a\xb5\x49\xaf\x7f\x4d\xf2\x8e\xd0\x95\xf0\x65\xb9\x5a\xe7\xbb\x9b\xed\x1c\x96\xcb\x5d\xbe\xba\x9d\xc3\x72\xb1\xce\xb7\xab\x17\xad\xa8\xd0\x52\x09\xab\xed\x2e\xf3\x03\xf7\x03\x8f\x99\x4b\x50\xc9\xad\xaf\xd3\xf7\x28\xcb\x20\x2d\x96\x50\x13\xca\xec\xc8\x00\x66\x80\x97\xe9\xbc\xd6\x3f\x07\x9d\xc1\xa5\x56\x79\x61\x13\x2c\x56\x24\x2c\xba\xc8\x39\x65\x30\x4b\xbe\x2e\x96\xd3\xea\xe4\x39\xee\x87\x60\xcb\x84\xd2\xb2\x28\xe2\x3a\xc7\x0e\xbf\x7a\x87\x87\x38\x42\x95\x7d\xa0\x3c\x8d\xf2\xdc\x87\xa6\x88\x47\x97\x90\x92\xe6\x9c\x23\x9e\x16\x72\x7e\x96\x9c\xe0\x6c\x55\xb5\xa4\x1e\xe3\xd0\x95\xb0\xd1\xab\xf5\xa6\xda\xde\xae\xd7\xa8\x70\xb3\xb9\x5b\xdd\x2e\x76\x5b\x5c\xde\x2e\x74\xb5\x5e\x2c\x77\x98\x25\x68\x49\x7b\x5e\x0e\x96\x38\xa2\x0d\x9a\x80\xfd\x44\x4d\x32\x4d\xcb\x51\x46\x97\x1f\x82\x22\x49\x21\x49\xf7\x3d\x72\xfb\xeb\xc3\x4f\xae\xe2\x48\xbc\x22\x50\x74\xf4\x7c\x3e\xeb\x0b\x4d\xbd\xf5\xc7\xfd\xdb\xf5\xbd\xf3\x7b\x45\xc6\xee\x65\x77\xde\x07\xcf\x7e\x4c\x77\x8a\xea\x77\x8d\xe1\xad\xf3\x3c\x0d\x09\xf1\x2c\xad\x35\x71\x2f\xac\x37\x4f\x02\x1d\xb4\x91\x60\x06\xa6\x96\x99\x3b\x17\x24\x38\x79\x41\x85\x91\xa4\xab\x72\xd4\x20\x0c\xc1\xca\xe4\x42\x37\x8e\xf3\x27\xc1\xda\xff\x3f\xb3\xb4\xf3\x5c\xd2\x71\x20\x8e\x55\x4f\xf9\x89\xdc\x81\x26\xe7\x99\xe4\x3b\x61\xe8\xed\x23\x44\xb7\x94\x6e\x44\x69\xb6\x0a\xf8\x93\xcd\x4b\x73\xe9\xa4\x32\x63\xa8\x53\x32\x19\x8c\x6a\x17\xa8\x21\xb5\x50\xb7\xb4\xbd\xb9\x5d\x6c\x16\xaa\xaa\x6f\x76\x8b\xed\x4e\x53\xb5\x59\x56\xb8\xc0\xfa\x46\xee\x1e\x2f\xe1\x9d\xa1\xb6\xa5\x2d\xa9\xcd\x5d\xb5\x58\xe8\xbb\x7a\xb9\xd3\xcb\x0d\xaa\xdd\x76\xbb\xd5\xea\xee\x6e\x55\xab\x3a\x43\xe6\x60\xaa\x81\xc7\xd9\x4e\xcf\x1c\xf0\x74\x30\x9f\x65\x19\xc0\xa3\x71\xba\x84\xfb\x87\x87\xa9\x32\xf2\x2f\x94\x74\x34\x04\xb4\xa7\x3d\xef\xee\x1f\x1e\xe6\xf0\x59\x5e\x79\x9e\xbf\x17\x5a\xcb\x0d\xce\xb8\x66\x3f\x0d\xd5\x12\xfe\x22\x57\x82\x07\x62\x99\x68\xe3\xa0\x3d\xdd\xc4\xd2\x15\x71\xda\x20\x87\x2f\x3a\x53\x53\xe4\x3d\x0e\xdc\xfa\x50\x02\x56\x7a\xb0\x32\x5f\x5b\xa3\x35\x09\xdb\xc3\x20\x2d\xff\x48\x31\x62\x43\x23\xaf\xaf\x12\x42\xf2\x4f\xde\x5b\xe3\x9a\x4f\x2f\x87\xf1\x55\x3a\xac\x9d\x87\xda\x90\xd5\xa9\x27\x1a\xae\x4e\x38\xbe\xca\x66\x89\xf4\x6f\x8e\xa6\x3f\xfd\xe3\xaf\xf7\x13\x3d\xfa\xc1\xda\x62\xbd\xd8\xde\x14\xb5\xb1\x14\xb3\xff\x05\x00\x00\xff\xff\x33\x59\x1f\xd0\x21\x0b\x00\x00")

FileResNeXt10132x4dYml is "/ResNeXt101-32x4d.yml"

View Source
var FileResNeXt2632x4dPrivYml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x04\xff\xac\x56\xcd\x6e\xdb\xc6\x13\xbf\xf3\x29\x06\xd6\x25\x01\x24\x52\x5f\x96\x6d\x1e\xfe\x87\xbf\x4f\x05\x5a\x37\x08\x8a\xa2\x40\x50\x08\xc3\xdd\x21\xb9\xf5\x72\x97\xd8\x1d\x5a\x56\x4e\x79\x90\xf6\xe5\xf2\x24\xc5\x2c\x69\x49\x4e\x83\xa4\x87\xea\x20\x90\x33\xb3\xb3\xf3\xf1\xfb\xcd\xd0\x61\x47\x25\xbc\xa7\xf8\x40\xbf\xf1\x7a\xb7\xd8\xac\x9f\xb7\x1a\x66\x20\x72\xf0\x35\x1c\xfd\x10\xa0\xf3\x9a\x6c\x56\x07\xec\xe8\xe0\xc3\x63\x99\x41\xd2\x97\x70\x8f\x75\x4d\x30\x83\x93\x0a\x6a\x1f\x80\x5b\x9a\x8e\x00\x3c\x51\x88\xc6\xbb\x12\x56\xf9\xf2\x95\xe1\xa4\x00\xe5\x1d\x07\x34\x8e\xb3\x49\xf2\x62\x3a\xbd\x82\x71\xb5\x0f\x1d\xb2\xf1\xf2\x0c\x91\x3a\x74\x6c\xd4\x49\x3f\x6a\x33\xf1\x83\xc6\x51\x28\x61\x96\x9c\xa6\x97\x08\x43\x24\x0d\xec\xa1\xa7\x20\x96\x63\x60\xd0\x07\xd2\x46\x89\xcf\x0c\xce\xbf\x19\x74\x83\x65\xd3\x5b\x82\xde\x22\x8b\x7d\x04\x85\x0e\x2a\x82\xd8\x93\x32\xb5\x21\x9d\x01\x60\xa7\x77\x5b\xa9\x02\x40\xd3\x0f\x25\x04\x34\x7d\xf0\x7f\x90\xe2\x42\x61\xe8\xec\x42\x49\x5d\xca\x64\xb6\x50\xfd\x90\xee\x50\xdf\xb5\x6c\x92\x65\xdf\xab\xdd\xd6\xd2\xe8\xfe\x5b\x87\x26\xc3\xe9\xd8\xb7\x43\xb9\xb4\xd5\x14\x55\x30\xbd\x24\x5f\xc2\xff\x32\x78\xe9\x3e\x98\x08\x08\xd1\x74\xbd\xa5\x39\xb4\xa6\x69\xed\x51\xca\x35\x58\x0c\xe6\x23\x69\x70\xc4\xd2\x7e\xc0\xa0\x5a\xc3\xa4\x78\x08\x24\xe5\x07\xd3\x61\x43\xa0\x2c\xc6\x68\x6a\xa3\x52\xaf\x72\xf8\x79\x08\xa7\x23\x26\x4a\x4f\x22\x87\x41\x31\x69\xa8\x8e\x10\xa8\x27\x64\xe3\x1a\xa9\x27\x54\x83\xb1\xda\xb8\x06\x2a\xeb\xd5\x23\x70\x8b\x0c\xd8\x34\x81\x1a\x64\x4a\x61\x11\x0b\x1c\x39\xa0\x8b\xd2\x97\x74\x47\x84\x83\xe1\x36\xe1\x2d\x62\x47\xc0\xbe\xf7\xd6\x37\xc7\xf1\xee\x31\x13\xd0\x14\x4d\xe3\x20\x50\x1c\x2c\x47\x30\x0e\x10\x5a\xdf\xf9\x86\x1c\xf9\x21\xce\x33\x18\xbb\xbe\xa8\x02\x3a\xd5\xbe\xce\x2e\x05\xd2\x62\x04\xef\xec\x11\x10\x6a\x3a\x40\x7b\xec\x29\x2c\x7a\x0c\xd8\x11\x53\x88\x82\xae\x48\x9c\xc3\x2f\xad\x89\x10\x39\x20\x53\x73\x04\x7a\xee\x7d\x4c\xb1\x3b\x3a\x80\x36\x1d\x39\x61\xc2\x1c\x0e\xad\x51\x2d\x1c\x08\x14\x5a\x9b\x01\x7c\xfe\xf4\xa7\xc2\xa0\x8d\x43\x6b\xf8\xf8\xf9\xd3\x5f\xf0\x46\x18\x14\xcd\xc7\xc4\xc0\xf4\xfc\xd5\xec\xdf\xce\x01\x23\xa0\x03\x8a\x91\x1c\x1b\xb4\x50\xa3\x62\x1f\x52\x92\x5a\x1b\x69\xb1\x44\x27\x2e\x4e\x01\x44\xa9\xa3\xa6\x9e\x5b\x40\xa7\xe1\x60\x34\xb7\x79\x16\xa8\xa6\x40\x4e\x51\x14\xfe\x9c\xdf\xe4\x78\x8f\xbd\xa4\x59\xc0\x81\xaa\x68\xa4\x1f\x05\x10\xab\x3c\x97\xda\xaa\x60\x2a\x69\x9c\xdc\x31\xce\x09\x80\x05\xb4\xcc\x7d\x2c\x8b\xa2\x31\xdc\x0e\x55\xae\x7c\x57\x44\x4f\xf8\x44\xa1\x48\xdc\x58\x24\xd3\x82\x03\x51\xd1\x61\x64\x91\xdb\xf8\xbd\xa3\xfd\x91\x7d\x50\xed\xe2\x35\xd2\xb2\x19\x58\xa3\xc8\xc5\x53\xb9\x92\xf3\x6c\x12\x96\x30\xb8\x40\x91\x83\x11\xe8\x65\x33\x30\xae\x1f\x38\x25\x76\x8e\x79\x94\x09\xe7\x66\x50\x9b\x10\x79\xb4\x02\x3e\xf6\x23\xc4\xcf\xa6\x92\x9e\x88\xcb\x11\xf6\x89\xdb\xb3\xa9\x12\x89\x54\x52\x5f\x31\xbf\xf0\x93\x8c\x5e\xf1\x4e\x0c\xd2\xa5\x17\x5e\xce\x90\x92\x1e\xc8\x1d\x17\xa2\xe4\x02\x2e\xda\x58\xc2\x87\xcd\x1c\xd6\xeb\x6d\xfa\xfb\x7d\xd2\x77\x84\xae\x84\x0f\xab\xf5\x26\xdf\xdd\x5c\xcf\x61\xb5\xda\xe5\xeb\xdb\x39\xac\x96\x9b\xfc\x7a\xfd\x62\x15\x15\x5a\x2a\x61\x7d\xbd\xcb\xfc\xc0\xfd\xc0\x63\xe6\x12\x54\xba\xd6\xd7\xe9\x79\xd4\x65\x90\x84\x25\xd4\x84\x42\xf9\x0c\x60\x06\x78\x99\xce\x6b\xfb\x73\xd0\x19\x5c\x5a\x95\x17\x3e\xc1\x62\x45\x02\xfe\x8b\x9c\x53\x06\xb3\x74\xd7\x85\x38\x49\xa7\x9b\xe3\x7e\x08\xb6\x4c\xe0\x2a\x8b\x22\x6e\x72\xec\xf0\xa3\x77\x78\x88\x23\xc2\xd8\x07\xca\xd3\x04\xce\x7d\x68\x8a\x78\x74\x91\x38\x16\x69\x3c\x39\xe2\x49\x90\xf3\xb3\xe4\x04\x67\xaf\xaa\x25\xf5\x18\x87\xae\x84\xad\x5e\x6f\xb6\xd5\xf5\xed\x66\x83\x0a\xb7\xdb\xbb\xf5\xed\x72\x77\x8d\xab\xdb\xa5\xae\x36\xcb\xd5\x0e\xb3\x04\x2d\x69\xcf\xcb\x3e\x88\x23\xda\xa0\x09\xd8\x4f\x8c\x22\xd3\xb4\x1c\x65\xe2\xf8\x21\x28\x92\x14\x92\x76\xdf\x23\xb7\xff\x3e\xfc\x74\x55\x1c\xf9\x52\x04\x8a\x8e\x9e\x4f\x1b\x7a\xd1\x07\xf3\x54\x68\xea\xad\x3f\xee\xbf\xa6\xdb\x3b\xbf\x57\x64\xec\x5e\xbc\xe4\x7d\xf0\xec\xc7\xb4\xa7\xe8\xfe\xf3\x58\xbe\x16\x44\x9e\xb8\x2e\x11\x48\xab\x4d\xdc\xa7\xcd\xf1\x24\x50\x42\x1b\x09\x66\x60\x6a\x19\x9d\x73\x41\x86\x93\x3f\xa8\x30\x92\x74\x59\x36\x06\xc2\x10\xac\x0c\x20\x74\xe3\x54\x7e\x12\xec\xfd\xf3\x37\x4b\x27\xcf\x25\x1e\xe7\xda\xd8\x85\x94\xa7\xe8\x1d\x68\x72\x9e\x49\x9e\x13\xa6\xbe\xfc\x09\xf1\x2d\xa5\x0f\x9b\x34\x22\x85\x0c\xc9\xe7\xa5\xbb\xb4\x70\xcc\x18\xea\x94\x4c\x06\xa3\xd9\x05\x8a\xb4\xa6\x2d\xd6\xdb\xfa\xee\x6e\x53\x2d\x75\xb5\x53\x77\xd5\x4e\xd7\xa4\x6e\x6b\xb5\xa1\xdd\xea\x3a\x03\x78\x09\xef\x0c\x3d\x5c\xe9\x65\x7d\xb3\x5b\x6d\x6e\xd4\x76\x75\xb7\x45\xdc\xae\xee\x6e\x75\xbd\xc1\xdd\x4d\x5d\xd7\xeb\x5d\x86\xcc\xc1\x54\x03\x8f\x23\x9a\x9e\x39\xe0\x69\xbf\x9e\x75\x19\xc0\xa3\x71\xba\x84\xfb\x87\x87\xa9\x32\xf2\x2e\x14\x75\x34\x04\xb4\xa7\x33\x6f\xee\x1f\x1e\xe6\xf0\x5e\xfe\xf2\x3c\x7f\x2b\x34\x97\x0f\x31\xe3\x9a\xbd\x46\xc6\x48\x5c\xc2\x0f\xb2\xd9\x1f\x88\x65\xc2\x8d\xb2\xd3\x07\x55\xfa\xd2\x9b\x0e\xc8\x0e\x45\x67\x6a\x8a\xbc\xc7\x81\x5b\x1f\x4a\xc0\x4a\x0f\x56\xe6\x6d\x6b\xb4\x26\x61\x7f\x18\xa4\xe5\x3f\x51\x8c\xd8\xd0\xc8\xf3\xab\x84\x90\xfc\x9d\xf7\xd6\xb8\xe6\xdd\xcb\x4e\xbd\x4a\x3b\xd7\x79\xa8\x0d\x59\x9d\x7a\xa2\xe1\xea\x84\xe7\xab\x6c\x96\x86\xc0\x17\x1b\xe6\xff\xbf\xfe\x78\x3f\xd1\xa5\x1f\xac\x2d\x36\xcb\xeb\x9b\xa2\x36\x96\x62\xf6\x77\x00\x00\x00\xff\xff\x81\xe6\xf7\x19\xe7\x0a\x00\x00")

FileResNeXt2632x4dPrivYml is "/ResNeXt26-32x4d-priv.yml"

View Source
var FileResNeXt5032x4dYml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x04\xff\xac\x56\xcd\x6e\xe4\xb8\x11\xbe\xeb\x29\x0a\xee\xcb\x0c\xd0\x96\xfa\xdf\xb6\x0e\x01\x12\x67\x0e\x01\x32\xce\x60\x10\x04\x01\x06\x41\xa3\x44\x96\x24\xc6\x14\x29\x90\x25\xb7\x7b\x4e\xf3\x20\xc9\xcb\xcd\x93\x04\x45\xc9\xdd\x6d\x67\x77\x76\x17\x58\x1d\x04\xa9\x58\xac\xdf\xef\x2b\xd2\x61\x47\x25\x7c\xa6\xf8\x40\xff\xe4\xed\xe2\x7a\xbd\x7a\xde\x68\x98\x81\xc8\xc1\xd7\x70\xf4\x43\x80\xce\x6b\xb2\x59\x1d\xb0\xa3\x83\x0f\x8f\x65\x06\x69\xbd\x84\x7b\xac\x6b\x82\x19\x9c\x96\xa0\xf6\x01\xb8\xa5\x69\x0b\xc0\x13\x85\x68\xbc\x2b\x61\x99\x2f\x5e\x29\x4e\x0b\xa0\xbc\xe3\x80\xc6\x71\x36\x49\x5e\x54\xa7\x5f\x30\xae\xf6\xa1\x43\x36\x5e\xbe\x21\x52\x87\x8e\x8d\x3a\xad\x8f\xab\x99\xd8\x41\xe3\x28\x94\x30\x4b\x46\xd3\x4f\x84\x21\x92\x06\xf6\xd0\x53\x10\xcd\x31\x30\xe8\x03\x69\xa3\xc4\x66\x06\xe7\x67\x06\xdd\x60\xd9\xf4\x96\xa0\xb7\xc8\xa2\x1f\x41\xa1\x83\x8a\x20\xf6\xa4\x4c\x6d\x48\x67\x00\xd8\xe9\xdd\x46\xaa\x00\xd0\xf4\x43\x09\x01\x4d\x1f\xfc\xbf\x49\x71\xa1\x30\x74\xf6\x5a\x49\x5d\xca\xa4\x76\xad\xfa\x21\xf9\x50\xbf\xa8\xd9\x24\xcd\xbe\x57\xbb\x8d\xa5\xd1\xfc\x8f\x36\x4d\x8a\xd3\xb6\x1f\x87\x72\xa9\xab\x29\xaa\x60\x7a\x49\xbe\x84\x3f\x64\xf0\xd2\x7d\x30\x11\x10\xa2\xe9\x7a\x4b\x73\x68\x4d\xd3\xda\xa3\x94\x6b\xb0\x18\xcc\x57\xd2\xe0\x88\xa5\xfd\x80\x41\xb5\x86\x49\xf1\x10\x48\xca\x0f\xa6\xc3\x86\x40\x59\x8c\xd1\xd4\x46\xa5\x5e\xe5\xf0\xb7\x21\x9c\xb6\x98\x28\x3d\x89\x1c\x06\xc5\xa4\xa1\x3a\x42\xa0\x9e\x90\x8d\x6b\xa4\x9e\x50\x0d\xc6\x6a\xe3\x1a\xa8\xac\x57\x8f\xc0\x2d\x32\x60\xd3\x04\x6a\x90\x29\x85\x45\x2c\x70\xe4\x80\x2e\x4a\x5f\x92\x8f\x08\x07\xc3\x6d\xc2\x5b\xc4\x8e\x80\x7d\xef\xad\x6f\x8e\xa3\xef\x31\x13\xd0\x14\x4d\xe3\x20\x50\x1c\x2c\x47\x30\x0e\x10\x5a\xdf\xf9\x86\x1c\xf9\x21\xce\x33\x18\xbb\x7e\x5d\x05\x74\xaa\x7d\x9d\x5d\x0a\xa4\xc5\x08\xde\xd9\x23\x20\xd4\x74\x80\xf6\xd8\x53\xb8\xee\x31\x60\x47\x4c\x21\x0a\xba\x22\x71\x0e\x7f\x6f\x4d\x84\xc8\x01\x99\x9a\x23\xd0\x73\xef\x63\x8a\xdd\xd1\x01\xb4\xe9\xc8\x09\x13\xe6\x70\x68\x8d\x6a\xe1\x40\xa0\xd0\xda\x0c\xe0\xfb\xb7\xff\x28\x0c\xda\x38\xb4\x86\x8f\xdf\xbf\xfd\x17\xde\x09\x83\xa2\xf9\x9a\x18\x98\xbe\x7f\x32\xfb\xf7\x73\xc0\x08\xe8\x80\x62\x24\xc7\x06\x2d\xd4\xa8\xd8\x87\x94\xa4\xd6\x46\x5a\x2c\xd1\x89\x89\x53\x00\x51\xea\xa8\xa9\xe7\x16\xd0\x69\x38\x18\xcd\x6d\x9e\x05\xaa\x29\x90\x53\x14\x85\x3f\xe7\x3f\xd9\xde\x63\x2f\x69\x16\x70\xa0\x2a\x1a\xe9\x47\x01\xc4\x2a\xcf\xa5\xb6\x2a\x98\x4a\x1a\x27\x3e\xc6\x39\x01\x70\x0d\x2d\x73\x1f\xcb\xa2\x68\x0c\xb7\x43\x95\x2b\xdf\x15\xd1\x13\x3e\x51\x28\x12\x37\xae\x93\x6a\xc1\x81\xa8\xe8\x30\xb2\xc8\x6d\xfc\xb9\xad\x35\x2a\xaa\xbc\x7f\x0c\x14\x49\xc0\x57\x4c\xf3\xea\xb7\xea\x17\x95\xf5\xd5\x8b\x3f\x8d\x8c\x91\x38\x16\x9f\x3f\xfc\xf1\xcf\x1f\x3f\xe4\x9d\xce\x66\x60\x8d\x22\x17\x4f\x75\x4f\x51\x66\x93\xb0\x84\xc1\x05\x8a\x1c\x8c\x60\x38\x9b\x81\x71\xfd\xc0\xa9\x42\xe7\xe4\x47\x99\x90\x77\x06\xb5\x09\x91\x47\x2d\xe0\x63\x3f\x72\xe5\xac\x2a\x75\x12\x71\x39\xf2\x27\x0d\x89\xd9\x54\xd2\xc4\x4e\x69\x94\xa8\x5f\xd8\x49\x4a\xaf\x08\x2c\x0a\xc9\xe9\x85\x95\x33\x36\xa5\x99\xe2\xe3\x42\x94\x4c\xc0\x05\x1e\x4a\xf8\xb2\x9e\xc3\x6a\xb5\x49\xaf\x7f\x4d\xeb\x1d\xa1\x2b\xe1\xcb\x72\xb5\xce\x77\x37\xdb\x39\x2c\x97\xbb\x7c\x75\x3b\x87\xe5\x62\x9d\x6f\x57\x2f\x5a\x51\xa1\xa5\x12\x56\xdb\x5d\xe6\x07\xee\x07\x1e\x33\x97\xa0\x92\x5b\x5f\xa7\xef\x71\x2d\x83\x24\x2c\xa1\x26\x94\xd9\x91\x01\xcc\x00\x2f\xd3\x79\xad\x7f\x0e\x3a\x83\x4b\xad\xf2\xc2\x26\x58\xac\x48\x58\x74\x91\x73\xca\x60\x96\x7c\x5d\x88\x93\x74\xf2\x1c\xf7\x43\xb0\x65\x42\x69\x59\x14\x71\x9d\x63\x87\x5f\xbd\xc3\x43\x1c\xa1\xca\x3e\x50\x9e\x46\x79\xee\x43\x53\xc4\xa3\x4b\x48\x49\x73\xce\x11\x4f\x82\x9c\x9f\x25\x27\x38\x5b\x55\x2d\xa9\xc7\x38\x74\x25\x6c\xf4\x6a\xbd\xa9\xb6\xb7\xeb\x35\x2a\xdc\x6c\xee\x56\xb7\x8b\xdd\x16\x97\xb7\x0b\x5d\xad\x17\xcb\x1d\x66\x09\x5a\xd2\x9e\x97\x83\x25\x8e\x68\x83\x26\x60\x3f\x51\x93\x4c\xd3\x72\x94\xd1\xe5\x87\xa0\x48\x52\x48\xab\xfb\x1e\xb9\xfd\xf5\xe1\x27\x57\x71\x24\x5e\x11\x28\x3a\x7a\x3e\x1d\xf5\x85\xa6\xde\xfa\xe3\xfe\x8d\x78\xef\xfc\x5e\x91\xb1\x7b\xd9\x9b\xf7\xc1\xb3\x1f\x93\x9d\x62\xfa\x3d\x23\x78\xe3\x3a\x4f\x03\x42\xfc\x4a\x5b\x4d\xdc\x0b\xe3\xcd\x93\xc0\x06\x6d\x24\x98\x81\xa9\x65\xde\xce\x05\x05\x4e\x5e\x50\x61\x24\xe9\xa8\x1c\x33\x08\x43\xb0\x32\xb5\xd0\x8d\xa3\xfc\x49\x70\xf6\xff\xcf\x2c\xed\x3c\x97\x73\x1c\x86\x63\xc5\x53\x76\xb2\xee\x40\x93\xf3\x4c\xf2\x9d\xf0\xf3\xf6\x11\x92\x5b\x4a\xb7\xa1\x34\x57\x05\xf8\xc9\xe6\xa5\xb9\x74\x4a\x99\x31\xd4\x29\x99\x0c\x46\xb5\x0b\xc4\x54\xea\x66\xb9\x59\x6f\xeb\xc5\x66\xa9\x6f\xea\x3b\xaa\xb6\x9b\xd5\x8a\x6e\xf5\xdd\x6e\x53\x2d\xb5\x5e\x67\x00\x2f\xe1\x9d\x61\xa6\x6f\x2a\xbc\xb9\x59\x2f\xb7\x3b\xbd\xbb\xd3\xba\x5a\xde\xde\x21\xd6\xbb\xcd\x7a\xbd\xdd\x55\x77\x6a\x9b\x21\x73\x30\xd5\xc0\xe3\x5c\xa7\x67\x0e\x78\x3a\x94\xcf\x6b\x19\xc0\xa3\x71\xba\x84\xfb\x87\x87\xa9\x32\xf2\x2f\x74\x74\x34\x04\xb4\xa7\x3d\xef\xee\x1f\x1e\xe6\xf0\x59\x5e\x79\x9e\xbf\x17\x4a\xcb\xed\xcd\xb8\x66\x3f\x0d\xd4\x12\xfe\x22\xd7\x81\x07\x62\x99\x66\xe3\x90\x3d\xdd\xc2\xd2\xf5\x70\xda\x20\x07\x2f\x3a\x53\x53\xe4\x3d\x0e\xdc\xfa\x50\x02\x56\x7a\xb0\x32\x5b\x5b\xa3\x35\x09\xd3\xc3\x20\x2d\xff\x48\x31\x62\x43\x23\xa7\xaf\x12\x42\xf2\x4f\xde\x5b\xe3\x9a\x4f\x2f\x07\xf1\x55\x3a\xa8\x9d\x87\xda\x90\xd5\xa9\x27\x1a\xae\x4e\x28\xbe\xca\x66\x89\xf0\x6f\x8e\xa5\x3f\xfd\xe3\xaf\xf7\x13\x35\xfa\xc1\xda\x62\xbd\xd8\xde\x14\xb5\xb1\x14\xb3\xff\x05\x00\x00\xff\xff\xb6\x22\xf2\x4e\x1c\x0b\x00\x00")

FileResNeXt5032x4dYml is "/ResNeXt50-32x4d.yml"

View Source
var FileResNet101V2Yml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x04\xff\xac\x56\x5b\x8b\xeb\xc8\x11\x7e\xd7\xaf\x28\x30\x81\x04\x66\x24\x5f\xc7\x1e\x3d\x04\x36\x27\x70\x08\x84\x09\x9c\x84\xcd\xc3\xb2\x0c\xa5\x56\xc9\xea\x4c\xab\xbb\xe9\x2a\xd9\xe3\xfd\xf5\xa1\x5a\x1a\xdb\xb3\xcb\x6e\xf2\xb0\x7e\x30\xea\xba\xd7\x57\x97\x6e\x8f\x03\xd5\xf0\x8d\xf8\x85\x64\xb5\x5c\xc1\x02\x94\x02\xa1\x83\x4b\x18\x13\x0c\xa1\x25\x57\x74\x09\x07\x3a\x87\xf4\x56\x17\x90\xf9\x35\x7c\xc1\xae\x23\x58\xc0\x95\x05\x5d\x48\x20\x3d\xcd\x2a\x00\x27\x4a\x6c\x83\xaf\x61\x55\x2e\x3f\x09\xce\x0c\x30\xc1\x4b\x42\xeb\xa5\x98\x29\x35\xac\xb3\xe8\x7c\x04\xeb\xbb\x90\x06\x14\x1b\xf4\x1b\x98\x06\xf4\x62\xcd\x95\x3f\x71\x0b\xb5\x83\xd6\x53\xaa\x61\x91\x8d\xe6\x03\xc3\xc8\xd4\x82\x04\x88\x94\x54\x72\x0a\x0c\x62\xa2\xd6\x1a\xb5\x59\xc0\xed\xb7\x80\x61\x74\x62\xa3\x23\x88\x0e\x45\xe5\x19\x0c\x7a\x68\x08\x38\x92\xb1\x9d\xa5\xb6\x00\xc0\xa1\x7d\xda\x2a\x0a\x00\xc7\x38\xd6\x90\xd0\xc6\x14\xfe\x43\x46\x2a\x83\x69\x70\x8f\x46\x71\xa9\xb3\xd8\xa3\x89\x63\xf6\x61\xfe\xa7\xe4\x31\x4b\xc6\x68\x9e\xb6\x8e\x26\xf3\xbf\xa5\x34\x0b\xce\x6a\xbf\x1d\xca\xbd\x6c\x4b\x6c\x92\x8d\x9a\x7c\x0d\x7f\x2e\x00\xbe\xd3\xca\xdb\x76\x44\x07\x8e\x30\x79\xeb\x8f\x77\x15\x95\x00\x84\x4c\xb9\xaa\xb9\x52\xca\x0e\x1d\x78\x12\x6d\x06\x06\xe9\x51\x00\x13\x01\x8f\x0d\x8b\x16\x07\x9d\xbb\x40\x4b\x14\x49\x9b\x01\x3d\x48\x1f\x98\xa6\x52\xc4\x44\x27\x1b\x46\x76\x97\xb2\x00\xf8\x37\x01\xbd\x47\x67\x8d\x15\x77\x81\x44\x0a\xf9\xe8\x50\x26\x77\x0e\x2f\x94\x18\x90\x6f\x71\x25\x9a\x23\xed\x46\x9f\xeb\xc7\x70\xb6\xd2\xab\x2a\x25\xf2\x86\x34\x5e\x6d\xc0\xac\x0b\xd6\xc7\x51\xf8\x01\xac\x67\x21\x6c\x35\xee\x6b\x8a\xa3\x4f\x34\x2b\xb5\x37\x73\x73\x54\x31\x85\x93\x6d\x09\x4c\x18\x62\xa2\x9e\x3c\xdb\x13\x01\x0d\xd1\x26\x6b\xd0\x01\x29\x57\xdd\x71\x1f\xce\x8a\x48\x46\x41\x7a\x62\xba\xc5\x78\x85\x48\xd1\x21\x64\xab\x78\x04\x08\x51\xec\x60\x7f\xa2\x07\x40\xdf\xe6\xfe\x3a\xa2\xf5\x80\xc6\x8c\x09\xcd\x05\xba\x14\x06\x6d\x61\xb6\x2d\x25\x6c\xdc\x05\xac\x37\x49\x8b\xd0\x42\x4b\x51\x7a\x8d\xf1\x1f\x8a\x2a\xc1\xdf\x06\x3c\xd2\x0b\x09\xb4\x28\xc8\x24\x70\x26\xa0\x13\xba\x51\x31\xbc\x82\xe5\x49\x66\x9c\x70\xb2\xa0\x40\x8c\x51\xb1\x5a\xed\xd6\x13\x56\xfc\xf8\xf8\x78\x78\xff\x54\xb6\xef\xbf\x7e\x9d\x54\x9b\x51\x80\xc5\x3a\x07\x3d\x9e\x34\x5b\x17\xce\x94\x32\x38\x8e\xde\xad\xe4\x5a\x7e\xe7\x81\x3c\xd3\xd0\xb8\xbc\x39\x7e\x89\x05\x03\x9a\xde\xd2\x89\x18\x36\xe5\x6e\xff\x07\xa0\x94\x42\x82\xf0\xb3\x4c\x84\x58\x80\x49\x4a\xf8\x57\x6f\x59\x93\x18\x9d\xc0\x79\x16\x5b\xb1\xe8\x70\x1a\xba\xea\xfd\xfd\x9f\xdf\x7f\xfb\x02\xeb\xe5\x6a\x07\xc6\x21\xb3\xed\xac\x99\xd6\x85\x20\xbf\x95\xc5\xb5\xca\xac\xab\xe1\x76\xd2\xec\x23\x46\xed\xb0\x0a\xce\xd4\xb0\x15\x62\xa8\x80\xc4\x94\x25\x4c\x53\xd2\x68\xb2\xda\x4e\xd3\x0a\x04\x78\x84\x5e\x24\x72\x5d\x55\x47\x2b\xfd\xd8\x94\x26\x0c\x15\x07\xc2\x13\xa5\x2a\x8f\xfd\x63\x16\xad\x24\x11\x55\x03\xb2\x28\xdd\xf1\xaf\xa9\x9a\x84\x9d\x7c\xfd\xcb\x5f\xaf\x1f\x9f\x04\x31\xbd\xdb\x53\x19\xd2\xb1\xc2\x86\xab\xd5\x6e\xb5\x2e\x97\x9b\xcd\x61\x57\x2c\xc0\x59\xa3\x68\x6b\x21\x6f\xf1\xcd\xc4\x3a\xf7\x36\x4b\xb2\x46\xa8\x2d\x16\xf3\x18\x68\xc2\x37\xd9\x69\x34\x74\xcd\x2c\xa0\xb3\x89\x65\x92\x02\xb9\x44\xd2\xa5\x7a\x27\xaa\x69\x2b\xb9\x06\xab\xed\x96\xd7\xd9\x62\x46\x28\xea\x1e\xf9\x88\xe2\xce\x4e\x16\x9a\x40\xcc\x22\x75\xb6\x97\x9d\xde\x59\x89\x98\x70\x20\xa1\x94\x6b\xa3\x3e\xee\x48\xd9\x04\x40\x6b\x07\x1d\xbf\xe0\xb9\x86\x1f\x36\x0f\xb0\x5e\x6f\xf3\xdf\x8f\x33\x7f\x20\xf4\x35\xfc\xb0\x5a\xaf\xcb\xfd\x7e\xfd\x00\xab\xd5\xae\x7c\xde\xee\x1f\x60\xb5\x5c\x97\xcf\x87\x1f\x8b\x30\x4a\x1c\x65\xca\x54\xf3\xcf\x6e\x42\x97\xbf\x27\x5e\x01\x99\x58\x43\x47\x28\x63\xd2\x0c\x17\x79\x54\xae\x9b\xf2\xb3\xfc\x2d\xc8\x02\x7e\x99\xe4\x64\x13\x1c\x36\xe4\x0a\xb8\xc9\x66\xb0\x01\x16\xd9\xd7\x1d\x39\xe7\x31\x7b\xe6\xd7\x31\xb9\x3a\x37\x59\x5d\x55\xbc\x29\x71\xc0\x9f\x82\xc7\x33\x4f\x9d\x26\x21\x51\x99\x2f\x99\xdc\x16\x7c\xf1\x4c\xc2\x55\xae\x8b\x27\x99\x09\xa5\xbc\x6b\x4e\x70\xb3\x6a\x7a\x32\x6f\x3c\x0e\x35\x6c\xdb\xf5\x66\xdb\xec\x0e\x9b\x0d\x1a\xdc\x6e\x9f\xd7\x87\xe5\xd3\x0e\x57\x87\x65\xdb\x6c\x96\xab\x27\x2c\x72\xff\xea\xa8\x7c\x5c\x79\x3c\x75\x3f\x1c\x13\xc6\x3e\xef\xac\x33\xd9\x63\x2f\x79\x36\xc3\x98\x0c\x69\x0a\x99\xfb\x1a\x51\xfa\xff\x3f\xfc\xec\x8a\xa7\xb9\xa9\x12\xb1\xcf\xcf\x8f\xc7\xd3\xba\x6a\x29\xba\x70\x79\xbd\xa7\x95\x31\x05\x09\x53\x66\x73\x00\xbf\x9b\xbb\x4f\x7e\xf2\x18\xe7\xd0\x0a\x00\xcb\xaf\x98\x4c\x6f\x4f\xda\x1d\xe8\x98\x60\x01\xb6\xd3\xfd\xf4\xa0\x0d\x34\xed\xae\x06\x99\xb4\x70\x60\x19\x10\xc6\xe4\x74\xd4\xd0\xc3\xac\x99\x0b\xfc\xf3\xdf\x42\xd5\xef\x50\xbb\x07\x36\xe7\xa5\x7c\x0f\x2d\xf9\x30\x5d\x87\xbf\x62\xa5\xb3\x8e\xf2\x73\x8c\x3f\x7a\x34\x57\xe2\xde\x5c\xbe\x22\xed\x14\xea\x2d\xa4\x2c\x76\xd7\x18\xcf\x4b\xda\xe0\xd3\xa1\xc5\xe7\x6e\x43\x06\x97\x9b\xf5\x7e\xb9\x3d\xec\xb1\x31\x2b\x32\xdb\x56\x1f\x3e\x1f\xb0\xdf\xba\x69\x7f\x58\x76\xd4\x34\xdd\xce\x6c\xf7\xb4\x5d\xee\xb6\x4f\xed\xb2\xdd\xef\x70\xbf\x33\xe6\xf0\xb4\x7b\x2e\x50\x24\xd9\x66\x94\x69\xfb\xd2\xbb\x24\xd4\x3b\x45\x9f\x0e\x70\xe3\x15\x00\x6f\xd6\xb7\x35\x7c\x79\x79\x99\x91\xd1\xb3\x66\xe4\x69\x4c\xe8\xae\x3a\x7f\xfc\xf2\xf2\xf2\x00\xdf\xf4\xaf\x2c\xcb\x3f\xe9\xe4\xea\xf3\xd1\xfa\xe3\xeb\x7c\x05\xd6\xb7\x4b\x71\x71\xbd\x16\x3f\x9e\x81\xf9\x7d\x3a\x2b\x14\x00\x03\x7a\xdb\x11\xcb\x2b\x8e\xd2\x87\x54\x03\x36\xed\xe8\xda\xe2\xbf\x01\x00\x00\xff\xff\xeb\x0d\x93\x71\x11\x0b\x00\x00")

FileResNet101V2Yml is "/ResNet101-v2.yml"

View Source
var FileResNet101Yml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x04\xff\xac\x56\x4f\x8f\xdb\xb6\x12\xbf\xeb\x53\x0c\x60\x3c\xe0\x3d\x60\x2d\x5b\x96\xbd\x6b\xeb\xf0\x80\x60\x0f\x69\xd1\x62\x0b\xa4\x45\x7a\x08\x82\xc5\x88\x1a\x59\xec\x52\x24\x41\x8e\xec\x75\x3e\x7d\x31\x94\xfc\x67\x13\x34\xed\xa1\x3e\x18\x22\xe7\xff\x6f\x7e\x1c\xd2\x62\x4f\x15\x7c\xa0\xf8\x44\x5c\x2c\x0b\x98\x81\xec\x80\x6b\xe1\xe4\x86\x00\xbd\x6b\xc8\x64\x6d\xc0\x9e\x8e\x2e\xbc\x54\x19\x24\x79\x05\x8f\xd8\xb6\x04\x33\xb8\x88\xa0\x75\x01\xb8\xa3\xc9\x04\xe0\x40\x21\x6a\x67\x2b\x28\xf2\xe5\x1b\xc5\x49\x00\xca\x59\x0e\xa8\x2d\x67\xd3\xce\x59\x75\x5a\x82\xb6\xad\x0b\x3d\xb2\x76\xf2\x0d\x91\x7a\xb4\xac\xd5\x45\x3e\x4a\x33\xf1\x83\xda\x52\xa8\x60\x96\x9c\xa6\x45\x84\x21\x52\x03\xec\xc0\x53\x10\xcd\x31\x31\xf0\x81\x1a\xad\xc4\x67\x06\xd7\xdf\x0c\xfa\xc1\xb0\xf6\x86\xc0\x1b\x64\xd1\x8f\xa0\xd0\x42\x4d\x10\x3d\x29\xdd\x6a\x6a\x32\x00\xec\x9b\xfb\xb5\xa0\x00\xb0\xf7\x43\x05\x01\xb5\x0f\xee\x0f\x52\xbc\x50\x18\x7a\x33\x57\x82\x4b\x95\xd4\xe6\xca\x0f\x29\x86\xfa\x5b\xcd\x7d\xd2\xf4\x5e\xdd\xaf\x0d\x8d\xee\xbf\x67\x34\x29\x4e\x66\xdf\x4f\xe5\x56\xb7\xa1\xa8\x82\xf6\x52\x7c\x05\xff\xcf\x00\xde\x49\xe7\x75\x33\xa0\x01\x43\x18\xac\xb6\xfb\x9b\x8e\xb2\x03\xc2\x48\xa9\xab\xa9\x53\x22\x76\x2d\x58\x62\x21\x43\x04\xee\x90\x01\x03\x41\x1c\xea\xc8\xd2\x1c\x34\xe6\x04\x0d\x91\x27\x21\x03\x5a\xe0\xce\x45\x1a\x5b\xe1\x03\x1d\xb4\x1b\xa2\x39\xe5\x19\xc0\xef\x04\xf4\xea\x8d\x56\x9a\xcd\x09\x02\x09\xe4\x83\x41\x1e\xc3\x19\x3c\x51\x88\x80\xf1\x9a\x57\xa0\x29\xd3\x76\xb0\xa9\x7f\x11\x8e\x9a\x3b\x31\xa5\x40\x56\x91\xe4\x2b\x04\x4c\xb6\xa0\xad\x1f\x38\xde\x81\xb6\x91\x09\x1b\xc9\xfb\x52\xe2\x60\x03\x4d\x46\xcd\xd5\xdd\x94\x95\x0f\xee\xa0\x1b\x02\xe5\x7a\x1f\xa8\x23\x1b\xf5\x81\x80\x7a\xaf\x83\x56\x68\x80\x44\x2a\xe1\x62\xe7\x8e\x82\x48\x42\x81\x3b\x8a\x74\xcd\xf1\x02\x91\xa0\x43\x18\xb5\xe0\xe1\xc0\x79\xd6\xbd\xfe\x42\x77\x80\xb6\x49\xfc\xda\xa3\xb6\x80\x4a\x0d\x01\xd5\x09\xda\xe0\x7a\xa1\x70\xd4\x0d\x05\xac\xcd\x09\xb4\x55\x41\x9a\xd0\x40\x43\x9e\x3b\xc9\xf1\x17\x41\x95\xe0\xc7\x1e\xf7\xf4\x44\x0c\x0d\x32\x46\x62\x38\x12\xd0\x01\xcd\x20\x18\x5e\xc0\xb2\xc4\x13\x4e\x38\x7a\x10\x20\x06\x2f\x58\x15\x9b\xd5\x88\x55\x9c\xcf\xe7\xdb\xd7\x37\x6d\xfb\xf8\xfe\xfd\x68\x5a\x0f\x0c\x91\xb5\x31\xd0\xe1\x41\xaa\x35\xee\x48\x21\x81\x63\xe8\x55\x73\xea\xe5\x3b\x0b\x64\x23\xf5\xb5\x49\x93\xe3\x5b\x2c\x22\xa0\xea\x34\x1d\x28\x42\x99\x6f\x1e\xfe\x03\x14\x82\x0b\xe0\xbe\xaa\x84\x29\x32\x44\xe2\x1c\x7e\xeb\x74\x94\x22\x06\xc3\x70\x9c\xd4\x8a\xc8\x72\x38\x15\x5d\xec\x7e\xfe\xf5\xe3\x87\x47\x58\x2d\x8b\x0d\x28\x83\x31\xea\x56\xab\x71\x5c\x30\xc6\x97\x3c\xbb\x74\x39\xca\x68\xb8\xae\xa4\x7a\x8f\x5e\x18\xb6\x80\x23\xd5\x51\x33\x45\x58\x00\xb1\xca\x73\x18\x4f\x49\x2d\xc5\x0a\x9d\xc6\x11\x08\x30\x87\x8e\xd9\xc7\x6a\xb1\xd8\x6b\xee\x86\x3a\x57\xae\x5f\xfc\x84\xba\xd7\x76\xff\x03\x2d\x84\xf4\xf3\x33\xec\xf3\x73\xff\xdf\xd8\x61\x78\xd5\x87\xdc\x85\xfd\x02\xeb\xb8\x28\x36\xc5\x2a\x5f\x96\xe5\x76\x93\xcd\xc0\x68\x25\x08\x4a\x73\xae\x31\xa7\xcd\x2a\xf1\x35\x72\xd0\x8a\xa9\xc9\x66\x13\xb5\xa5\x88\xab\xee\x48\x77\x19\x1d\x33\x68\x75\x88\x3c\x6a\x01\x9f\x3c\xc9\xa0\xbc\x51\x95\x52\x64\xbb\x02\x2d\x14\x4a\x23\x6a\x36\x55\xed\x65\x36\x9c\xb3\xb8\xf1\x93\x94\x46\x60\x92\x4a\x95\xfc\xa5\xa0\x37\x5e\x3c\x06\xec\x89\x29\x24\xbc\x25\xc6\xcd\x56\x72\x01\xd0\xe8\x5e\x8e\x94\xb3\xb1\x82\x4f\xe5\x1d\xac\x56\xeb\xf4\xf7\x79\x92\xf7\x84\xb6\x82\x4f\xc5\xaa\xcc\xef\xb7\x77\x50\x14\xf7\xf9\xc3\xc3\xee\x0e\x8a\x65\x99\xef\xca\xdd\xe7\xcc\x0d\xec\x07\x1e\x2b\x95\xfa\x53\x18\xd7\xa6\xef\x51\x96\x41\xda\xac\xa0\x25\xe4\x21\x48\x85\xb3\x44\xff\xcb\xf4\x7b\xab\x7f\x4d\x32\x83\x6f\x8b\x1c\x7d\x82\xc1\x9a\x4c\x06\x57\xdd\x04\x36\xc0\x2c\xc5\xba\xd9\x4e\x75\x4c\x91\xe3\xf3\x10\x4c\x95\x88\x53\x2d\x16\xb1\xcc\xb1\xc7\x2f\xce\xe2\x31\x26\xf6\x44\x76\x81\xf2\x74\x71\x24\x5a\xc4\x93\x8d\xc4\x71\x91\xfa\x62\x89\xa7\x8d\x9c\x5f\xa5\x26\xb8\x7a\x55\x1d\xa9\x97\x38\xf4\x15\xac\x9b\x55\xb9\xae\x37\xdb\xb2\x44\x85\xeb\xf5\x6e\xb5\x5d\xde\x6f\xb0\xd8\x2e\x9b\xba\x5c\x16\xf7\x98\x25\xfa\x0a\xfd\xcf\xd7\x58\x1c\x19\x0d\xfb\x80\xbe\x4b\x73\xe8\x48\x7a\xdf\x71\x3a\x6f\x6e\x08\x8a\xa4\x84\x24\x7d\xf6\xc8\xdd\x3f\x4f\x3f\x85\x8a\x8b\x74\x05\x2e\x02\x45\x9b\x9e\x14\x8b\xf1\x71\x31\x2f\x96\xc5\xbc\x21\x6f\xdc\x29\xf7\xc1\xb1\x1b\x8b\x9a\x62\xff\xeb\x91\x52\x2e\x79\x4a\x25\x7d\x66\x00\x3a\x3e\x63\x50\x9d\x3e\x08\x33\xd0\x44\x82\x19\xe8\x56\xe6\xcd\x9d\x90\x67\x9c\x45\x35\x46\x92\xa6\x81\x8e\x80\x30\x04\x23\xc7\x0c\x2d\x4c\x96\xa9\xb9\x5f\xff\x66\x62\x7e\x83\xd8\x2d\xa8\xa9\x30\x91\x5b\x68\xc8\xba\xf1\x7a\xfb\x0b\x2f\xad\x36\x94\x9e\x57\xf1\xcc\xcf\xd4\x85\x5b\x77\xe9\xca\xd3\x63\xaa\xd7\x94\x92\xda\x0d\x29\x4a\x52\x65\x53\xe0\xa6\x59\x97\x2b\x6a\x37\x6b\x55\xaf\x9a\x02\x5b\xb5\x6b\xb7\xe5\x7a\x59\x62\x06\x70\xc6\xfd\xca\xa4\xb2\xdd\x2a\xa5\x76\x65\xb9\xda\x35\x8d\x5a\x6d\x97\xf5\xae\xa0\x16\x69\xb9\x6b\x1f\x8a\xdd\x43\x99\x21\x73\xd0\xf5\xc0\xe3\x34\xa5\x57\x0e\x28\x77\x84\x3c\x05\xe0\x2a\xcb\x00\x5e\xb4\x6d\x2a\x78\x7c\x7a\x9a\x90\x91\xb5\x54\x64\x69\x08\x68\x2e\x36\xff\x7d\x7c\x7a\xba\x83\x0f\xf2\x97\xe7\xf9\xff\xe4\xd4\xca\x73\x50\xdb\xfd\xf3\x74\xa5\x55\xd7\x4b\x6e\x76\xb9\xe6\xce\xcf\xba\xf4\xde\x9c\x0c\x32\x80\x1e\xad\x6e\x29\xf2\x33\x0e\xdc\xb9\x50\x01\xd6\xcd\x60\x9a\xec\xcf\x00\x00\x00\xff\xff\x9a\x08\x5b\x1d\xe1\x0a\x00\x00")

FileResNet101Yml is "/ResNet101.yml"

View Source
var FileResNet152V2Yml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x04\xff\xac\x56\x5f\x8b\xeb\xba\x11\x7f\xf7\xa7\x18\x08\x85\x16\x36\x8e\xe3\xc4\xf9\xe3\x87\x42\xbb\x85\x43\xa1\x6c\xe1\xb4\xdc\x3e\x5c\x2e\xcb\x58\x1a\xc7\xea\xca\x92\x91\xc6\xc9\xe6\x7e\xfa\x32\xb2\x37\xc9\xde\xc3\x39\xed\x43\xf3\x10\x6c\xcd\xff\xdf\xfc\x66\x64\x87\x3d\xd5\xf0\x95\xe2\x0b\xf1\xba\x2a\x61\x01\x72\x02\xbe\x85\xab\x1f\x03\xf4\x5e\x93\xcd\xda\x80\x3d\x5d\x7c\x78\xab\x33\x48\xf2\x1a\x9e\xb1\x6d\x09\x16\x70\x13\x41\xeb\x03\x70\x47\xb3\x09\xc0\x99\x42\x34\xde\xd5\xb0\xce\x8b\x4f\x8a\xb3\x00\x94\x77\x1c\xd0\x38\xce\xe6\x93\x1a\xca\xa4\x3a\xbf\x82\x71\xad\x0f\x3d\xb2\xf1\xf2\x0c\x91\x7a\x74\x6c\xd4\x4d\x3e\x49\x33\xf1\x83\xc6\x51\xa8\x61\x91\x9c\xa6\x97\x08\x63\x24\x0d\xec\x61\xa0\x20\x9a\x53\x62\x30\x04\xd2\x46\x89\xcf\x0c\xee\xbf\x05\xf4\xa3\x65\x33\x58\x82\xc1\x22\x8b\x7e\x04\x85\x0e\x1a\x82\x38\x90\x32\xad\x21\x9d\x01\x60\xaf\x77\x5b\x41\x01\xe0\x34\x8c\x35\x04\x34\x43\xf0\xff\x26\xc5\x2b\x85\xa1\xb7\x4b\x25\xb8\xd4\x49\x6d\xa9\x86\x31\xc5\x50\xff\x55\xf3\x94\x34\x87\x41\xed\xb6\x96\x26\xf7\x3f\x32\x9a\x15\x67\xb3\x1f\xa7\xf2\xa8\xab\x29\xaa\x60\x06\x29\xbe\x86\x3f\x66\x20\x7d\x37\x7a\x44\x0b\x96\x30\x38\xe3\x4e\x0f\xfd\x64\x0f\x84\x91\x52\x4f\x53\x9f\x44\xec\x5b\x70\xc4\x42\x85\x08\xdc\x21\x03\x06\x82\x38\x36\x91\xa5\x35\x68\xed\x15\x34\xd1\x40\x42\x05\x74\xc0\x9d\x8f\x34\x35\x62\x08\x74\x36\x7e\x8c\xf6\x9a\x67\x00\xff\x22\xa0\xf7\xc1\x1a\x65\xd8\x5e\x21\x90\x00\x3e\x5a\xe4\x29\x9c\xc5\x2b\x85\x08\x18\xef\x79\x05\x9a\x33\x6d\x47\x97\xba\x17\xe1\x62\xb8\x13\x53\x0a\xe4\x14\x49\xbe\x42\xbf\x64\x0b\xc6\x0d\x23\xc7\x27\x30\x2e\x32\xa1\x96\xbc\x6f\x25\x8e\x2e\xd0\x6c\xa4\xef\xee\xe6\xac\x86\xe0\xcf\x46\x13\x28\xdf\x0f\x81\x3a\x72\xd1\x9c\x09\xa8\x1f\x4c\x30\x0a\x2d\x90\x48\x25\x5c\xec\xfc\x45\x10\x49\x28\x70\x47\x91\xee\x39\xde\x20\x12\x74\x08\xa3\x11\x3c\x3c\xf8\x81\x4d\x6f\x7e\xa5\x27\x40\xa7\x13\xbb\x4e\x68\x1c\xa0\x52\x63\x40\x75\x85\x36\xf8\x5e\x08\x1c\x8d\xa6\x80\x8d\xbd\x82\x71\x2a\x48\x13\x34\x68\x1a\xb8\x93\x1c\xff\x2e\xa8\x12\xfc\xb5\xc7\x13\xbd\x10\x83\x46\xc6\x48\x0c\x17\x02\x3a\xa3\x1d\x05\xc3\x1b\x58\x8e\x78\xc6\x09\x27\x0f\x02\xc4\x38\x08\x56\x32\xec\x09\xab\xb8\x5c\x2e\x0f\xef\x9f\xda\xf6\xd3\x97\x2f\x93\x69\x33\x32\x44\x36\xd6\x42\x87\x67\xa9\xd6\xfa\x0b\x85\x04\x8e\xa5\x77\xc3\xa9\x97\x7f\x72\x40\x2e\x52\xdf\xd8\xb4\x37\xbe\xc5\x22\x02\xaa\xce\xd0\x99\x22\x6c\xf2\x6a\xff\x3b\xa0\x10\x7c\x00\xff\x9b\x4a\x98\x22\x43\x24\xce\xe1\x9f\x9d\x89\x52\xc4\x68\x19\x2e\xb3\xda\x3a\xb2\x8c\xa6\xa2\x9b\xdd\xdf\xfe\xf1\xd3\xd7\x67\x28\x8b\x75\x05\xca\x62\x8c\xa6\x35\x6a\x5a\x16\x8c\xf1\x2d\xcf\x6e\x5d\x8e\xb2\x18\xee\x6f\x52\xfd\x80\x83\x30\x6c\x05\x17\x6a\xa2\x61\x8a\xb0\x02\x62\x95\xe7\x30\xcd\x48\x23\xc5\x0a\x9d\xa6\x05\x08\xb0\x84\x8e\x79\x88\xf5\x6a\x75\x32\xdc\x8d\x4d\xae\x7c\xbf\x8a\x9e\xf0\x4c\x61\x95\x86\x7e\x99\x54\x57\x1c\x88\x56\x3d\x46\x96\x73\x1b\xbf\x67\xaa\x02\xb6\xfc\xe5\xcf\x7f\xb9\x3d\x7c\x52\xc4\xf0\x6e\xce\xb9\x0f\xa7\x15\x36\x71\xb5\xae\xd6\x65\x5e\x6c\x36\x87\x2a\x5b\x80\x35\x4a\xd0\x96\x46\xde\xf3\x9b\x0f\xeb\xc4\xed\xc8\xc1\x28\x26\x9d\x2d\xe6\x31\x90\x82\xef\xba\xd3\x68\xc8\x92\x59\x40\x6b\x42\xe4\x49\x0b\xf8\x3a\x90\xac\xd4\x07\x55\x29\x5b\x8e\x6b\x30\x42\xb7\xb4\xcc\x16\x33\x42\x83\x6c\x91\x8f\x2c\x1e\xfc\x24\xa5\x09\xc4\xa4\x52\x27\x7f\x29\xe8\x83\x97\x01\x03\xf6\xc4\x14\x52\x6f\x24\xc6\xc3\x51\x72\x01\xa0\x4d\x2f\xe3\xe7\x5d\xac\xe1\xe7\xcd\x13\x94\xe5\x36\xfd\xfd\x32\xcb\x7b\x42\x57\xc3\xcf\xeb\xb2\xcc\xf7\xfb\xf2\x09\xd6\xeb\x2a\x3f\x6e\xf7\x4f\xb0\x2e\xca\xfc\x78\xf8\x25\xf3\x23\x0f\x23\x4f\x95\x4a\xfd\x29\x8c\x6f\xd3\xf3\x24\xcb\x20\x1d\xd6\xd0\x12\xf2\x18\xa4\xc2\x45\x1a\x95\xdb\x9e\xfc\xac\x7f\x4f\x32\x83\x6f\x8b\x9c\x7c\x82\xc5\x86\x6c\x06\x77\xdd\x04\x36\xc0\x22\xc5\x7a\x38\x4e\x75\xcc\x91\xe3\xeb\x18\x6c\x9d\x48\x56\xaf\x56\x71\x93\x63\x8f\xbf\x7a\x87\x97\x38\x31\x8d\x7d\xa0\x3c\x5d\x31\x89\x16\xf1\xea\x22\x71\x5c\xa5\xbe\x38\xe2\xf9\x20\xe7\x77\xa9\x09\xee\x5e\x55\x47\xea\x2d\x8e\x7d\x0d\x5b\x5d\x6e\xb6\x4d\x75\xd8\x6c\x50\xe1\x76\x7b\x2c\x0f\xc5\xae\xc2\xf5\xa1\xd0\xcd\xa6\x58\xef\x30\x4b\xfc\x95\x51\xf9\xb8\xf0\xe2\xc4\x7e\x38\x05\x1c\xba\xb4\xb3\x2e\x64\x4e\x1d\xa7\xd9\xf4\x63\x50\x24\x25\x24\xe9\xeb\x80\xdc\xfd\xef\xe9\xa7\x50\x71\x9a\x9b\x55\xa0\xe8\xd2\xc7\xc7\xf2\x5c\xae\x34\x0d\xd6\x5f\x5f\x1f\xcf\xf2\x21\x78\xf6\x53\x65\x73\x02\xff\xb7\x70\x9f\xe2\xa4\x31\x4e\xa9\x65\x00\x26\xbe\x62\x50\x9d\x39\x0b\x3b\xd0\x46\x82\x05\x98\x56\xf6\xd3\x93\x10\x68\xda\x5d\x0d\x46\x92\xc6\x81\x89\x80\x30\x06\x2b\xa3\x86\x0e\x66\xcb\xd4\xe0\xdf\xfe\x16\x62\xfe\x80\xda\x23\xb0\xa9\x2e\x91\x3b\xd0\xe4\xfc\x74\x1d\x7e\xc7\x4b\x6b\x2c\xa5\x8f\xb1\xf8\xc1\xd1\xd4\x89\x47\x77\xe9\x8a\x34\x53\xaa\xf7\x94\x16\x93\xe2\x23\x35\x8a\x9d\xae\x8a\xc3\xae\x68\xb0\x50\x65\xb1\x6e\xab\xc3\x46\xed\x2b\x5d\xea\xb2\x3c\xb6\xfb\x26\x13\xf2\x7e\x40\x7f\x67\x54\x5b\x1c\x8e\xd5\x1e\xf7\xdb\x6a\x5f\x16\x0d\xae\xdb\xa6\xdd\x1c\xb7\xd5\xee\xa0\x49\x35\x47\xdd\x66\x00\x29\xa5\x07\x13\x2a\xa9\x29\xf6\xdb\x96\xaa\x9d\xda\x1e\xaa\x2d\xea\x75\x71\xdc\x1c\x68\xb3\xd7\xfb\x5d\x55\x14\x19\xc0\xb7\x71\x8e\x87\x72\xb3\x2b\xb0\xd9\x6d\x55\x81\x6b\xac\x48\xef\xa9\xc5\x56\x1f\xb6\xaa\xaa\x74\x81\x19\x32\x07\xd3\x8c\x3c\x6d\x7a\x7a\xe7\x80\x72\x7f\xc9\x67\x0a\xdc\x65\x19\xc0\x9b\x71\xba\x86\xe7\x97\x97\xb9\x0b\xf2\x2e\xe8\x39\x1a\x03\xda\x9b\xcd\xef\x9f\x5f\x5e\x9e\xe0\xab\xfc\xe5\x79\xfe\x07\xd9\x12\xf2\xa1\x6a\xdc\xe9\x75\xbe\x6e\xeb\xfb\x05\xbc\xb8\x5d\xc1\x1f\x1f\x9c\xe9\x4b\x78\x36\xc8\x00\x7a\x74\xa6\xa5\xc8\xaf\x38\x72\xe7\x43\x0d\xd8\xe8\xd1\xca\x7a\x76\xde\x2d\x7b\x0a\x27\xb9\xd3\x08\x4c\x04\xe3\x50\xa9\x31\x20\x53\x96\xfd\x27\x00\x00\xff\xff\xe5\x99\x95\xe2\x9a\x0b\x00\x00")

FileResNet152V2Yml is "/ResNet152-v2.yml"

View Source
var FileResNet152Yml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x04\xff\xac\x56\xcd\x8e\xe3\xb8\x11\xbe\xeb\x29\x0a\x30\x02\x24\x40\x5b\xb6\x2c\xdb\x6d\xeb\x10\x60\xd0\x87\x49\x90\xa0\x03\x4c\x82\xc9\x61\x30\x68\x94\xa8\x92\xc5\x6d\x8a\x24\xc8\x92\xdd\x9e\xa7\x5f\x14\x25\xff\xf4\x0c\x76\x76\x0f\xeb\x83\x21\xb2\xfe\xbf\xfa\x58\xa4\xc5\x9e\x2a\xf8\x44\xf1\x99\xb8\xd8\xac\x60\x06\xb2\x03\xae\x85\xb3\x1b\x02\xf4\xae\x21\x93\xb5\x01\x7b\x3a\xb9\xf0\x5a\x65\x90\xe4\x15\x3c\x61\xdb\x12\xcc\xe0\x2a\x82\xd6\x05\xe0\x8e\x26\x13\x80\x23\x85\xa8\x9d\xad\xa0\xc8\x97\xef\x14\x27\x01\x28\x67\x39\xa0\xb6\x9c\x4d\x3b\x17\xd5\x69\x09\xda\xb6\x2e\xf4\xc8\xda\xc9\x37\x44\xea\xd1\xb2\x56\x57\xf9\x28\xcd\xc4\x0f\x6a\x4b\xa1\x82\x59\x72\x9a\x16\x11\x86\x48\x0d\xb0\x03\x4f\x41\x34\xc7\xc4\xc0\x07\x6a\xb4\x12\x9f\x19\xdc\x7e\x33\xe8\x07\xc3\xda\x1b\x02\x6f\x90\x45\x3f\x82\x42\x0b\x35\x41\xf4\xa4\x74\xab\xa9\xc9\x00\xb0\x6f\xb6\x6b\x41\x01\xe0\xe0\x87\x0a\x02\x6a\x1f\xdc\x2f\xa4\x78\xa1\x30\xf4\x66\xae\x04\x97\x2a\xa9\xcd\x95\x1f\x52\x0c\xf5\xbb\x9a\x87\xa4\xe9\xbd\xda\xae\x0d\x8d\xee\x7f\x66\x34\x29\x4e\x66\x3f\x4f\xe5\x5e\xb7\xa1\xa8\x82\xf6\x52\x7c\x05\x7f\xcf\x00\x3e\x48\xe7\x75\x33\xa0\x01\x43\x18\xac\xb6\x87\xbb\x8e\xb2\x03\xc2\x48\xa9\xab\xa9\x53\x22\x76\x2d\x58\x62\x21\x43\x04\xee\x90\x01\x03\x41\x1c\xea\xc8\xd2\x1c\x34\xe6\x0c\x0d\x91\x27\x21\x03\x5a\xe0\xce\x45\x1a\x5b\xe1\x03\x1d\xb5\x1b\xa2\x39\xe7\x19\xc0\xff\x09\xe8\xcd\x1b\xad\x34\x9b\x33\x04\x12\xc8\x07\x83\x3c\x86\x33\x78\xa6\x10\x01\xe3\x2d\xaf\x40\x53\xa6\xed\x60\x53\xff\x22\x9c\x34\x77\x62\x4a\x81\xac\x22\xc9\x57\x08\x98\x6c\x41\x5b\x3f\x70\x7c\x00\x6d\x23\x13\x36\x92\xf7\xb5\xc4\xc1\x06\x9a\x8c\x9a\x9b\xbb\x29\x2b\x1f\xdc\x51\x37\x04\xca\xf5\x3e\x50\x47\x36\xea\x23\x01\xf5\x5e\x07\xad\xd0\x00\x89\x54\xc2\xc5\xce\x9d\x04\x91\x84\x02\x77\x14\xe9\x96\xe3\x15\x22\x41\x87\x30\x6a\xc1\xc3\x81\xf3\xac\x7b\xfd\x8d\x1e\x00\x6d\x93\xf8\x75\x40\x6d\x01\x95\x1a\x02\xaa\x33\xb4\xc1\xf5\x42\xe1\xa8\x1b\x0a\x58\x9b\x33\x68\xab\x82\x34\xa1\x81\x86\x3c\x77\x92\xe3\x7f\x04\x55\x82\x7f\xf6\x78\xa0\x67\x62\x68\x90\x31\x12\xc3\x89\x80\x8e\x68\x06\xc1\xf0\x0a\x96\x25\x9e\x70\xc2\xd1\x83\x00\x31\x78\xc1\x4a\x8e\x7b\xc2\x2a\xce\xe7\xf3\xdd\xdb\xbb\xb6\x7d\xfe\xf8\x71\x34\xad\x07\x86\xc8\xda\x18\xe8\xf0\x28\xd5\x1a\x77\xa2\x90\xc0\x31\xf4\xa6\x39\xf5\xf2\x83\x05\xb2\x91\xfa\xda\xa4\xc9\xf1\x23\x16\x11\x50\x75\x9a\x8e\x14\xa1\xcc\x37\x8f\x7f\x01\x0a\xc1\x05\x70\xdf\x55\xc2\x14\x19\x22\x71\x0e\xff\xeb\x74\x94\x22\x06\xc3\x70\x9a\xd4\x8a\xc8\x72\x38\x15\x5d\xed\xfe\xfd\xdf\xcf\x9f\x9e\x60\xb5\x2c\x36\xa0\x0c\xc6\xa8\x5b\xad\xc6\x71\xc1\x18\x5f\xf3\xec\xda\xe5\x28\xa3\xe1\xb6\x92\xea\x3d\x7a\x61\xd8\x02\x4e\x54\x47\xcd\x14\x61\x01\xc4\x2a\xcf\x61\x3c\x25\xb5\x14\x2b\x74\x1a\x47\x20\xc0\x1c\x3a\x66\x1f\xab\xc5\xe2\xa0\xb9\x1b\xea\x5c\xb9\x7e\xf1\x2f\xd4\xbd\xb6\x87\x7f\xd0\x42\x48\x3f\xbf\xc0\x3e\xbf\xf4\xff\x9d\x1d\x86\x37\x7d\xcc\x5d\x38\x2c\xb0\x8e\x8b\x62\x53\xac\xf2\x65\x59\xee\x36\xd9\x0c\x8c\x56\x82\xa0\x34\xe7\x16\x73\xda\xac\x12\x5f\x23\x07\xad\x98\x9a\x6c\x36\x51\x5b\x8a\xb8\xe9\x8e\x74\x97\xd1\x31\x83\x56\x87\xc8\xa3\x16\xf0\xd9\x93\x0c\xca\x3b\x55\x29\x45\xb6\x2b\xd0\x42\xa1\x34\xa2\x66\x53\xd5\x5e\x66\xc3\x25\x8b\x3b\x3f\x49\x69\x04\x26\xa9\x54\xc9\x5f\x0a\x7a\xe7\xc5\x63\xc0\x9e\x98\x42\xc2\x5b\x62\xdc\x6d\x25\x17\x00\x8d\xee\xe5\x48\x39\x1b\x2b\xf8\x52\x3e\xc0\x6a\xb5\x4e\x7f\x5f\x27\x79\x4f\x68\x2b\xf8\x52\xac\xca\x7c\xbb\x7b\x80\xa2\xd8\xe6\x8f\x8f\xfb\x07\x28\x96\x65\xbe\x2f\xf7\x5f\x33\x37\xb0\x1f\x78\xac\x54\xea\x4f\x61\x5c\x9b\xbe\x47\x59\x06\x69\xb3\x82\x96\x90\x87\x20\x15\xce\x12\xfd\xaf\xd3\xef\xbd\xfe\x2d\xc9\x0c\x7e\x2c\x72\xf4\x09\x06\x6b\x32\x19\xdc\x74\x13\xd8\x00\xb3\x14\xeb\x6e\x3b\xd5\x31\x45\x8e\x2f\x43\x30\x55\x22\x4e\xb5\x58\xc4\x32\xc7\x1e\xbf\x39\x8b\xa7\x98\xd8\x13\xd9\x05\xca\xd3\xc5\x91\x68\x11\xcf\x36\x12\xc7\x45\xea\x8b\x25\x9e\x36\x72\x7e\x93\x9a\xe0\xe6\x55\x75\xa4\x5e\xe3\xd0\x57\xb0\x6e\x56\xe5\xba\xde\xec\xca\x12\x15\xae\xd7\xfb\xd5\x6e\xb9\xdd\x60\xb1\x5b\x36\x75\xb9\x2c\xb6\x98\x25\xfa\x0a\xfd\x2f\xd7\x58\x1c\x19\x0d\x87\x80\xbe\x4b\x73\xe8\x44\xfa\xd0\x71\x3a\x6f\x6e\x08\x8a\xa4\x84\x24\x7d\xf1\xc8\xdd\x1f\x4f\x3f\x85\x8a\x8b\x74\x05\x2e\x02\x45\x9b\x9e\x14\x8b\xf1\x71\x31\x2f\x36\xab\x79\x43\xde\xb8\x73\xee\x83\x63\x37\x16\x35\xc5\xfe\xd3\x23\xa5\x5c\xf2\x94\x4a\xfa\xcc\x00\x74\x7c\xc1\xa0\x3a\x7d\x14\x66\xa0\x89\x04\x33\xd0\xad\xcc\x9b\x07\x21\xcf\x38\x8b\x6a\x8c\x24\x4d\x03\x1d\x01\x61\x08\x46\x8e\x19\x5a\x98\x2c\x53\x73\xbf\xff\xcd\xc4\xfc\x0e\xb1\x7b\x50\x53\x61\x22\xb7\xd0\x90\x75\xe3\xf5\xf6\x1b\x5e\x5a\x6d\x28\x3d\xaf\xe2\x85\x9f\xa9\x0b\xf7\xee\xd2\x95\xa7\xc7\x54\x6f\x29\x25\xb5\x3b\x52\x94\xcd\xaa\xde\x6f\x8b\xfd\x6e\xb5\xda\xef\xb0\xde\xad\x97\xcb\xb2\xd8\x2b\xb5\x2b\x9b\x72\x4d\x8f\x65\x06\x70\xc1\xfd\xc6\xa4\xed\x66\xbd\xdb\xaf\x70\x55\x36\x6d\xb9\x5c\x2a\x5c\x3f\x52\xdd\xd2\x76\x5b\xaf\x55\x8b\x58\xd4\x19\x32\x07\x5d\x0f\x3c\x4e\x53\x7a\xe3\x80\x72\x47\xc8\x53\x00\x6e\xb2\x0c\xe0\x55\xdb\xa6\x82\xa7\xe7\xe7\x09\x19\x59\x4b\x45\x96\x86\x80\xe6\x6a\xf3\xd7\xa7\xe7\xe7\x07\xf8\x24\x7f\x79\x9e\xff\x4d\x4e\xad\x3c\x07\xb5\x3d\xbc\x4c\x57\x5a\x75\xbb\xe4\x66\xd7\x6b\xee\xf2\xac\x4b\xef\xcd\xc9\x20\x03\xe8\xd1\xea\x96\x22\xbf\xe0\xc0\x9d\x0b\x15\x60\xdd\x0c\xa6\xc9\x7e\x0d\x00\x00\xff\xff\x1a\xb7\x37\x53\xe1\x0a\x00\x00")

FileResNet152Yml is "/ResNet152.yml"

View Source
var FileResNet18PrivYml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x04\xff\xac\x56\x4f\x8f\xeb\xb8\x0d\xbf\xfb\x53\x10\x2f\x28\xd0\x02\x13\x3b\xce\xbf\x97\xf1\xa1\xc0\x76\x0e\x8b\x02\xdb\xe9\xe2\xb5\x78\x3d\x2c\x8a\x80\x96\xe8\x58\x7d\xb2\x24\x88\x72\x32\xd9\x4f\x5f\x50\xf6\x24\x99\x5d\x60\xb7\x87\x5e\x82\x58\xfc\x91\x22\x7f\xfc\x27\x87\x03\x35\xf0\x85\xf8\x95\x52\x7d\x80\x05\xc8\x01\xf8\x0e\xae\x7e\x8c\x30\x78\x4d\xb6\xe8\x22\x0e\x74\xf1\xf1\x5b\x53\x40\x96\x37\xf0\x82\x5d\x47\xb0\x80\x9b\x08\x3a\x1f\x21\xf5\x34\xab\x00\x9c\x29\xb2\xf1\xae\x81\xba\x5c\x7d\x00\xce\x02\x50\xde\xa5\x88\xc6\xa5\x62\x3e\x79\x87\xce\x9f\x60\x5c\xe7\xe3\x80\xc9\x78\xf9\x0f\x4c\x03\xba\x64\xd4\x4d\x3e\x49\x0b\xb1\x83\xc6\x51\x6c\x60\x91\x8d\xe6\x0f\x86\x91\x49\x43\xf2\x10\x28\x0a\x72\x72\x0c\x42\x24\x6d\x94\xd8\x2c\x00\x16\x30\x8c\x36\x99\x60\x09\x82\xc5\x24\x30\x06\x85\x0e\x5a\x02\x0e\xa4\x4c\x67\x48\x17\x00\x38\xe8\xfd\x56\x82\x07\x38\x85\xb1\x81\x88\x26\x44\xff\x1f\x52\xa9\x52\x18\x07\xbb\x54\x42\x47\x93\x61\x4b\x15\xc6\x02\x00\x40\xfd\x2e\xf2\x94\x91\x21\xa8\xfd\xd6\xd2\x64\xfe\xb7\x94\x66\xe0\xac\xf6\xdb\xae\x3c\x62\x35\xb1\x8a\x26\x48\xcc\x0d\xfc\xb9\x00\xf8\x4e\xf2\x6d\xf4\x88\x16\x2c\x61\x74\xc6\x9d\x1e\x12\x99\x3c\x10\x32\xe5\x64\xe6\x04\x89\xd8\x77\xe0\x28\x49\x0d\x30\xa4\x1e\x13\x60\x24\xe0\xb1\xe5\x24\x39\x41\x6b\xaf\xa0\x89\x02\x49\x0d\xa0\x83\xd4\x7b\xa6\x29\x03\x21\xd2\xd9\xf8\x91\xed\xb5\x2c\x00\xfe\x45\x40\x6f\xc1\x1a\x65\x92\xbd\x42\x24\xa1\x7c\xb4\x98\xa6\xeb\x2c\x5e\x29\x32\x20\xdf\xfd\x8a\x34\x7b\xda\x8d\x2e\xa7\x8d\xe1\x62\x52\x2f\xaa\x14\xc9\x29\x12\x7f\xa5\xee\xb2\x2e\x18\x17\xc6\xc4\x4f\x60\x1c\x27\x42\x2d\x7e\xdf\x42\x1c\x5d\xa4\x59\x49\xdf\xcd\xcd\x5e\x85\xe8\xcf\x46\x13\x28\x3f\x84\x48\x3d\x39\x36\x67\x02\x1a\x82\x89\x46\xa1\x05\x12\xa9\x5c\xc7\xbd\xbf\x08\x23\x99\x85\xd4\x13\xd3\xdd\xc7\x1b\x45\xc2\x0e\x21\x1b\xe1\xc3\x83\x0f\xc9\x0c\xe6\x67\x7a\x02\x74\x3a\xd7\xd7\x09\x8d\x03\x54\x6a\x8c\xa8\xae\xd0\x45\x3f\x48\xe5\xb2\xd1\x14\xb1\xb5\x57\x30\x4e\x45\x49\x82\x06\x4d\x21\xf5\xe2\xe3\xdf\x85\x55\x82\xbf\x0e\x78\xa2\x57\x4a\xa0\x31\x21\x53\x82\x0b\x01\x9d\xd1\x8e\xc2\xe1\x8d\x2c\x47\x69\xe6\x09\x27\x0b\x42\xc4\x18\x84\xab\x7a\xb7\x9e\xb8\xe2\xe5\x72\x79\x78\xfb\x90\xb6\xaf\xdf\x7f\x3f\xa9\xb6\x63\x02\x4e\xc6\x5a\xe8\xf1\x2c\xd1\x5a\x7f\xa1\x98\xc9\xb1\xf4\x66\x52\xce\xe5\x77\x0e\xc8\x31\x0d\xad\xcd\x03\xe3\xd7\x5c\x30\xa0\xea\x0d\x9d\x89\x61\x53\xee\x3e\xff\x01\x28\x46\x1f\xc1\xff\x22\x92\x44\x9c\x80\x29\x95\xf0\xcf\xde\xb0\x04\x31\xda\x04\x97\x19\x56\x73\x92\xe6\x54\x74\xd3\xfb\xe1\x1f\x5f\xbf\xbc\xc0\x7a\x55\xef\x40\x59\x64\x36\x9d\x51\xd3\x94\x48\xc8\xdf\xca\xe2\x96\x65\x96\x89\x70\xff\x92\xe8\x03\x06\xa9\xb0\x0a\x2e\xd4\xb2\x49\xc4\x50\x01\x25\x55\x96\x30\x75\x49\x2b\xc1\x4a\x39\x4d\x93\x0f\x60\x09\x7d\x4a\x81\x9b\xaa\x3a\x99\xd4\x8f\x6d\xa9\xfc\x50\xb1\x27\x3c\x53\xac\x72\xdb\x2f\x33\xb4\x4a\x91\xa8\x1a\x90\x93\x9c\x5b\xfe\x3d\xd5\x70\x4d\x3e\xaa\x7e\xf9\x31\x82\x0f\x5a\x18\xdf\xcc\xb9\xf4\xf1\x54\x61\xcb\x55\xbd\xab\xd7\xe5\x6a\xb3\x39\xec\x8a\x05\x58\xa3\x84\x7a\xc9\xea\xdd\xd9\xf9\xb0\xc9\x85\xce\x29\x1a\x95\x48\x17\x8b\xb9\x27\x24\xfa\x3b\x76\xea\x13\x99\x39\x0b\xe8\x4c\xe4\x34\xa1\x20\x5d\x03\xc9\x60\x7d\x80\x0a\x07\x72\xdc\x80\x91\xda\xcb\xb3\x6d\x31\xd3\x15\x64\xa8\xbc\x7b\xf1\x60\x27\x83\x26\x46\x33\xa4\xc9\xf6\xf2\xa5\x0f\x56\x02\x46\x1c\x28\x51\xcc\x89\x92\x3b\x1e\x8e\xb2\x09\x00\x6d\x06\xe9\x45\xef\xb8\x81\x9f\x36\x4f\xb0\x5e\x6f\xf3\xcf\xbf\x67\xf9\x40\xe8\x1a\xf8\xa9\x5e\x6f\xca\xfd\xe7\xdd\x13\xd4\xf5\xbe\x5c\x1f\x9e\xa0\x5e\x6d\xca\xdd\xfa\x1d\xc5\x0a\x2d\x35\x50\xaf\x0f\x85\x1f\x53\x18\xd3\x14\xb9\xf0\x91\xaf\xf5\x5d\xfe\x3f\xc9\x0a\xc8\x87\x0d\x74\x84\x69\x8c\x12\xf1\x22\xf7\xd1\x6d\x8c\x7e\xc4\xdf\x9d\x2e\xe0\xd7\x41\x4f\x36\xc1\x62\x4b\xb6\x80\x3b\x36\x93\x2f\x2b\x28\x3b\x70\xa7\x22\xc7\x35\xdf\xcc\xc7\x31\xda\x26\x57\x60\x53\x55\xbc\x29\x71\xc0\x9f\xbd\xc3\x0b\x4f\x65\x98\x7c\xa4\x32\x6f\xa0\x5c\x26\x7c\x75\x4c\x89\xab\x9c\x27\x47\x69\x3e\x28\xd3\x9b\xc4\x04\x77\xab\xaa\x27\xf5\x8d\xc7\xa1\x81\xad\x5e\x6f\xb6\xed\xee\xb0\xd9\xa0\xc2\xed\xf6\x79\x7d\x58\xed\x77\x58\x1f\x56\xba\xdd\xac\xea\x3d\x16\xb9\xb8\xa5\x8f\xde\xf7\x21\x4f\xad\x01\xa7\x88\xa1\xcf\x03\xed\x42\xe6\xd4\xa7\xdc\xb8\x7e\x8c\x8a\x24\x84\x2c\x3d\x06\x4c\xfd\xff\xee\x7e\xbe\x8a\xa7\xa6\xaa\x22\xb1\x93\x17\xc9\x32\x44\x73\xae\x34\x05\xeb\xaf\xc7\x0f\x87\x47\xe7\x8f\x8a\x8c\x3d\x8a\x5e\x19\xa2\x4f\x7e\x0a\x74\xf6\xe7\xff\x77\xfb\x87\x6b\xcb\xdc\xf4\x72\xa7\xa4\xd3\xf0\x11\xa3\xea\xcd\x79\xde\xdf\x1d\x5a\x26\x58\x80\xe9\x64\xa2\x3d\x49\x55\x4d\xd3\xae\x45\x26\xc9\x26\x18\x06\x84\x31\x5a\xe9\x47\x74\x30\x6b\xe7\xac\x2f\x04\xfe\x40\xdd\x23\xbb\x39\x1a\x91\x3b\xd0\xe4\xfc\xb4\x30\x67\xad\xce\x58\xca\xef\x32\x7e\x2f\xcc\x4c\xff\xa3\x7a\x5e\x9a\x66\x72\xe5\x7e\x65\x86\x3d\x54\x43\xbb\xda\x77\x75\x57\x6b\xbd\xad\x77\x3b\xf5\xb9\xae\x57\x07\x7d\xa8\x9f\xeb\xdd\xee\x79\xb7\xc7\xe7\x43\x01\xf0\x4e\xee\xbd\x84\x56\xcf\xab\xad\xde\xaf\xea\x4e\x3d\x6f\x56\x7a\xdb\xad\xd4\x7e\x8d\x6b\x7c\xde\xb5\x1b\xb5\x69\x9f\x37\x05\xa6\x14\x4d\x3b\xa6\x69\x1e\xd3\x5b\x8a\x28\x5b\x46\x1e\x13\x70\x97\x15\x00\xdf\x8c\xd3\x0d\xbc\xbc\xbe\xce\x4c\xc8\xb7\x44\xe4\x68\x8c\x68\x6f\x3a\x7f\x7c\x79\x7d\x7d\x82\x2f\xf2\x53\x96\xe5\x9f\xa4\x5d\xe5\x1d\x69\xdc\xe9\x38\x2f\xc5\xe6\xbe\x26\x17\xb7\x45\xf9\xfe\x1e\xcc\x0f\xd5\x59\xa1\x00\x18\xd0\x99\x8e\x38\x1d\x71\x4c\xbd\x8f\x0d\x60\xab\x47\x2b\x73\xb3\x37\x5a\x93\x8c\xae\x38\x4a\x4a\xff\x46\xcc\x78\xa2\xa9\x5f\x3f\xe5\x2a\x28\x7f\xf4\xde\x1a\x77\xfa\xf1\x7d\x90\x7d\x82\x1e\x19\x9c\x87\xce\x90\xd5\x39\x27\x1a\x3e\xdd\xaa\xf4\x53\xb1\xc8\xcd\xfc\x8b\x75\xf2\x97\xaf\x3f\xbc\xcc\x65\x1f\x46\x6b\xab\xcd\x6a\xf7\xb9\xea\x8c\x25\x2e\x8a\xff\x06\x00\x00\xff\xff\x96\x48\x46\xa1\xa0\x0b\x00\x00")

FileResNet18PrivYml is "/ResNet18-priv.yml"

View Source
var FileResNet269V2Yml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x04\xff\xac\x56\x4d\x8b\xf3\xc8\x11\xbe\xeb\x57\x14\x98\x40\x02\x33\xb2\x2d\xdb\x63\x8f\x0e\x81\xcd\x1b\x78\x09\x84\x09\xbc\x09\x9b\xc3\xb2\x0c\xa5\x56\xc9\xea\x4c\xab\xbb\xe9\x2a\xd9\xe3\xfd\xf5\xa1\x5a\x1a\xdb\xb3\xcb\x6e\x72\x58\x1f\x8c\xd4\xf5\xd4\xd7\x53\x1f\x2d\x8f\x03\xd5\xf0\x8d\xf8\x85\xa4\x7a\x7a\x86\x05\xe8\x09\x84\x0e\x2e\x61\x4c\x30\x84\x96\x5c\xd1\x25\x1c\xe8\x1c\xd2\x5b\x5d\x40\x96\xd7\xf0\x05\xbb\x8e\x60\x01\x57\x11\x74\x21\x81\xf4\x34\xab\x00\x9c\x28\xb1\x0d\xbe\x86\x75\xb9\xfa\x04\x9c\x05\x60\x82\x97\x84\xd6\x4b\x31\x9f\xd4\x50\x65\xe8\xfc\x0a\xd6\x77\x21\x0d\x28\x36\xe8\x33\x30\x0d\xe8\xc5\x9a\xab\x7c\x92\x16\x6a\x07\xad\xa7\x54\xc3\x22\x1b\xcd\x2f\x0c\x23\x53\x0b\x12\x20\x52\x52\xe4\x14\x18\xc4\x44\xad\x35\x6a\xb3\x80\xdb\x6f\x01\xc3\xe8\xc4\x46\x47\x10\x1d\x8a\xe2\x19\x0c\x7a\x68\x08\x38\x92\xb1\x9d\xa5\xb6\x00\xc0\xa1\x7d\xda\x2a\x0b\x00\xc7\x38\xd6\x90\xd0\xc6\x14\xfe\x43\x46\x96\x06\xd3\xe0\x1e\x8d\xf2\x52\x67\xd8\xa3\x89\x63\xf6\x61\xfe\x27\xf2\x98\x91\x31\x9a\xa7\xad\xa3\xc9\xfc\x6f\x29\xcd\xc0\x59\xed\xb7\x43\xb9\xc7\xb6\xc4\x26\xd9\xa8\xc9\xd7\xf0\xe7\x02\xe0\x3b\xad\xbc\x6d\x47\x74\xe0\x08\x93\xb7\xfe\x78\x57\x51\x09\x40\xc8\x94\xab\x9a\x2b\xa5\xe2\xd0\x81\x27\xd1\x66\x60\x90\x1e\x05\x30\x11\xf0\xd8\xb0\x68\x71\xd0\xb9\x0b\xb4\x44\x91\xb4\x19\xd0\x83\xf4\x81\x69\x2a\x45\x4c\x74\xb2\x61\x64\x77\x29\x0b\x80\x7f\x13\xd0\x7b\x74\xd6\x58\x71\x17\x48\xa4\x94\x8f\x0e\x65\x72\xe7\xf0\x42\x89\x01\xf9\x16\x57\xa2\x39\xd2\x6e\xf4\xb9\x7e\x0c\x67\x2b\xbd\xaa\x52\x22\x6f\x48\xe3\xd5\x06\xcc\xba\x60\x7d\x1c\x85\x1f\xc0\x7a\x16\xc2\x56\xe3\xbe\xa6\x38\xfa\x44\xb3\x52\x7b\x33\x37\x47\x15\x53\x38\xd9\x96\xc0\x84\x21\x26\xea\xc9\xb3\x3d\x11\xd0\x10\x6d\xb2\x06\x1d\x90\x4a\xd5\x1d\xf7\xe1\xac\x8c\x64\x16\xa4\x27\xa6\x5b\x8c\x57\x8a\x94\x1d\x42\xb6\xca\x47\x80\x10\xc5\x0e\xf6\x27\x7a\x00\xf4\x6d\xee\xaf\x23\x5a\x0f\x68\xcc\x98\xd0\x5c\xa0\x4b\x61\xd0\x16\x66\xdb\x52\xc2\xc6\x5d\xc0\x7a\x93\xb4\x08\x2d\xb4\x14\xa5\xd7\x18\xff\xa1\xac\x12\xfc\x6d\xc0\x23\xbd\x90\x40\x8b\x82\x4c\x02\x67\x02\x3a\xa1\x1b\x95\xc3\x2b\x59\x9e\x64\xe6\x09\x27\x0b\x4a\xc4\x18\x95\xab\xf5\xae\x9a\xb8\xe2\xc7\xc7\xc7\xc3\xfb\xa7\xb2\x7d\xff\xf5\xeb\xa4\xda\x8c\x02\x2c\xd6\x39\xe8\xf1\xa4\xd9\xba\x70\xa6\x94\xc9\x71\xf4\x6e\x25\xd7\xf2\x3b\x0f\xe4\x99\x86\xc6\xe5\xcd\xf1\x4b\x2e\x18\xd0\xf4\x96\x4e\xc4\xb0\x29\x77\xfb\x3f\x00\xa5\x14\x12\x84\x9f\x65\x22\xc4\x02\x4c\x52\xc2\xbf\x7a\xcb\x9a\xc4\xe8\x04\xce\x33\x6c\xcd\xa2\xc3\x69\xe8\xaa\xf7\xf7\x7f\x7e\xff\xed\x0b\x54\xab\xf5\x0e\x8c\x43\x66\xdb\x59\x33\xad\x0b\x41\x7e\x2b\x8b\x6b\x95\x59\x57\xc3\xed\x4d\xb3\x8f\x18\xb5\xc3\x96\x70\xa6\x86\xad\x10\xc3\x12\x48\x4c\x59\xc2\x34\x25\x8d\x26\xab\xed\x34\xad\x40\x80\x47\xe8\x45\x22\xd7\xcb\xe5\xd1\x4a\x3f\x36\xa5\x09\xc3\x92\x03\xe1\x89\xd2\x32\x8f\xfd\x63\x86\x2e\x25\x11\x2d\x07\x64\xd1\x73\xc7\xbf\xa6\x6a\x12\x76\xf2\xf5\x2f\x7f\xbd\x3e\x7c\x02\x62\x7a\xb7\xa7\x32\xa4\xe3\x12\x1b\x5e\xae\x77\xeb\xaa\x5c\x6d\x36\x87\x5d\xb1\x00\x67\x8d\xb2\xad\x85\xbc\xc5\x37\x1f\xd6\xb9\xb7\x59\x92\x35\x42\x6d\xb1\x98\xc7\x40\x13\xbe\x61\xa7\xd1\xd0\x35\xb3\x80\xce\x26\x96\x09\x05\x72\x89\xa4\x4b\xf5\x0e\xaa\x69\xeb\x71\x0d\x56\xdb\x2d\xaf\xb3\xc5\xcc\x50\xd4\x3d\xf2\x11\xc5\x9d\x9d\x0c\x9a\x48\xcc\x90\x3a\xdb\xcb\x4e\xef\xac\x44\x4c\x38\x90\x50\xca\xb5\x51\x1f\x77\x47\xd9\x04\x40\x6b\x07\x1d\xbf\xe0\xb9\x86\x1f\x36\x0f\x50\x55\xdb\xfc\xf7\xe3\x2c\x1f\x08\x7d\x0d\x3f\xac\xab\xaa\xdc\xef\xab\x07\x58\xaf\x77\xe5\xf3\x76\xff\x00\xeb\x55\x55\x3e\x1f\x7e\x2c\xc2\x28\x71\x94\x29\x53\xcd\x3f\xbb\x09\x5d\x7e\x9e\x64\x05\xe4\xc3\x1a\x3a\x42\x19\x93\x66\xb8\xc8\xa3\x72\xdd\x94\x9f\xf1\xb7\x20\x0b\xf8\x65\x92\x93\x4d\x70\xd8\x90\x2b\xe0\x86\xcd\x64\x03\x2c\xb2\xaf\xbb\xe3\x9c\xc7\xec\x99\x5f\xc7\xe4\xea\xdc\x64\xf5\x72\xc9\x9b\x12\x07\xfc\x29\x78\x3c\xf3\xd4\x69\x12\x12\x95\xf9\x92\xc9\x6d\xc1\x17\xcf\x24\xbc\xcc\x75\xf1\x24\xf3\x41\x29\xef\x9a\x13\xdc\xac\x9a\x9e\xcc\x1b\x8f\x43\x0d\xdb\xb6\xda\x6c\x9b\xdd\x61\xb3\x41\x83\xdb\xed\x73\x75\x58\x3d\xed\x70\x7d\x58\xb5\xcd\x66\xb5\x7e\xc2\x22\xf7\xaf\x8e\xca\xc7\x95\xc7\x53\xf7\xc3\x31\x61\xec\xf3\xce\x3a\x93\x3d\xf6\x92\x67\x33\x8c\xc9\x90\xa6\x90\xa5\xaf\x11\xa5\xff\xff\xc3\xcf\xae\x78\x9a\x9b\x65\x22\xf6\xf9\xf3\xe3\xf1\x54\x2d\x5b\x8a\x2e\x5c\x5e\xef\xcf\xca\x98\x82\x84\x29\xb3\x39\x80\xdf\xcd\xdd\x27\x3f\x79\x8c\x73\x68\x05\x80\xe5\x57\x4c\xa6\xb7\x27\xed\x0e\x74\x4c\xb0\x00\xdb\xe9\x7e\x7a\xd0\x06\x9a\x76\x57\x83\x4c\x5a\x38\xb0\x0c\x08\x63\x72\x3a\x6a\xe8\x61\xd6\xcc\x05\xfe\xf9\x6f\xa1\xea\x77\xac\xdd\x13\x9b\xf3\x52\xb9\x87\x96\x7c\x98\xae\xc3\x5f\xb1\xd2\x59\x47\xf9\x73\x8c\x3f\x7a\x34\x57\xe2\xde\x5c\xbe\x22\xed\x14\xea\x2d\xa4\x0c\xbb\x6b\x8c\xd5\xae\x5b\xed\x91\xda\xc3\x8a\x0e\xfb\xf6\x69\xd3\x36\xfb\xcd\xb6\xdb\x74\xd5\x01\xab\x66\xdd\xad\x0b\x80\x0f\xda\x6f\xdd\xd4\x3e\x1f\xb6\xdd\x76\xbf\xdf\x9a\xee\xf0\xb4\xdb\x57\x87\x6a\xfd\x8c\x2d\x1e\x9a\x8e\xcc\x6a\xf5\xbc\x2d\x50\x24\xd9\x66\x94\x69\xfb\xd2\xbb\x24\xd4\x3b\x45\x3f\x1d\xe0\x26\x2b\x00\xde\xac\x6f\x6b\xf8\xf2\xf2\x32\x33\xa3\xef\x9a\x91\xa7\x31\xa1\xbb\xea\xfc\xf1\xcb\xcb\xcb\x03\x7c\xd3\xbf\xb2\x2c\xff\xa4\x93\xab\x9f\x8f\xd6\x1f\x5f\xe7\x2b\xb0\xbe\x5d\x8a\x8b\xeb\xb5\xf8\xf1\x19\x98\xbf\x4f\x67\x85\x02\x60\x40\x6f\x3b\x62\x79\xc5\x51\xfa\x90\x6a\xc0\xa6\x1d\x5d\x5b\xfc\x37\x00\x00\xff\xff\x21\x66\xde\x99\x11\x0b\x00\x00")

FileResNet269V2Yml is "/ResNet269-v2.yml"

View Source
var FileResNet50Yml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x04\xff\xac\x56\x5f\x8b\xe3\x36\x10\x7f\xf7\xa7\x18\x08\x85\x16\x36\x76\x12\x27\xd9\xc4\x0f\x85\x63\x1f\xae\xa5\x65\x0b\xd7\x72\x7d\x38\x8e\x65\x2c\x8f\x63\x75\x65\x49\x48\xe3\x64\x73\x9f\xbe\x8c\xec\x4d\x72\x77\xf4\xda\x87\xe6\x21\x58\x9a\xff\xbf\xf9\x69\x24\x8b\x3d\x55\xf0\x8e\xe2\x23\xf1\x66\x01\x33\x90\x0d\x70\x2d\x9c\xdd\x10\xa0\x77\x0d\x99\xac\x0d\xd8\xd3\xc9\x85\xe7\x2a\x83\x24\xaf\xe0\x01\xdb\x96\x60\x06\x17\x11\xb4\x2e\x00\x77\x34\x99\x00\x1c\x29\x44\xed\x6c\x05\xcb\x5c\xdc\x5e\x15\x27\x01\x28\x67\x39\xa0\xb6\x9c\x4d\x3b\xaf\xaa\xd3\x12\xb4\x6d\x5d\xe8\x91\xb5\x93\x6f\x88\xd4\xa3\x65\xad\x2e\xf2\x51\x9a\x89\x1f\xd4\x96\x42\x05\xb3\xe4\x34\x2d\x22\x0c\x91\x1a\x60\x07\x9e\x82\x68\x8e\x89\x81\x0f\xd4\x68\x25\x3e\x33\xb8\xfe\x66\xd0\x0f\x86\xb5\x37\x04\xde\x20\x8b\x7e\x04\x85\x16\x6a\x82\xe8\x49\xe9\x56\x53\x93\x01\x60\xdf\x6c\xd7\x82\x02\xc0\xc1\x0f\x15\x04\xd4\x3e\xb8\xbf\x48\x71\xa1\x30\xf4\x66\xae\x04\x97\x2a\xa9\xcd\x95\x1f\x52\x0c\xf5\xaf\x9a\x87\xa4\xe9\xbd\xda\xae\x0d\x8d\xee\xbf\x65\x34\x29\x4e\x66\xdf\x4e\xe5\x56\xb7\xa1\xa8\x82\xf6\x52\x7c\x05\x3f\x66\x00\x6f\xa4\xf1\xba\x19\xd0\x80\x21\x0c\x56\xdb\xc3\x4d\xa3\xd8\x01\x61\xa4\xd4\xd5\xd4\x29\x11\xbb\x16\x2c\xb1\x90\x21\x02\x77\xc8\x80\x81\x20\x0e\x75\x64\x69\x0e\x1a\x73\x86\x86\xc8\x93\x90\x01\x2d\x70\xe7\x22\x8d\xad\xf0\x81\x8e\xda\x0d\xd1\x9c\xf3\x0c\xe0\x4f\x02\x7a\xf1\x46\x2b\xcd\xe6\x0c\x81\x04\xf2\xc1\x20\x8f\xe1\x0c\x9e\x29\x44\xc0\x78\xcd\x2b\xd0\x94\x69\x3b\xd8\xd4\xbf\x08\x27\xcd\x9d\x98\x52\x20\xab\x48\xf2\x15\x02\x26\x5b\xd0\xd6\x0f\x1c\xef\x40\xdb\xc8\x84\x8d\xe4\x7d\x29\x71\xb0\x81\x26\xa3\xe6\xea\x6e\xca\xca\x07\x77\xd4\x0d\x81\x72\xbd\x0f\xd4\x91\x8d\xfa\x48\x40\xbd\xd7\x41\x2b\x34\x40\x22\x95\x70\xb1\x73\x27\x41\x24\xa1\xc0\x1d\x45\xba\xe6\x78\x81\x48\xd0\x21\x8c\x5a\xf0\x70\xe0\x3c\xeb\x5e\x7f\xa2\x3b\x40\xdb\x24\x7e\x1d\x50\x5b\x40\xa5\x86\x80\xea\x0c\x6d\x70\xbd\x50\x38\xea\x86\x02\xd6\xe6\x0c\xda\xaa\x20\x4d\x68\xa0\x21\xcf\x9d\xe4\xf8\x9b\xa0\x4a\xf0\x73\x8f\x07\x7a\x24\x86\x06\x19\x23\x31\x9c\x08\xe8\x88\x66\x10\x0c\x2f\x60\x59\xe2\x09\x27\x1c\x3d\x08\x10\x83\x17\xac\x96\x9b\xd5\x88\x55\x9c\xcf\xe7\xbb\x97\xcf\xda\xf6\xfe\xed\xdb\xd1\xb4\x1e\x18\x22\x6b\x63\xa0\xc3\xa3\x54\x6b\xdc\x89\x42\x02\xc7\xd0\x8b\xe6\xd4\xcb\x37\x16\xc8\x46\xea\x6b\x93\x26\xc7\xd7\x58\x44\x40\xd5\x69\x3a\x52\x84\x32\xdf\xdc\x7f\x07\x14\x82\x0b\xe0\xbe\xa8\x84\x29\x32\x44\xe2\x1c\xfe\xe8\x74\x94\x22\x06\xc3\x70\x9a\xd4\x96\x91\xe5\x70\x2a\xba\xd8\xfd\xfa\xfb\xfb\x77\x0f\xb0\x5a\x2c\x37\xa0\x0c\xc6\xa8\x5b\xad\xc6\x71\xc1\x18\x9f\xf3\xec\xd2\xe5\x28\xa3\xe1\xba\x92\xea\x3d\x7a\x61\x58\x01\x27\xaa\xa3\x66\x8a\x50\x00\xb1\xca\x73\x18\x4f\x49\x2d\xc5\x0a\x9d\xc6\x11\x08\x30\x87\x8e\xd9\xc7\xaa\x28\x0e\x9a\xbb\xa1\xce\x95\xeb\x8b\x5f\x50\xf7\xda\x1e\x7e\xa2\x42\x48\x3f\x7f\x85\x7d\xfe\xda\xff\xcf\xec\x30\xbc\xe8\x63\xee\xc2\xa1\xc0\x3a\x16\xcb\xcd\x72\x95\x2f\xca\x72\xb7\xc9\x66\x60\xb4\x12\x04\xa5\x39\xd7\x98\xd3\x66\x95\xf8\x1a\x39\x68\xc5\xd4\x64\xb3\x89\xda\x52\xc4\x55\x77\xa4\xbb\x8c\x8e\x19\xb4\x3a\x44\x1e\xb5\x80\xcf\x9e\x64\x50\xde\xa8\x4a\x29\xb2\x5d\x81\x16\x0a\xa5\x11\x35\x9b\xaa\xf6\x32\x1b\x5e\xb3\xb8\xf1\x93\x94\x46\x60\x92\x4a\x95\xfc\xa5\xa0\x37\x5e\x3c\x06\xec\x89\x29\x24\xbc\x25\xc6\xcd\x56\x72\x01\xd0\xe8\x5e\x8e\x94\xb3\xb1\x82\x0f\xe5\x1d\xac\x56\xeb\xf4\xf7\x71\x92\xf7\x84\xb6\x82\x0f\xcb\x55\x99\x6f\x77\x77\xb0\x5c\x6e\xf3\xfb\xfb\xfd\x1d\x2c\x17\x65\xbe\x2f\xf7\x1f\x33\x37\xb0\x1f\x78\xac\x54\xea\x4f\x61\x5c\x9b\xbe\x47\x59\x06\x69\xb3\x82\x96\x90\x87\x20\x15\xce\x12\xfd\x2f\xd3\xef\x73\xfd\x6b\x92\x19\x7c\x5d\xe4\xe8\x13\x0c\xd6\x64\x32\xb8\xea\x26\xb0\x01\x66\x29\xd6\xcd\x76\xaa\x63\x8a\x1c\x9f\x86\x60\xaa\x44\x9c\xaa\x28\x62\x99\x63\x8f\x9f\x9c\xc5\x53\x4c\xec\x89\xec\x02\xe5\xe9\xe2\x48\xb4\x88\x67\x1b\x89\x63\x91\xfa\x62\x89\xa7\x8d\x9c\x5f\xa4\x26\xb8\x7a\x55\x1d\xa9\xe7\x38\xf4\x15\xac\x9b\x55\xb9\xae\x37\xbb\xb2\x44\x85\xeb\xf5\x7e\xb5\x5b\x6c\x37\xb8\xdc\x2d\x9a\xba\x5c\x2c\xb7\x98\x25\xfa\x0a\xfd\x5f\xaf\xb1\x38\x32\x1a\x0e\x01\x7d\x97\xe6\xd0\x89\xf4\xa1\xe3\x74\xde\xdc\x10\x14\x49\x09\x49\xfa\xe4\x91\xbb\xff\x9e\x7e\x0a\x15\x8b\x74\x05\x16\x81\xa2\x95\x17\x45\x31\x3e\x2d\xe6\x9b\xc5\xbc\x21\x6f\xdc\x39\xf7\xc1\xb1\x1b\x4b\x9a\x22\xff\xcf\x71\x52\x1e\x79\x4a\x23\x7d\x66\x00\x3a\x3e\x61\x50\x9d\x3e\x0a\x2b\xd0\x44\x82\x19\xe8\x56\x66\xcd\x9d\x10\x67\x9c\x43\x35\x46\x92\x86\x81\x8e\x80\x30\x04\x23\x47\x0c\x2d\x4c\x96\xa9\xb1\x5f\xfe\x66\x62\x7e\x83\xd6\x2d\xa0\xa9\x2c\x91\x5b\x68\xc8\xba\xf1\x6a\xfb\x07\x2f\xad\x36\x94\x9e\x56\xf1\x95\x9b\xa9\x03\xb7\xee\xd2\x75\xa7\xc7\x54\xaf\x29\x25\xb5\x5b\x42\xd4\x58\xb6\xfb\xf5\x86\xee\xeb\xdd\xb6\x5e\xdc\x6f\xd7\x3b\x5a\xb7\xeb\x72\xb3\x6c\x68\xb1\xdd\xef\x33\xb8\xa0\x7e\xc3\xa2\x75\xbd\x5a\x6c\xb7\x0b\xb5\xd9\xaf\x77\xe5\x7e\x79\x5f\xae\x17\xe5\x76\xbf\x2d\x69\xb7\xd9\x34\xcd\x2a\x43\xe6\xa0\xeb\x81\x29\x9d\x6c\x7a\xe1\x80\x72\x3f\xc8\x33\x00\xae\xb2\x0c\xe0\x59\xdb\xa6\x82\x87\xc7\xc7\x09\x19\x59\x4b\x45\x96\x86\x80\xe6\x62\xf3\xfd\xc3\xe3\xe3\x1d\xbc\x93\xbf\x3c\xcf\x7f\x90\x13\x2b\x4f\x41\x6d\x0f\x4f\xd3\x75\x56\x5d\x2f\xb8\xd9\xe5\x8a\x7b\x7d\xd2\xa5\xb7\xe6\x64\x90\x01\xf4\x68\x75\x4b\x91\x9f\x70\xe0\xce\x85\x0a\xb0\x6e\x06\xd3\x64\x7f\x07\x00\x00\xff\xff\xc2\x2d\x23\x58\xdc\x0a\x00\x00")

FileResNet50Yml is "/ResNet50.yml"

View Source
var FileShufflenet1xG3Yml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x04\xff\xbc\x56\x4b\x8f\xe4\x34\x10\xbe\xe7\x57\x7c\xda\x3e\xb0\x2b\xcd\x24\xe9\xc7\xcc\x4e\xe7\x80\x84\x86\x45\xe2\xc0\x1c\x60\x91\x10\x08\xb5\xaa\x9d\x4a\x62\xc6\xb1\xb3\xb6\x33\x33\xcd\xaf\x47\xe5\xa4\x37\xbd\x3c\x16\x71\xe1\x92\xb6\x5d\x5f\x55\x7d\xf5\x70\xb9\x2d\xf5\x5c\x21\x74\x63\xd3\x18\xb6\x1c\x0f\xeb\x97\x43\xbb\xc5\x0a\x22\x80\x6b\x70\x72\xa3\x47\xef\x6a\x36\x59\xe3\xa9\xe7\x67\xe7\x1f\xab\x0c\x49\x5e\xe1\x9e\x9a\x86\xb1\xc2\x47\x11\x1a\xe7\x11\x3b\x9e\x55\x80\x27\xf6\x41\x3b\x5b\x61\x9d\x97\x9f\x00\x67\x01\x94\xb3\xd1\x93\xb6\x31\x9b\x4f\xce\xd0\x79\x0b\x6d\x1b\xe7\x7b\x8a\xda\xc9\x1a\x81\x7b\xb2\x51\xab\x8f\xf2\x49\x9a\x89\x1d\xd2\x96\x7d\x85\x55\x32\x9a\x36\x01\x63\xe0\x1a\xd1\x61\x60\x2f\xc8\x89\x18\x06\xcf\xb5\x56\x62\x33\x03\x56\xe8\x47\x13\xf5\x60\x18\x83\xa1\x28\xb0\x00\x45\x16\x47\x46\x18\x58\xe9\x46\x73\x9d\x01\xd4\xd7\xb7\x3b\x09\x1e\x68\x87\xb1\x82\x27\x3d\x78\xf7\x1b\xab\x58\x28\xf2\xbd\xb9\x56\x92\x8e\x2a\xc1\xae\xd5\x30\x66\x00\xa0\xfe\x15\xd9\x26\xe4\x30\xa8\xdb\x9d\xe1\xc9\xfc\xe7\x94\x66\xe0\xac\xf6\x79\x2a\x97\xd8\x9a\x83\xf2\x7a\x90\x98\x2b\x7c\x99\xbd\xef\x74\x80\x96\x38\xa5\x84\xba\x1f\x0c\xf7\x6c\xe3\x94\x67\xd7\xe0\x87\xa9\x27\x1e\x38\x5e\xe1\x1b\xe7\x51\x73\x24\x6d\xc2\x15\x06\xc3\x14\x18\x9e\xa9\x4e\x95\x76\x5e\xb7\xda\x92\xc1\x40\x03\xfb\x2a\x7b\xb5\x68\x56\xf8\xca\xe2\xdd\x4b\xf4\xdc\xb3\x39\xe1\x5d\xd3\x68\xa5\xd9\x46\xdc\x3b\xfb\xe4\xcc\x28\x5c\xc8\xe0\x81\x47\x9f\x7e\xa2\x74\x97\x14\x14\xdf\xb9\xa3\x36\x8c\xaf\xf9\x49\x2b\x0e\xaf\x70\x3c\xe1\x27\x4d\xb6\x3d\x8d\xf8\xb9\x23\xdb\x82\x63\x0e\x32\x39\x36\xe5\xfa\x6d\x8e\xf7\x12\x8c\x72\x35\x4b\x44\x47\x92\x92\x3b\x0b\x45\x3d\x9b\xb2\x7c\xfb\x45\xf8\x53\x7c\xaf\xbb\x18\x87\x50\x15\x45\xab\x63\x37\x1e\x73\xe5\xfa\xe2\x0c\x2e\x52\x4f\x5f\x2f\x41\xbc\xb9\xc2\x71\x8c\xf8\x16\x9e\x93\x07\xe9\x6e\x35\xd6\x84\x46\x18\x4a\xbf\x93\x52\x6c\xd8\xa7\xd4\xe5\x99\xe7\x86\x3d\x5b\xc5\x41\x3a\x71\xd9\xa5\x26\x94\x14\x05\x14\x78\xe6\x63\xd0\x91\x65\xc9\x51\xe5\x39\xa6\xea\x1c\xb5\x6d\x93\x83\xe9\xc6\x01\xd7\xf8\x1b\xaa\x0d\xf9\x5e\xdb\xf6\x44\xbe\x2e\x16\x9e\xff\x0d\x5d\xe8\x10\x46\x0e\xc5\xfa\x9f\xd4\xfa\x60\x3f\x7c\x60\x7f\xe9\x20\x5b\xc1\x68\xc5\x36\xa4\xc9\x20\x79\x98\x68\xce\x87\x15\x46\xeb\x39\x44\xaf\x55\xe4\x3a\x5b\x41\xdb\x61\x8c\x29\xee\x05\x3b\x9d\x49\x97\xaf\xd0\x68\x1f\xe2\x84\x42\x3c\x0d\x9c\x92\xb9\x40\x25\x7a\x39\xae\xa0\x7b\x6a\x39\xdd\xa6\xd5\x9c\xa8\xd4\xc6\xd2\xa6\x02\xbf\xb0\x93\x40\x53\x2e\x13\xa4\x4a\x80\xe4\xf4\xc2\xca\x40\x32\xca\x22\xfb\x54\x22\xf1\x71\x71\x94\x4c\x00\xb5\xee\xd9\xca\xe8\x0a\x15\x7e\xd9\x5e\x61\xb3\xd9\xa5\xcf\xaf\x99\x1b\xe3\x30\xc6\x29\x04\x71\x9f\xf4\x5d\x93\xd6\x93\x2c\x43\x3a\xac\xd0\x30\xc5\xd1\x0b\xf5\x15\xe8\x92\xd7\xa7\xf8\xc5\x7b\x86\x4b\xd4\xc4\x7e\xb2\x09\x43\x47\x36\x19\x16\x6c\xca\xa2\x4c\xaf\x44\x60\x89\x29\x05\x30\x7b\x0e\x87\xd1\x9b\x2a\x35\x51\x55\x14\x35\x45\xca\xeb\xde\xa8\xbc\x37\x45\xff\x62\x39\x16\xa9\x82\xa1\x48\x19\x96\x7d\x38\xd9\xc0\x31\x8f\x2f\x12\x04\x16\x33\xaa\x63\xf5\x18\xc6\xbe\xc2\xae\xde\x6c\x77\xc7\x9b\xbb\xed\x96\x14\xed\x76\xfb\xcd\x5d\x79\x7b\x43\xeb\xbb\xb2\x3e\x6e\xcb\xf5\x2d\x65\xc9\xa4\xf4\xfe\x79\x76\x86\xa9\x4f\xd0\x7a\x1a\x3a\x90\xad\xf1\xcc\xba\xed\x62\x80\xe7\xe0\x46\xaf\x58\x38\x27\xe9\x61\xa0\xd8\x4d\x7c\xe5\x7e\x86\x6d\x4e\x3d\xfd\xee\x2c\x3d\x87\x74\x4b\x43\x74\x9e\xf3\x34\x6d\x73\xe7\xdb\x33\xfd\x34\x78\x8b\xe5\x19\xbb\x58\x4e\x2f\xda\x5f\x0e\x0e\x35\x0f\xc6\x9d\xf2\xc1\xbb\xe8\xa6\x68\x67\x52\xff\x1b\x85\x3c\xb1\x4e\xd9\xca\x00\x1d\x0e\xe4\x55\xa7\x9f\xe6\x27\xa0\x21\x13\xe4\x69\xd5\x0d\x82\xcc\xe0\xd8\xb1\x95\x4f\x1a\x6f\x52\x55\x19\x75\x84\xd1\x1b\x19\x2c\x64\x31\x6b\xa7\xea\xaf\x12\x72\xc9\xe8\x65\xd2\x53\x7c\x22\xb7\xa8\xd9\xba\xc8\xb2\x9e\xb5\xd2\x48\x93\xa7\x3f\x9c\x1b\x34\xd9\xb8\x54\xc7\xb3\x8e\x9d\x9e\xa8\x2c\x2e\x13\xec\xa2\x49\x6e\x68\x53\xef\x6a\xba\x69\x14\xed\xeb\x7d\xb9\xdf\x6f\xd7\xb7\xb7\xe5\xee\xae\x51\x9b\x9a\xd6\x2c\xfe\xce\xe9\x5e\x3a\xeb\x6d\xbd\xdf\xde\x31\x97\xfb\x7a\xb7\xbb\xb9\x2b\x89\xa9\xdc\xd3\xba\xdc\xae\x9b\x7d\xb9\xd9\xdd\xee\x33\x8a\xd1\xeb\xe3\x18\xa7\xd1\xca\x2f\xd1\x13\xec\xfc\x6a\x2c\xb2\x0c\x78\xd4\xb6\xae\x70\xff\xf0\x30\x67\x42\xf6\x12\x91\xe5\xf4\xd2\x9c\x75\x5e\xdf\x3f\x3c\x5c\xe1\x7b\xf9\xe4\x79\xfe\x46\xae\xad\xfc\x15\xd1\xb6\x3d\xc8\x55\x09\x1c\x2b\xfc\x68\x1f\xad\x7b\xb6\x32\x79\x28\xca\xd1\xc7\x7f\x14\x32\xfa\xcf\xf8\x0c\xe8\xc9\xea\x86\x43\x3c\xd0\x18\x3b\xe7\x2b\xa8\x8e\x6d\x9b\xfd\x11\x00\x00\xff\xff\xac\x57\x85\x6e\x62\x09\x00\x00")

FileShufflenet1xG3Yml is "/shufflenet_1x_g3.yml"

View Source
var FileSphereFaceYml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x04\xff\xb4\x55\x3d\x8f\xe3\x36\x10\xed\xf5\x2b\x1e\xe0\x26\x01\x76\x65\xcb\xdf\x56\x11\xe0\xb0\x49\x90\x34\x5b\xdc\x15\x29\x0e\x81\x31\x22\x87\x16\xb3\x12\x49\x90\xd4\xf9\x36\xbf\x3e\x20\xa5\x5d\x29\x29\x2e\x4d\xd2\xd8\xd4\xcc\x9b\x8f\x37\x9c\x19\x1a\xea\xb9\xc6\x27\xd7\xb2\xe7\x9f\x49\x30\x56\x48\x22\x58\x85\x57\x3b\x78\xf4\x56\x72\x57\x28\x4f\x3d\xdf\xad\x7f\xa9\x0b\x64\x7d\x8d\x27\x52\x2a\xa1\xdf\x55\x50\xd6\x23\xb6\x3c\x99\x00\x5f\xd8\x07\x6d\x4d\x8d\xaa\xdc\x60\xb5\x00\x4e\x0a\x08\x6b\xa2\x27\x6d\x62\x31\x49\xde\xa0\xd3\x27\xb4\x51\xd6\xf7\x14\xb5\x4d\x67\x04\xee\xc9\x44\x2d\xde\xf5\xa3\xb6\x48\x7e\x48\x1b\xf6\x35\x56\xd9\x69\xfe\x08\x18\x02\x4b\x44\x0b\xc7\x3e\x21\xc7\xc4\xe0\x3c\x4b\x2d\x92\xcf\x02\x58\xa1\x1f\xba\xa8\x5d\xc7\x70\x1d\xc5\x04\x0b\x10\x64\xd0\x30\x82\x63\xa1\x95\x66\x59\x00\xd4\xcb\xe3\x3e\x91\x07\x6e\x6e\xa8\xe1\x49\x3b\x6f\xff\x60\x11\xd7\x82\x7c\xdf\x3d\x8a\x54\x8e\x3a\xc3\x1e\x85\x1b\x0a\x00\x10\xff\x8a\xbc\x65\xa4\x73\xe2\xb8\xef\x78\x74\xff\x2d\xa3\x09\x38\x99\x7d\x3b\x95\x25\x56\x72\x10\x5e\xbb\xc4\xb9\xc6\x0f\x05\xf0\x23\xb3\xc3\x2f\xaf\x8e\x7d\xc8\x37\x8f\x9f\xfa\x86\xa5\xd4\xe6\x96\x6a\x8a\xdc\x08\x1f\x59\xd8\x9b\xd1\xc9\xa8\xf0\xac\xd8\xb3\x11\x1c\x52\x89\xe7\xaf\x5c\x5d\x4a\x6e\xb0\xc6\x9d\x9b\xa0\x23\xa7\x23\x47\x51\x96\x18\xc3\x36\xc9\xeb\xb2\x2f\x1e\xd1\xc6\xe8\x42\xbd\x5e\xdf\x74\x6c\x87\xa6\x14\xb6\x5f\xdf\x5f\x2b\x3d\xac\xc7\x6c\x14\x09\x2e\x56\xe8\xb4\x60\x13\x72\x2b\xce\xe6\x93\xb0\xc6\x60\x3c\x87\xe8\xb5\x88\x2c\x8b\x15\xb4\x71\x43\xcc\xf9\xcc\xd8\x51\x96\xca\xba\x82\xd2\x3e\xc4\x11\x85\xf8\xea\x38\xf3\x9c\xa1\xc0\x63\x16\xd7\xd0\x3d\xdd\x38\x5f\xdf\x6a\x22\x90\xeb\x96\x06\x22\xc1\x17\x7e\x32\x68\xe4\x98\x21\x75\x06\xe4\xa0\x0b\x2f\x8e\xd2\xec\x44\xf6\xb9\x74\x39\xf4\x2c\xca\x2e\x00\xa9\x7b\x36\x69\x56\x42\x8d\xcf\xbb\x07\x54\xd5\xf6\x01\x97\xe3\xef\x93\xba\x67\x32\x35\x3e\x57\xdb\x53\x79\x78\xc0\xf2\xef\x0d\x11\x04\x75\x5c\xa3\xda\x9e\x0b\x3b\x44\x37\xc4\x91\x74\x4a\x38\x47\xb4\x2a\x9f\x47\x5d\x81\x2c\xac\xa1\x98\xe2\xe0\x13\xd9\x15\x68\xc9\xe4\xef\xf8\x39\xdf\x02\x4b\xd4\xc8\x77\xf4\x89\x8e\x1a\xee\x0a\xcc\xd8\x5c\xf7\x34\x60\x39\x81\x7f\x50\x9e\x22\x87\xeb\xe0\xbb\xfa\xbd\x1d\xc2\xae\xa4\x9e\xfe\xb4\x86\xee\x21\x37\x45\x88\xd6\x73\x99\x07\xac\xb4\xfe\xb6\xce\xcb\x28\xac\xf3\xac\x2d\x7a\x65\xed\x48\xfb\x50\xc6\xaf\x89\x1a\x66\xe7\xa2\x65\xf1\x12\x86\xbe\xc6\x45\x55\x0d\x55\xa7\x3d\xef\xb9\x12\x87\xcd\x59\xa9\x93\x90\xaa\xda\x90\xd8\xed\xce\x74\x92\x45\xf6\x9c\x7a\xfb\x6d\xe8\xc3\xb4\x2d\x6e\x9e\x5c\x0b\x32\x12\x77\xd6\xb7\x36\x06\x78\x0e\x76\xf0\x82\xd3\xe5\x65\xed\xd5\x51\x6c\xff\x03\x16\x73\xf3\x5f\x25\xbb\xce\xbe\x96\xce\xdb\x68\x47\x5a\x53\xf4\xff\x21\x56\xa6\x5e\xe6\x9a\xe6\x63\x01\xe8\x70\x25\x2f\x5a\xfd\x65\xda\x49\x8a\xba\x90\x76\xbd\x56\x08\x1c\x1f\x52\x2f\x99\xf4\x83\x86\x02\xa7\x3b\x84\x0e\x20\x0c\xbe\x4b\x0b\x81\x0c\x26\xeb\xdc\xbf\xab\x8c\x9c\x2b\xb5\x2c\x66\xa6\x93\xf4\x06\x92\x8d\x8d\x9c\xce\x93\x95\xd2\x1d\xe7\xb7\x26\xbc\xb5\x63\xf6\xb1\x34\xc7\x5d\xc7\x56\x8f\xa9\xcc\x21\x33\x6c\x71\xf9\xc7\xa3\x38\x1d\x36\xcd\x89\x2e\x17\x49\xbb\xfd\x5e\x9d\xab\xd3\x61\x4b\x07\xb9\x69\x48\x6e\x28\xad\xf7\xb7\xea\x2e\x3a\x66\xb3\x95\xe7\xcb\x79\x23\x77\xbb\xcb\xe9\x70\xb8\x70\xb5\x15\x47\xb9\x57\x82\x78\xdf\x9c\xa8\x29\x28\x46\xaf\x9b\x21\x72\x9e\x6b\xfe\x1a\x3d\xc1\x70\x4c\x8f\x24\x66\x5d\x01\xbc\x68\x23\x6b\x3c\x3d\x3f\x4f\x95\x48\xdf\x89\x91\xe1\xc1\x53\xf7\x6e\xf3\xdd\xd3\xf3\xf3\x03\x3e\xa6\x9f\xb2\x2c\xbf\x4f\x43\x9a\xde\x46\x6d\x6e\x57\x49\x91\x02\xc7\x1a\x4f\x1f\x3e\xfd\xfa\xe1\xf1\x37\x6e\xf2\x82\x5e\x61\x52\xbc\x3f\x74\xf9\x05\x9e\xac\x0a\xa0\x27\xa3\x15\x87\x78\xa5\x21\xb6\xd6\xd7\xa0\x46\x0e\x9d\x2c\x5a\x2d\x25\x9b\x1a\x8a\xba\xc0\xc5\x5f\x01\x00\x00\xff\xff\xa4\x01\xa2\xfd\x02\x08\x00\x00")

FileSphereFaceYml is "/SphereFace.yml"

View Source
var FileSqueezeNetV10Yml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x04\xff\x8c\x56\x4d\x6f\xdc\x38\x0f\xbe\xfb\x57\x3c\xc0\xa0\xc0\xfb\x02\x89\x3d\x5f\x4e\xa6\x3e\x2c\xd0\xed\x5e\x7a\xc9\xa1\x3d\x16\x45\x40\xcb\xf4\x58\x1b\x59\x72\x25\x39\x93\xf4\xd7\x2f\x28\x3b\x63\x77\x81\xed\xee\x1c\x0c\x8b\x7c\xf8\xf0\x43\x24\xc7\x96\x7a\xae\xf0\xe5\xfb\xc8\xfc\x83\x1f\x38\x62\x03\x11\xc1\xb5\x78\x75\xa3\x47\xef\x1a\x36\x59\xeb\xa9\xe7\x8b\xf3\x4f\x55\x86\xa4\xaf\xf0\x91\xda\x96\xb1\xc1\x55\x85\xd6\x79\xc4\x8e\x67\x13\xe0\x99\x7d\xd0\xce\x56\xd8\xe5\xdb\x9f\x80\xb3\x02\xca\xd9\xe8\x49\xdb\x98\xcd\x92\x37\xe8\x7c\x84\xb6\xad\xf3\x3d\x45\xed\xe4\x1d\x81\x7b\xb2\x51\xab\xab\x7e\xd2\x66\xc2\x43\xda\xb2\xaf\xb0\x49\xa4\xe9\x10\x30\x06\x6e\x10\x1d\x06\xf6\x82\x9c\x02\xc3\xe0\xb9\xd1\x4a\x38\x33\x2c\xbf\x0d\xfa\xd1\x44\x3d\x18\xc6\x60\x28\x0a\x3e\x40\x91\x45\xcd\x08\x03\x2b\xdd\x6a\x6e\x32\x80\xfa\xe6\xee\x28\x55\x00\xce\xc3\x58\xc1\x93\x1e\xbc\xfb\x93\x55\x2c\x14\xf9\xde\xdc\x2a\xa9\x4b\x95\x60\xb7\x6a\x18\x93\x0f\xf5\xaf\xc8\x73\x42\x0e\x83\xba\x3b\x1a\x9e\xe8\x7f\x65\x34\x03\x67\xb3\x5f\x87\xb2\xc6\x36\x1c\x94\xd7\x83\x24\x5f\xe1\xb7\x0c\x6f\x17\x6f\x39\x82\x54\xa7\xf9\x99\x03\x82\xee\xb5\x21\x0f\xcf\x61\x34\x31\x48\x05\x3f\x18\x7e\x79\xe0\x78\x03\x8a\x28\xb7\x2f\x68\xf9\xc2\x1e\x03\x49\x5b\x44\xf6\x01\x64\x1b\xec\x8a\x72\xbb\x8d\x5d\xea\x81\xa0\x7f\x70\x2e\xfc\x3d\x19\x33\x15\x3e\x80\xbc\x34\x87\x67\xb4\x4c\x41\xd7\x86\x85\xba\xe1\xc1\xb8\x57\x38\x8b\x8e\x7c\x73\x11\xcc\x45\xc7\x0e\x46\xf7\x3a\x72\x83\x9e\x7b\xe7\x5f\x6f\xe0\xf9\xfb\xa8\x3d\xc3\x70\x08\x19\xa0\x5c\xdf\x8f\x56\x2b\x92\x5c\xd0\x8c\x5e\xdb\x33\x1a\x1d\xa2\xd7\xf5\x28\x76\xa9\xb3\xb4\x3d\xdf\xa4\xd8\x84\x56\x9c\xb2\x4f\x3e\xaf\x38\x39\x29\xa3\xd9\xc6\x90\xc2\x5d\xe6\xe0\x5a\x8e\xf2\x3e\x2f\xdf\x25\x92\xd3\x36\x3f\xbc\x43\x74\xc3\xed\x2e\x9d\xe5\xad\x04\xa9\xd1\x93\x8a\x29\x85\x4f\x3d\x9d\x65\x8a\xf2\xcc\x73\xcb\x9e\xad\xe2\x20\x4d\xb9\x9c\xc4\xe1\x40\x83\xd4\xac\xc0\x85\xeb\xa0\x23\x07\x14\xe0\xa8\xf2\x1c\xd3\xfd\xd4\x92\xcb\x7a\x92\x6e\xd1\xc5\x38\x84\xaa\x28\xce\x3a\x76\x63\x9d\x2b\xd7\x17\x7f\x30\x0f\x5f\x14\x19\x2e\x96\xa8\x33\xac\xb0\xe4\x5f\xf4\x73\xee\xfc\xb9\xa0\x3a\x14\xbb\xbb\xed\x3e\xdf\xde\x1f\xee\xb6\xd9\x06\x46\x2b\xb6\x21\x4d\xf9\xe2\x67\x16\x56\xf8\xfd\xc3\xa7\xcf\xd9\x06\xda\x0e\xe3\x74\xfd\x0b\x66\x92\x49\x83\x6e\xd0\x6a\x1f\xe2\x84\x42\x7c\x1d\x58\xc6\x71\x05\x95\x50\x44\x5c\x41\x4b\x55\xd2\x20\x6c\xe6\x0c\x53\x07\xca\x8e\x11\xe6\x15\x4f\x02\x4d\x45\x48\x90\x2a\x01\x92\xd3\x15\xcb\xd2\x77\x52\x5b\xf1\xb1\x12\x25\x0a\xa0\xd1\x3d\x5b\x59\x3f\xa1\xc2\xd7\xc3\x0d\xf6\xfb\xfb\xf4\xf8\x36\xeb\x7b\x26\x5b\xe1\xeb\x6e\x7f\xba\xc1\xdb\xe3\x5b\xe6\xc6\x38\x8c\x71\x4a\x4f\x42\x4b\xdc\xae\x4d\xef\x93\x2e\x43\x12\x56\xd2\xc3\x71\xf4\x92\xd6\x06\xb4\x8e\xf9\x67\xfc\x12\x59\x86\x35\x6a\xca\x6c\xe2\x84\xa1\x9a\x4d\x86\x05\x9b\x2a\x0c\x6c\x92\xaf\x95\x38\x05\xdf\x72\xf2\x1c\x1e\x47\x6f\xaa\xd4\x19\x55\x51\x34\x14\x29\x6f\x7a\xa3\xf2\xde\x14\xfd\x8b\xe5\x58\xa4\xd5\x1d\x8a\x54\x7d\x39\x87\x57\x1b\x38\xe6\xf1\x45\x92\xc0\x42\xa3\x3a\x56\x4f\x61\xec\x2b\x1c\x9b\xfd\xe1\x58\x97\xa7\xc3\x81\x14\x1d\x8f\xef\xf7\xa7\xed\x5d\x49\xbb\xd3\xb6\xa9\x0f\xdb\xdd\x1d\x65\x89\x52\x8a\xfe\xb6\x12\xc3\x34\xdb\x38\x7b\x1a\xba\x34\x14\x17\xd6\xe7\x2e\x06\xd9\x1e\x6e\xf4\x8a\x25\xe6\x9a\x02\x2f\xd1\xfe\x87\x3e\x2e\x3c\x5d\x8a\x9e\x42\x64\xbf\xea\xee\xc7\xe7\x5d\xbe\x2d\x32\x4c\xde\x1e\x07\x8a\x5d\x35\xef\x8f\x7c\xf0\x2e\xba\x29\xb5\x39\x82\x59\x1f\xa6\x91\xb6\x3c\x99\xe7\x69\x3f\xa7\x3c\x32\x40\x87\x47\xf2\xaa\xd3\xcf\x72\xa1\x64\x82\xfc\xa1\xe9\x16\x41\x56\x5d\xec\xd8\xca\xe3\x1a\x3d\x74\x00\x61\xf4\x46\x66\x98\x2c\x66\xcb\x74\x27\x7f\xff\x6d\x92\x65\xaa\x4a\x8a\x63\x5d\x9a\x49\x90\xe8\x1b\xb6\x2e\xb2\xbc\xff\x03\x4b\xab\x0d\xa7\x3f\xdc\xf0\xd6\x56\x89\x73\x4d\x97\xd6\xa5\x9e\x42\x5d\x42\x4a\xb0\xd5\xd5\xb2\x3a\x1c\xb8\xa9\xdb\xdd\x3d\x6f\x4f\xfb\xfa\xd0\x96\xf7\x87\xb2\x65\xa5\x4a\x3a\x34\xef\xef\x8f\x19\xf0\x56\xb7\xa5\x1f\xea\xfa\x3d\xed\xdb\xe6\x58\xf3\xae\x3c\x71\x59\xef\xb8\x3c\x51\xa9\x1a\xb5\xaf\x8f\x44\x74\xca\x28\xce\xfb\x36\x4d\x22\xbf\x44\x4f\xb0\x1c\xe5\x4b\x01\x8b\x2e\x03\x9e\xb4\x6d\x2a\x7c\x7c\x78\x98\x2b\x23\x67\xc9\xc8\xf2\xe8\xc9\x5c\x6d\xfe\xf7\xf1\xe1\xe1\x06\x9f\xe5\x91\xe7\xf9\xff\x65\xd8\xe4\x03\x41\xdb\xf3\xa3\x34\x78\xe0\x58\x5d\x77\xac\x2c\x13\x8a\x22\xbb\xfe\xd1\xa7\x2f\x90\xd9\x20\x03\x7a\xb2\xba\xe5\x10\x1f\x69\x8c\x9d\xf3\x15\xa8\x6e\x46\xd3\x64\x7f\x05\x00\x00\xff\xff\xb3\x19\xcd\x02\xf4\x08\x00\x00")

FileSqueezeNetV10Yml is "/SqueezeNet-v1.0.yml"

View Source
var FileSqueezeNetV11Yml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x04\xff\x84\x56\x4d\x8f\xa4\x36\x10\xbd\xf3\x2b\x4a\x6a\x69\x95\x48\xd3\xd0\x74\x33\xdd\xbd\x48\x9b\x28\xd9\x5c\xf6\x32\x87\xdd\xe3\x6a\x35\x2a\xec\xa2\x71\x06\x6c\xc7\x2e\xa6\x67\xf2\xeb\xa3\x32\xcc\xc0\xac\x92\x0d\x07\x04\xae\xe7\x57\xcf\xf5\x05\x99\xc5\x81\x6a\xf8\xf2\xd7\x48\xf4\x37\xdd\x11\xc3\x06\x64\x09\x5c\x0b\xcf\x6e\x0c\x30\x38\x4d\x7d\xd6\x06\x1c\xe8\xea\xc2\x43\x9d\x41\xb2\xd7\xf0\x11\xdb\x96\x60\x03\xaf\x26\x68\x5d\x00\xee\x68\xde\x02\xf0\x48\x21\x1a\x67\x6b\x28\xf3\xdd\x1b\xe0\x6c\x00\xe5\x2c\x07\x34\x96\xb3\x79\x45\xa0\x25\x6c\x5e\x01\xc6\xb6\x2e\x0c\xc8\xc6\x59\x30\x16\x22\x0d\x68\xd9\xa8\x57\xfb\x64\xcd\x84\x07\x8d\xa5\x50\xc3\x26\x91\xa6\x97\x08\x63\x24\x0d\xec\xc0\x53\x10\xe4\x24\x0c\x7c\x20\x6d\x94\x70\x66\xb0\x5c\x1b\x18\xc6\x9e\x8d\xef\x09\x7c\x8f\x2c\xf8\x08\x0a\x2d\x34\x04\xd1\x93\x32\xad\x21\x9d\x01\xe0\xa0\x8f\x95\x44\x01\xe0\xe2\xc7\x1a\x02\x1a\x1f\xdc\x9f\xa4\xb8\x50\x18\x86\x7e\xab\x24\x2e\x75\x82\x6d\x95\x1f\x93\x0f\xf5\xbf\xc8\x4b\x42\x7a\xaf\x8e\x55\x4f\x13\xfd\x8f\x36\xcd\xc0\x79\xdb\x8f\xa5\xac\xb1\x9a\xa2\x0a\xc6\xcb\xe1\x6b\xf8\x25\x83\x75\xe2\x1f\xcb\xbc\x84\x0e\x23\xec\xf3\xea\x09\x7a\x8a\x11\x94\x1b\xfc\xc8\x53\xfc\xb9\x43\x2b\x98\xdd\x0d\x5c\x0d\x77\x6e\x64\x88\xa8\x82\x69\x8d\x32\xf6\x02\xa8\xd4\x18\x50\x3d\xe7\x59\xa0\x96\x02\x59\x45\x51\xd2\xb1\xbc\xa5\x4c\xa0\xa7\x10\xa1\x80\x2b\x35\xd1\x30\xc9\x23\xb1\xca\x73\x98\x94\x35\x42\xb5\xae\xa1\x2d\x74\xcc\x3e\xd6\x45\x71\x31\xdc\x8d\x4d\xae\xdc\x50\xfc\x41\xe4\xbf\x28\xec\xa9\x58\xea\x36\x83\x15\x16\xc3\x93\x79\xcc\x5d\xb8\x14\xd8\xc4\xa2\x3c\xee\xf6\xf9\xee\x74\x38\xee\xde\x80\x56\x84\xda\x3c\x1a\x6d\xd8\x14\xea\x61\xca\x5f\xc1\x81\xa8\x18\x30\x32\x85\xc2\xa3\x7a\xc0\x0b\x15\x29\xb3\xa9\x1f\xb6\x9a\xc8\x47\x51\xb0\x8d\x53\xe7\x58\xe2\x6d\x99\x97\xaf\x0e\xea\xa2\x50\x0f\xd6\x5d\x7b\xd2\x17\x4a\x4a\x02\x79\x57\x5c\xa9\xc9\x7d\xe7\x7f\x65\x1a\xa4\xca\xe8\xc3\x02\x7a\xf7\xee\xaa\x8c\xfe\x30\x3b\xab\x6f\xdf\x57\x65\x75\xa8\xce\x4d\xd9\x68\xd2\xcd\x6d\xb6\x81\xde\x28\xb2\x31\xb5\xe6\x12\xa2\x79\xb1\x86\xdf\x7f\xfb\xf4\x39\xdb\x80\xb1\x7e\xe4\x14\xeb\x05\x33\xad\x49\x55\x6d\xa0\x35\x21\xf2\x84\x02\x7e\xf6\x24\x3d\xb4\x82\x4a\x14\x65\xb9\x06\x33\xe0\x85\x52\xf5\x6e\xe6\xe4\xa4\xb2\x91\xc1\x20\xcc\x2b\x9e\x04\x9a\xf2\x97\x20\x75\x02\x24\xa7\x2b\x16\x8f\x32\x43\x98\x42\x94\xb2\x10\x1f\xab\xa5\x44\x01\xa0\xcd\x40\x56\x66\x46\xac\xe1\xeb\xe1\x06\xf6\xfb\x53\xba\x7d\x9b\xed\x03\xa1\xad\xe1\x6b\xb9\x3f\xdf\xc0\xcb\xed\x5b\xe6\x46\xf6\x23\x4f\xc7\x13\x69\x89\xdb\xb5\xe9\x79\xb2\x65\x90\x16\x6b\x68\x09\x79\x0c\x72\xac\x0d\xe0\x5a\xf3\x5b\xfc\xa2\x2c\x83\x35\x6a\x3a\xd9\xc4\x09\x3d\x36\xd4\x67\xb0\x60\x53\x84\x01\x36\xc9\xd7\x6a\x39\x89\x9f\x3d\xc7\xfb\x31\xf4\x75\x2a\xea\xba\x28\x34\x32\xe6\x7a\xe8\x55\x3e\xf4\xc5\xf0\x64\x89\x8b\x54\x5f\xb1\x48\xd1\x97\xf7\xf8\x6c\x23\x71\xce\x4f\x72\x08\x58\x68\x54\x47\xea\x21\x8e\x43\x0d\x95\xde\x1f\xaa\xe6\xf6\x7c\x38\xa0\xc2\xaa\x7a\xbf\x3f\xef\x8e\xb7\x58\x9e\x77\xba\x39\xec\xca\x23\x66\x89\x52\x82\xfe\x32\xc7\xe2\x3c\x09\x2f\x01\x7d\x07\x68\x35\x5c\xc9\x5c\x3a\x8e\x10\x28\xba\x31\x28\x12\xcd\xc9\x7a\xef\x91\xbb\x49\xaf\x34\x61\xc0\x6b\x3e\xf5\xcd\x18\x29\xc8\xdc\x25\xcb\xa9\x27\x03\x9a\xed\xdb\x41\x98\xdc\xc6\x97\x26\x4a\xcd\x53\x2c\xdd\x72\x2f\xe3\xa6\xd0\xe4\x7b\xf7\x9c\xfb\xe0\xd8\x4d\x47\x9c\x95\x7c\xe7\x77\xf2\x99\x1c\xfd\x5b\xf3\x8b\xae\x17\x47\xcb\x48\x98\x5c\x7c\xe7\x32\x4f\x42\x92\xb6\x0c\xc0\xc4\x7b\x0c\xaa\x33\x8f\x52\x1b\xd8\x47\xf9\xa0\x99\x16\x22\xf1\x8d\x94\x8f\x95\x1b\x34\x18\x49\xd2\x06\x26\x02\xc2\x18\x7a\x99\x64\x68\x61\xde\x99\xd2\xfb\xfd\xb5\x49\x3b\x97\x10\xae\xa3\x9c\xce\x26\x76\x0b\x9a\xac\x63\x92\xe7\xff\x60\x69\x4d\x4f\xe9\x83\x1b\x5f\x2a\x34\x71\xae\xe9\xd2\x38\x36\x93\xd4\x45\x52\x82\xad\xaa\xa4\xa4\xe3\x49\x35\xe5\xa9\xa4\xf2\x88\x95\x3e\x1e\x5b\x7d\x38\x94\xd5\xee\xbd\xde\xb7\xa7\x66\x27\x9f\xb6\x97\xd0\x2f\xa5\xb5\x3b\xdc\x9e\xa8\xa2\xb2\xd4\xe5\xe9\xa0\x4e\x7b\xdc\x95\xc7\xf2\xf6\x7c\x3e\x9f\xf7\xc7\x46\x9d\x29\x43\xe6\x60\x9a\x91\xa7\x59\x4f\x4f\x1c\x10\x2c\xb1\xfc\x29\xc0\x62\xcb\x00\x1e\x8c\xd5\x35\x7c\xbc\xbb\x9b\x23\x23\xef\x72\x22\x4b\x63\xc0\xfe\x75\xcf\x4f\x1f\xef\xee\x6e\xe0\xb3\xdc\xf2\x3c\xff\x59\xfa\x56\x7e\x10\x8c\xbd\xdc\x4b\xaf\x44\xe2\x1a\x3e\xc9\x60\x9a\xfe\x54\xe6\xb5\xd7\x0f\x7d\xfa\x03\x99\x37\x64\x00\x03\x5a\xd3\x52\xe4\x7b\x1c\xb9\x73\xa1\x06\x6c\xf4\xd8\xeb\xec\x9f\x00\x00\x00\xff\xff\x90\xa4\x95\x4b\xf5\x08\x00\x00")

FileSqueezeNetV11Yml is "/SqueezeNet-v1.1.yml"

View Source
var FileVGG16SODYml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x04\xff\xac\x56\xcf\x6f\xdb\xb0\x15\xbe\xeb\xaf\xf8\x00\x1f\xd6\x02\x0e\x25\xd9\xb1\x1c\xe9\xb0\x43\x53\xa0\xd8\xd0\x24\x45\xdd\x15\x43\x8b\xc2\xa0\xc8\x27\x8b\x8d\x44\x0a\x24\x95\xa4\x39\xec\x6f\x1f\x48\x29\xb6\xdb\xa1\xdd\x61\xf3\xc1\x90\xde\xfb\xde\xef\x8f\x8f\xd2\xbc\xa7\x0a\x9f\xdf\xbd\xcb\x8b\xfd\xee\xee\x2d\x16\x08\x12\x98\x06\x3f\xcc\x68\xd1\x1b\x49\x5d\xd2\x58\xde\xd3\xa3\xb1\xf7\x55\x82\xa8\xaf\x70\xcd\x9b\x86\xb0\xc0\x51\x85\xc6\x58\xf8\x96\x66\x13\xe0\x81\xac\x53\x46\x57\xc8\x59\xf6\x13\x70\x56\x40\x18\xed\x2d\x57\xda\x27\xb3\xe4\x05\x3a\xbf\x42\xe9\xc6\xd8\x9e\x7b\x65\xc2\x33\x1c\xf5\x5c\x7b\x25\x8e\xfa\x49\x9b\x04\x3f\x5c\x69\xb2\x15\x16\xd1\x69\x7c\x71\x18\x1d\x49\x78\x83\x81\x6c\x40\x4e\x89\x61\xb0\x24\x95\x08\x3e\x13\x9c\x7e\x0b\xf4\x63\xe7\xd5\xd0\x11\x86\x8e\xfb\x80\x77\x10\x5c\xa3\x26\xb8\x81\x84\x6a\x14\xc9\x04\xe0\xbd\x2c\x2e\x43\x17\x80\xc3\x30\x56\xb0\x5c\x0d\xd6\x7c\x27\xe1\x53\xc1\x6d\xdf\x5d\x88\xd0\x97\x2a\xc2\x2e\xc4\x30\xc6\x18\xe2\xbf\x22\x0f\x11\x39\x0c\xa2\xb8\xec\x68\x72\xff\x27\xa3\x19\x38\x9b\xfd\x39\x95\x73\xac\x24\x27\xac\x1a\x42\xf1\x15\xfe\x9a\x00\x9f\x5a\x42\x63\xba\xce\x3c\x2a\x7d\x98\x1b\xc4\x2d\xa1\x51\x9a\xfc\xa8\x49\xc2\xe8\x38\xd4\x1d\xef\x14\x69\x8f\xbb\x3a\xd4\x8a\xdd\x58\x2b\xaf\x9e\x83\x91\xe4\x9e\x3b\xf2\x78\xf5\xaf\x4d\x96\x65\x50\x3d\x3f\x90\x7b\x8d\x47\xe5\x5b\xd4\x66\xd4\x32\x80\x6a\xf3\x04\xae\xb5\xf1\x71\x98\x8e\x25\xc0\xf5\xed\xed\x14\xd0\x85\x39\xc6\x20\xa7\x4c\xae\x3f\x7f\xf8\xf8\x97\xbc\xc0\xc0\x07\xb2\x17\xf8\x87\x16\x46\xbb\x48\x16\x92\xbf\xe6\xf2\x96\x3c\xc5\x79\xe2\x41\x71\x7c\xb0\x66\x30\x8e\x77\x21\xc5\x90\xd6\xdd\xe0\x55\xaf\x9e\x63\xdc\x04\xf8\x3b\xc3\x97\x96\xeb\xc3\x12\x3b\x86\x9d\xe8\xb8\x35\x4d\xb3\xc4\x17\x86\xf7\x4a\x2f\xf1\x4f\x86\x5d\x4b\x7a\x89\x37\x0c\x1f\xac\x12\x04\xae\x25\x3e\x32\xdc\x90\x68\x19\x42\x5a\x4b\xac\xb2\xbc\x60\x89\xa5\x86\x2c\x69\x41\x2e\xd0\xee\xf4\x16\x19\x17\xd2\x76\x48\xf1\x48\xb5\x53\x9e\xc2\x23\x79\xc1\x18\xa6\x09\xd4\xa1\x27\xe7\x67\xe5\x02\xad\xf7\x83\xab\xd2\xf4\xa0\x9c\x67\x07\xe5\xdb\xb1\x66\xc2\xf4\xe9\x77\xd5\xf7\x8a\xd6\xeb\x74\x93\x95\x79\x9e\x37\x57\x3c\xcb\x78\x49\x82\x56\x62\x2d\x37\x52\x52\xc1\xb7\x9b\x2c\x5f\x95\x09\x70\x71\xe6\xe5\x3f\x1d\xec\xee\xde\x26\xbf\xc1\xbc\xf9\xfc\xfe\x3a\x8d\xcc\x4d\x1f\xd5\xbd\x4a\x6f\xc2\xa9\xbf\xf8\x62\xcc\xd1\xa0\x4a\x53\xe1\x2e\x06\x32\x43\x47\xac\x1e\x19\xc9\x31\xfd\xde\x3f\x87\x56\xa6\xce\x48\xd6\xfa\xbe\x3b\x82\x43\x1d\xdc\x3e\xa9\x07\x66\xec\x21\xe5\xb5\x4b\xf3\xcb\xac\x64\xf9\x66\x53\x24\x0b\x74\x4a\x90\x76\x71\xc5\x9c\x5a\x30\x0b\x2b\xdc\xfc\xed\x53\xb2\x80\xd2\xc3\xe8\x63\x2b\x4f\x90\x49\x56\x25\x08\xcb\x44\x59\xe7\x27\x14\xfc\x8f\x21\x90\x78\xa2\xd0\xb4\xaf\x42\x99\x41\x5c\x4d\x74\x8c\x87\x70\x31\xf7\x3e\xb2\x1f\xa6\x89\x9e\xcf\xfc\x44\xd0\x34\x9e\x08\xa9\x22\x20\x06\x3d\xf3\x32\xf0\xb0\x0a\x3d\xd9\x38\xf5\x10\xe3\x4c\x14\x5d\x00\x52\xf5\xa4\xc3\xea\x73\x15\xbe\xae\x97\x58\xad\x2e\xe3\xdf\xb7\x59\xdf\x13\xd7\x15\xbe\xe6\xab\x35\x2b\xae\x96\xc8\xf3\x82\x6d\xb7\xe5\x12\x79\xb6\x66\xe5\xba\xfc\x96\x98\xd1\x0f\xa3\x9f\x2a\x0d\xf5\xc7\x30\x73\xc6\x93\x2e\x41\x14\x56\x68\x88\xfb\xd1\x86\x0a\x17\xe0\xe7\xe9\xff\x8c\x3f\x25\x99\xe0\x1c\x35\x15\x39\xf9\x44\xc7\x6b\x0a\x43\x3c\xab\x31\x66\xbc\x88\xb1\xce\xc4\x51\x3a\x47\x76\xfb\xd1\x76\x55\x24\x5e\x95\xa6\x6e\xcd\x78\xcf\x9f\x8d\xe6\x8f\x2e\xd2\xd7\x79\x63\x89\xc5\xd5\x18\xc9\x10\xe7\xe3\x66\xae\x3d\x1c\x0e\x79\xb1\x77\x46\xa6\x82\xb4\x27\x9b\x67\x19\xf3\x4f\xa1\x38\x9c\xdc\x8b\x96\xc4\xbd\x1b\xfb\x0a\x05\xf1\xad\xcc\x6b\x59\xf2\xd5\x65\xcd\xd7\xb5\x90\x54\x88\xac\xd8\xca\x5a\x16\xf9\xd5\xa6\x49\xa2\xf3\x70\x1a\x5f\x36\xb6\x9b\xf8\x80\x83\xe5\x43\x1b\x8f\xf2\x23\xa9\x43\xeb\x1d\x2c\x39\x33\x5a\x41\xa1\x96\xa8\xdd\x0f\xdc\xb7\xff\x73\x1d\x92\x86\xce\xfc\x60\x83\x35\xde\x4c\x95\xcc\x01\xff\x3f\xee\x8f\xd7\xf4\xfe\x65\x41\xb3\x78\x6a\x63\xe1\x09\xa0\xdc\x9e\x5b\xd1\xaa\x87\xc0\x0c\xde\xb9\x70\x41\xab\x06\x8e\xfc\x32\x10\x69\x5a\xe5\x35\x77\x14\x86\x06\xe5\xc0\x31\xda\x2e\x6c\x2c\xae\x31\x5b\xc6\xe1\xfe\xfa\x5b\x04\xf3\xb3\x46\x9d\xf7\x32\x96\x16\xf4\x1a\x92\xb4\xf1\x14\x9e\x7f\xe3\xa5\x51\x1d\xc5\x0f\x08\xf7\xc2\xcf\xd8\xfc\x73\x77\xf1\xe6\x50\x53\xaa\xa7\x94\x22\xec\x8c\x0b\xc4\x45\x21\x57\xe5\xf6\x4a\x34\x4d\xb1\x59\xe7\xa5\xd8\x52\xb3\xbe\xe4\xfc\xaa\x94\xdb\x22\x13\x09\xf0\xd2\xf9\x13\x81\x4a\xbe\x95\x82\x8a\x46\x94\x57\x99\x58\x95\xb2\x2c\x56\xcd\x56\xac\xb6\x9b\xab\x7a\xb5\x2d\x72\x99\x70\xef\xad\xaa\x47\x3f\xed\x74\x7a\xf2\x96\x43\x93\x0f\x5f\x3e\x38\xe9\x12\xe0\x5e\x69\x59\xc5\x2b\x6c\xea\x4c\x78\x0f\x15\x69\x1a\x2d\xef\x8e\x36\xaf\xae\x6f\x6f\x97\xf8\x18\xfe\x18\x63\xaf\xc3\xa9\x0d\x1f\x3c\x4a\x1f\xf6\xf3\xb5\x59\xc5\x2b\xf8\x66\x77\x77\xbc\x47\x17\xc7\xa7\x97\xef\x97\xf8\x61\x35\xdb\x25\x40\xcf\xb5\x6a\xc8\xf9\x3d\x1f\x7d\x6b\x6c\x05\x5e\xcb\xb1\x93\xc9\xbf\x03\x00\x00\xff\xff\xb0\x72\xbb\x9a\xca\x09\x00\x00")

FileVGG16SODYml is "/VGG16_SOD.yml"

View Source
var FileVGG16SOSYml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x04\xff\xac\x56\x4b\x8f\xdb\xb6\x13\xbf\xeb\x53\x0c\x62\xfc\xf1\x4f\x80\x5d\xbd\x6c\xcb\x6b\x1d\x7a\x88\x0b\xe4\xd2\xee\x16\x71\x11\xa0\x0d\x02\x63\x44\x0d\x25\xee\x4a\xa4\x40\x52\xeb\x24\x9f\xbe\x18\x4a\x6b\x2b\x05\x92\x1e\x5a\x1f\x0c\x6a\xe6\x37\xef\x07\xa9\xb1\xa7\x12\x3e\xbc\x7b\x97\x15\xa7\xe3\xc3\x11\x56\xc0\x14\x30\x12\xbe\x98\xd1\x42\x6f\x6a\xea\x22\x69\xb1\xa7\xb3\xb1\x4f\x65\x04\x81\x5f\xc2\x01\xa5\x24\x58\xc1\x85\x05\xd2\x58\xf0\x2d\xcd\x22\x00\xcf\x64\x9d\x32\xba\x84\x2c\x4e\xbf\x01\xce\x0c\x10\x46\x7b\x8b\x4a\xfb\x68\xa6\xbc\x40\xe7\x4f\x50\x5a\x1a\xdb\xa3\x57\x86\xcf\xe0\xa8\x47\xed\x95\xb8\xf0\x27\x6e\xc4\x7a\x50\x69\xb2\x25\xac\x82\xd2\xf0\xe1\x60\x74\x54\x83\x37\x30\x90\x65\xe4\xe4\x18\x0c\x96\x6a\x25\x58\x67\x04\xd7\xdf\x0a\xfa\xb1\xf3\x6a\xe8\x08\x86\x0e\x3d\xe3\x1d\x08\xd4\x50\x11\xb8\x81\x84\x92\x8a\xea\x08\x00\xfb\xba\xd8\x70\x16\x00\x9a\x61\x2c\xc1\xa2\x1a\xac\x79\x24\xe1\x13\x81\xb6\xef\x6e\x05\xe7\xa5\x0c\xb0\x5b\x31\x8c\xc1\x86\xf8\x47\x64\x13\x90\xc3\x20\x8a\x4d\x47\x93\xfa\x1f\x09\xcd\xc0\x59\xec\xc7\xae\x2c\xb1\x35\x39\x61\xd5\xc0\xc1\x97\xf0\x53\x04\x53\xdd\x41\x2a\x4d\x7e\xd4\x54\x83\xd1\xa1\x84\x47\xec\x14\x69\x0f\x0f\x15\x47\x06\xc7\xb1\x52\x5e\x7d\x55\xba\x81\xd7\xc7\x87\xe3\x1b\xa8\xd1\xa3\x23\x7f\x03\xe7\x56\x89\x16\x94\x83\x3a\x68\xae\xa8\x06\x35\xa9\x38\x7c\xf8\xed\xfd\xff\xb3\x2d\x0c\x38\x70\x61\x5e\x7d\x57\xe5\xab\xc8\x92\x24\x4b\x5a\x90\xe3\x02\x5e\xbf\x42\xed\x58\xdc\x41\x02\x67\xaa\x9c\xf2\xc4\x47\xf2\x22\x8e\x5f\x2c\xb2\x53\xcb\xae\xbb\x85\xd6\xfb\xc1\x95\x49\xd2\x28\xe7\xe3\x46\xf9\x76\xac\x62\x61\xfa\xe4\x51\xf5\xbd\xa2\xf5\x3a\xc9\x77\x22\x13\x29\xee\x76\xeb\xa2\xc2\xa2\x10\xf9\x7a\xbf\x8d\x60\x96\x2c\x93\x44\xb8\xdb\x81\xcc\xd0\x51\x5c\x8d\x31\xd5\x63\xf2\xd8\x7f\x6d\x51\x37\x89\x33\x2e\x6e\x7d\xdf\x45\x00\x4b\x33\x17\x0b\x6f\x3f\xfc\x72\x48\x42\x03\x24\x67\xf5\xa4\x92\x5f\x79\x78\x6e\xff\x34\xe6\xa2\x9d\xfd\x42\xfb\x59\x3d\xc7\xc6\x36\x09\x56\x2e\xc9\x36\xe9\x3e\xce\xb6\xdb\x22\x5a\x41\xa7\x04\x69\x17\x86\xef\x1a\xd2\x4c\x2c\xe1\x70\x80\xb7\x7f\xdc\xde\x1f\x60\x13\xa7\xd1\x0a\x94\x1e\x46\x1f\x72\x74\xc5\x4e\x34\xee\x9f\x15\x48\x65\x9d\x9f\x50\xe0\xbf\x0c\xc4\xd3\xb2\x80\x72\x08\x4c\x2e\x41\xf5\xd8\x50\xe8\xd3\xd5\x9c\xd4\xd0\x20\xbc\x02\x58\xf3\x42\x4f\x00\x7d\xd3\x43\x0c\x08\x46\x17\x5a\x06\xe4\x6d\xe1\xc9\x86\x72\xb2\x8d\x05\x29\xa8\x00\xa8\x55\x4f\x9a\xb7\x83\x2b\xe1\xe3\xfa\x06\xf2\x7c\x13\xfe\x3e\xcd\xfc\x9e\x50\x97\xf0\x31\xcb\xd7\x71\x71\x77\x03\x59\x56\xc4\xbb\xdd\xfe\x06\xb2\x74\x1d\xef\xd7\xfb\x4f\x91\x19\xfd\x30\xfa\x29\x52\x76\x22\x98\x31\x32\x9c\x27\x5e\x04\x81\x58\x82\x24\xf4\xa3\xe5\x08\x57\x80\x4b\xf7\xbf\xc5\x5f\x9d\x8c\x60\x89\x2a\x17\x3a\xa1\xc3\x8a\xb8\xfc\x8b\x18\x83\xc7\xab\x60\x6b\x41\x0e\xd4\xd9\xb2\x3b\x8d\xb6\x2b\x43\x5f\x96\x49\xe2\xd6\x31\xf6\xf8\xd5\x68\x3c\xbb\xd0\x97\xce\x1b\x4b\x71\xd8\x1e\xa1\x2b\xc2\xca\x75\x73\x1f\x3d\x37\x4d\x56\x9c\x9c\x71\xc9\xff\xf2\xd4\x4d\x63\x79\x32\x61\x2c\x4f\xee\x32\x96\xb1\xff\xcc\xf1\xc2\xd5\xa2\x68\x49\x3c\xb9\xb1\x2f\xa1\xc6\x3b\x2a\xb0\xba\xcb\xb7\xb8\xd9\xe0\x3e\x4d\x65\x56\x6c\x37\x32\xdd\xcb\x6d\x56\xef\x32\x19\x05\x7b\x3c\x79\x2f\x7b\xce\xcd\x9b\xb2\xb1\x38\xb4\x80\xba\x86\x33\xa9\xa6\xf5\x0e\x2c\x39\x33\x5a\x41\x1c\x5e\xe0\x9e\x06\xf4\xed\xbf\x0e\xad\xa6\xa1\x33\x5f\xe2\xc1\x1a\x6f\x7c\x88\x64\x36\xf8\xdf\xa8\x9f\x2f\x37\xec\x1e\xaa\xc7\x23\x2f\x03\x5e\xd1\x21\xea\x08\x40\xb9\x13\x5a\xd1\xaa\x67\xee\x14\xec\x1c\xdf\x69\x4a\x42\xd8\x6e\xbe\xa5\x69\x99\x55\xe8\x88\x8b\xc8\x9b\x0e\x61\xb4\x1d\xaf\x26\xd4\x30\x4b\x86\x62\xff\xfd\xb7\x62\xf1\x45\x96\x96\x89\x0c\x71\x31\x5f\x43\x4d\xda\x78\xe2\xf3\x77\xb4\x48\xd5\x51\xb8\x73\xdd\x4b\xbf\x86\xcc\x2f\xd5\xc1\x59\xf9\x76\xde\xbb\x57\x97\x02\x6c\xd1\x08\x54\xdd\xe5\x29\xed\x69\x53\x17\x72\xbd\xc5\x7d\x91\x15\x45\x81\x42\xa6\x32\x97\xd9\x16\xf3\x08\xe0\x25\xed\xd7\xee\x91\xb8\xbb\xbb\x2b\x30\x97\x42\xe6\x59\x95\x8a\xcd\x5e\x52\x2e\xf3\x2a\x4f\x25\x6d\x8b\xcd\x3a\x42\xef\xad\xaa\x46\x3f\x2d\x6f\xfa\xec\x2d\x82\x26\xcf\x8f\x05\xb8\xf2\x22\x80\x27\xa5\xeb\x12\x0e\xf7\xf7\x73\x66\xf8\x9b\x23\xd2\x34\x5a\xec\x2e\x32\xaf\x0f\xf7\xf7\x37\xf0\x9e\xff\xe2\x38\x7e\xc3\x53\xcc\x6f\x04\xa5\x9b\xd3\x7c\xeb\x94\xf0\x7b\x4b\xc0\x6f\x95\x9f\xa7\x6b\x88\xf7\xd6\x7c\x7a\xb9\xf2\xc3\x5b\x64\x96\x8b\x00\x7a\xd4\x4a\x92\xf3\x27\x1c\x7d\x6b\x6c\x09\x58\xd5\x63\x57\x47\x7f\x05\x00\x00\xff\xff\x13\x3a\x31\x3a\xfd\x08\x00\x00")

FileVGG16SOSYml is "/VGG16_SOS.yml"

View Source
var FileVGG16Yml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x04\xff\x8c\x56\x4d\x8f\xdb\x36\x13\xbe\xeb\x57\x0c\xe0\x4b\x02\xac\x44\x7d\xd9\xb2\x75\x78\x0f\xd9\xc3\x22\x40\xde\x3d\xa4\xc5\x02\x6d\x10\x18\x23\x72\x24\xb3\x2b\x91\x02\x49\xd9\xeb\x4b\x7f\x7b\x41\x4a\xbb\xd6\x06\x6d\x5a\x1f\x0c\x91\xf3\xcc\xf7\x33\x23\x29\x1c\xa8\x86\xa7\x87\x87\x6c\x07\x1b\xf0\x27\xd0\x2d\x5c\xf5\x64\x60\xd0\x82\xfa\xa8\x35\x38\xd0\x45\x9b\xe7\x3a\x82\x20\xaf\xe1\x1e\xdb\x96\x60\x03\x6f\x22\x68\xb5\x01\x77\xa2\x45\x05\xe0\x4c\xc6\x4a\xad\x6a\xc8\x92\xf4\x1d\x70\x11\x00\xd7\xca\x19\x94\xca\x45\xcb\xcd\x2b\x74\x39\x82\x54\xad\x36\x03\x3a\xa9\xfd\x33\x58\x1a\x50\x39\xc9\xdf\xe4\xb3\x34\xf2\x76\x50\x2a\x32\x35\x6c\x82\xd1\x70\xb0\x30\x59\x12\xe0\x34\x8c\x64\x3c\x72\x0e\x0c\x46\x43\x42\x72\x6f\x33\x82\xdb\x6f\x03\xc3\xd4\x3b\x39\xf6\x04\x63\x8f\xce\xe3\x2d\x70\x54\xd0\x10\xd8\x91\xb8\x6c\x25\x89\x08\x00\x07\xb1\x2b\x7d\x15\x00\xba\x71\xaa\xc1\xa0\x1c\x8d\xfe\x83\xb8\x63\x1c\xcd\xd0\xc7\xdc\xd7\xa5\x0e\xb0\x98\x8f\x53\xf0\xc1\xff\x15\xd9\x05\xe4\x38\xf2\x5d\xd9\xd3\x6c\xfe\x67\x4a\x0b\x70\x51\xfb\x79\x28\x6b\xac\x20\xcb\x8d\x1c\x7d\xf2\x35\xfc\x2f\x02\xf8\xf5\xb5\x5f\x20\x2d\xa0\x02\x39\x8c\x46\x9f\x49\xbc\x95\x58\xb7\xa1\xa7\xd9\x2e\xee\xf1\x4a\x0b\x1f\xe6\xca\x36\xd7\x20\x7a\x7a\x78\x00\x47\x38\x80\x54\xe1\xfc\xf9\xcb\x2f\x4f\x5f\xef\xe3\x3c\xcd\x4a\xe0\x7a\x18\xc9\x49\xef\x2f\x89\x0c\xb5\x64\x48\x71\xb2\xbe\x4f\xb7\x53\x68\x11\x8e\x64\x2c\x30\xb8\x50\x63\xa5\x23\xff\x48\x8e\x27\x09\xcc\x21\x37\x52\x75\xc1\xfa\xcc\x47\x80\x18\x4e\xce\x8d\xb6\x66\xac\x93\xd6\x25\x9d\x74\xa7\xa9\x49\xb8\x1e\xd8\xb3\x95\x83\x56\x57\x54\x2c\xcf\xb2\x7d\x71\xa0\xaa\x4a\xdb\xaa\xd9\x16\x7b\xca\xc5\x3e\x7a\xaf\xfa\xa6\xf5\xe9\xe9\xcb\x3d\x0b\xbd\x63\x17\xf9\x2c\xd9\xff\x3d\xef\xe3\xdf\xb5\xde\x04\x8f\x36\xf6\x64\x8a\x9b\x6b\xec\x4e\x14\x9f\xbb\x2e\xf6\x29\xc7\x52\xc5\xb2\xb7\x67\xc3\x43\xba\xef\xc2\x42\xf3\x22\xcf\x89\x36\x1d\xc3\xc6\xb2\xac\x4c\x0f\x49\xb6\xdd\xee\xa2\x0d\xf4\x92\x93\xb2\x61\xc4\x6e\xe3\xb2\x5c\xd6\x70\x7f\x0f\x9f\x7e\x83\x32\x49\xe1\x03\xd7\xc3\x40\x86\x4b\x0c\x05\x0f\x1d\xea\x7b\x7d\x21\xf1\x31\xda\x80\x54\xe3\xe4\x42\xed\x6e\x46\xe6\x3b\x4f\x9f\x0d\xb4\xd2\x58\x37\xa3\xc0\x5d\x47\xf2\xc3\xb2\x82\xfa\x32\xf8\xeb\x1a\xe4\x80\x1d\x05\x9a\x6e\x96\x62\x07\x7e\xbc\x76\x7e\x65\x27\x80\xe6\x7e\x04\x48\x1d\xec\x05\xa7\x2b\x2b\x23\xfa\x65\xe1\xc8\x84\x36\x7b\x1f\xab\xab\x60\x02\x40\xc8\x81\x94\x5f\x0e\xb6\x86\x6f\xc5\x1d\xe4\x79\x19\xfe\xbe\x2f\xf2\x81\x50\xd5\xf0\x2d\xcb\x8b\x64\xb7\xbf\x83\x2c\xdb\x25\x55\x75\xb8\x83\x2c\x2d\x92\x43\x71\xf8\x1e\xe9\xc9\x8d\x93\x9b\x33\xf5\xf9\x07\x37\x0b\x57\x67\x59\x04\xe1\xb2\x86\x96\xd0\x4d\xc6\x67\xb8\x01\x5c\x87\xff\x1e\x7f\x0b\x32\x82\x35\x6a\x4e\x72\xb6\x09\x3d\x36\xd4\x47\x70\xc3\x86\x62\x03\x6c\x82\xaf\xd5\x75\xc8\x63\xf1\x6c\x8f\x93\xe9\xeb\xc0\xd7\x9a\x31\x81\x0e\x13\x31\xf4\x3c\x19\x7a\x36\xbc\x28\x72\x6c\x66\x18\x0b\x8d\xf0\x67\x7b\x55\x96\x5c\xe2\x5e\x7c\x12\x70\x33\xc3\x4f\xc4\x9f\xed\x34\xd4\x50\x8a\xbc\x28\x9b\xed\xbe\x28\x90\x63\x59\x1e\xf2\x7d\xba\xdb\x62\xb6\x4f\x45\x53\xa4\xd9\x0e\xa3\x60\xd2\x8f\xd9\xeb\xee\xb2\xf3\xe4\x40\x67\x70\x3c\x01\x2a\x01\x17\x92\xdd\xc9\x59\x30\x64\xf5\x64\x38\xf9\x98\x83\xf4\x38\xa2\x3b\xcd\xf1\xfe\x30\x5f\x93\x25\xe3\x97\x2d\x29\xf7\x1f\x46\x8d\x19\xbc\x30\x41\xe2\x50\xec\x8a\x46\x1c\x0a\xe2\x29\xaf\xaa\x34\x2b\xca\xb6\xa4\x62\x5f\x89\x3d\x22\x22\xe6\x65\x5a\x71\x62\x4f\x0f\x0f\xc7\xcf\x61\x75\x1c\xb3\xdd\x31\x2c\x1b\x7b\x14\x34\xf6\xfa\x9a\x8c\x46\x3b\x3d\x97\x63\x89\x7a\x15\x63\xcd\xd8\xe5\x72\x49\x8c\x6e\xb4\xb3\x89\x7e\x49\x90\x27\xd3\x33\xfb\xf3\xdc\x75\xcc\xea\xd6\x5d\xd0\x10\x3b\x93\xb9\x1e\x05\xd1\xc8\xe6\x19\x7f\xfa\x1b\x6f\x49\x10\x85\xca\x45\x00\xd2\x1e\xd1\xf0\x93\x3c\x7b\x0a\x61\x6f\xfd\xbb\x4e\xb6\x60\xc9\xdd\x79\xc6\xcd\xbb\xae\x41\x4b\xbe\xbb\x61\x36\x61\x32\xbd\xdf\x65\xa8\x60\xd1\x0c\x2c\xf8\xf1\xb7\xf1\xea\xab\x4a\xaf\x9b\x11\xd2\xf2\x72\x05\x82\x94\x76\xe4\x9f\xff\xc1\x4a\x2b\x7b\x0a\xef\x62\xfb\x4a\xe4\xd0\xbd\xb5\x39\xb8\x48\x77\x5a\xd6\xf2\x2d\xa4\x00\x5b\x91\x89\x57\xe9\x76\x9b\xb6\xfb\x3c\x2d\xb0\x24\x44\xda\x16\xa2\xe2\xc5\x81\xda\xa2\xe4\x87\xdc\xbf\xf5\x5e\xab\xbe\x62\x60\x99\x15\xd9\xb6\x49\xdb\x76\x77\x28\x72\xd1\xb4\x82\x0e\x55\x55\x64\x0d\x55\x1c\xf7\xdb\x3c\x42\xe7\x8c\x6c\x26\x47\x61\x0d\xd0\x8b\x33\x08\x8a\x9c\xff\x88\x80\x9b\x2c\x02\x78\x96\x4a\xd4\x70\xff\xf8\xb8\x54\xc6\x9f\x7d\x46\x8a\x26\x83\xfd\x9b\xce\x87\xfb\xc7\xc7\x3b\xf8\xea\xff\x92\x24\xf9\xe8\xc7\xdb\x7f\x3b\x48\xd5\x1d\xfd\x48\x59\x72\x35\x7c\xf6\xab\xec\x91\x9c\xdf\x64\xe8\xfc\xdd\xfc\xa6\x72\x7a\xde\x7e\x8b\x42\x04\x30\xa0\x92\x2d\x59\x77\xc4\xc9\x9d\xb4\xa9\x01\x1b\x31\xf5\x22\xfa\x2b\x00\x00\xff\xff\xb9\x20\x49\xac\x0a\x09\x00\x00")

FileVGG16Yml is "/VGG16.yml"

View Source
var FileVGG19Yml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x04\xff\x8c\x56\x4d\x8f\xa3\x38\x13\xbe\xf3\x2b\x4a\xca\x65\x46\x6a\x20\x24\x40\x02\x87\xf7\x30\x39\xb4\x46\x9a\xb7\x0f\xb3\xab\x96\x76\x47\xa3\xa8\xb0\xcb\xc4\xdb\x60\x23\xdb\x24\x9d\xcb\xfe\xf6\x95\x0d\xe9\xd0\xa3\xdd\xd9\xcd\x21\xc2\xae\xa7\xbe\x9f\x2a\x50\xd8\x53\x0d\xcf\x8f\x8f\x59\x05\x2b\xf0\x27\xd0\x02\xae\x7a\x34\xd0\x6b\x4e\x5d\x24\x0c\xf6\x74\xd1\xe6\xa5\x8e\x20\xc8\x6b\x38\xa0\x10\x04\x2b\x78\x13\x81\xd0\x06\xdc\x89\x66\x15\x80\x33\x19\x2b\xb5\xaa\x21\x4b\xd6\xef\x80\xb3\x00\x98\x56\xce\xa0\x54\x2e\x9a\x6f\x6e\xd0\xf9\x08\x52\x09\x6d\x7a\x74\x52\xfb\x67\xb0\xd4\xa3\x72\x92\xbd\xc9\x27\x69\xe4\xed\xa0\x54\x64\x6a\x58\x05\xa3\xe1\x60\x61\xb4\xc4\xc1\x69\x18\xc8\x78\xe4\x14\x18\x0c\x86\xb8\x64\xde\x66\x04\xf7\xdf\x0a\xfa\xb1\x73\x72\xe8\x08\x86\x0e\x9d\xc7\x5b\x60\xa8\xa0\x21\xb0\x03\x31\x29\x24\xf1\x08\x00\x7b\x5e\xe6\xbe\x0a\x00\xed\x30\xd6\x60\x50\x0e\x46\xff\x41\xcc\xa5\x0c\x4d\xdf\xc5\xcc\xd7\xa5\x0e\xb0\x98\x0d\x63\xf0\xc1\xfe\x15\xd9\x06\xe4\x30\xb0\x32\xef\x68\x32\xff\x33\xa5\x19\x38\xab\xfd\x3c\x94\x25\x96\x93\x65\x46\x0e\x3e\xf9\x1a\xfe\x17\x01\xfc\x7a\xeb\x17\x48\x0b\xa8\x40\xf6\x83\xd1\x67\xe2\x6f\x25\xd6\x22\xf4\x34\xab\xe2\x0e\xaf\x34\xf3\x61\xaa\x6c\x73\x0d\xa2\xe7\xc7\x47\x70\x84\x3d\x48\x15\xce\x9f\xbf\xfc\xf2\xfc\xf5\x10\x6f\xd6\x59\x0e\x4c\xf7\x03\x39\xe9\xfd\x25\x91\x21\x41\x86\x14\x23\xeb\xfb\x74\x3f\x85\x16\xe1\x40\xc6\x42\x0a\x17\x6a\xac\x74\xe4\x1f\xc9\xb1\x24\x81\x29\xe4\x46\xaa\x36\x58\x9f\xf8\x08\x10\xc3\xc9\xb9\xc1\xd6\x69\xda\x4a\xeb\x92\x56\xba\xd3\xd8\x24\x4c\xf7\xe9\x8b\x95\xbd\x56\x57\x54\xe9\x76\xb7\x2f\xb2\x72\x23\xaa\x82\xf1\x0d\x2f\x04\xd1\x6e\x17\xbd\x57\x7d\xd3\xfa\xf4\xfc\xe5\x90\x86\xde\xa5\x17\xf9\x22\xd3\xff\x7b\xde\xc7\xbf\x6b\xbd\x0a\x1e\x6d\xec\xc9\x14\x37\xd7\xd8\x9d\x28\x3e\xb7\x6d\xec\x53\x8e\xa5\x8a\x65\x67\xcf\x86\x85\x74\xdf\x85\x85\xe6\x55\x9e\x13\x6d\xda\x14\x1b\x9b\x66\xf9\xba\x4a\xb2\xa2\x28\xa3\x15\x74\x92\x91\xb2\x61\xc4\xee\xe3\x32\x5f\xd6\x70\x38\xc0\xa7\xdf\x20\x4f\xd6\xf0\x81\xe9\xbe\x27\xc3\x24\x86\x82\x87\x0e\x75\x9d\xbe\x10\xff\x18\xad\x40\xaa\x61\x74\xa1\x76\x77\x23\xd3\x9d\xa7\xcf\x0a\x84\x34\xd6\x4d\x28\x70\xd7\x81\xfc\xb0\x2c\xa0\xbe\x0c\xfe\xba\x06\xd9\x63\x4b\x81\xa6\xab\xb9\xd8\x81\x1f\xb7\xce\x2f\xec\x04\xd0\xd4\x8f\x00\xa9\x83\xbd\xe0\x74\x61\x65\x40\xbf\x2c\x1c\x99\xd0\x66\xef\x63\x71\x15\x4c\x00\x70\xd9\x93\xf2\xcb\xc1\xd6\xf0\x6d\xfb\x00\x9b\x4d\x1e\xfe\xbe\xcf\xf2\x9e\x50\xd5\xf0\x2d\xdb\x6c\x93\x72\xff\x00\x59\x56\x26\xbb\x5d\xf5\x00\xd9\x7a\x9b\x54\xdb\xea\x7b\xa4\x47\x37\x8c\x6e\xca\xd4\xe7\x1f\xdc\xcc\x5c\x9d\x64\x11\x84\xcb\x1a\x04\xa1\x1b\x8d\xcf\x70\x05\xb8\x0c\xff\x3d\xfe\x1e\x64\x04\x4b\xd4\x94\xe4\x64\x13\x3a\x6c\xa8\x8b\xe0\x8e\x0d\xc5\x06\x58\x05\x5f\x8b\xeb\x90\xc7\xec\xd9\x1e\x47\xd3\xd5\x81\xaf\x75\x9a\x72\x74\x98\xf0\xbe\x63\x49\xdf\xa5\xfd\xab\x22\x97\x4e\x0c\x4b\x43\x23\xfc\xd9\x5e\x95\x25\x97\xb8\x57\x9f\x04\xdc\xcd\xb0\x13\xb1\x17\x3b\xf6\x35\xe4\x7c\xb3\xcd\x9b\x62\xbf\xdd\x22\xc3\x3c\xaf\x36\xfb\x75\x59\x60\xb6\x5f\xf3\x66\xbb\xce\x4a\x8c\x82\x49\x3f\x66\xb7\xdd\x65\xa7\xc9\x81\xd6\xe0\x70\x02\x54\x1c\x2e\x24\xdb\x93\xb3\x60\xc8\xea\xd1\x30\xf2\x31\x07\xe9\x71\x40\x77\x9a\xe2\xfd\x61\xbe\x46\x4b\xc6\x2f\x5b\x52\xee\x3f\x8c\x5a\x6a\xf0\x92\x8a\x7c\x4b\x44\x82\xed\xcb\x8a\x97\x79\xd9\xe4\x79\x85\x58\x32\x2a\x4b\xb1\xdf\x35\xa2\xda\xef\x30\x63\x55\x53\xa4\xcf\x8f\x8f\xc7\xcf\x61\x75\x1c\xb3\xea\x18\x96\x8d\x3d\x72\x1a\x3a\x7d\x4d\x06\xa3\x9d\x9e\xca\x31\x47\xbd\x88\xb1\x4e\xd3\xcb\xe5\x92\x18\xdd\x68\x67\x13\xfd\x9a\x20\x4b\xc6\x97\xf4\xcf\x73\xdb\xa6\x56\x0b\x77\x41\x43\xe9\x99\xcc\xf5\xc8\x89\x86\x74\x9a\xf1\xe7\xbf\xf1\x96\x04\x51\xa8\x5c\x04\x20\xed\x11\x0d\x3b\xc9\xb3\xa7\x10\x76\xd6\xbf\xeb\xa4\x00\x4b\xee\xc1\x33\x6e\xda\x75\x0d\x5a\xf2\xdd\x0d\xb3\x09\xa3\xe9\xfc\x2e\x43\x05\xb3\x66\x60\xc1\x8f\xbf\x95\x57\x5f\x54\x7a\xd9\x8c\x90\x96\x97\x2b\xe0\xa4\xb4\x23\xff\xfc\x0f\x56\x84\xec\x28\xbc\x8b\xed\x8d\xc8\xa1\x7b\x4b\x73\x70\x91\xee\x34\xaf\xe5\x7b\x48\x01\xb6\x20\x13\x63\x4d\xc3\x39\x16\xd5\x26\x5b\x6f\xd6\xfb\x86\xb6\x95\xd8\x57\xbb\x5c\x14\x4d\xb1\x2b\x0b\xef\xff\x56\xf5\x3b\x03\x9b\x82\x95\x79\xde\x10\x36\x7c\xc7\xc4\xba\x6c\x38\xaf\xd6\x65\xc1\x04\x2f\x77\x39\xab\x76\x11\x3a\x67\x64\x33\xba\x69\xdb\xd3\xab\x33\x08\x8a\x9c\xff\x88\x80\xbb\x2c\x02\x78\x91\x8a\xd7\x70\x78\x7a\x9a\x2b\xe3\xcf\x3e\x23\x45\xa3\xc1\xee\x4d\xe7\xc3\xe1\xe9\xe9\x01\xbe\xfa\xbf\x24\x49\x3e\xfa\xf1\xf6\xdf\x0e\x52\xb5\x47\x3f\x52\x96\x5c\x0d\x9f\xfd\x2a\x7b\x22\xe7\x37\x19\x3a\x7f\x37\xbd\xa9\x9c\x86\xf0\x71\x32\x2b\x44\x00\x3d\x2a\x29\xc8\xba\x23\x8e\xee\xa4\x4d\x0d\xd8\xf0\xb1\xe3\xd1\x5f\x01\x00\x00\xff\xff\x2a\xed\x8c\x0f\x0a\x09\x00\x00")

FileVGG19Yml is "/VGG19.yml"

View Source
var FileWRN502Yml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x04\xff\xac\x56\x4b\x8f\xe3\xb8\x11\xbe\xeb\x57\x14\xe0\xcb\x2c\x60\x4b\x7e\xaa\xdd\x3a\xe4\x90\xce\x21\x41\x36\x3e\x74\x16\x69\x20\x8b\xc0\x28\x91\x25\x8b\x31\x45\x0a\x7c\x58\xed\xf9\xf5\x41\x51\x72\xdb\xbd\x93\x4c\xe6\xb0\x3e\x18\x22\xf9\xd5\x83\x55\x5f\x55\xd1\x60\x47\x15\xbc\xbd\x1e\x76\x4b\x98\x01\xaf\xc0\x36\x70\xb5\xd1\x41\x67\x25\xe9\xac\x71\xd8\xd1\x60\xdd\xb9\xca\x20\x9d\x57\xf0\x82\x4d\x43\x30\x83\x8f\x23\x68\xac\x83\xd0\xd2\x24\x02\x70\x21\xe7\x95\x35\x15\xac\x72\x56\x7b\x07\x4e\x07\x20\xac\x09\x0e\x95\x09\xd9\xb4\x53\xc1\x3a\x41\xa7\x25\x28\xd3\x58\xd7\x61\x50\x96\xbf\xc1\x53\x87\x26\x28\xf1\x71\x3e\x9e\x66\xac\x07\x95\x21\x57\xc1\x2c\x29\x4d\x0b\x0f\xd1\x93\x84\x60\xa1\x27\xc7\xc8\xd1\x31\xe8\x1d\x49\x25\x58\x67\x06\xf7\xdf\x0c\xba\xa8\x83\xea\x35\x41\xaf\x31\x30\xde\x83\x40\x03\x35\x81\xef\x49\xa8\x46\x91\xcc\x00\xb0\x93\xe5\x96\xa3\x00\x70\xea\x63\x05\x0e\x55\xef\xec\xbf\x49\x84\x42\xa0\xeb\xf4\x42\x70\x5c\xaa\x04\x5b\x88\x3e\x26\x1b\xe2\xff\x22\x4f\x09\xd9\xf7\xa2\xdc\x6a\x1a\xd5\x7f\x4f\x68\x02\x4e\x62\xdf\x77\xe5\x11\x2b\xc9\x0b\xa7\x7a\xbe\x7c\x05\x7f\xc8\x00\x7e\x69\x95\x9f\xe2\x32\xe0\x14\x31\xce\x23\xbd\xf7\xe4\x54\x47\x26\x78\x18\x54\x68\xe1\x4d\x49\x82\x57\xf2\x4a\x46\xd4\x70\xa0\x30\x58\x77\xf6\xf0\xe5\x8f\x7f\xfb\xc7\x0b\xac\x97\xab\xf2\x27\x68\x43\xe8\xab\xa2\x40\xf7\xae\x2e\xb9\x75\xa7\x02\x6b\x5f\xac\xca\xe5\x2e\x5f\x3e\xad\xb6\x25\xd4\x57\xf8\x3b\xb9\x13\x5d\xe1\x9f\x78\xb2\x2e\x5e\xcf\x16\xd0\x48\x38\xa8\xb3\xf5\xf0\x57\xdb\x59\x89\x67\xe5\xf3\x0c\xe0\x4f\x44\x3d\x38\xf2\xa3\x35\x73\xb3\x36\x90\x23\xf0\xad\x1d\x0c\xa7\xb5\x26\xc0\x5a\x13\x7f\x7a\x81\x9a\x20\xf6\xfc\x1d\x5a\x1b\x3d\x1a\xe9\x99\xc3\x1a\xaf\xe4\x3c\xa0\x91\xe0\x83\xd2\x1a\x5a\xbc\x10\xa8\xae\x77\xf6\xa2\xcc\xe9\x46\x0d\x34\x82\x72\xf8\xb3\x1d\xe8\x42\x6e\x0e\x84\xa2\x65\xbe\x26\x96\xb0\x1a\x64\xa0\x20\x13\x32\xe0\xe5\x28\x4f\x12\x50\x88\xe8\x50\x5c\x41\x58\x1f\x3c\x18\x42\xa7\xaf\x20\x6d\xac\x35\x6b\xe7\x6a\x30\xb1\xab\xc9\xb1\xd4\xe8\xcb\x7c\x74\xc6\x42\xa2\x3e\xa3\x2e\xe4\xae\x20\x89\xfe\xdb\x8d\x5b\xf4\x6c\xdc\xd9\x5a\x53\xc7\x4a\xa4\xea\x94\x51\xbe\x65\xc1\x86\x30\x44\x47\xe0\x28\x7a\x9a\x67\x00\x43\xab\x44\x0b\x1d\x9e\xc9\xb3\x6d\x4f\xf7\xd0\x25\x23\x5e\xdb\x21\x85\x88\xab\x2e\x87\x5f\x2c\x04\x14\x67\x0e\x61\xcb\xe0\xc9\x8c\x9f\x83\x32\x10\x98\x19\x5c\xf2\x30\x10\x17\x95\x8c\x22\x00\x82\xa4\x80\x4a\x93\x7c\x60\x08\x6a\xf0\x21\xca\x2b\x58\x96\x22\x40\x27\x5a\x15\x48\x24\xdf\x6c\xc3\xac\x39\x50\x80\x5a\x5b\x71\xf6\xec\x66\x8d\x5c\x98\xd6\x4c\xfe\x0e\xc4\x96\x7b\xeb\x09\x10\x8c\xbd\x90\xfe\xac\x62\x68\x39\xed\x03\x81\x24\xe1\x08\x3d\x7f\xf4\xa1\x4d\x71\x54\x66\xda\x1a\x94\x0c\x2d\x5b\x73\x37\x8e\xde\x58\x93\xc3\x1b\x81\x40\xad\x39\x24\x7c\xcc\x75\x6e\x4e\xb7\x73\xf0\xc1\xc5\xe4\x2b\x33\x5d\x26\xc4\x6f\x68\xf7\xe5\xed\xf5\xe0\x7f\xe2\xe2\x67\x1a\xb5\x1c\xc3\x16\x03\xab\x63\x97\x1d\x41\x83\x0e\x7c\xe4\x8a\xb1\x0e\xec\x85\x52\x1f\x54\x0e\x84\xed\x3a\x6b\xf4\x75\xea\x44\xad\x32\xc9\xe9\x94\x8b\x94\x70\x61\xa3\x09\xe4\x7a\x74\xc1\x67\x8e\x1a\x72\x64\x04\x79\xee\x63\xf7\x15\x67\xac\xc7\x9e\x79\x5c\xc0\x40\xb5\x57\x81\x3c\x14\x40\x41\xe4\x39\x8c\x25\x5d\xf3\x8d\x98\x6e\x63\xbf\x06\x58\xa4\x72\xf4\x55\x51\x9c\x54\x68\x63\x9d\x0b\xdb\x15\xde\x12\x5e\xc8\x15\xa9\x47\x2d\x12\xb4\x08\x8e\xa8\xe8\xd0\x07\xde\xd7\xfe\x93\xe8\xff\x2a\xe5\x4f\xa0\x47\xfd\x5f\x6f\x85\x5d\x0c\x4a\xd2\xe2\x96\x8b\xc5\x2d\x17\x3f\x20\xd8\x44\x93\xca\x0e\xf5\xe2\xab\xb5\x45\xad\x6d\x7d\x73\x4f\x75\x78\x22\x43\x61\x71\x41\xad\x64\x1a\x0b\x79\x7f\x9d\xfd\x5c\x3e\x2f\x7e\xde\xef\xb3\x19\x68\x25\xc8\xf8\x34\xbc\xee\xb1\x98\x36\x2b\x88\xc6\x91\x0f\x4e\x89\x40\x32\x9b\x81\x32\x7d\x0c\x29\xb8\x77\xec\xb8\xc7\xfd\x77\x06\x8d\x72\x3e\x8c\x28\x08\xd7\x9e\x52\x5f\xbc\x43\x39\xc4\xbc\x5d\x41\x72\x2b\xf5\xf9\xd9\x94\x8d\xd4\x60\x99\x8c\x0c\x7f\xd0\x93\x40\x63\xc2\x12\xa4\x4a\x80\x64\xf4\x41\x4b\x8f\x0e\x3b\x0a\xe4\x12\x0f\xd8\xc6\xc3\x56\x52\x01\x20\xb9\x37\xf3\x74\xf5\x15\xfc\xba\x99\xc3\x7a\xbd\x4d\x7f\xff\x9a\xce\x3b\x42\x53\xc1\xaf\xab\xf5\x26\x2f\xf7\x73\x58\xad\xca\xfc\xe9\xe9\x79\x0e\xab\xe5\x26\x7f\xde\x3c\xdf\x60\xa9\x6f\x56\xb0\xde\x95\x99\x8d\xa1\x8f\x61\xbc\x3a\xbb\x9d\xec\xda\x26\x7d\x8f\x67\x19\xa4\xcd\xea\xd6\x77\x32\x80\x59\xea\x08\x1f\x33\xe5\x33\xfe\xee\x75\x06\xdf\xde\x7a\xd4\x09\x1a\x6b\xd2\x19\xdc\xb1\x29\xfa\xac\x39\x39\x70\x8f\x45\xba\xd8\xd4\xf1\xfc\x31\x3a\x5d\x25\x86\x57\x45\xe1\x37\x39\x76\xf8\xd5\x1a\x1c\xfc\x48\xf3\x60\x1d\xe5\x69\x1c\xe7\x3c\x87\xfc\xd5\x78\x0a\xfe\x83\x3f\xd3\x46\x1e\xde\xf9\x4e\x70\xd7\x2a\x5a\x12\x67\x1f\xbb\x0a\xb6\x72\xbd\xd9\xd6\xbb\xfd\x66\x83\x02\xb7\xdb\xe7\xf5\x7e\x59\xee\x70\xb5\x5f\xca\x7a\xb3\x5c\x95\x98\xa5\xe2\xe1\x3a\xbd\x3d\x0e\x6e\x63\xf4\xe4\xb0\x1f\x7b\xd3\x40\xea\xd4\x06\xcf\x2d\xc7\x46\x27\x88\xaf\x90\x4e\x8f\x3d\x86\xf6\xc7\xdd\x4f\xa6\xfc\x58\xb4\xc5\xe0\xcc\x6e\xb9\x58\x17\x92\x7a\x6d\xaf\xc7\x69\x79\x34\xf6\x28\x48\xe9\x23\x63\xf3\xde\xd9\x60\xc7\xcb\x4d\x3e\xfc\x1e\x16\x27\x53\x79\x6a\x1e\x6c\x87\xd3\xa6\xfc\x31\xb5\xfb\x0b\xd3\x02\xb5\xe7\x17\xa1\x6a\xc0\x53\x98\x33\x73\xc6\x81\xc0\xfd\x9e\x33\x06\x8a\x87\x59\x74\x9a\x3b\x1a\x9a\xb1\xcb\x5f\x98\x47\xdf\xfe\x66\x2c\xfe\x10\xae\xd4\x38\x1f\x6f\xc3\xe7\x06\x24\x19\x1b\x88\xbf\x13\x3f\x7e\xfb\xe3\x2a\xd6\x94\x5e\xac\xe9\x39\xc0\xc4\x4e\x29\x78\x54\x97\x1e\x38\x69\xe2\x4d\xb3\x2b\xb9\x94\x60\x0f\x8c\xa0\x46\xae\x77\x7b\xda\x88\xf5\x5e\x60\xbd\x6a\x96\xb4\xc4\x4d\x29\x9e\x9e\x10\xeb\xb5\x24\xc1\xe3\x77\x4c\xf8\xa3\x10\x96\xe2\x79\x29\xd7\xcd\xaa\xc4\xd5\x76\x29\x97\x9b\xfd\x66\xf7\x5c\xae\xcb\xba\x79\xda\xaf\x57\xab\x0c\x43\x70\xaa\x8e\x81\x52\xad\xd3\x7b\x70\xf8\x31\x98\xee\x67\x19\xc0\x59\x19\x59\xc1\xcb\xe1\x30\x45\x86\xd7\x5c\x6e\x86\xa2\x43\xfd\x21\xf3\xe5\xe5\x70\x98\xc3\x2b\xff\xe5\x79\xce\x33\x2b\xcd\x7a\x65\x4e\x47\x89\x01\x3d\x85\x0a\xfe\xc2\x6d\x94\x27\xf2\x0c\xa6\xbd\x69\x3e\xd9\xb1\xc5\xf1\xe3\x40\x99\x53\x06\xd0\xa1\x51\x0d\xf9\x70\xc4\x18\x5a\xeb\x2a\xc0\x5a\x46\x2d\xb3\xff\x04\x00\x00\xff\xff\x1b\xee\x01\x55\x30\x0c\x00\x00")

FileWRN502Yml is "/WRN50-2.yml"

View Source
var FileXceptionYml = []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x04\xff\xac\x57\x4d\x8f\xe3\xb8\x11\xbd\xeb\x57\x3c\xc0\x97\x19\xc0\x2d\xd9\x6d\xb7\xbb\x47\x87\x00\xc9\x9c\x06\x08\xfa\x90\x04\x9b\x00\x8b\xa0\x51\x22\x4b\x16\x33\x14\x29\x90\x94\xdd\xce\xaf\x0f\x8a\x92\x6d\xf5\xce\x66\x37\x87\xe8\xa0\x6e\xb1\xbe\x5f\x3d\x16\x69\x47\x3d\xd7\xf8\x87\xe2\x21\x19\xef\xb0\x82\x2c\xc0\xb7\xb8\xf8\x31\xa0\xf7\x9a\x6d\xd1\x06\xea\xf9\xec\xc3\xf7\xba\x40\x96\xd7\xf8\x4a\x6d\xcb\x58\xe1\x26\x42\xeb\x03\x52\xc7\xb3\x09\x70\xe2\x10\x8d\x77\x35\xb6\xe5\xe6\x83\xe2\x2c\x80\xf2\x2e\x05\x32\x2e\x15\xf3\xca\x55\x75\xfe\x84\x71\xad\x0f\x3d\xe5\xbc\x8c\x43\xe4\x9e\x5c\x32\xea\x26\x9f\xa4\x85\xf8\x21\xe3\x38\xd4\x58\x65\xa7\xf9\x23\x62\x8c\xac\x91\x3c\x06\x0e\xa2\x39\x25\x86\x21\xb0\x36\x4a\x7c\x16\xb8\x3f\x2b\xf4\xa3\x4d\x66\xb0\x8c\xc1\x52\x12\xfd\x08\x45\x0e\x0d\x23\x0e\xac\x4c\x6b\x58\x17\x00\xf5\xfa\xb0\x17\x14\x80\xe3\x30\xd6\x08\x64\x86\xe0\xff\xc5\x2a\x55\x8a\x42\x6f\x1f\x94\xe0\x52\x67\xb5\x07\x35\x8c\x39\x86\xfa\x5d\xcd\x63\xd6\x1c\x06\x75\xd8\x5b\x9e\xdc\xff\x96\xd1\xac\x38\x9b\xfd\x76\x2a\x4b\x5d\xcd\x51\x05\x93\x1b\x5d\xe3\x0f\x05\xf0\x47\x01\x39\x71\x18\x02\xa7\x09\x67\xdf\xe2\x9b\xbb\x92\xa1\xf7\x7a\xb4\x1c\x05\x7c\xe5\xdd\xc9\xdb\x51\x70\x23\x0b\xc7\x63\xc8\x7f\x92\xb0\x22\x82\x22\x1a\x36\xee\x08\x9a\x1d\xf6\xac\x0d\x25\x46\x4c\x3c\xc0\xb8\x87\x86\xd3\x99\x59\x20\x0f\x7c\x1c\x2d\x85\xa5\x43\x90\xd3\x99\x3a\x9a\x87\xd4\x9d\x4d\x64\x44\x1e\x28\x50\x63\xf9\x83\x9e\x1f\x38\x4c\x69\x7e\xa2\x85\xf2\x22\x37\xb4\xde\x5a\x7f\x66\x8d\xe6\x02\xc2\xe0\x8d\x4b\xd9\xe1\x42\xe7\x73\x59\x00\xdf\x1c\x52\x67\x22\xac\x39\x76\x69\x8d\xa5\xbb\x5f\x8f\x3d\x93\x61\x74\x9a\x43\x4c\xde\x6b\x29\x9a\xdc\x0f\x68\xe1\x6c\x52\x07\x42\x4f\xef\xa6\x27\x6b\x2f\xb0\x14\x8e\x0c\x37\xf6\x0d\x07\xc1\x37\xf9\x33\x87\x28\x49\xfc\x4d\x32\xf0\x4d\xe4\x70\x9a\xca\xb2\x4c\x5a\x88\x9b\x69\x1b\xfc\xe0\x23\x83\xe0\xfc\x89\x2d\x34\xf3\xb0\x2c\x23\xe3\xbf\x6c\x03\x28\xa8\xce\x24\x56\x69\x0c\x0c\xe3\xe2\x60\xc2\x04\xc4\xad\xa3\x6b\x9c\x3b\x0e\x7c\x5f\x28\x70\x6b\x72\x47\x27\x46\xc3\xec\x10\x78\xb0\xa4\x58\x4f\xa5\xfc\x4e\x53\x62\x89\xbf\x33\x62\xe7\xcf\x48\x1d\xa5\x09\xd5\x65\x26\x6b\xe8\xb1\x69\x58\xdf\x66\xcc\x1a\x31\xa3\x6e\x2f\xf0\x63\x9a\x77\x67\xcc\x3d\xb9\x12\xef\xa7\x1d\xbc\x34\x88\xf1\xad\xa7\x23\xbf\x72\x82\xa6\x44\x91\x13\x3e\x9d\x3b\xa3\xba\x7b\x05\xa2\x7b\xa6\x08\xcd\xd1\x1c\x1d\x6b\x99\x0a\x9f\xd7\x10\x4a\xc9\x82\x69\x8d\x22\xf7\x8b\x58\x1f\xad\xbd\x03\x4d\x4d\x0a\x30\x12\xae\x00\x94\xa5\x18\xb3\xad\x30\xfe\x16\x5c\xf9\x7e\x08\x26\x0a\xd3\x77\x4f\x1b\xf4\xc6\x5a\x19\x9a\xd9\x2a\xe6\x98\xdb\xe7\xf5\x66\xb3\x99\xec\x39\x96\xf8\xab\x71\x8a\x33\xb9\x6f\x23\x76\x09\x0e\x3a\x8a\x59\x1a\xa9\x5f\x72\x44\xd8\xdf\x73\xe2\x20\xb8\xd0\xc7\x84\xd7\xd9\x60\xc6\x8d\xc4\xfd\x91\x8c\x8b\xa0\xc0\x70\x3e\x41\x8f\x2c\xfc\x31\x4e\x05\x26\x99\x81\x8a\x06\x52\x26\x5d\xd0\x8c\x09\x81\x52\xc7\x41\x14\x08\xbd\x0f\x0c\x6e\x5b\xa3\x0c\xbb\x24\x03\x53\xf8\x99\x67\xfe\x22\x83\x12\x45\xe0\x96\x03\x3b\xc5\x51\x66\xec\xfd\x4b\xdc\x0c\x34\x70\x88\xa8\x70\xe6\x26\x9a\xc4\xf2\x2f\x27\x55\x96\xd2\x12\x15\x4c\x23\x68\x2d\x0f\x86\x07\x74\x29\x0d\xb1\xae\xaa\xa3\x49\xdd\xd8\x94\xca\xf7\x55\xf4\x4c\x27\x0e\x55\x9e\x9f\x0f\x39\x85\x2a\x05\xe6\xaa\xa7\x98\x64\xdd\x0a\x12\xbf\x6a\xfa\xa7\x9f\xfe\xfc\x75\xb2\xab\x86\xd1\xda\xea\xe9\x70\x78\xaa\x5a\x63\xf9\xbf\x5a\xb4\xaa\xf3\xd6\x72\xaa\x64\x4f\x3d\x58\xa6\xe0\x8c\x3b\x4e\x51\x63\xd5\x58\xdf\x5c\xc3\xbe\xcf\x8c\x2c\x87\x4b\x81\x45\x78\x0a\xef\xe6\x54\xfa\x70\xac\xa8\x89\xd5\xf6\xb0\xdd\x94\x9b\xc7\xdd\xd3\x73\xb1\x82\x35\x8a\x5d\xcc\x48\xde\xab\x9e\x17\x6b\x8c\x2e\x70\x4c\xc1\xa8\xc4\xba\x58\xc1\xb8\x61\x4c\x19\xc6\xbb\xee\xb4\x26\xa7\xc0\x0a\xad\x09\x31\x4d\x5a\x48\x97\x81\x85\xdd\x0b\x55\x49\x49\x96\xeb\x89\x82\xf9\xb4\x59\xcd\xb8\x0f\x99\xb9\xbe\xcd\xea\x0b\x3f\x59\xe9\xc3\x49\x20\xa1\x73\xd0\x85\x97\x3b\x01\xa5\xe3\x12\x63\xb1\x94\x5d\x00\xda\xf4\xec\xe4\x8c\x8f\x35\x7e\xde\xad\xf1\xf8\xe5\x4b\x7e\xfd\x73\x96\xf7\x4c\xae\xc6\xcf\xdb\xc7\x97\x35\xae\xaf\xab\x2c\x2a\xb2\x5c\xcb\x72\x21\x43\x60\x4c\x53\xbd\x92\x4a\x0e\x36\xe7\x3d\xc9\x0a\xe4\xc5\x1a\x2d\x93\x0c\xb7\x02\x58\xe5\x91\x2d\xfc\xfa\x50\xe7\xa4\x7f\x4f\xb5\xc0\x8f\xa5\xce\x3a\x96\x1a\xb6\x05\xee\xba\x19\x72\xf1\x9c\x13\xb8\x03\x90\xab\x99\x23\xc7\xb7\x31\xd8\x3a\x13\xb8\xae\xaa\xb8\x2b\xa9\xa7\x7f\x7b\x47\xe7\x38\xb1\x38\xf9\xc0\x65\xbe\x09\x64\x72\xc4\x8b\x8b\x9c\x62\x95\x07\x84\xe3\x34\x2f\x94\xe9\x5d\x6a\xc2\xdd\xab\xea\x58\x7d\x8f\x63\x5f\x63\xaf\x1f\x77\xfb\xe6\xe9\x65\xb7\x23\x45\xfb\xfd\x97\xc7\x97\xcd\xe1\x89\xb6\x2f\x1b\xdd\xec\x36\xdb\x03\x15\x79\x6f\x48\x53\xae\xf7\x92\x38\xef\xd8\x63\xa0\xa1\xcb\x43\xe8\xcc\x72\xaa\x45\x04\x8e\x7e\x0c\x2a\x6f\x84\x2c\x7d\x1b\x28\x75\xff\x7b\xfa\x39\x54\x9c\xf7\xd6\x75\x2b\x54\x9a\x07\xeb\x2f\x6f\xd7\xef\x72\x08\x3e\xf9\xa9\xa2\x39\xf0\xff\x25\xcc\xcd\x7f\x1e\x09\x39\x95\x02\x30\xf1\x2d\xcf\xcf\x93\xb0\x81\x6c\x94\x3b\xa8\x69\x11\x39\xe5\xb1\x38\x1d\x1a\x0d\x45\x96\x46\xc1\x44\x10\xc6\x60\x65\x4e\x91\x9b\x26\xef\x49\xe8\xf3\xe3\xb3\xca\xdc\xbb\xa3\xb4\x04\x32\xd7\x23\x72\x07\xcd\xce\xa7\x3c\xd0\x33\x2d\x7e\xf9\xc8\x8e\xb5\x9c\xef\xc8\xf1\xca\xe1\xec\x73\xe9\x2e\x9f\xab\x66\x4a\x75\x2e\xa6\xc0\xa4\xb6\x20\x82\xde\xe8\x76\x47\x44\xb4\xdf\xf1\xbe\x79\x79\xe4\xfd\xf3\x97\x7d\xf3\xf2\x65\xff\xb8\x69\x9e\x37\x87\xe7\x02\xb8\xc2\x7d\x67\x8f\x22\xbd\x55\xcf\x07\xde\x3e\x37\xac\x88\x9b\x4d\xa3\x79\xb3\x7b\xda\xaa\xb6\x39\xe8\x86\x5e\x0a\x4a\x29\x98\x66\x4c\xd3\x24\xe7\xf7\x14\x08\x6e\xba\xc6\xe1\x2e\x2b\x80\xef\xc6\xe9\x1a\x5f\x5f\x5f\x67\x64\xe4\x5b\x2a\xfa\x78\xf5\xc3\xa7\xaf\xaf\xaf\x6b\xfc\x45\x5e\x65\x59\x7e\x96\x9d\x2a\x77\x7a\xe3\x8e\x6f\xf3\x89\x5d\xdf\xcf\xf0\xd5\xed\x20\xbd\xde\xcd\xf3\x8f\x86\xd9\x40\xee\x22\xe4\x4c\xcb\x31\xbd\xd1\x98\x3a\x1f\x6a\x50\xa3\x47\xab\x8b\xff\x04\x00\x00\xff\xff\x6b\x2b\x34\x1d\xa5\x0c\x00\x00")

FileXceptionYml is "/Xception.yml"

View Source
var FillerParameter_VarianceNorm_name = map[int32]string{
	0: "FAN_IN",
	1: "FAN_OUT",
	2: "AVERAGE",
}
View Source
var FillerParameter_VarianceNorm_value = map[string]int32{
	"FAN_IN":  0,
	"FAN_OUT": 1,
	"AVERAGE": 2,
}
View Source
var FrameworkManifest = dlframework.FrameworkManifest{
	Name:    "Caffe",
	Version: "1.0",
	Container: map[string]*dlframework.ContainerHardware{
		"amd64": {
			Cpu: "raiproject/carml-caffe:amd64-cpu",
			Gpu: "raiproject/carml-caffe:amd64-gpu",
		},
		"ppc64le": {
			Cpu: "raiproject/carml-caffe:ppc64le-gpu",
			Gpu: "raiproject/carml-caffe:ppc64le-gpu",
		},
	},
}

FrameworkManifest ...

View Source
var HingeLossParameter_Norm_name = map[int32]string{
	1: "L1",
	2: "L2",
}
View Source
var HingeLossParameter_Norm_value = map[string]int32{
	"L1": 1,
	"L2": 2,
}
View Source
var LRNParameter_Engine_name = map[int32]string{
	0: "DEFAULT",
	1: "CAFFE",
	2: "CUDNN",
}
View Source
var LRNParameter_Engine_value = map[string]int32{
	"DEFAULT": 0,
	"CAFFE":   1,
	"CUDNN":   2,
}
View Source
var LRNParameter_NormRegion_name = map[int32]string{
	0: "ACROSS_CHANNELS",
	1: "WITHIN_CHANNEL",
}
View Source
var LRNParameter_NormRegion_value = map[string]int32{
	"ACROSS_CHANNELS": 0,
	"WITHIN_CHANNEL":  1,
}
View Source
var LossParameter_NormalizationMode_name = map[int32]string{
	0: "FULL",
	1: "VALID",
	2: "BATCH_SIZE",
	3: "NONE",
}
View Source
var LossParameter_NormalizationMode_value = map[string]int32{
	"FULL":       0,
	"VALID":      1,
	"BATCH_SIZE": 2,
	"NONE":       3,
}
View Source
var ParamSpec_DimCheckMode_name = map[int32]string{
	0: "STRICT",
	1: "PERMISSIVE",
}
View Source
var ParamSpec_DimCheckMode_value = map[string]int32{
	"STRICT":     0,
	"PERMISSIVE": 1,
}
View Source
var Phase_name = map[int32]string{
	0: "TRAIN",
	1: "TEST",
}
View Source
var Phase_value = map[string]int32{
	"TRAIN": 0,
	"TEST":  1,
}
View Source
var PoolingParameter_Engine_name = map[int32]string{
	0: "DEFAULT",
	1: "CAFFE",
	2: "CUDNN",
}
View Source
var PoolingParameter_Engine_value = map[string]int32{
	"DEFAULT": 0,
	"CAFFE":   1,
	"CUDNN":   2,
}
View Source
var PoolingParameter_PoolMethod_name = map[int32]string{
	0: "MAX",
	1: "AVE",
	2: "STOCHASTIC",
}
View Source
var PoolingParameter_PoolMethod_value = map[string]int32{
	"MAX":        0,
	"AVE":        1,
	"STOCHASTIC": 2,
}
View Source
var ReLUParameter_Engine_name = map[int32]string{
	0: "DEFAULT",
	1: "CAFFE",
	2: "CUDNN",
}
View Source
var ReLUParameter_Engine_value = map[string]int32{
	"DEFAULT": 0,
	"CAFFE":   1,
	"CUDNN":   2,
}
View Source
var ReductionParameter_ReductionOp_name = map[int32]string{
	1: "SUM",
	2: "ASUM",
	3: "SUMSQ",
	4: "MEAN",
}
View Source
var ReductionParameter_ReductionOp_value = map[string]int32{
	"SUM":   1,
	"ASUM":  2,
	"SUMSQ": 3,
	"MEAN":  4,
}
View Source
var SPPParameter_Engine_name = map[int32]string{
	0: "DEFAULT",
	1: "CAFFE",
	2: "CUDNN",
}
View Source
var SPPParameter_Engine_value = map[string]int32{
	"DEFAULT": 0,
	"CAFFE":   1,
	"CUDNN":   2,
}
View Source
var SPPParameter_PoolMethod_name = map[int32]string{
	0: "MAX",
	1: "AVE",
	2: "STOCHASTIC",
}
View Source
var SPPParameter_PoolMethod_value = map[string]int32{
	"MAX":        0,
	"AVE":        1,
	"STOCHASTIC": 2,
}
View Source
var SigmoidParameter_Engine_name = map[int32]string{
	0: "DEFAULT",
	1: "CAFFE",
	2: "CUDNN",
}
View Source
var SigmoidParameter_Engine_value = map[string]int32{
	"DEFAULT": 0,
	"CAFFE":   1,
	"CUDNN":   2,
}
View Source
var SoftmaxParameter_Engine_name = map[int32]string{
	0: "DEFAULT",
	1: "CAFFE",
	2: "CUDNN",
}
View Source
var SoftmaxParameter_Engine_value = map[string]int32{
	"DEFAULT": 0,
	"CAFFE":   1,
	"CUDNN":   2,
}
View Source
var SolverParameter_SnapshotFormat_name = map[int32]string{
	0: "HDF5",
	1: "BINARYPROTO",
}
View Source
var SolverParameter_SnapshotFormat_value = map[string]int32{
	"HDF5":        0,
	"BINARYPROTO": 1,
}
View Source
var SolverParameter_SolverMode_name = map[int32]string{
	0: "CPU",
	1: "GPU",
}
View Source
var SolverParameter_SolverMode_value = map[string]int32{
	"CPU": 0,
	"GPU": 1,
}
View Source
var SolverParameter_SolverType_name = map[int32]string{
	0: "SGD",
	1: "NESTEROV",
	2: "ADAGRAD",
	3: "RMSPROP",
	4: "ADADELTA",
	5: "ADAM",
}
View Source
var SolverParameter_SolverType_value = map[string]int32{
	"SGD":      0,
	"NESTEROV": 1,
	"ADAGRAD":  2,
	"RMSPROP":  3,
	"ADADELTA": 4,
	"ADAM":     5,
}
View Source
var TanHParameter_Engine_name = map[int32]string{
	0: "DEFAULT",
	1: "CAFFE",
	2: "CUDNN",
}
View Source
var TanHParameter_Engine_value = map[string]int32{
	"DEFAULT": 0,
	"CAFFE":   1,
	"CUDNN":   2,
}
View Source
var V0LayerParameter_PoolMethod_name = map[int32]string{
	0: "MAX",
	1: "AVE",
	2: "STOCHASTIC",
}
View Source
var V0LayerParameter_PoolMethod_value = map[string]int32{
	"MAX":        0,
	"AVE":        1,
	"STOCHASTIC": 2,
}
View Source
var V1LayerParameter_DimCheckMode_name = map[int32]string{
	0: "STRICT",
	1: "PERMISSIVE",
}
View Source
var V1LayerParameter_DimCheckMode_value = map[string]int32{
	"STRICT":     0,
	"PERMISSIVE": 1,
}
View Source
var V1LayerParameter_LayerType_name = map[int32]string{
	0:  "NONE",
	35: "ABSVAL",
	1:  "ACCURACY",
	30: "ARGMAX",
	2:  "BNLL",
	3:  "CONCAT",
	37: "CONTRASTIVE_LOSS",
	4:  "CONVOLUTION",
	5:  "DATA",
	39: "DECONVOLUTION",
	6:  "DROPOUT",
	32: "DUMMY_DATA",
	7:  "EUCLIDEAN_LOSS",
	25: "ELTWISE",
	38: "EXP",
	8:  "FLATTEN",
	9:  "HDF5_DATA",
	10: "HDF5_OUTPUT",
	28: "HINGE_LOSS",
	11: "IM2COL",
	12: "IMAGE_DATA",
	13: "INFOGAIN_LOSS",
	14: "INNER_PRODUCT",
	15: "LRN",
	29: "MEMORY_DATA",
	16: "MULTINOMIAL_LOGISTIC_LOSS",
	34: "MVN",
	17: "POOLING",
	26: "POWER",
	18: "RELU",
	19: "SIGMOID",
	27: "SIGMOID_CROSS_ENTROPY_LOSS",
	36: "SILENCE",
	20: "SOFTMAX",
	21: "SOFTMAX_LOSS",
	22: "SPLIT",
	33: "SLICE",
	23: "TANH",
	24: "WINDOW_DATA",
	31: "THRESHOLD",
}
View Source
var V1LayerParameter_LayerType_value = map[string]int32{
	"NONE":                       0,
	"ABSVAL":                     35,
	"ACCURACY":                   1,
	"ARGMAX":                     30,
	"BNLL":                       2,
	"CONCAT":                     3,
	"CONTRASTIVE_LOSS":           37,
	"CONVOLUTION":                4,
	"DATA":                       5,
	"DECONVOLUTION":              39,
	"DROPOUT":                    6,
	"DUMMY_DATA":                 32,
	"EUCLIDEAN_LOSS":             7,
	"ELTWISE":                    25,
	"EXP":                        38,
	"FLATTEN":                    8,
	"HDF5_DATA":                  9,
	"HDF5_OUTPUT":                10,
	"HINGE_LOSS":                 28,
	"IM2COL":                     11,
	"IMAGE_DATA":                 12,
	"INFOGAIN_LOSS":              13,
	"INNER_PRODUCT":              14,
	"LRN":                        15,
	"MEMORY_DATA":                29,
	"MULTINOMIAL_LOGISTIC_LOSS":  16,
	"MVN":                        34,
	"POOLING":                    17,
	"POWER":                      26,
	"RELU":                       18,
	"SIGMOID":                    19,
	"SIGMOID_CROSS_ENTROPY_LOSS": 27,
	"SILENCE":                    36,
	"SOFTMAX":                    20,
	"SOFTMAX_LOSS":               21,
	"SPLIT":                      22,
	"SLICE":                      33,
	"TANH":                       23,
	"WINDOW_DATA":                24,
	"THRESHOLD":                  31,
}

Functions

func Asset

func Asset(name string) ([]byte, error)

Asset loads and returns the asset for the given name. It returns an error if the asset could not be found or could not be loaded.

func AssetDir

func AssetDir(name string) ([]string, error)

AssetDir returns the file names below a certain directory embedded in the file by go-bindata. For example if you run go-bindata on data/... and data contains the following hierarchy:

data/
  foo.txt
  img/
    a.png
    b.png

then AssetDir("data") would return []string{"foo.txt", "img"} AssetDir("data/img") would return []string{"a.png", "b.png"} AssetDir("foo.txt") and AssetDir("notexist") would return an error AssetDir("") will return []string{"data"}.

func AssetInfo

func AssetInfo(name string) (os.FileInfo, error)

AssetInfo loads and returns the asset info for the given name. It returns an error if the asset could not be found or could not be loaded.

func AssetNames

func AssetNames() []string

AssetNames returns the names of the assets.

func MustAsset

func MustAsset(name string) []byte

MustAsset is like Asset but panics when Asset would return an error. It simplifies safe initialization of global variables.

func ReadFile

func ReadFile(path string) ([]byte, error)

ReadFile is adapTed from ioutil

func Register

func Register()

func RestoreAsset

func RestoreAsset(dir, name string) error

RestoreAsset restores an asset under the given directory

func RestoreAssets

func RestoreAssets(dir, name string) error

RestoreAssets restores an asset under the given directory recursively

func WalkDirs

func WalkDirs(name string, includeDirsInList bool, files ...string) ([]string, error)

WalkDirs looks for files in the given dir and returns a list of files in it usage for all files in the b0x: WalkDirs("", false)

func WriteFile

func WriteFile(filename string, data []byte, perm os.FileMode) error

WriteFile is adapTed from ioutil

Types

type AccuracyParameter

type AccuracyParameter struct {
	// When computing accuracy, count as correct by comparing the true label to
	// the top k scoring classes.  By default, only compare to the top scoring
	// class (i.e. argmax).
	TopK *uint32 `protobuf:"varint,1,opt,name=top_k,json=topK,def=1" json:"top_k,omitempty"`
	// The "label" axis of the prediction blob, whose argmax corresponds to the
	// predicted label -- may be negative to index from the end (e.g., -1 for the
	// last axis).  For example, if axis == 1 and the predictions are
	// (N x C x H x W), the label blob is expected to contain N*H*W ground truth
	// labels with integer values in {0, 1, ..., C-1}.
	Axis *int32 `protobuf:"varint,2,opt,name=axis,def=1" json:"axis,omitempty"`
	// If specified, ignore instances with the given label.
	IgnoreLabel int32 `protobuf:"varint,3,opt,name=ignore_label,json=ignoreLabel" json:"ignore_label"`
}

func (*AccuracyParameter) Descriptor

func (*AccuracyParameter) Descriptor() ([]byte, []int)

func (*AccuracyParameter) GetAxis

func (m *AccuracyParameter) GetAxis() int32

func (*AccuracyParameter) GetIgnoreLabel

func (m *AccuracyParameter) GetIgnoreLabel() int32

func (*AccuracyParameter) GetTopK

func (m *AccuracyParameter) GetTopK() uint32

func (*AccuracyParameter) Marshal

func (m *AccuracyParameter) Marshal() (dAtA []byte, err error)

func (*AccuracyParameter) MarshalTo

func (m *AccuracyParameter) MarshalTo(dAtA []byte) (int, error)

func (*AccuracyParameter) ProtoMessage

func (*AccuracyParameter) ProtoMessage()

func (*AccuracyParameter) Reset

func (m *AccuracyParameter) Reset()

func (*AccuracyParameter) Size

func (m *AccuracyParameter) Size() (n int)

func (*AccuracyParameter) String

func (m *AccuracyParameter) String() string

func (*AccuracyParameter) Unmarshal

func (m *AccuracyParameter) Unmarshal(dAtA []byte) error

type ArgMaxParameter

type ArgMaxParameter struct {
	// If true produce pairs (argmax, maxval)
	OutMaxVal *bool   `protobuf:"varint,1,opt,name=out_max_val,json=outMaxVal,def=0" json:"out_max_val,omitempty"`
	TopK      *uint32 `protobuf:"varint,2,opt,name=top_k,json=topK,def=1" json:"top_k,omitempty"`
	// The axis along which to maximise -- may be negative to index from the
	// end (e.g., -1 for the last axis).
	// By default ArgMaxLayer maximizes over the flattened trailing dimensions
	// for each index of the first / num dimension.
	Axis int32 `protobuf:"varint,3,opt,name=axis" json:"axis"`
}

func (*ArgMaxParameter) Descriptor

func (*ArgMaxParameter) Descriptor() ([]byte, []int)

func (*ArgMaxParameter) GetAxis

func (m *ArgMaxParameter) GetAxis() int32

func (*ArgMaxParameter) GetOutMaxVal

func (m *ArgMaxParameter) GetOutMaxVal() bool

func (*ArgMaxParameter) GetTopK

func (m *ArgMaxParameter) GetTopK() uint32

func (*ArgMaxParameter) Marshal

func (m *ArgMaxParameter) Marshal() (dAtA []byte, err error)

func (*ArgMaxParameter) MarshalTo

func (m *ArgMaxParameter) MarshalTo(dAtA []byte) (int, error)

func (*ArgMaxParameter) ProtoMessage

func (*ArgMaxParameter) ProtoMessage()

func (*ArgMaxParameter) Reset

func (m *ArgMaxParameter) Reset()

func (*ArgMaxParameter) Size

func (m *ArgMaxParameter) Size() (n int)

func (*ArgMaxParameter) String

func (m *ArgMaxParameter) String() string

func (*ArgMaxParameter) Unmarshal

func (m *ArgMaxParameter) Unmarshal(dAtA []byte) error

type BatchNormParameter

type BatchNormParameter struct {
	// If false, accumulate global mean/variance values via a moving average. If
	// true, use those accumulated values instead of computing mean/variance
	// across the batch.
	UseGlobalStats bool `protobuf:"varint,1,opt,name=use_global_stats,json=useGlobalStats" json:"use_global_stats"`
	// How much does the moving average decay each iteration?
	MovingAverageFraction *float32 `` /* 131-byte string literal not displayed */
	// Small value to add to the variance estimate so that we don't divide by
	// zero.
	Eps *float32 `protobuf:"fixed32,3,opt,name=eps,def=1e-05" json:"eps,omitempty"`
}

func (*BatchNormParameter) Descriptor

func (*BatchNormParameter) Descriptor() ([]byte, []int)

func (*BatchNormParameter) GetEps

func (m *BatchNormParameter) GetEps() float32

func (*BatchNormParameter) GetMovingAverageFraction

func (m *BatchNormParameter) GetMovingAverageFraction() float32

func (*BatchNormParameter) GetUseGlobalStats

func (m *BatchNormParameter) GetUseGlobalStats() bool

func (*BatchNormParameter) Marshal

func (m *BatchNormParameter) Marshal() (dAtA []byte, err error)

func (*BatchNormParameter) MarshalTo

func (m *BatchNormParameter) MarshalTo(dAtA []byte) (int, error)

func (*BatchNormParameter) ProtoMessage

func (*BatchNormParameter) ProtoMessage()

func (*BatchNormParameter) Reset

func (m *BatchNormParameter) Reset()

func (*BatchNormParameter) Size

func (m *BatchNormParameter) Size() (n int)

func (*BatchNormParameter) String

func (m *BatchNormParameter) String() string

func (*BatchNormParameter) Unmarshal

func (m *BatchNormParameter) Unmarshal(dAtA []byte) error

type BiasParameter

type BiasParameter struct {
	// The first axis of bottom[0] (the first input Blob) along which to apply
	// bottom[1] (the second input Blob).  May be negative to index from the end
	// (e.g., -1 for the last axis).
	//
	// For example, if bottom[0] is 4D with shape 100x3x40x60, the output
	// top[0] will have the same shape, and bottom[1] may have any of the
	// following shapes (for the given value of axis):
	//    (axis == 0 == -4) 100; 100x3; 100x3x40; 100x3x40x60
	//    (axis == 1 == -3)          3;     3x40;     3x40x60
	//    (axis == 2 == -2)                   40;       40x60
	//    (axis == 3 == -1)                                60
	// Furthermore, bottom[1] may have the empty shape (regardless of the value of
	// "axis") -- a scalar bias.
	Axis *int32 `protobuf:"varint,1,opt,name=axis,def=1" json:"axis,omitempty"`
	// (num_axes is ignored unless just one bottom is given and the bias is
	// a learned parameter of the layer.  Otherwise, num_axes is determined by the
	// number of axes by the second bottom.)
	// The number of axes of the input (bottom[0]) covered by the bias
	// parameter, or -1 to cover all axes of bottom[0] starting from `axis`.
	// Set num_axes := 0, to add a zero-axis Blob: a scalar.
	NumAxes *int32 `protobuf:"varint,2,opt,name=num_axes,json=numAxes,def=1" json:"num_axes,omitempty"`
	// (filler is ignored unless just one bottom is given and the bias is
	// a learned parameter of the layer.)
	// The initialization for the learned bias parameter.
	// Default is the zero (0) initialization, resulting in the BiasLayer
	// initially performing the identity operation.
	Filler *FillerParameter `protobuf:"bytes,3,opt,name=filler" json:"filler,omitempty"`
}

func (*BiasParameter) Descriptor

func (*BiasParameter) Descriptor() ([]byte, []int)

func (*BiasParameter) GetAxis

func (m *BiasParameter) GetAxis() int32

func (*BiasParameter) GetFiller

func (m *BiasParameter) GetFiller() *FillerParameter

func (*BiasParameter) GetNumAxes

func (m *BiasParameter) GetNumAxes() int32

func (*BiasParameter) Marshal

func (m *BiasParameter) Marshal() (dAtA []byte, err error)

func (*BiasParameter) MarshalTo

func (m *BiasParameter) MarshalTo(dAtA []byte) (int, error)

func (*BiasParameter) ProtoMessage

func (*BiasParameter) ProtoMessage()

func (*BiasParameter) Reset

func (m *BiasParameter) Reset()

func (*BiasParameter) Size

func (m *BiasParameter) Size() (n int)

func (*BiasParameter) String

func (m *BiasParameter) String() string

func (*BiasParameter) Unmarshal

func (m *BiasParameter) Unmarshal(dAtA []byte) error

type BlobProto

type BlobProto struct {
	Shape      *BlobShape `protobuf:"bytes,7,opt,name=shape" json:"shape,omitempty"`
	Data       []float32  `protobuf:"fixed32,5,rep,packed,name=data" json:"data,omitempty"`
	Diff       []float32  `protobuf:"fixed32,6,rep,packed,name=diff" json:"diff,omitempty"`
	DoubleData []float64  `protobuf:"fixed64,8,rep,packed,name=double_data,json=doubleData" json:"double_data,omitempty"`
	DoubleDiff []float64  `protobuf:"fixed64,9,rep,packed,name=double_diff,json=doubleDiff" json:"double_diff,omitempty"`
	// 4D dimensions -- deprecated.  Use "shape" instead.
	Num      *int32 `protobuf:"varint,1,opt,name=num,def=0" json:"num,omitempty"`
	Channels *int32 `protobuf:"varint,2,opt,name=channels,def=0" json:"channels,omitempty"`
	Height   *int32 `protobuf:"varint,3,opt,name=height,def=0" json:"height,omitempty"`
	Width    *int32 `protobuf:"varint,4,opt,name=width,def=0" json:"width,omitempty"`
}

func ReadBlob

func ReadBlob(protoFileName string) (*BlobProto, error)

ReadBlob ...

func (*BlobProto) Descriptor

func (*BlobProto) Descriptor() ([]byte, []int)

func (*BlobProto) GetChannels

func (m *BlobProto) GetChannels() int32

func (*BlobProto) GetData

func (m *BlobProto) GetData() []float32

func (*BlobProto) GetDiff

func (m *BlobProto) GetDiff() []float32

func (*BlobProto) GetDoubleData

func (m *BlobProto) GetDoubleData() []float64

func (*BlobProto) GetDoubleDiff

func (m *BlobProto) GetDoubleDiff() []float64

func (*BlobProto) GetHeight

func (m *BlobProto) GetHeight() int32

func (*BlobProto) GetNum

func (m *BlobProto) GetNum() int32

func (*BlobProto) GetShape

func (m *BlobProto) GetShape() *BlobShape

func (*BlobProto) GetWidth

func (m *BlobProto) GetWidth() int32

func (*BlobProto) Marshal

func (m *BlobProto) Marshal() (dAtA []byte, err error)

func (*BlobProto) MarshalTo

func (m *BlobProto) MarshalTo(dAtA []byte) (int, error)

func (*BlobProto) ProtoMessage

func (*BlobProto) ProtoMessage()

func (*BlobProto) Reset

func (m *BlobProto) Reset()

func (*BlobProto) Size

func (m *BlobProto) Size() (n int)

func (*BlobProto) String

func (m *BlobProto) String() string

func (*BlobProto) Unmarshal

func (m *BlobProto) Unmarshal(dAtA []byte) error

type BlobProtoVector

type BlobProtoVector struct {
	Blobs []*BlobProto `protobuf:"bytes,1,rep,name=blobs" json:"blobs,omitempty"`
}

The BlobProtoVector is simply a way to pass multiple blobproto instances around.

func (*BlobProtoVector) Descriptor

func (*BlobProtoVector) Descriptor() ([]byte, []int)

func (*BlobProtoVector) GetBlobs

func (m *BlobProtoVector) GetBlobs() []*BlobProto

func (*BlobProtoVector) Marshal

func (m *BlobProtoVector) Marshal() (dAtA []byte, err error)

func (*BlobProtoVector) MarshalTo

func (m *BlobProtoVector) MarshalTo(dAtA []byte) (int, error)

func (*BlobProtoVector) ProtoMessage

func (*BlobProtoVector) ProtoMessage()

func (*BlobProtoVector) Reset

func (m *BlobProtoVector) Reset()

func (*BlobProtoVector) Size

func (m *BlobProtoVector) Size() (n int)

func (*BlobProtoVector) String

func (m *BlobProtoVector) String() string

func (*BlobProtoVector) Unmarshal

func (m *BlobProtoVector) Unmarshal(dAtA []byte) error

type BlobShape

type BlobShape struct {
	Dim []int64 `protobuf:"varint,1,rep,packed,name=dim" json:"dim,omitempty"`
}

Specifies the shape (dimensions) of a Blob.

func (*BlobShape) Descriptor

func (*BlobShape) Descriptor() ([]byte, []int)

func (*BlobShape) GetDim

func (m *BlobShape) GetDim() []int64

func (*BlobShape) Marshal

func (m *BlobShape) Marshal() (dAtA []byte, err error)

func (*BlobShape) MarshalTo

func (m *BlobShape) MarshalTo(dAtA []byte) (int, error)

func (*BlobShape) ProtoMessage

func (*BlobShape) ProtoMessage()

func (*BlobShape) Reset

func (m *BlobShape) Reset()

func (*BlobShape) Size

func (m *BlobShape) Size() (n int)

func (*BlobShape) String

func (m *BlobShape) String() string

func (*BlobShape) Unmarshal

func (m *BlobShape) Unmarshal(dAtA []byte) error

type ConcatParameter

type ConcatParameter struct {
	// The axis along which to concatenate -- may be negative to index from the
	// end (e.g., -1 for the last axis).  Other axes must have the
	// same dimension for all the bottom blobs.
	// By default, ConcatLayer concatenates blobs along the "channels" axis (1).
	Axis *int32 `protobuf:"varint,2,opt,name=axis,def=1" json:"axis,omitempty"`
	// DEPRECATED: alias for "axis" -- does not support negative indexing.
	ConcatDim *uint32 `protobuf:"varint,1,opt,name=concat_dim,json=concatDim,def=1" json:"concat_dim,omitempty"`
}

func (*ConcatParameter) Descriptor

func (*ConcatParameter) Descriptor() ([]byte, []int)

func (*ConcatParameter) GetAxis

func (m *ConcatParameter) GetAxis() int32

func (*ConcatParameter) GetConcatDim

func (m *ConcatParameter) GetConcatDim() uint32

func (*ConcatParameter) Marshal

func (m *ConcatParameter) Marshal() (dAtA []byte, err error)

func (*ConcatParameter) MarshalTo

func (m *ConcatParameter) MarshalTo(dAtA []byte) (int, error)

func (*ConcatParameter) ProtoMessage

func (*ConcatParameter) ProtoMessage()

func (*ConcatParameter) Reset

func (m *ConcatParameter) Reset()

func (*ConcatParameter) Size

func (m *ConcatParameter) Size() (n int)

func (*ConcatParameter) String

func (m *ConcatParameter) String() string

func (*ConcatParameter) Unmarshal

func (m *ConcatParameter) Unmarshal(dAtA []byte) error

type ContrastiveLossParameter

type ContrastiveLossParameter struct {
	// margin for dissimilar pair
	Margin *float32 `protobuf:"fixed32,1,opt,name=margin,def=1" json:"margin,omitempty"`
	// The first implementation of this cost did not exactly match the cost of
	// Hadsell et al 2006 -- using (margin - d^2) instead of (margin - d)^2.
	// legacy_version = false (the default) uses (margin - d)^2 as proposed in the
	// Hadsell paper. New models should probably use this version.
	// legacy_version = true uses (margin - d^2). This is kept to support /
	// reproduce existing models and results
	LegacyVersion *bool `protobuf:"varint,2,opt,name=legacy_version,json=legacyVersion,def=0" json:"legacy_version,omitempty"`
}

func (*ContrastiveLossParameter) Descriptor

func (*ContrastiveLossParameter) Descriptor() ([]byte, []int)

func (*ContrastiveLossParameter) GetLegacyVersion

func (m *ContrastiveLossParameter) GetLegacyVersion() bool

func (*ContrastiveLossParameter) GetMargin

func (m *ContrastiveLossParameter) GetMargin() float32

func (*ContrastiveLossParameter) Marshal

func (m *ContrastiveLossParameter) Marshal() (dAtA []byte, err error)

func (*ContrastiveLossParameter) MarshalTo

func (m *ContrastiveLossParameter) MarshalTo(dAtA []byte) (int, error)

func (*ContrastiveLossParameter) ProtoMessage

func (*ContrastiveLossParameter) ProtoMessage()

func (*ContrastiveLossParameter) Reset

func (m *ContrastiveLossParameter) Reset()

func (*ContrastiveLossParameter) Size

func (m *ContrastiveLossParameter) Size() (n int)

func (*ContrastiveLossParameter) String

func (m *ContrastiveLossParameter) String() string

func (*ContrastiveLossParameter) Unmarshal

func (m *ContrastiveLossParameter) Unmarshal(dAtA []byte) error

type ConvolutionParameter

type ConvolutionParameter struct {
	NumOutput uint32 `protobuf:"varint,1,opt,name=num_output,json=numOutput" json:"num_output"`
	BiasTerm  *bool  `protobuf:"varint,2,opt,name=bias_term,json=biasTerm,def=1" json:"bias_term,omitempty"`
	// Pad, kernel size, and stride are all given as a single value for equal
	// dimensions in all spatial dimensions, or once per spatial dimension.
	Pad        []uint32 `protobuf:"varint,3,rep,name=pad" json:"pad,omitempty"`
	KernelSize []uint32 `protobuf:"varint,4,rep,name=kernel_size,json=kernelSize" json:"kernel_size,omitempty"`
	Stride     []uint32 `protobuf:"varint,6,rep,name=stride" json:"stride,omitempty"`
	// Factor used to dilate the kernel, (implicitly) zero-filling the resulting
	// holes. (Kernel dilation is sometimes referred to by its use in the
	// algorithme à trous from Holschneider et al. 1987.)
	Dilation []uint32 `protobuf:"varint,18,rep,name=dilation" json:"dilation,omitempty"`
	// For 2D convolution only, the *_h and *_w versions may also be used to
	// specify both spatial dimensions.
	PadH         *uint32                      `protobuf:"varint,9,opt,name=pad_h,json=padH,def=0" json:"pad_h,omitempty"`
	PadW         *uint32                      `protobuf:"varint,10,opt,name=pad_w,json=padW,def=0" json:"pad_w,omitempty"`
	KernelH      uint32                       `protobuf:"varint,11,opt,name=kernel_h,json=kernelH" json:"kernel_h"`
	KernelW      uint32                       `protobuf:"varint,12,opt,name=kernel_w,json=kernelW" json:"kernel_w"`
	StrideH      uint32                       `protobuf:"varint,13,opt,name=stride_h,json=strideH" json:"stride_h"`
	StrideW      uint32                       `protobuf:"varint,14,opt,name=stride_w,json=strideW" json:"stride_w"`
	Group        *uint32                      `protobuf:"varint,5,opt,name=group,def=1" json:"group,omitempty"`
	WeightFiller *FillerParameter             `protobuf:"bytes,7,opt,name=weight_filler,json=weightFiller" json:"weight_filler,omitempty"`
	BiasFiller   *FillerParameter             `protobuf:"bytes,8,opt,name=bias_filler,json=biasFiller" json:"bias_filler,omitempty"`
	Engine       *ConvolutionParameter_Engine `protobuf:"varint,15,opt,name=engine,enum=caffe.ConvolutionParameter_Engine,def=0" json:"engine,omitempty"`
	// The axis to interpret as "channels" when performing convolution.
	// Preceding dimensions are treated as independent inputs;
	// succeeding dimensions are treated as "spatial".
	// With (N, C, H, W) inputs, and axis == 1 (the default), we perform
	// N independent 2D convolutions, sliding C-channel (or (C/g)-channels, for
	// groups g>1) filters across the spatial axes (H, W) of the input.
	// With (N, C, D, H, W) inputs, and axis == 1, we perform
	// N independent 3D convolutions, sliding (C/g)-channels
	// filters across the spatial axes (D, H, W) of the input.
	Axis *int32 `protobuf:"varint,16,opt,name=axis,def=1" json:"axis,omitempty"`
	// Whether to force use of the general ND convolution, even if a specific
	// implementation for blobs of the appropriate number of spatial dimensions
	// is available. (Currently, there is only a 2D-specific convolution
	// implementation; for input blobs with num_axes != 2, this option is
	// ignored and the ND implementation will be used.)
	ForceNdIm2Col *bool `protobuf:"varint,17,opt,name=force_nd_im2col,json=forceNdIm2col,def=0" json:"force_nd_im2col,omitempty"`
}

func (*ConvolutionParameter) Descriptor

func (*ConvolutionParameter) Descriptor() ([]byte, []int)

func (*ConvolutionParameter) GetAxis

func (m *ConvolutionParameter) GetAxis() int32

func (*ConvolutionParameter) GetBiasFiller

func (m *ConvolutionParameter) GetBiasFiller() *FillerParameter

func (*ConvolutionParameter) GetBiasTerm

func (m *ConvolutionParameter) GetBiasTerm() bool

func (*ConvolutionParameter) GetDilation

func (m *ConvolutionParameter) GetDilation() []uint32

func (*ConvolutionParameter) GetEngine

func (*ConvolutionParameter) GetForceNdIm2Col

func (m *ConvolutionParameter) GetForceNdIm2Col() bool

func (*ConvolutionParameter) GetGroup

func (m *ConvolutionParameter) GetGroup() uint32

func (*ConvolutionParameter) GetKernelH

func (m *ConvolutionParameter) GetKernelH() uint32

func (*ConvolutionParameter) GetKernelSize

func (m *ConvolutionParameter) GetKernelSize() []uint32

func (*ConvolutionParameter) GetKernelW

func (m *ConvolutionParameter) GetKernelW() uint32

func (*ConvolutionParameter) GetNumOutput

func (m *ConvolutionParameter) GetNumOutput() uint32

func (*ConvolutionParameter) GetPad

func (m *ConvolutionParameter) GetPad() []uint32

func (*ConvolutionParameter) GetPadH

func (m *ConvolutionParameter) GetPadH() uint32

func (*ConvolutionParameter) GetPadW

func (m *ConvolutionParameter) GetPadW() uint32

func (*ConvolutionParameter) GetStride

func (m *ConvolutionParameter) GetStride() []uint32

func (*ConvolutionParameter) GetStrideH

func (m *ConvolutionParameter) GetStrideH() uint32

func (*ConvolutionParameter) GetStrideW

func (m *ConvolutionParameter) GetStrideW() uint32

func (*ConvolutionParameter) GetWeightFiller

func (m *ConvolutionParameter) GetWeightFiller() *FillerParameter

func (*ConvolutionParameter) Marshal

func (m *ConvolutionParameter) Marshal() (dAtA []byte, err error)

func (*ConvolutionParameter) MarshalTo

func (m *ConvolutionParameter) MarshalTo(dAtA []byte) (int, error)

func (*ConvolutionParameter) ProtoMessage

func (*ConvolutionParameter) ProtoMessage()

func (*ConvolutionParameter) Reset

func (m *ConvolutionParameter) Reset()

func (*ConvolutionParameter) Size

func (m *ConvolutionParameter) Size() (n int)

func (*ConvolutionParameter) String

func (m *ConvolutionParameter) String() string

func (*ConvolutionParameter) Unmarshal

func (m *ConvolutionParameter) Unmarshal(dAtA []byte) error

type ConvolutionParameter_Engine

type ConvolutionParameter_Engine int32
const (
	ConvolutionParameter_DEFAULT ConvolutionParameter_Engine = 0
	ConvolutionParameter_CAFFE   ConvolutionParameter_Engine = 1
	ConvolutionParameter_CUDNN   ConvolutionParameter_Engine = 2
)
const Default_ConvolutionParameter_Engine ConvolutionParameter_Engine = ConvolutionParameter_DEFAULT

func (ConvolutionParameter_Engine) Enum

func (ConvolutionParameter_Engine) EnumDescriptor

func (ConvolutionParameter_Engine) EnumDescriptor() ([]byte, []int)

func (ConvolutionParameter_Engine) String

func (*ConvolutionParameter_Engine) UnmarshalJSON

func (x *ConvolutionParameter_Engine) UnmarshalJSON(data []byte) error

type CropParameter

type CropParameter struct {
	// To crop, elements of the first bottom are selected to fit the dimensions
	// of the second, reference bottom. The crop is configured by
	// - the crop `axis` to pick the dimensions for cropping
	// - the crop `offset` to set the shift for all/each dimension
	// to align the cropped bottom with the reference bottom.
	// All dimensions up to but excluding `axis` are preserved, while
	// the dimensions including and trailing `axis` are cropped.
	// If only one `offset` is set, then all dimensions are offset by this amount.
	// Otherwise, the number of offsets must equal the number of cropped axes to
	// shift the crop in each dimension accordingly.
	// Note: standard dimensions are N,C,H,W so the default is a spatial crop,
	// and `axis` may be negative to index from the end (e.g., -1 for the last
	// axis).
	Axis   *int32   `protobuf:"varint,1,opt,name=axis,def=2" json:"axis,omitempty"`
	Offset []uint32 `protobuf:"varint,2,rep,name=offset" json:"offset,omitempty"`
}

func (*CropParameter) Descriptor

func (*CropParameter) Descriptor() ([]byte, []int)

func (*CropParameter) GetAxis

func (m *CropParameter) GetAxis() int32

func (*CropParameter) GetOffset

func (m *CropParameter) GetOffset() []uint32

func (*CropParameter) Marshal

func (m *CropParameter) Marshal() (dAtA []byte, err error)

func (*CropParameter) MarshalTo

func (m *CropParameter) MarshalTo(dAtA []byte) (int, error)

func (*CropParameter) ProtoMessage

func (*CropParameter) ProtoMessage()

func (*CropParameter) Reset

func (m *CropParameter) Reset()

func (*CropParameter) Size

func (m *CropParameter) Size() (n int)

func (*CropParameter) String

func (m *CropParameter) String() string

func (*CropParameter) Unmarshal

func (m *CropParameter) Unmarshal(dAtA []byte) error

type DataParameter

type DataParameter struct {
	// Specify the data source.
	Source string `protobuf:"bytes,1,opt,name=source" json:"source"`
	// Specify the batch size.
	BatchSize uint32 `protobuf:"varint,4,opt,name=batch_size,json=batchSize" json:"batch_size"`
	// The rand_skip variable is for the data layer to skip a few data points
	// to avoid all asynchronous sgd clients to start at the same point. The skip
	// point would be set as rand_skip * rand(0,1). Note that rand_skip should not
	// be larger than the number of keys in the database.
	// DEPRECATED. Each solver accesses a different subset of the database.
	RandSkip *uint32           `protobuf:"varint,7,opt,name=rand_skip,json=randSkip,def=0" json:"rand_skip,omitempty"`
	Backend  *DataParameter_DB `protobuf:"varint,8,opt,name=backend,enum=caffe.DataParameter_DB,def=0" json:"backend,omitempty"`
	// DEPRECATED. See TransformationParameter. For data pre-processing, we can do
	// simple scaling and subtracting the data mean, if provided. Note that the
	// mean subtraction is always carried out before scaling.
	Scale    *float32 `protobuf:"fixed32,2,opt,name=scale,def=1" json:"scale,omitempty"`
	MeanFile string   `protobuf:"bytes,3,opt,name=mean_file,json=meanFile" json:"mean_file"`
	// DEPRECATED. See TransformationParameter. Specify if we would like to randomly
	// crop an image.
	CropSize *uint32 `protobuf:"varint,5,opt,name=crop_size,json=cropSize,def=0" json:"crop_size,omitempty"`
	// DEPRECATED. See TransformationParameter. Specify if we want to randomly mirror
	// data.
	Mirror *bool `protobuf:"varint,6,opt,name=mirror,def=0" json:"mirror,omitempty"`
	// Force the encoded image to have 3 color channels
	ForceEncodedColor *bool `protobuf:"varint,9,opt,name=force_encoded_color,json=forceEncodedColor,def=0" json:"force_encoded_color,omitempty"`
	// Prefetch queue (Number of batches to prefetch to host memory, increase if
	// data access bandwidth varies).
	Prefetch *uint32 `protobuf:"varint,10,opt,name=prefetch,def=4" json:"prefetch,omitempty"`
}

func (*DataParameter) Descriptor

func (*DataParameter) Descriptor() ([]byte, []int)

func (*DataParameter) GetBackend

func (m *DataParameter) GetBackend() DataParameter_DB

func (*DataParameter) GetBatchSize

func (m *DataParameter) GetBatchSize() uint32

func (*DataParameter) GetCropSize

func (m *DataParameter) GetCropSize() uint32

func (*DataParameter) GetForceEncodedColor

func (m *DataParameter) GetForceEncodedColor() bool

func (*DataParameter) GetMeanFile

func (m *DataParameter) GetMeanFile() string

func (*DataParameter) GetMirror

func (m *DataParameter) GetMirror() bool

func (*DataParameter) GetPrefetch

func (m *DataParameter) GetPrefetch() uint32

func (*DataParameter) GetRandSkip

func (m *DataParameter) GetRandSkip() uint32

func (*DataParameter) GetScale

func (m *DataParameter) GetScale() float32

func (*DataParameter) GetSource

func (m *DataParameter) GetSource() string

func (*DataParameter) Marshal

func (m *DataParameter) Marshal() (dAtA []byte, err error)

func (*DataParameter) MarshalTo

func (m *DataParameter) MarshalTo(dAtA []byte) (int, error)

func (*DataParameter) ProtoMessage

func (*DataParameter) ProtoMessage()

func (*DataParameter) Reset

func (m *DataParameter) Reset()

func (*DataParameter) Size

func (m *DataParameter) Size() (n int)

func (*DataParameter) String

func (m *DataParameter) String() string

func (*DataParameter) Unmarshal

func (m *DataParameter) Unmarshal(dAtA []byte) error

type DataParameter_DB

type DataParameter_DB int32
const (
	DataParameter_LEVELDB DataParameter_DB = 0
	DataParameter_LMDB    DataParameter_DB = 1
)
const Default_DataParameter_Backend DataParameter_DB = DataParameter_LEVELDB

func (DataParameter_DB) Enum

func (DataParameter_DB) EnumDescriptor

func (DataParameter_DB) EnumDescriptor() ([]byte, []int)

func (DataParameter_DB) String

func (x DataParameter_DB) String() string

func (*DataParameter_DB) UnmarshalJSON

func (x *DataParameter_DB) UnmarshalJSON(data []byte) error

type Datum

type Datum struct {
	Channels int32 `protobuf:"varint,1,opt,name=channels" json:"channels"`
	Height   int32 `protobuf:"varint,2,opt,name=height" json:"height"`
	Width    int32 `protobuf:"varint,3,opt,name=width" json:"width"`
	// the actual image data, in bytes
	Data  []byte `protobuf:"bytes,4,opt,name=data" json:"data"`
	Label int32  `protobuf:"varint,5,opt,name=label" json:"label"`
	// Optionally, the datum could also hold float data.
	FloatData []float32 `protobuf:"fixed32,6,rep,name=float_data,json=floatData" json:"float_data,omitempty"`
	// If true data contains an encoded image that need to be decoded
	Encoded *bool `protobuf:"varint,7,opt,name=encoded,def=0" json:"encoded,omitempty"`
}

func (*Datum) Descriptor

func (*Datum) Descriptor() ([]byte, []int)

func (*Datum) GetChannels

func (m *Datum) GetChannels() int32

func (*Datum) GetData

func (m *Datum) GetData() []byte

func (*Datum) GetEncoded

func (m *Datum) GetEncoded() bool

func (*Datum) GetFloatData

func (m *Datum) GetFloatData() []float32

func (*Datum) GetHeight

func (m *Datum) GetHeight() int32

func (*Datum) GetLabel

func (m *Datum) GetLabel() int32

func (*Datum) GetWidth

func (m *Datum) GetWidth() int32

func (*Datum) Marshal

func (m *Datum) Marshal() (dAtA []byte, err error)

func (*Datum) MarshalTo

func (m *Datum) MarshalTo(dAtA []byte) (int, error)

func (*Datum) ProtoMessage

func (*Datum) ProtoMessage()

func (*Datum) Reset

func (m *Datum) Reset()

func (*Datum) Size

func (m *Datum) Size() (n int)

func (*Datum) String

func (m *Datum) String() string

func (*Datum) Unmarshal

func (m *Datum) Unmarshal(dAtA []byte) error

type DropoutParameter

type DropoutParameter struct {
	DropoutRatio *float32 `protobuf:"fixed32,1,opt,name=dropout_ratio,json=dropoutRatio,def=0.5" json:"dropout_ratio,omitempty"`
}

func (*DropoutParameter) Descriptor

func (*DropoutParameter) Descriptor() ([]byte, []int)

func (*DropoutParameter) GetDropoutRatio

func (m *DropoutParameter) GetDropoutRatio() float32

func (*DropoutParameter) Marshal

func (m *DropoutParameter) Marshal() (dAtA []byte, err error)

func (*DropoutParameter) MarshalTo

func (m *DropoutParameter) MarshalTo(dAtA []byte) (int, error)

func (*DropoutParameter) ProtoMessage

func (*DropoutParameter) ProtoMessage()

func (*DropoutParameter) Reset

func (m *DropoutParameter) Reset()

func (*DropoutParameter) Size

func (m *DropoutParameter) Size() (n int)

func (*DropoutParameter) String

func (m *DropoutParameter) String() string

func (*DropoutParameter) Unmarshal

func (m *DropoutParameter) Unmarshal(dAtA []byte) error

type DummyDataParameter

type DummyDataParameter struct {
	// This layer produces N >= 1 top blobs.  DummyDataParameter must specify 1 or N
	// shape fields, and 0, 1 or N data_fillers.
	//
	// If 0 data_fillers are specified, ConstantFiller with a value of 0 is used.
	// If 1 data_filler is specified, it is applied to all top blobs.  If N are
	// specified, the ith is applied to the ith top blob.
	DataFiller []*FillerParameter `protobuf:"bytes,1,rep,name=data_filler,json=dataFiller" json:"data_filler,omitempty"`
	Shape      []*BlobShape       `protobuf:"bytes,6,rep,name=shape" json:"shape,omitempty"`
	// 4D dimensions -- deprecated.  Use "shape" instead.
	Num      []uint32 `protobuf:"varint,2,rep,name=num" json:"num,omitempty"`
	Channels []uint32 `protobuf:"varint,3,rep,name=channels" json:"channels,omitempty"`
	Height   []uint32 `protobuf:"varint,4,rep,name=height" json:"height,omitempty"`
	Width    []uint32 `protobuf:"varint,5,rep,name=width" json:"width,omitempty"`
}

DummyDataLayer fills any number of arbitrarily shaped blobs with random (or constant) data generated by "Fillers" (see "message FillerParameter").

func (*DummyDataParameter) Descriptor

func (*DummyDataParameter) Descriptor() ([]byte, []int)

func (*DummyDataParameter) GetChannels

func (m *DummyDataParameter) GetChannels() []uint32

func (*DummyDataParameter) GetDataFiller

func (m *DummyDataParameter) GetDataFiller() []*FillerParameter

func (*DummyDataParameter) GetHeight

func (m *DummyDataParameter) GetHeight() []uint32

func (*DummyDataParameter) GetNum

func (m *DummyDataParameter) GetNum() []uint32

func (*DummyDataParameter) GetShape

func (m *DummyDataParameter) GetShape() []*BlobShape

func (*DummyDataParameter) GetWidth

func (m *DummyDataParameter) GetWidth() []uint32

func (*DummyDataParameter) Marshal

func (m *DummyDataParameter) Marshal() (dAtA []byte, err error)

func (*DummyDataParameter) MarshalTo

func (m *DummyDataParameter) MarshalTo(dAtA []byte) (int, error)

func (*DummyDataParameter) ProtoMessage

func (*DummyDataParameter) ProtoMessage()

func (*DummyDataParameter) Reset

func (m *DummyDataParameter) Reset()

func (*DummyDataParameter) Size

func (m *DummyDataParameter) Size() (n int)

func (*DummyDataParameter) String

func (m *DummyDataParameter) String() string

func (*DummyDataParameter) Unmarshal

func (m *DummyDataParameter) Unmarshal(dAtA []byte) error

type ELUParameter

type ELUParameter struct {
	// Described in:
	// Clevert, D.-A., Unterthiner, T., & Hochreiter, S. (2015). Fast and Accurate
	// Deep Network Learning by Exponential Linear Units (ELUs). arXiv
	Alpha *float32 `protobuf:"fixed32,1,opt,name=alpha,def=1" json:"alpha,omitempty"`
}

Message that stores parameters used by ELULayer

func (*ELUParameter) Descriptor

func (*ELUParameter) Descriptor() ([]byte, []int)

func (*ELUParameter) GetAlpha

func (m *ELUParameter) GetAlpha() float32

func (*ELUParameter) Marshal

func (m *ELUParameter) Marshal() (dAtA []byte, err error)

func (*ELUParameter) MarshalTo

func (m *ELUParameter) MarshalTo(dAtA []byte) (int, error)

func (*ELUParameter) ProtoMessage

func (*ELUParameter) ProtoMessage()

func (*ELUParameter) Reset

func (m *ELUParameter) Reset()

func (*ELUParameter) Size

func (m *ELUParameter) Size() (n int)

func (*ELUParameter) String

func (m *ELUParameter) String() string

func (*ELUParameter) Unmarshal

func (m *ELUParameter) Unmarshal(dAtA []byte) error

type EltwiseParameter

type EltwiseParameter struct {
	Operation *EltwiseParameter_EltwiseOp `protobuf:"varint,1,opt,name=operation,enum=caffe.EltwiseParameter_EltwiseOp,def=1" json:"operation,omitempty"`
	Coeff     []float32                   `protobuf:"fixed32,2,rep,name=coeff" json:"coeff,omitempty"`
	// Whether to use an asymptotically slower (for >2 inputs) but stabler method
	// of computing the gradient for the PROD operation. (No effect for SUM op.)
	StableProdGrad *bool `protobuf:"varint,3,opt,name=stable_prod_grad,json=stableProdGrad,def=1" json:"stable_prod_grad,omitempty"`
}

func (*EltwiseParameter) Descriptor

func (*EltwiseParameter) Descriptor() ([]byte, []int)

func (*EltwiseParameter) GetCoeff

func (m *EltwiseParameter) GetCoeff() []float32

func (*EltwiseParameter) GetOperation

func (m *EltwiseParameter) GetOperation() EltwiseParameter_EltwiseOp

func (*EltwiseParameter) GetStableProdGrad

func (m *EltwiseParameter) GetStableProdGrad() bool

func (*EltwiseParameter) Marshal

func (m *EltwiseParameter) Marshal() (dAtA []byte, err error)

func (*EltwiseParameter) MarshalTo

func (m *EltwiseParameter) MarshalTo(dAtA []byte) (int, error)

func (*EltwiseParameter) ProtoMessage

func (*EltwiseParameter) ProtoMessage()

func (*EltwiseParameter) Reset

func (m *EltwiseParameter) Reset()

func (*EltwiseParameter) Size

func (m *EltwiseParameter) Size() (n int)

func (*EltwiseParameter) String

func (m *EltwiseParameter) String() string

func (*EltwiseParameter) Unmarshal

func (m *EltwiseParameter) Unmarshal(dAtA []byte) error

type EltwiseParameter_EltwiseOp

type EltwiseParameter_EltwiseOp int32
const (
	EltwiseParameter_PROD EltwiseParameter_EltwiseOp = 0
	EltwiseParameter_SUM  EltwiseParameter_EltwiseOp = 1
	EltwiseParameter_MAX  EltwiseParameter_EltwiseOp = 2
)
const Default_EltwiseParameter_Operation EltwiseParameter_EltwiseOp = EltwiseParameter_SUM

func (EltwiseParameter_EltwiseOp) Enum

func (EltwiseParameter_EltwiseOp) EnumDescriptor

func (EltwiseParameter_EltwiseOp) EnumDescriptor() ([]byte, []int)

func (EltwiseParameter_EltwiseOp) String

func (*EltwiseParameter_EltwiseOp) UnmarshalJSON

func (x *EltwiseParameter_EltwiseOp) UnmarshalJSON(data []byte) error

type EmbedParameter

type EmbedParameter struct {
	NumOutput uint32 `protobuf:"varint,1,opt,name=num_output,json=numOutput" json:"num_output"`
	// The input is given as integers to be interpreted as one-hot
	// vector indices with dimension num_input.  Hence num_input should be
	// 1 greater than the maximum possible input value.
	InputDim     uint32           `protobuf:"varint,2,opt,name=input_dim,json=inputDim" json:"input_dim"`
	BiasTerm     *bool            `protobuf:"varint,3,opt,name=bias_term,json=biasTerm,def=1" json:"bias_term,omitempty"`
	WeightFiller *FillerParameter `protobuf:"bytes,4,opt,name=weight_filler,json=weightFiller" json:"weight_filler,omitempty"`
	BiasFiller   *FillerParameter `protobuf:"bytes,5,opt,name=bias_filler,json=biasFiller" json:"bias_filler,omitempty"`
}

Message that stores parameters used by EmbedLayer

func (*EmbedParameter) Descriptor

func (*EmbedParameter) Descriptor() ([]byte, []int)

func (*EmbedParameter) GetBiasFiller

func (m *EmbedParameter) GetBiasFiller() *FillerParameter

func (*EmbedParameter) GetBiasTerm

func (m *EmbedParameter) GetBiasTerm() bool

func (*EmbedParameter) GetInputDim

func (m *EmbedParameter) GetInputDim() uint32

func (*EmbedParameter) GetNumOutput

func (m *EmbedParameter) GetNumOutput() uint32

func (*EmbedParameter) GetWeightFiller

func (m *EmbedParameter) GetWeightFiller() *FillerParameter

func (*EmbedParameter) Marshal

func (m *EmbedParameter) Marshal() (dAtA []byte, err error)

func (*EmbedParameter) MarshalTo

func (m *EmbedParameter) MarshalTo(dAtA []byte) (int, error)

func (*EmbedParameter) ProtoMessage

func (*EmbedParameter) ProtoMessage()

func (*EmbedParameter) Reset

func (m *EmbedParameter) Reset()

func (*EmbedParameter) Size

func (m *EmbedParameter) Size() (n int)

func (*EmbedParameter) String

func (m *EmbedParameter) String() string

func (*EmbedParameter) Unmarshal

func (m *EmbedParameter) Unmarshal(dAtA []byte) error

type ExpParameter

type ExpParameter struct {
	// ExpLayer computes outputs y = base ^ (shift + scale * x), for base > 0.
	// Or if base is set to the default (-1), base is set to e,
	// so y = exp(shift + scale * x).
	Base  *float32 `protobuf:"fixed32,1,opt,name=base,def=-1" json:"base,omitempty"`
	Scale *float32 `protobuf:"fixed32,2,opt,name=scale,def=1" json:"scale,omitempty"`
	Shift *float32 `protobuf:"fixed32,3,opt,name=shift,def=0" json:"shift,omitempty"`
}

Message that stores parameters used by ExpLayer

func (*ExpParameter) Descriptor

func (*ExpParameter) Descriptor() ([]byte, []int)

func (*ExpParameter) GetBase

func (m *ExpParameter) GetBase() float32

func (*ExpParameter) GetScale

func (m *ExpParameter) GetScale() float32

func (*ExpParameter) GetShift

func (m *ExpParameter) GetShift() float32

func (*ExpParameter) Marshal

func (m *ExpParameter) Marshal() (dAtA []byte, err error)

func (*ExpParameter) MarshalTo

func (m *ExpParameter) MarshalTo(dAtA []byte) (int, error)

func (*ExpParameter) ProtoMessage

func (*ExpParameter) ProtoMessage()

func (*ExpParameter) Reset

func (m *ExpParameter) Reset()

func (*ExpParameter) Size

func (m *ExpParameter) Size() (n int)

func (*ExpParameter) String

func (m *ExpParameter) String() string

func (*ExpParameter) Unmarshal

func (m *ExpParameter) Unmarshal(dAtA []byte) error

type FillerParameter

type FillerParameter struct {
	// The filler type.
	Type  *string  `protobuf:"bytes,1,opt,name=type,def=constant" json:"type,omitempty"`
	Value *float32 `protobuf:"fixed32,2,opt,name=value,def=0" json:"value,omitempty"`
	Min   *float32 `protobuf:"fixed32,3,opt,name=min,def=0" json:"min,omitempty"`
	Max   *float32 `protobuf:"fixed32,4,opt,name=max,def=1" json:"max,omitempty"`
	Mean  *float32 `protobuf:"fixed32,5,opt,name=mean,def=0" json:"mean,omitempty"`
	Std   *float32 `protobuf:"fixed32,6,opt,name=std,def=1" json:"std,omitempty"`
	// The expected number of non-zero output weights for a given input in
	// Gaussian filler -- the default -1 means don't perform sparsification.
	Sparse       *int32                        `protobuf:"varint,7,opt,name=sparse,def=-1" json:"sparse,omitempty"`
	VarianceNorm *FillerParameter_VarianceNorm `` /* 137-byte string literal not displayed */
}

func (*FillerParameter) Descriptor

func (*FillerParameter) Descriptor() ([]byte, []int)

func (*FillerParameter) GetMax

func (m *FillerParameter) GetMax() float32

func (*FillerParameter) GetMean

func (m *FillerParameter) GetMean() float32

func (*FillerParameter) GetMin

func (m *FillerParameter) GetMin() float32

func (*FillerParameter) GetSparse

func (m *FillerParameter) GetSparse() int32

func (*FillerParameter) GetStd

func (m *FillerParameter) GetStd() float32

func (*FillerParameter) GetType

func (m *FillerParameter) GetType() string

func (*FillerParameter) GetValue

func (m *FillerParameter) GetValue() float32

func (*FillerParameter) GetVarianceNorm

func (m *FillerParameter) GetVarianceNorm() FillerParameter_VarianceNorm

func (*FillerParameter) Marshal

func (m *FillerParameter) Marshal() (dAtA []byte, err error)

func (*FillerParameter) MarshalTo

func (m *FillerParameter) MarshalTo(dAtA []byte) (int, error)

func (*FillerParameter) ProtoMessage

func (*FillerParameter) ProtoMessage()

func (*FillerParameter) Reset

func (m *FillerParameter) Reset()

func (*FillerParameter) Size

func (m *FillerParameter) Size() (n int)

func (*FillerParameter) String

func (m *FillerParameter) String() string

func (*FillerParameter) Unmarshal

func (m *FillerParameter) Unmarshal(dAtA []byte) error

type FillerParameter_VarianceNorm

type FillerParameter_VarianceNorm int32

Normalize the filler variance by fan_in, fan_out, or their average. Applies to 'xavier' and 'msra' fillers.

const (
	FillerParameter_FAN_IN  FillerParameter_VarianceNorm = 0
	FillerParameter_FAN_OUT FillerParameter_VarianceNorm = 1
	FillerParameter_AVERAGE FillerParameter_VarianceNorm = 2
)
const Default_FillerParameter_VarianceNorm FillerParameter_VarianceNorm = FillerParameter_FAN_IN

func (FillerParameter_VarianceNorm) Enum

func (FillerParameter_VarianceNorm) EnumDescriptor

func (FillerParameter_VarianceNorm) EnumDescriptor() ([]byte, []int)

func (FillerParameter_VarianceNorm) String

func (*FillerParameter_VarianceNorm) UnmarshalJSON

func (x *FillerParameter_VarianceNorm) UnmarshalJSON(data []byte) error

type FlattenParameter

type FlattenParameter struct {
	// The first axis to flatten: all preceding axes are retained in the output.
	// May be negative to index from the end (e.g., -1 for the last axis).
	Axis *int32 `protobuf:"varint,1,opt,name=axis,def=1" json:"axis,omitempty"`
	// The last axis to flatten: all following axes are retained in the output.
	// May be negative to index from the end (e.g., the default -1 for the last
	// axis).
	EndAxis *int32 `protobuf:"varint,2,opt,name=end_axis,json=endAxis,def=-1" json:"end_axis,omitempty"`
}

/ Message that stores parameters used by FlattenLayer

func (*FlattenParameter) Descriptor

func (*FlattenParameter) Descriptor() ([]byte, []int)

func (*FlattenParameter) GetAxis

func (m *FlattenParameter) GetAxis() int32

func (*FlattenParameter) GetEndAxis

func (m *FlattenParameter) GetEndAxis() int32

func (*FlattenParameter) Marshal

func (m *FlattenParameter) Marshal() (dAtA []byte, err error)

func (*FlattenParameter) MarshalTo

func (m *FlattenParameter) MarshalTo(dAtA []byte) (int, error)

func (*FlattenParameter) ProtoMessage

func (*FlattenParameter) ProtoMessage()

func (*FlattenParameter) Reset

func (m *FlattenParameter) Reset()

func (*FlattenParameter) Size

func (m *FlattenParameter) Size() (n int)

func (*FlattenParameter) String

func (m *FlattenParameter) String() string

func (*FlattenParameter) Unmarshal

func (m *FlattenParameter) Unmarshal(dAtA []byte) error

type HDF5DataParameter

type HDF5DataParameter struct {
	// Specify the data source.
	Source string `protobuf:"bytes,1,opt,name=source" json:"source"`
	// Specify the batch size.
	BatchSize uint32 `protobuf:"varint,2,opt,name=batch_size,json=batchSize" json:"batch_size"`
	// Specify whether to shuffle the data.
	// If shuffle == true, the ordering of the HDF5 files is shuffled,
	// and the ordering of data within any given HDF5 file is shuffled,
	// but data between different files are not interleaved; all of a file's
	// data are output (in a random order) before moving onto another file.
	Shuffle *bool `protobuf:"varint,3,opt,name=shuffle,def=0" json:"shuffle,omitempty"`
}

Message that stores parameters used by HDF5DataLayer

func (*HDF5DataParameter) Descriptor

func (*HDF5DataParameter) Descriptor() ([]byte, []int)

func (*HDF5DataParameter) GetBatchSize

func (m *HDF5DataParameter) GetBatchSize() uint32

func (*HDF5DataParameter) GetShuffle

func (m *HDF5DataParameter) GetShuffle() bool

func (*HDF5DataParameter) GetSource

func (m *HDF5DataParameter) GetSource() string

func (*HDF5DataParameter) Marshal

func (m *HDF5DataParameter) Marshal() (dAtA []byte, err error)

func (*HDF5DataParameter) MarshalTo

func (m *HDF5DataParameter) MarshalTo(dAtA []byte) (int, error)

func (*HDF5DataParameter) ProtoMessage

func (*HDF5DataParameter) ProtoMessage()

func (*HDF5DataParameter) Reset

func (m *HDF5DataParameter) Reset()

func (*HDF5DataParameter) Size

func (m *HDF5DataParameter) Size() (n int)

func (*HDF5DataParameter) String

func (m *HDF5DataParameter) String() string

func (*HDF5DataParameter) Unmarshal

func (m *HDF5DataParameter) Unmarshal(dAtA []byte) error

type HDF5OutputParameter

type HDF5OutputParameter struct {
	FileName string `protobuf:"bytes,1,opt,name=file_name,json=fileName" json:"file_name"`
}

func (*HDF5OutputParameter) Descriptor

func (*HDF5OutputParameter) Descriptor() ([]byte, []int)

func (*HDF5OutputParameter) GetFileName

func (m *HDF5OutputParameter) GetFileName() string

func (*HDF5OutputParameter) Marshal

func (m *HDF5OutputParameter) Marshal() (dAtA []byte, err error)

func (*HDF5OutputParameter) MarshalTo

func (m *HDF5OutputParameter) MarshalTo(dAtA []byte) (int, error)

func (*HDF5OutputParameter) ProtoMessage

func (*HDF5OutputParameter) ProtoMessage()

func (*HDF5OutputParameter) Reset

func (m *HDF5OutputParameter) Reset()

func (*HDF5OutputParameter) Size

func (m *HDF5OutputParameter) Size() (n int)

func (*HDF5OutputParameter) String

func (m *HDF5OutputParameter) String() string

func (*HDF5OutputParameter) Unmarshal

func (m *HDF5OutputParameter) Unmarshal(dAtA []byte) error

type HTTPFS

type HTTPFS struct {
	// Prefix allows to limit the path of all requests. F.e. a prefix "css" would allow only calls to /css/*
	Prefix string
}

HTTPFS implements http.FileSystem

func (*HTTPFS) Open

func (hfs *HTTPFS) Open(path string) (http.File, error)

Open a file

type HingeLossParameter

type HingeLossParameter struct {
	// Specify the Norm to use L1 or L2
	Norm *HingeLossParameter_Norm `protobuf:"varint,1,opt,name=norm,enum=caffe.HingeLossParameter_Norm,def=1" json:"norm,omitempty"`
}

func (*HingeLossParameter) Descriptor

func (*HingeLossParameter) Descriptor() ([]byte, []int)

func (*HingeLossParameter) GetNorm

func (*HingeLossParameter) Marshal

func (m *HingeLossParameter) Marshal() (dAtA []byte, err error)

func (*HingeLossParameter) MarshalTo

func (m *HingeLossParameter) MarshalTo(dAtA []byte) (int, error)

func (*HingeLossParameter) ProtoMessage

func (*HingeLossParameter) ProtoMessage()

func (*HingeLossParameter) Reset

func (m *HingeLossParameter) Reset()

func (*HingeLossParameter) Size

func (m *HingeLossParameter) Size() (n int)

func (*HingeLossParameter) String

func (m *HingeLossParameter) String() string

func (*HingeLossParameter) Unmarshal

func (m *HingeLossParameter) Unmarshal(dAtA []byte) error

type HingeLossParameter_Norm

type HingeLossParameter_Norm int32
const (
	HingeLossParameter_L1 HingeLossParameter_Norm = 1
	HingeLossParameter_L2 HingeLossParameter_Norm = 2
)
const Default_HingeLossParameter_Norm HingeLossParameter_Norm = HingeLossParameter_L1

func (HingeLossParameter_Norm) Enum

func (HingeLossParameter_Norm) EnumDescriptor

func (HingeLossParameter_Norm) EnumDescriptor() ([]byte, []int)

func (HingeLossParameter_Norm) String

func (x HingeLossParameter_Norm) String() string

func (*HingeLossParameter_Norm) UnmarshalJSON

func (x *HingeLossParameter_Norm) UnmarshalJSON(data []byte) error

type ImageDataParameter

type ImageDataParameter struct {
	// Specify the data source.
	Source string `protobuf:"bytes,1,opt,name=source" json:"source"`
	// Specify the batch size.
	BatchSize *uint32 `protobuf:"varint,4,opt,name=batch_size,json=batchSize,def=1" json:"batch_size,omitempty"`
	// The rand_skip variable is for the data layer to skip a few data points
	// to avoid all asynchronous sgd clients to start at the same point. The skip
	// point would be set as rand_skip * rand(0,1). Note that rand_skip should not
	// be larger than the number of keys in the database.
	RandSkip *uint32 `protobuf:"varint,7,opt,name=rand_skip,json=randSkip,def=0" json:"rand_skip,omitempty"`
	// Whether or not ImageLayer should shuffle the list of files at every epoch.
	Shuffle *bool `protobuf:"varint,8,opt,name=shuffle,def=0" json:"shuffle,omitempty"`
	// It will also resize images if new_height or new_width are not zero.
	NewHeight *uint32 `protobuf:"varint,9,opt,name=new_height,json=newHeight,def=0" json:"new_height,omitempty"`
	NewWidth  *uint32 `protobuf:"varint,10,opt,name=new_width,json=newWidth,def=0" json:"new_width,omitempty"`
	// Specify if the images are color or gray
	IsColor *bool `protobuf:"varint,11,opt,name=is_color,json=isColor,def=1" json:"is_color,omitempty"`
	// DEPRECATED. See TransformationParameter. For data pre-processing, we can do
	// simple scaling and subtracting the data mean, if provided. Note that the
	// mean subtraction is always carried out before scaling.
	Scale    *float32 `protobuf:"fixed32,2,opt,name=scale,def=1" json:"scale,omitempty"`
	MeanFile string   `protobuf:"bytes,3,opt,name=mean_file,json=meanFile" json:"mean_file"`
	// DEPRECATED. See TransformationParameter. Specify if we would like to randomly
	// crop an image.
	CropSize *uint32 `protobuf:"varint,5,opt,name=crop_size,json=cropSize,def=0" json:"crop_size,omitempty"`
	// DEPRECATED. See TransformationParameter. Specify if we want to randomly mirror
	// data.
	Mirror     *bool   `protobuf:"varint,6,opt,name=mirror,def=0" json:"mirror,omitempty"`
	RootFolder *string `protobuf:"bytes,12,opt,name=root_folder,json=rootFolder,def=" json:"root_folder,omitempty"`
}

func (*ImageDataParameter) Descriptor

func (*ImageDataParameter) Descriptor() ([]byte, []int)

func (*ImageDataParameter) GetBatchSize

func (m *ImageDataParameter) GetBatchSize() uint32

func (*ImageDataParameter) GetCropSize

func (m *ImageDataParameter) GetCropSize() uint32

func (*ImageDataParameter) GetIsColor

func (m *ImageDataParameter) GetIsColor() bool

func (*ImageDataParameter) GetMeanFile

func (m *ImageDataParameter) GetMeanFile() string

func (*ImageDataParameter) GetMirror

func (m *ImageDataParameter) GetMirror() bool

func (*ImageDataParameter) GetNewHeight

func (m *ImageDataParameter) GetNewHeight() uint32

func (*ImageDataParameter) GetNewWidth

func (m *ImageDataParameter) GetNewWidth() uint32

func (*ImageDataParameter) GetRandSkip

func (m *ImageDataParameter) GetRandSkip() uint32

func (*ImageDataParameter) GetRootFolder

func (m *ImageDataParameter) GetRootFolder() string

func (*ImageDataParameter) GetScale

func (m *ImageDataParameter) GetScale() float32

func (*ImageDataParameter) GetShuffle

func (m *ImageDataParameter) GetShuffle() bool

func (*ImageDataParameter) GetSource

func (m *ImageDataParameter) GetSource() string

func (*ImageDataParameter) Marshal

func (m *ImageDataParameter) Marshal() (dAtA []byte, err error)

func (*ImageDataParameter) MarshalTo

func (m *ImageDataParameter) MarshalTo(dAtA []byte) (int, error)

func (*ImageDataParameter) ProtoMessage

func (*ImageDataParameter) ProtoMessage()

func (*ImageDataParameter) Reset

func (m *ImageDataParameter) Reset()

func (*ImageDataParameter) Size

func (m *ImageDataParameter) Size() (n int)

func (*ImageDataParameter) String

func (m *ImageDataParameter) String() string

func (*ImageDataParameter) Unmarshal

func (m *ImageDataParameter) Unmarshal(dAtA []byte) error

type InfogainLossParameter

type InfogainLossParameter struct {
	// Specify the infogain matrix source.
	Source string `protobuf:"bytes,1,opt,name=source" json:"source"`
}

func (*InfogainLossParameter) Descriptor

func (*InfogainLossParameter) Descriptor() ([]byte, []int)

func (*InfogainLossParameter) GetSource

func (m *InfogainLossParameter) GetSource() string

func (*InfogainLossParameter) Marshal

func (m *InfogainLossParameter) Marshal() (dAtA []byte, err error)

func (*InfogainLossParameter) MarshalTo

func (m *InfogainLossParameter) MarshalTo(dAtA []byte) (int, error)

func (*InfogainLossParameter) ProtoMessage

func (*InfogainLossParameter) ProtoMessage()

func (*InfogainLossParameter) Reset

func (m *InfogainLossParameter) Reset()

func (*InfogainLossParameter) Size

func (m *InfogainLossParameter) Size() (n int)

func (*InfogainLossParameter) String

func (m *InfogainLossParameter) String() string

func (*InfogainLossParameter) Unmarshal

func (m *InfogainLossParameter) Unmarshal(dAtA []byte) error

type InnerProductParameter

type InnerProductParameter struct {
	NumOutput    uint32           `protobuf:"varint,1,opt,name=num_output,json=numOutput" json:"num_output"`
	BiasTerm     *bool            `protobuf:"varint,2,opt,name=bias_term,json=biasTerm,def=1" json:"bias_term,omitempty"`
	WeightFiller *FillerParameter `protobuf:"bytes,3,opt,name=weight_filler,json=weightFiller" json:"weight_filler,omitempty"`
	BiasFiller   *FillerParameter `protobuf:"bytes,4,opt,name=bias_filler,json=biasFiller" json:"bias_filler,omitempty"`
	// The first axis to be lumped into a single inner product computation;
	// all preceding axes are retained in the output.
	// May be negative to index from the end (e.g., -1 for the last axis).
	Axis *int32 `protobuf:"varint,5,opt,name=axis,def=1" json:"axis,omitempty"`
	// Specify whether to transpose the weight matrix or not.
	// If transpose == true, any operations will be performed on the transpose
	// of the weight matrix. The weight matrix itself is not going to be transposed
	// but rather the transfer flag of operations will be toggled accordingly.
	Transpose *bool `protobuf:"varint,6,opt,name=transpose,def=0" json:"transpose,omitempty"`
}

func (*InnerProductParameter) Descriptor

func (*InnerProductParameter) Descriptor() ([]byte, []int)

func (*InnerProductParameter) GetAxis

func (m *InnerProductParameter) GetAxis() int32

func (*InnerProductParameter) GetBiasFiller

func (m *InnerProductParameter) GetBiasFiller() *FillerParameter

func (*InnerProductParameter) GetBiasTerm

func (m *InnerProductParameter) GetBiasTerm() bool

func (*InnerProductParameter) GetNumOutput

func (m *InnerProductParameter) GetNumOutput() uint32

func (*InnerProductParameter) GetTranspose

func (m *InnerProductParameter) GetTranspose() bool

func (*InnerProductParameter) GetWeightFiller

func (m *InnerProductParameter) GetWeightFiller() *FillerParameter

func (*InnerProductParameter) Marshal

func (m *InnerProductParameter) Marshal() (dAtA []byte, err error)

func (*InnerProductParameter) MarshalTo

func (m *InnerProductParameter) MarshalTo(dAtA []byte) (int, error)

func (*InnerProductParameter) ProtoMessage

func (*InnerProductParameter) ProtoMessage()

func (*InnerProductParameter) Reset

func (m *InnerProductParameter) Reset()

func (*InnerProductParameter) Size

func (m *InnerProductParameter) Size() (n int)

func (*InnerProductParameter) String

func (m *InnerProductParameter) String() string

func (*InnerProductParameter) Unmarshal

func (m *InnerProductParameter) Unmarshal(dAtA []byte) error

type InputParameter

type InputParameter struct {
	// This layer produces N >= 1 top blob(s) to be assigned manually.
	// Define N shapes to set a shape for each top.
	// Define 1 shape to set the same shape for every top.
	// Define no shape to defer to reshaping manually.
	Shape []*BlobShape `protobuf:"bytes,1,rep,name=shape" json:"shape,omitempty"`
}

func (*InputParameter) Descriptor

func (*InputParameter) Descriptor() ([]byte, []int)

func (*InputParameter) GetShape

func (m *InputParameter) GetShape() []*BlobShape

func (*InputParameter) Marshal

func (m *InputParameter) Marshal() (dAtA []byte, err error)

func (*InputParameter) MarshalTo

func (m *InputParameter) MarshalTo(dAtA []byte) (int, error)

func (*InputParameter) ProtoMessage

func (*InputParameter) ProtoMessage()

func (*InputParameter) Reset

func (m *InputParameter) Reset()

func (*InputParameter) Size

func (m *InputParameter) Size() (n int)

func (*InputParameter) String

func (m *InputParameter) String() string

func (*InputParameter) Unmarshal

func (m *InputParameter) Unmarshal(dAtA []byte) error

type LRNParameter

type LRNParameter struct {
	LocalSize  *uint32                  `protobuf:"varint,1,opt,name=local_size,json=localSize,def=5" json:"local_size,omitempty"`
	Alpha      *float32                 `protobuf:"fixed32,2,opt,name=alpha,def=1" json:"alpha,omitempty"`
	Beta       *float32                 `protobuf:"fixed32,3,opt,name=beta,def=0.75" json:"beta,omitempty"`
	NormRegion *LRNParameter_NormRegion `` /* 126-byte string literal not displayed */
	K          *float32                 `protobuf:"fixed32,5,opt,name=k,def=1" json:"k,omitempty"`
	Engine     *LRNParameter_Engine     `protobuf:"varint,6,opt,name=engine,enum=caffe.LRNParameter_Engine,def=0" json:"engine,omitempty"`
}

Message that stores parameters used by LRNLayer

func (*LRNParameter) Descriptor

func (*LRNParameter) Descriptor() ([]byte, []int)

func (*LRNParameter) GetAlpha

func (m *LRNParameter) GetAlpha() float32

func (*LRNParameter) GetBeta

func (m *LRNParameter) GetBeta() float32

func (*LRNParameter) GetEngine

func (m *LRNParameter) GetEngine() LRNParameter_Engine

func (*LRNParameter) GetK

func (m *LRNParameter) GetK() float32

func (*LRNParameter) GetLocalSize

func (m *LRNParameter) GetLocalSize() uint32

func (*LRNParameter) GetNormRegion

func (m *LRNParameter) GetNormRegion() LRNParameter_NormRegion

func (*LRNParameter) Marshal

func (m *LRNParameter) Marshal() (dAtA []byte, err error)

func (*LRNParameter) MarshalTo

func (m *LRNParameter) MarshalTo(dAtA []byte) (int, error)

func (*LRNParameter) ProtoMessage

func (*LRNParameter) ProtoMessage()

func (*LRNParameter) Reset

func (m *LRNParameter) Reset()

func (*LRNParameter) Size

func (m *LRNParameter) Size() (n int)

func (*LRNParameter) String

func (m *LRNParameter) String() string

func (*LRNParameter) Unmarshal

func (m *LRNParameter) Unmarshal(dAtA []byte) error

type LRNParameter_Engine

type LRNParameter_Engine int32
const (
	LRNParameter_DEFAULT LRNParameter_Engine = 0
	LRNParameter_CAFFE   LRNParameter_Engine = 1
	LRNParameter_CUDNN   LRNParameter_Engine = 2
)
const Default_LRNParameter_Engine LRNParameter_Engine = LRNParameter_DEFAULT

func (LRNParameter_Engine) Enum

func (LRNParameter_Engine) EnumDescriptor

func (LRNParameter_Engine) EnumDescriptor() ([]byte, []int)

func (LRNParameter_Engine) String

func (x LRNParameter_Engine) String() string

func (*LRNParameter_Engine) UnmarshalJSON

func (x *LRNParameter_Engine) UnmarshalJSON(data []byte) error

type LRNParameter_NormRegion

type LRNParameter_NormRegion int32
const (
	LRNParameter_ACROSS_CHANNELS LRNParameter_NormRegion = 0
	LRNParameter_WITHIN_CHANNEL  LRNParameter_NormRegion = 1
)
const Default_LRNParameter_NormRegion LRNParameter_NormRegion = LRNParameter_ACROSS_CHANNELS

func (LRNParameter_NormRegion) Enum

func (LRNParameter_NormRegion) EnumDescriptor

func (LRNParameter_NormRegion) EnumDescriptor() ([]byte, []int)

func (LRNParameter_NormRegion) String

func (x LRNParameter_NormRegion) String() string

func (*LRNParameter_NormRegion) UnmarshalJSON

func (x *LRNParameter_NormRegion) UnmarshalJSON(data []byte) error

type LayerParameter

type LayerParameter struct {
	Name   string   `protobuf:"bytes,1,opt,name=name" json:"name"`
	Type   string   `protobuf:"bytes,2,opt,name=type" json:"type"`
	Bottom []string `protobuf:"bytes,3,rep,name=bottom" json:"bottom,omitempty"`
	Top    []string `protobuf:"bytes,4,rep,name=top" json:"top,omitempty"`
	// The train / test phase for computation.
	Phase Phase `protobuf:"varint,10,opt,name=phase,enum=caffe.Phase" json:"phase"`
	// The amount of weight to assign each top blob in the objective.
	// Each layer assigns a default value, usually of either 0 or 1,
	// to each top blob.
	LossWeight []float32 `protobuf:"fixed32,5,rep,name=loss_weight,json=lossWeight" json:"loss_weight,omitempty"`
	// Specifies training parameters (multipliers on global learning constants,
	// and the name and other settings used for weight sharing).
	Param []*ParamSpec `protobuf:"bytes,6,rep,name=param" json:"param,omitempty"`
	// The blobs containing the numeric parameters of the layer.
	Blobs []*BlobProto `protobuf:"bytes,7,rep,name=blobs" json:"blobs,omitempty"`
	// Specifies whether to backpropagate to each bottom. If unspecified,
	// Caffe will automatically infer whether each input needs backpropagation
	// to compute parameter gradients. If set to true for some inputs,
	// backpropagation to those inputs is forced; if set false for some inputs,
	// backpropagation to those inputs is skipped.
	//
	// The size must be either 0 or equal to the number of bottoms.
	PropagateDown []bool `protobuf:"varint,11,rep,name=propagate_down,json=propagateDown" json:"propagate_down,omitempty"`
	// Rules controlling whether and when a layer is included in the network,
	// based on the current NetState.  You may specify a non-zero number of rules
	// to include OR exclude, but not both.  If no include or exclude rules are
	// specified, the layer is always included.  If the current NetState meets
	// ANY (i.e., one or more) of the specified rules, the layer is
	// included/excluded.
	Include []*NetStateRule `protobuf:"bytes,8,rep,name=include" json:"include,omitempty"`
	Exclude []*NetStateRule `protobuf:"bytes,9,rep,name=exclude" json:"exclude,omitempty"`
	// Parameters for data pre-processing.
	TransformParam *TransformationParameter `protobuf:"bytes,100,opt,name=transform_param,json=transformParam" json:"transform_param,omitempty"`
	// Parameters shared by loss layers.
	LossParam *LossParameter `protobuf:"bytes,101,opt,name=loss_param,json=lossParam" json:"loss_param,omitempty"`
	// Layer type-specific parameters.
	//
	// Note: certain layers may have more than one computational engine
	// for their implementation. These layers include an Engine type and
	// engine parameter for selecting the implementation.
	// The default for the engine is set by the ENGINE switch at compile-time.
	AccuracyParam        *AccuracyParameter        `protobuf:"bytes,102,opt,name=accuracy_param,json=accuracyParam" json:"accuracy_param,omitempty"`
	ArgmaxParam          *ArgMaxParameter          `protobuf:"bytes,103,opt,name=argmax_param,json=argmaxParam" json:"argmax_param,omitempty"`
	BatchNormParam       *BatchNormParameter       `protobuf:"bytes,139,opt,name=batch_norm_param,json=batchNormParam" json:"batch_norm_param,omitempty"`
	BiasParam            *BiasParameter            `protobuf:"bytes,141,opt,name=bias_param,json=biasParam" json:"bias_param,omitempty"`
	ConcatParam          *ConcatParameter          `protobuf:"bytes,104,opt,name=concat_param,json=concatParam" json:"concat_param,omitempty"`
	ContrastiveLossParam *ContrastiveLossParameter `protobuf:"bytes,105,opt,name=contrastive_loss_param,json=contrastiveLossParam" json:"contrastive_loss_param,omitempty"`
	ConvolutionParam     *ConvolutionParameter     `protobuf:"bytes,106,opt,name=convolution_param,json=convolutionParam" json:"convolution_param,omitempty"`
	CropParam            *CropParameter            `protobuf:"bytes,144,opt,name=crop_param,json=cropParam" json:"crop_param,omitempty"`
	DataParam            *DataParameter            `protobuf:"bytes,107,opt,name=data_param,json=dataParam" json:"data_param,omitempty"`
	DropoutParam         *DropoutParameter         `protobuf:"bytes,108,opt,name=dropout_param,json=dropoutParam" json:"dropout_param,omitempty"`
	DummyDataParam       *DummyDataParameter       `protobuf:"bytes,109,opt,name=dummy_data_param,json=dummyDataParam" json:"dummy_data_param,omitempty"`
	EltwiseParam         *EltwiseParameter         `protobuf:"bytes,110,opt,name=eltwise_param,json=eltwiseParam" json:"eltwise_param,omitempty"`
	EluParam             *ELUParameter             `protobuf:"bytes,140,opt,name=elu_param,json=eluParam" json:"elu_param,omitempty"`
	EmbedParam           *EmbedParameter           `protobuf:"bytes,137,opt,name=embed_param,json=embedParam" json:"embed_param,omitempty"`
	ExpParam             *ExpParameter             `protobuf:"bytes,111,opt,name=exp_param,json=expParam" json:"exp_param,omitempty"`
	FlattenParam         *FlattenParameter         `protobuf:"bytes,135,opt,name=flatten_param,json=flattenParam" json:"flatten_param,omitempty"`
	Hdf5DataParam        *HDF5DataParameter        `protobuf:"bytes,112,opt,name=hdf5_data_param,json=hdf5DataParam" json:"hdf5_data_param,omitempty"`
	Hdf5OutputParam      *HDF5OutputParameter      `protobuf:"bytes,113,opt,name=hdf5_output_param,json=hdf5OutputParam" json:"hdf5_output_param,omitempty"`
	HingeLossParam       *HingeLossParameter       `protobuf:"bytes,114,opt,name=hinge_loss_param,json=hingeLossParam" json:"hinge_loss_param,omitempty"`
	ImageDataParam       *ImageDataParameter       `protobuf:"bytes,115,opt,name=image_data_param,json=imageDataParam" json:"image_data_param,omitempty"`
	InfogainLossParam    *InfogainLossParameter    `protobuf:"bytes,116,opt,name=infogain_loss_param,json=infogainLossParam" json:"infogain_loss_param,omitempty"`
	InnerProductParam    *InnerProductParameter    `protobuf:"bytes,117,opt,name=inner_product_param,json=innerProductParam" json:"inner_product_param,omitempty"`
	InputParam           *InputParameter           `protobuf:"bytes,143,opt,name=input_param,json=inputParam" json:"input_param,omitempty"`
	LogParam             *LogParameter             `protobuf:"bytes,134,opt,name=log_param,json=logParam" json:"log_param,omitempty"`
	LrnParam             *LRNParameter             `protobuf:"bytes,118,opt,name=lrn_param,json=lrnParam" json:"lrn_param,omitempty"`
	MemoryDataParam      *MemoryDataParameter      `protobuf:"bytes,119,opt,name=memory_data_param,json=memoryDataParam" json:"memory_data_param,omitempty"`
	MvnParam             *MVNParameter             `protobuf:"bytes,120,opt,name=mvn_param,json=mvnParam" json:"mvn_param,omitempty"`
	ParameterParam       *ParameterParameter       `protobuf:"bytes,145,opt,name=parameter_param,json=parameterParam" json:"parameter_param,omitempty"`
	PoolingParam         *PoolingParameter         `protobuf:"bytes,121,opt,name=pooling_param,json=poolingParam" json:"pooling_param,omitempty"`
	PowerParam           *PowerParameter           `protobuf:"bytes,122,opt,name=power_param,json=powerParam" json:"power_param,omitempty"`
	PreluParam           *PReLUParameter           `protobuf:"bytes,131,opt,name=prelu_param,json=preluParam" json:"prelu_param,omitempty"`
	PythonParam          *PythonParameter          `protobuf:"bytes,130,opt,name=python_param,json=pythonParam" json:"python_param,omitempty"`
	RecurrentParam       *RecurrentParameter       `protobuf:"bytes,146,opt,name=recurrent_param,json=recurrentParam" json:"recurrent_param,omitempty"`
	ReductionParam       *ReductionParameter       `protobuf:"bytes,136,opt,name=reduction_param,json=reductionParam" json:"reduction_param,omitempty"`
	ReluParam            *ReLUParameter            `protobuf:"bytes,123,opt,name=relu_param,json=reluParam" json:"relu_param,omitempty"`
	ReshapeParam         *ReshapeParameter         `protobuf:"bytes,133,opt,name=reshape_param,json=reshapeParam" json:"reshape_param,omitempty"`
	ScaleParam           *ScaleParameter           `protobuf:"bytes,142,opt,name=scale_param,json=scaleParam" json:"scale_param,omitempty"`
	SigmoidParam         *SigmoidParameter         `protobuf:"bytes,124,opt,name=sigmoid_param,json=sigmoidParam" json:"sigmoid_param,omitempty"`
	SoftmaxParam         *SoftmaxParameter         `protobuf:"bytes,125,opt,name=softmax_param,json=softmaxParam" json:"softmax_param,omitempty"`
	SppParam             *SPPParameter             `protobuf:"bytes,132,opt,name=spp_param,json=sppParam" json:"spp_param,omitempty"`
	SliceParam           *SliceParameter           `protobuf:"bytes,126,opt,name=slice_param,json=sliceParam" json:"slice_param,omitempty"`
	TanhParam            *TanHParameter            `protobuf:"bytes,127,opt,name=tanh_param,json=tanhParam" json:"tanh_param,omitempty"`
	ThresholdParam       *ThresholdParameter       `protobuf:"bytes,128,opt,name=threshold_param,json=thresholdParam" json:"threshold_param,omitempty"`
	TileParam            *TileParameter            `protobuf:"bytes,138,opt,name=tile_param,json=tileParam" json:"tile_param,omitempty"`
	WindowDataParam      *WindowDataParameter      `protobuf:"bytes,129,opt,name=window_data_param,json=windowDataParam" json:"window_data_param,omitempty"`
}

NOTE Update the next available ID when you add a new LayerParameter field.

LayerParameter next available layer-specific ID: 147 (last added: recurrent_param)

func (*LayerParameter) Descriptor

func (*LayerParameter) Descriptor() ([]byte, []int)

func (*LayerParameter) GetAccuracyParam

func (m *LayerParameter) GetAccuracyParam() *AccuracyParameter

func (*LayerParameter) GetArgmaxParam

func (m *LayerParameter) GetArgmaxParam() *ArgMaxParameter

func (*LayerParameter) GetBatchNormParam

func (m *LayerParameter) GetBatchNormParam() *BatchNormParameter

func (*LayerParameter) GetBiasParam

func (m *LayerParameter) GetBiasParam() *BiasParameter

func (*LayerParameter) GetBlobs

func (m *LayerParameter) GetBlobs() []*BlobProto

func (*LayerParameter) GetBottom

func (m *LayerParameter) GetBottom() []string

func (*LayerParameter) GetConcatParam

func (m *LayerParameter) GetConcatParam() *ConcatParameter

func (*LayerParameter) GetContrastiveLossParam

func (m *LayerParameter) GetContrastiveLossParam() *ContrastiveLossParameter

func (*LayerParameter) GetConvolutionParam

func (m *LayerParameter) GetConvolutionParam() *ConvolutionParameter

func (*LayerParameter) GetCropParam

func (m *LayerParameter) GetCropParam() *CropParameter

func (*LayerParameter) GetDataParam

func (m *LayerParameter) GetDataParam() *DataParameter

func (*LayerParameter) GetDropoutParam

func (m *LayerParameter) GetDropoutParam() *DropoutParameter

func (*LayerParameter) GetDummyDataParam

func (m *LayerParameter) GetDummyDataParam() *DummyDataParameter

func (*LayerParameter) GetEltwiseParam

func (m *LayerParameter) GetEltwiseParam() *EltwiseParameter

func (*LayerParameter) GetEluParam

func (m *LayerParameter) GetEluParam() *ELUParameter

func (*LayerParameter) GetEmbedParam

func (m *LayerParameter) GetEmbedParam() *EmbedParameter

func (*LayerParameter) GetExclude

func (m *LayerParameter) GetExclude() []*NetStateRule

func (*LayerParameter) GetExpParam

func (m *LayerParameter) GetExpParam() *ExpParameter

func (*LayerParameter) GetFlattenParam

func (m *LayerParameter) GetFlattenParam() *FlattenParameter

func (*LayerParameter) GetHdf5DataParam

func (m *LayerParameter) GetHdf5DataParam() *HDF5DataParameter

func (*LayerParameter) GetHdf5OutputParam

func (m *LayerParameter) GetHdf5OutputParam() *HDF5OutputParameter

func (*LayerParameter) GetHingeLossParam

func (m *LayerParameter) GetHingeLossParam() *HingeLossParameter

func (*LayerParameter) GetImageDataParam

func (m *LayerParameter) GetImageDataParam() *ImageDataParameter

func (*LayerParameter) GetInclude

func (m *LayerParameter) GetInclude() []*NetStateRule

func (*LayerParameter) GetInfogainLossParam

func (m *LayerParameter) GetInfogainLossParam() *InfogainLossParameter

func (*LayerParameter) GetInnerProductParam

func (m *LayerParameter) GetInnerProductParam() *InnerProductParameter

func (*LayerParameter) GetInputParam

func (m *LayerParameter) GetInputParam() *InputParameter

func (*LayerParameter) GetLogParam

func (m *LayerParameter) GetLogParam() *LogParameter

func (*LayerParameter) GetLossParam

func (m *LayerParameter) GetLossParam() *LossParameter

func (*LayerParameter) GetLossWeight

func (m *LayerParameter) GetLossWeight() []float32

func (*LayerParameter) GetLrnParam

func (m *LayerParameter) GetLrnParam() *LRNParameter

func (*LayerParameter) GetMemoryDataParam

func (m *LayerParameter) GetMemoryDataParam() *MemoryDataParameter

func (*LayerParameter) GetMvnParam

func (m *LayerParameter) GetMvnParam() *MVNParameter

func (*LayerParameter) GetName

func (m *LayerParameter) GetName() string

func (*LayerParameter) GetParam

func (m *LayerParameter) GetParam() []*ParamSpec

func (*LayerParameter) GetParameterParam

func (m *LayerParameter) GetParameterParam() *ParameterParameter

func (*LayerParameter) GetPhase

func (m *LayerParameter) GetPhase() Phase

func (*LayerParameter) GetPoolingParam

func (m *LayerParameter) GetPoolingParam() *PoolingParameter

func (*LayerParameter) GetPowerParam

func (m *LayerParameter) GetPowerParam() *PowerParameter

func (*LayerParameter) GetPreluParam

func (m *LayerParameter) GetPreluParam() *PReLUParameter

func (*LayerParameter) GetPropagateDown

func (m *LayerParameter) GetPropagateDown() []bool

func (*LayerParameter) GetPythonParam

func (m *LayerParameter) GetPythonParam() *PythonParameter

func (*LayerParameter) GetRecurrentParam

func (m *LayerParameter) GetRecurrentParam() *RecurrentParameter

func (*LayerParameter) GetReductionParam

func (m *LayerParameter) GetReductionParam() *ReductionParameter

func (*LayerParameter) GetReluParam

func (m *LayerParameter) GetReluParam() *ReLUParameter

func (*LayerParameter) GetReshapeParam

func (m *LayerParameter) GetReshapeParam() *ReshapeParameter

func (*LayerParameter) GetScaleParam

func (m *LayerParameter) GetScaleParam() *ScaleParameter

func (*LayerParameter) GetSigmoidParam

func (m *LayerParameter) GetSigmoidParam() *SigmoidParameter

func (*LayerParameter) GetSliceParam

func (m *LayerParameter) GetSliceParam() *SliceParameter

func (*LayerParameter) GetSoftmaxParam

func (m *LayerParameter) GetSoftmaxParam() *SoftmaxParameter

func (*LayerParameter) GetSppParam

func (m *LayerParameter) GetSppParam() *SPPParameter

func (*LayerParameter) GetTanhParam

func (m *LayerParameter) GetTanhParam() *TanHParameter

func (*LayerParameter) GetThresholdParam

func (m *LayerParameter) GetThresholdParam() *ThresholdParameter

func (*LayerParameter) GetTileParam

func (m *LayerParameter) GetTileParam() *TileParameter

func (*LayerParameter) GetTop

func (m *LayerParameter) GetTop() []string

func (*LayerParameter) GetTransformParam

func (m *LayerParameter) GetTransformParam() *TransformationParameter

func (*LayerParameter) GetType

func (m *LayerParameter) GetType() string

func (*LayerParameter) GetWindowDataParam

func (m *LayerParameter) GetWindowDataParam() *WindowDataParameter

func (*LayerParameter) Marshal

func (m *LayerParameter) Marshal() (dAtA []byte, err error)

func (*LayerParameter) MarshalTo

func (m *LayerParameter) MarshalTo(dAtA []byte) (int, error)

func (*LayerParameter) ProtoMessage

func (*LayerParameter) ProtoMessage()

func (*LayerParameter) Reset

func (m *LayerParameter) Reset()

func (*LayerParameter) Size

func (m *LayerParameter) Size() (n int)

func (*LayerParameter) String

func (m *LayerParameter) String() string

func (*LayerParameter) Unmarshal

func (m *LayerParameter) Unmarshal(dAtA []byte) error

type LogParameter

type LogParameter struct {
	// LogLayer computes outputs y = log_base(shift + scale * x), for base > 0.
	// Or if base is set to the default (-1), base is set to e,
	// so y = ln(shift + scale * x) = log_e(shift + scale * x)
	Base  *float32 `protobuf:"fixed32,1,opt,name=base,def=-1" json:"base,omitempty"`
	Scale *float32 `protobuf:"fixed32,2,opt,name=scale,def=1" json:"scale,omitempty"`
	Shift *float32 `protobuf:"fixed32,3,opt,name=shift,def=0" json:"shift,omitempty"`
}

Message that stores parameters used by LogLayer

func (*LogParameter) Descriptor

func (*LogParameter) Descriptor() ([]byte, []int)

func (*LogParameter) GetBase

func (m *LogParameter) GetBase() float32

func (*LogParameter) GetScale

func (m *LogParameter) GetScale() float32

func (*LogParameter) GetShift

func (m *LogParameter) GetShift() float32

func (*LogParameter) Marshal

func (m *LogParameter) Marshal() (dAtA []byte, err error)

func (*LogParameter) MarshalTo

func (m *LogParameter) MarshalTo(dAtA []byte) (int, error)

func (*LogParameter) ProtoMessage

func (*LogParameter) ProtoMessage()

func (*LogParameter) Reset

func (m *LogParameter) Reset()

func (*LogParameter) Size

func (m *LogParameter) Size() (n int)

func (*LogParameter) String

func (m *LogParameter) String() string

func (*LogParameter) Unmarshal

func (m *LogParameter) Unmarshal(dAtA []byte) error

type LossParameter

type LossParameter struct {
	// If specified, ignore instances with the given label.
	IgnoreLabel   int32                            `protobuf:"varint,1,opt,name=ignore_label,json=ignoreLabel" json:"ignore_label"`
	Normalization *LossParameter_NormalizationMode `protobuf:"varint,3,opt,name=normalization,enum=caffe.LossParameter_NormalizationMode,def=1" json:"normalization,omitempty"`
	// Deprecated.  Ignored if normalization is specified.  If normalization
	// is not specified, then setting this to false will be equivalent to
	// normalization = BATCH_SIZE to be consistent with previous behavior.
	Normalize bool `protobuf:"varint,2,opt,name=normalize" json:"normalize"`
}

Message that stores parameters shared by loss layers

func (*LossParameter) Descriptor

func (*LossParameter) Descriptor() ([]byte, []int)

func (*LossParameter) GetIgnoreLabel

func (m *LossParameter) GetIgnoreLabel() int32

func (*LossParameter) GetNormalization

func (m *LossParameter) GetNormalization() LossParameter_NormalizationMode

func (*LossParameter) GetNormalize

func (m *LossParameter) GetNormalize() bool

func (*LossParameter) Marshal

func (m *LossParameter) Marshal() (dAtA []byte, err error)

func (*LossParameter) MarshalTo

func (m *LossParameter) MarshalTo(dAtA []byte) (int, error)

func (*LossParameter) ProtoMessage

func (*LossParameter) ProtoMessage()

func (*LossParameter) Reset

func (m *LossParameter) Reset()

func (*LossParameter) Size

func (m *LossParameter) Size() (n int)

func (*LossParameter) String

func (m *LossParameter) String() string

func (*LossParameter) Unmarshal

func (m *LossParameter) Unmarshal(dAtA []byte) error

type LossParameter_NormalizationMode

type LossParameter_NormalizationMode int32

How to normalize the loss for loss layers that aggregate across batches, spatial dimensions, or other dimensions. Currently only implemented in SoftmaxWithLoss layer.

const (
	// Divide by the number of examples in the batch times spatial dimensions.
	// Outputs that receive the ignore label will NOT be ignored in computing
	// the normalization factor.
	LossParameter_FULL LossParameter_NormalizationMode = 0
	// Divide by the total number of output locations that do not take the
	// ignore_label.  If ignore_label is not set, this behaves like FULL.
	LossParameter_VALID LossParameter_NormalizationMode = 1
	// Divide by the batch size.
	LossParameter_BATCH_SIZE LossParameter_NormalizationMode = 2
	// Do not normalize the loss.
	LossParameter_NONE LossParameter_NormalizationMode = 3
)
const Default_LossParameter_Normalization LossParameter_NormalizationMode = LossParameter_VALID

func (LossParameter_NormalizationMode) Enum

func (LossParameter_NormalizationMode) EnumDescriptor

func (LossParameter_NormalizationMode) EnumDescriptor() ([]byte, []int)

func (LossParameter_NormalizationMode) String

func (*LossParameter_NormalizationMode) UnmarshalJSON

func (x *LossParameter_NormalizationMode) UnmarshalJSON(data []byte) error

type MVNParameter

type MVNParameter struct {
	// This parameter can be set to false to normalize mean only
	NormalizeVariance *bool `protobuf:"varint,1,opt,name=normalize_variance,json=normalizeVariance,def=1" json:"normalize_variance,omitempty"`
	// This parameter can be set to true to perform DNN-like MVN
	AcrossChannels *bool `protobuf:"varint,2,opt,name=across_channels,json=acrossChannels,def=0" json:"across_channels,omitempty"`
	// Epsilon for not dividing by zero while normalizing variance
	Eps *float32 `protobuf:"fixed32,3,opt,name=eps,def=1e-09" json:"eps,omitempty"`
}

func (*MVNParameter) Descriptor

func (*MVNParameter) Descriptor() ([]byte, []int)

func (*MVNParameter) GetAcrossChannels

func (m *MVNParameter) GetAcrossChannels() bool

func (*MVNParameter) GetEps

func (m *MVNParameter) GetEps() float32

func (*MVNParameter) GetNormalizeVariance

func (m *MVNParameter) GetNormalizeVariance() bool

func (*MVNParameter) Marshal

func (m *MVNParameter) Marshal() (dAtA []byte, err error)

func (*MVNParameter) MarshalTo

func (m *MVNParameter) MarshalTo(dAtA []byte) (int, error)

func (*MVNParameter) ProtoMessage

func (*MVNParameter) ProtoMessage()

func (*MVNParameter) Reset

func (m *MVNParameter) Reset()

func (*MVNParameter) Size

func (m *MVNParameter) Size() (n int)

func (*MVNParameter) String

func (m *MVNParameter) String() string

func (*MVNParameter) Unmarshal

func (m *MVNParameter) Unmarshal(dAtA []byte) error

type MemoryDataParameter

type MemoryDataParameter struct {
	BatchSize uint32 `protobuf:"varint,1,opt,name=batch_size,json=batchSize" json:"batch_size"`
	Channels  uint32 `protobuf:"varint,2,opt,name=channels" json:"channels"`
	Height    uint32 `protobuf:"varint,3,opt,name=height" json:"height"`
	Width     uint32 `protobuf:"varint,4,opt,name=width" json:"width"`
}

func (*MemoryDataParameter) Descriptor

func (*MemoryDataParameter) Descriptor() ([]byte, []int)

func (*MemoryDataParameter) GetBatchSize

func (m *MemoryDataParameter) GetBatchSize() uint32

func (*MemoryDataParameter) GetChannels

func (m *MemoryDataParameter) GetChannels() uint32

func (*MemoryDataParameter) GetHeight

func (m *MemoryDataParameter) GetHeight() uint32

func (*MemoryDataParameter) GetWidth

func (m *MemoryDataParameter) GetWidth() uint32

func (*MemoryDataParameter) Marshal

func (m *MemoryDataParameter) Marshal() (dAtA []byte, err error)

func (*MemoryDataParameter) MarshalTo

func (m *MemoryDataParameter) MarshalTo(dAtA []byte) (int, error)

func (*MemoryDataParameter) ProtoMessage

func (*MemoryDataParameter) ProtoMessage()

func (*MemoryDataParameter) Reset

func (m *MemoryDataParameter) Reset()

func (*MemoryDataParameter) Size

func (m *MemoryDataParameter) Size() (n int)

func (*MemoryDataParameter) String

func (m *MemoryDataParameter) String() string

func (*MemoryDataParameter) Unmarshal

func (m *MemoryDataParameter) Unmarshal(dAtA []byte) error

type NetParameter

type NetParameter struct {
	Name string `protobuf:"bytes,1,opt,name=name" json:"name"`
	// DEPRECATED. See InputParameter. The input blobs to the network.
	Input []string `protobuf:"bytes,3,rep,name=input" json:"input,omitempty"`
	// DEPRECATED. See InputParameter. The shape of the input blobs.
	InputShape []*BlobShape `protobuf:"bytes,8,rep,name=input_shape,json=inputShape" json:"input_shape,omitempty"`
	// 4D input dimensions -- deprecated.  Use "input_shape" instead.
	// If specified, for each input blob there should be four
	// values specifying the num, channels, height and width of the input blob.
	// Thus, there should be a total of (4 * #input) numbers.
	InputDim []int32 `protobuf:"varint,4,rep,name=input_dim,json=inputDim" json:"input_dim,omitempty"`
	// Whether the network will force every layer to carry out backward operation.
	// If set False, then whether to carry out backward is determined
	// automatically according to the net structure and learning rates.
	ForceBackward *bool `protobuf:"varint,5,opt,name=force_backward,json=forceBackward,def=0" json:"force_backward,omitempty"`
	// The current "state" of the network, including the phase, level, and stage.
	// Some layers may be included/excluded depending on this state and the states
	// specified in the layers' include and exclude fields.
	State *NetState `protobuf:"bytes,6,opt,name=state" json:"state,omitempty"`
	// Print debugging information about results while running Net::Forward,
	// Net::Backward, and Net::Update.
	DebugInfo *bool `protobuf:"varint,7,opt,name=debug_info,json=debugInfo,def=0" json:"debug_info,omitempty"`
	// The layers that make up the net.  Each of their configurations, including
	// connectivity and behavior, is specified as a LayerParameter.
	Layer []*LayerParameter `protobuf:"bytes,100,rep,name=layer" json:"layer,omitempty"`
	// DEPRECATED: use 'layer' instead.
	Layers []*V1LayerParameter `protobuf:"bytes,2,rep,name=layers" json:"layers,omitempty"`
}

func ReadNet

func ReadNet(protoTextFileName string) (*NetParameter, error)

ReadBlob ...

func (*NetParameter) Descriptor

func (*NetParameter) Descriptor() ([]byte, []int)

func (*NetParameter) GetDebugInfo

func (m *NetParameter) GetDebugInfo() bool

func (*NetParameter) GetForceBackward

func (m *NetParameter) GetForceBackward() bool

func (*NetParameter) GetInput

func (m *NetParameter) GetInput() []string

func (*NetParameter) GetInputDim

func (m *NetParameter) GetInputDim() []int32

func (*NetParameter) GetInputShape

func (m *NetParameter) GetInputShape() []*BlobShape

func (*NetParameter) GetLayer

func (m *NetParameter) GetLayer() []*LayerParameter

func (*NetParameter) GetLayers

func (m *NetParameter) GetLayers() []*V1LayerParameter

func (*NetParameter) GetName

func (m *NetParameter) GetName() string

func (*NetParameter) GetState

func (m *NetParameter) GetState() *NetState

func (*NetParameter) Marshal

func (m *NetParameter) Marshal() (dAtA []byte, err error)

func (*NetParameter) MarshalTo

func (m *NetParameter) MarshalTo(dAtA []byte) (int, error)

func (*NetParameter) ProtoMessage

func (*NetParameter) ProtoMessage()

func (*NetParameter) Reset

func (m *NetParameter) Reset()

func (*NetParameter) Size

func (m *NetParameter) Size() (n int)

func (*NetParameter) String

func (m *NetParameter) String() string

func (*NetParameter) Unmarshal

func (m *NetParameter) Unmarshal(dAtA []byte) error

type NetState

type NetState struct {
	Phase *Phase   `protobuf:"varint,1,opt,name=phase,enum=caffe.Phase,def=1" json:"phase,omitempty"`
	Level *int32   `protobuf:"varint,2,opt,name=level,def=0" json:"level,omitempty"`
	Stage []string `protobuf:"bytes,3,rep,name=stage" json:"stage,omitempty"`
}

func (*NetState) Descriptor

func (*NetState) Descriptor() ([]byte, []int)

func (*NetState) GetLevel

func (m *NetState) GetLevel() int32

func (*NetState) GetPhase

func (m *NetState) GetPhase() Phase

func (*NetState) GetStage

func (m *NetState) GetStage() []string

func (*NetState) Marshal

func (m *NetState) Marshal() (dAtA []byte, err error)

func (*NetState) MarshalTo

func (m *NetState) MarshalTo(dAtA []byte) (int, error)

func (*NetState) ProtoMessage

func (*NetState) ProtoMessage()

func (*NetState) Reset

func (m *NetState) Reset()

func (*NetState) Size

func (m *NetState) Size() (n int)

func (*NetState) String

func (m *NetState) String() string

func (*NetState) Unmarshal

func (m *NetState) Unmarshal(dAtA []byte) error

type NetStateRule

type NetStateRule struct {
	// Set phase to require the NetState have a particular phase (TRAIN or TEST)
	// to meet this rule.
	Phase Phase `protobuf:"varint,1,opt,name=phase,enum=caffe.Phase" json:"phase"`
	// Set the minimum and/or maximum levels in which the layer should be used.
	// Leave undefined to meet the rule regardless of level.
	MinLevel int32 `protobuf:"varint,2,opt,name=min_level,json=minLevel" json:"min_level"`
	MaxLevel int32 `protobuf:"varint,3,opt,name=max_level,json=maxLevel" json:"max_level"`
	// Customizable sets of stages to include or exclude.
	// The net must have ALL of the specified stages and NONE of the specified
	// "not_stage"s to meet the rule.
	// (Use multiple NetStateRules to specify conjunctions of stages.)
	Stage    []string `protobuf:"bytes,4,rep,name=stage" json:"stage,omitempty"`
	NotStage []string `protobuf:"bytes,5,rep,name=not_stage,json=notStage" json:"not_stage,omitempty"`
}

func (*NetStateRule) Descriptor

func (*NetStateRule) Descriptor() ([]byte, []int)

func (*NetStateRule) GetMaxLevel

func (m *NetStateRule) GetMaxLevel() int32

func (*NetStateRule) GetMinLevel

func (m *NetStateRule) GetMinLevel() int32

func (*NetStateRule) GetNotStage

func (m *NetStateRule) GetNotStage() []string

func (*NetStateRule) GetPhase

func (m *NetStateRule) GetPhase() Phase

func (*NetStateRule) GetStage

func (m *NetStateRule) GetStage() []string

func (*NetStateRule) Marshal

func (m *NetStateRule) Marshal() (dAtA []byte, err error)

func (*NetStateRule) MarshalTo

func (m *NetStateRule) MarshalTo(dAtA []byte) (int, error)

func (*NetStateRule) ProtoMessage

func (*NetStateRule) ProtoMessage()

func (*NetStateRule) Reset

func (m *NetStateRule) Reset()

func (*NetStateRule) Size

func (m *NetStateRule) Size() (n int)

func (*NetStateRule) String

func (m *NetStateRule) String() string

func (*NetStateRule) Unmarshal

func (m *NetStateRule) Unmarshal(dAtA []byte) error

type PReLUParameter

type PReLUParameter struct {
	// Initial value of a_i. Default is a_i=0.25 for all i.
	Filler *FillerParameter `protobuf:"bytes,1,opt,name=filler" json:"filler,omitempty"`
	// Whether or not slope paramters are shared across channels.
	ChannelShared *bool `protobuf:"varint,2,opt,name=channel_shared,json=channelShared,def=0" json:"channel_shared,omitempty"`
}

func (*PReLUParameter) Descriptor

func (*PReLUParameter) Descriptor() ([]byte, []int)

func (*PReLUParameter) GetChannelShared

func (m *PReLUParameter) GetChannelShared() bool

func (*PReLUParameter) GetFiller

func (m *PReLUParameter) GetFiller() *FillerParameter

func (*PReLUParameter) Marshal

func (m *PReLUParameter) Marshal() (dAtA []byte, err error)

func (*PReLUParameter) MarshalTo

func (m *PReLUParameter) MarshalTo(dAtA []byte) (int, error)

func (*PReLUParameter) ProtoMessage

func (*PReLUParameter) ProtoMessage()

func (*PReLUParameter) Reset

func (m *PReLUParameter) Reset()

func (*PReLUParameter) Size

func (m *PReLUParameter) Size() (n int)

func (*PReLUParameter) String

func (m *PReLUParameter) String() string

func (*PReLUParameter) Unmarshal

func (m *PReLUParameter) Unmarshal(dAtA []byte) error

type ParamSpec

type ParamSpec struct {
	// The names of the parameter blobs -- useful for sharing parameters among
	// layers, but never required otherwise.  To share a parameter between two
	// layers, give it a (non-empty) name.
	Name string `protobuf:"bytes,1,opt,name=name" json:"name"`
	// Whether to require shared weights to have the same shape, or just the same
	// count -- defaults to STRICT if unspecified.
	ShareMode ParamSpec_DimCheckMode `protobuf:"varint,2,opt,name=share_mode,json=shareMode,enum=caffe.ParamSpec_DimCheckMode" json:"share_mode"`
	// The multiplier on the global learning rate for this parameter.
	LrMult *float32 `protobuf:"fixed32,3,opt,name=lr_mult,json=lrMult,def=1" json:"lr_mult,omitempty"`
	// The multiplier on the global weight decay for this parameter.
	DecayMult *float32 `protobuf:"fixed32,4,opt,name=decay_mult,json=decayMult,def=1" json:"decay_mult,omitempty"`
}

Specifies training parameters (multipliers on global learning constants, and the name and other settings used for weight sharing).

func (*ParamSpec) Descriptor

func (*ParamSpec) Descriptor() ([]byte, []int)

func (*ParamSpec) GetDecayMult

func (m *ParamSpec) GetDecayMult() float32

func (*ParamSpec) GetLrMult

func (m *ParamSpec) GetLrMult() float32

func (*ParamSpec) GetName

func (m *ParamSpec) GetName() string

func (*ParamSpec) GetShareMode

func (m *ParamSpec) GetShareMode() ParamSpec_DimCheckMode

func (*ParamSpec) Marshal

func (m *ParamSpec) Marshal() (dAtA []byte, err error)

func (*ParamSpec) MarshalTo

func (m *ParamSpec) MarshalTo(dAtA []byte) (int, error)

func (*ParamSpec) ProtoMessage

func (*ParamSpec) ProtoMessage()

func (*ParamSpec) Reset

func (m *ParamSpec) Reset()

func (*ParamSpec) Size

func (m *ParamSpec) Size() (n int)

func (*ParamSpec) String

func (m *ParamSpec) String() string

func (*ParamSpec) Unmarshal

func (m *ParamSpec) Unmarshal(dAtA []byte) error

type ParamSpec_DimCheckMode

type ParamSpec_DimCheckMode int32
const (
	// STRICT (default) requires that num, channels, height, width each match.
	ParamSpec_STRICT ParamSpec_DimCheckMode = 0
	// PERMISSIVE requires only the count (num*channels*height*width) to match.
	ParamSpec_PERMISSIVE ParamSpec_DimCheckMode = 1
)

func (ParamSpec_DimCheckMode) Enum

func (ParamSpec_DimCheckMode) EnumDescriptor

func (ParamSpec_DimCheckMode) EnumDescriptor() ([]byte, []int)

func (ParamSpec_DimCheckMode) String

func (x ParamSpec_DimCheckMode) String() string

func (*ParamSpec_DimCheckMode) UnmarshalJSON

func (x *ParamSpec_DimCheckMode) UnmarshalJSON(data []byte) error

type ParameterParameter

type ParameterParameter struct {
	Shape *BlobShape `protobuf:"bytes,1,opt,name=shape" json:"shape,omitempty"`
}

func (*ParameterParameter) Descriptor

func (*ParameterParameter) Descriptor() ([]byte, []int)

func (*ParameterParameter) GetShape

func (m *ParameterParameter) GetShape() *BlobShape

func (*ParameterParameter) Marshal

func (m *ParameterParameter) Marshal() (dAtA []byte, err error)

func (*ParameterParameter) MarshalTo

func (m *ParameterParameter) MarshalTo(dAtA []byte) (int, error)

func (*ParameterParameter) ProtoMessage

func (*ParameterParameter) ProtoMessage()

func (*ParameterParameter) Reset

func (m *ParameterParameter) Reset()

func (*ParameterParameter) Size

func (m *ParameterParameter) Size() (n int)

func (*ParameterParameter) String

func (m *ParameterParameter) String() string

func (*ParameterParameter) Unmarshal

func (m *ParameterParameter) Unmarshal(dAtA []byte) error

type Phase

type Phase int32
const (
	Phase_TRAIN Phase = 0
	Phase_TEST  Phase = 1
)
const Default_NetState_Phase Phase = Phase_TEST

func (Phase) Enum

func (x Phase) Enum() *Phase

func (Phase) EnumDescriptor

func (Phase) EnumDescriptor() ([]byte, []int)

func (Phase) String

func (x Phase) String() string

func (*Phase) UnmarshalJSON

func (x *Phase) UnmarshalJSON(data []byte) error

type PoolingParameter

type PoolingParameter struct {
	Pool *PoolingParameter_PoolMethod `protobuf:"varint,1,opt,name=pool,enum=caffe.PoolingParameter_PoolMethod,def=0" json:"pool,omitempty"`
	// Pad, kernel size, and stride are all given as a single value for equal
	// dimensions in height and width or as Y, X pairs.
	Pad        *uint32                  `protobuf:"varint,4,opt,name=pad,def=0" json:"pad,omitempty"`
	PadH       *uint32                  `protobuf:"varint,9,opt,name=pad_h,json=padH,def=0" json:"pad_h,omitempty"`
	PadW       *uint32                  `protobuf:"varint,10,opt,name=pad_w,json=padW,def=0" json:"pad_w,omitempty"`
	KernelSize uint32                   `protobuf:"varint,2,opt,name=kernel_size,json=kernelSize" json:"kernel_size"`
	KernelH    uint32                   `protobuf:"varint,5,opt,name=kernel_h,json=kernelH" json:"kernel_h"`
	KernelW    uint32                   `protobuf:"varint,6,opt,name=kernel_w,json=kernelW" json:"kernel_w"`
	Stride     *uint32                  `protobuf:"varint,3,opt,name=stride,def=1" json:"stride,omitempty"`
	StrideH    uint32                   `protobuf:"varint,7,opt,name=stride_h,json=strideH" json:"stride_h"`
	StrideW    uint32                   `protobuf:"varint,8,opt,name=stride_w,json=strideW" json:"stride_w"`
	Engine     *PoolingParameter_Engine `protobuf:"varint,11,opt,name=engine,enum=caffe.PoolingParameter_Engine,def=0" json:"engine,omitempty"`
	// If global_pooling then it will pool over the size of the bottom by doing
	// kernel_h = bottom->height and kernel_w = bottom->width
	GlobalPooling *bool `protobuf:"varint,12,opt,name=global_pooling,json=globalPooling,def=0" json:"global_pooling,omitempty"`
}

func (*PoolingParameter) Descriptor

func (*PoolingParameter) Descriptor() ([]byte, []int)

func (*PoolingParameter) GetEngine

func (*PoolingParameter) GetGlobalPooling

func (m *PoolingParameter) GetGlobalPooling() bool

func (*PoolingParameter) GetKernelH

func (m *PoolingParameter) GetKernelH() uint32

func (*PoolingParameter) GetKernelSize

func (m *PoolingParameter) GetKernelSize() uint32

func (*PoolingParameter) GetKernelW

func (m *PoolingParameter) GetKernelW() uint32

func (*PoolingParameter) GetPad

func (m *PoolingParameter) GetPad() uint32

func (*PoolingParameter) GetPadH

func (m *PoolingParameter) GetPadH() uint32

func (*PoolingParameter) GetPadW

func (m *PoolingParameter) GetPadW() uint32

func (*PoolingParameter) GetPool

func (*PoolingParameter) GetStride

func (m *PoolingParameter) GetStride() uint32

func (*PoolingParameter) GetStrideH

func (m *PoolingParameter) GetStrideH() uint32

func (*PoolingParameter) GetStrideW

func (m *PoolingParameter) GetStrideW() uint32

func (*PoolingParameter) Marshal

func (m *PoolingParameter) Marshal() (dAtA []byte, err error)

func (*PoolingParameter) MarshalTo

func (m *PoolingParameter) MarshalTo(dAtA []byte) (int, error)

func (*PoolingParameter) ProtoMessage

func (*PoolingParameter) ProtoMessage()

func (*PoolingParameter) Reset

func (m *PoolingParameter) Reset()

func (*PoolingParameter) Size

func (m *PoolingParameter) Size() (n int)

func (*PoolingParameter) String

func (m *PoolingParameter) String() string

func (*PoolingParameter) Unmarshal

func (m *PoolingParameter) Unmarshal(dAtA []byte) error

type PoolingParameter_Engine

type PoolingParameter_Engine int32
const (
	PoolingParameter_DEFAULT PoolingParameter_Engine = 0
	PoolingParameter_CAFFE   PoolingParameter_Engine = 1
	PoolingParameter_CUDNN   PoolingParameter_Engine = 2
)
const Default_PoolingParameter_Engine PoolingParameter_Engine = PoolingParameter_DEFAULT

func (PoolingParameter_Engine) Enum

func (PoolingParameter_Engine) EnumDescriptor

func (PoolingParameter_Engine) EnumDescriptor() ([]byte, []int)

func (PoolingParameter_Engine) String

func (x PoolingParameter_Engine) String() string

func (*PoolingParameter_Engine) UnmarshalJSON

func (x *PoolingParameter_Engine) UnmarshalJSON(data []byte) error

type PoolingParameter_PoolMethod

type PoolingParameter_PoolMethod int32
const (
	PoolingParameter_MAX        PoolingParameter_PoolMethod = 0
	PoolingParameter_AVE        PoolingParameter_PoolMethod = 1
	PoolingParameter_STOCHASTIC PoolingParameter_PoolMethod = 2
)
const Default_PoolingParameter_Pool PoolingParameter_PoolMethod = PoolingParameter_MAX

func (PoolingParameter_PoolMethod) Enum

func (PoolingParameter_PoolMethod) EnumDescriptor

func (PoolingParameter_PoolMethod) EnumDescriptor() ([]byte, []int)

func (PoolingParameter_PoolMethod) String

func (*PoolingParameter_PoolMethod) UnmarshalJSON

func (x *PoolingParameter_PoolMethod) UnmarshalJSON(data []byte) error

type PowerParameter

type PowerParameter struct {
	// PowerLayer computes outputs y = (shift + scale * x) ^ power.
	Power *float32 `protobuf:"fixed32,1,opt,name=power,def=1" json:"power,omitempty"`
	Scale *float32 `protobuf:"fixed32,2,opt,name=scale,def=1" json:"scale,omitempty"`
	Shift *float32 `protobuf:"fixed32,3,opt,name=shift,def=0" json:"shift,omitempty"`
}

func (*PowerParameter) Descriptor

func (*PowerParameter) Descriptor() ([]byte, []int)

func (*PowerParameter) GetPower

func (m *PowerParameter) GetPower() float32

func (*PowerParameter) GetScale

func (m *PowerParameter) GetScale() float32

func (*PowerParameter) GetShift

func (m *PowerParameter) GetShift() float32

func (*PowerParameter) Marshal

func (m *PowerParameter) Marshal() (dAtA []byte, err error)

func (*PowerParameter) MarshalTo

func (m *PowerParameter) MarshalTo(dAtA []byte) (int, error)

func (*PowerParameter) ProtoMessage

func (*PowerParameter) ProtoMessage()

func (*PowerParameter) Reset

func (m *PowerParameter) Reset()

func (*PowerParameter) Size

func (m *PowerParameter) Size() (n int)

func (*PowerParameter) String

func (m *PowerParameter) String() string

func (*PowerParameter) Unmarshal

func (m *PowerParameter) Unmarshal(dAtA []byte) error

type PythonParameter

type PythonParameter struct {
	Module string `protobuf:"bytes,1,opt,name=module" json:"module"`
	Layer  string `protobuf:"bytes,2,opt,name=layer" json:"layer"`
	// This value is set to the attribute `param_str` of the `PythonLayer` object
	// in Python before calling the `setup()` method. This could be a number,
	// string, dictionary in Python dict format, JSON, etc. You may parse this
	// string in `setup` method and use it in `forward` and `backward`.
	ParamStr *string `protobuf:"bytes,3,opt,name=param_str,json=paramStr,def=" json:"param_str,omitempty"`
	// Whether this PythonLayer is shared among worker solvers during data parallelism.
	// If true, each worker solver sequentially run forward from this layer.
	// This value should be set true if you are using it as a data layer.
	ShareInParallel *bool `protobuf:"varint,4,opt,name=share_in_parallel,json=shareInParallel,def=0" json:"share_in_parallel,omitempty"`
}

func (*PythonParameter) Descriptor

func (*PythonParameter) Descriptor() ([]byte, []int)

func (*PythonParameter) GetLayer

func (m *PythonParameter) GetLayer() string

func (*PythonParameter) GetModule

func (m *PythonParameter) GetModule() string

func (*PythonParameter) GetParamStr

func (m *PythonParameter) GetParamStr() string

func (*PythonParameter) GetShareInParallel

func (m *PythonParameter) GetShareInParallel() bool

func (*PythonParameter) Marshal

func (m *PythonParameter) Marshal() (dAtA []byte, err error)

func (*PythonParameter) MarshalTo

func (m *PythonParameter) MarshalTo(dAtA []byte) (int, error)

func (*PythonParameter) ProtoMessage

func (*PythonParameter) ProtoMessage()

func (*PythonParameter) Reset

func (m *PythonParameter) Reset()

func (*PythonParameter) Size

func (m *PythonParameter) Size() (n int)

func (*PythonParameter) String

func (m *PythonParameter) String() string

func (*PythonParameter) Unmarshal

func (m *PythonParameter) Unmarshal(dAtA []byte) error

type ReLUParameter

type ReLUParameter struct {
	// Allow non-zero slope for negative inputs to speed up optimization
	// Described in:
	// Maas, A. L., Hannun, A. Y., & Ng, A. Y. (2013). Rectifier nonlinearities
	// improve neural network acoustic models. In ICML Workshop on Deep Learning
	// for Audio, Speech, and Language Processing.
	NegativeSlope *float32              `protobuf:"fixed32,1,opt,name=negative_slope,json=negativeSlope,def=0" json:"negative_slope,omitempty"`
	Engine        *ReLUParameter_Engine `protobuf:"varint,2,opt,name=engine,enum=caffe.ReLUParameter_Engine,def=0" json:"engine,omitempty"`
}

Message that stores parameters used by ReLULayer

func (*ReLUParameter) Descriptor

func (*ReLUParameter) Descriptor() ([]byte, []int)

func (*ReLUParameter) GetEngine

func (m *ReLUParameter) GetEngine() ReLUParameter_Engine

func (*ReLUParameter) GetNegativeSlope

func (m *ReLUParameter) GetNegativeSlope() float32

func (*ReLUParameter) Marshal

func (m *ReLUParameter) Marshal() (dAtA []byte, err error)

func (*ReLUParameter) MarshalTo

func (m *ReLUParameter) MarshalTo(dAtA []byte) (int, error)

func (*ReLUParameter) ProtoMessage

func (*ReLUParameter) ProtoMessage()

func (*ReLUParameter) Reset

func (m *ReLUParameter) Reset()

func (*ReLUParameter) Size

func (m *ReLUParameter) Size() (n int)

func (*ReLUParameter) String

func (m *ReLUParameter) String() string

func (*ReLUParameter) Unmarshal

func (m *ReLUParameter) Unmarshal(dAtA []byte) error

type ReLUParameter_Engine

type ReLUParameter_Engine int32
const (
	ReLUParameter_DEFAULT ReLUParameter_Engine = 0
	ReLUParameter_CAFFE   ReLUParameter_Engine = 1
	ReLUParameter_CUDNN   ReLUParameter_Engine = 2
)
const Default_ReLUParameter_Engine ReLUParameter_Engine = ReLUParameter_DEFAULT

func (ReLUParameter_Engine) Enum

func (ReLUParameter_Engine) EnumDescriptor

func (ReLUParameter_Engine) EnumDescriptor() ([]byte, []int)

func (ReLUParameter_Engine) String

func (x ReLUParameter_Engine) String() string

func (*ReLUParameter_Engine) UnmarshalJSON

func (x *ReLUParameter_Engine) UnmarshalJSON(data []byte) error

type RecurrentParameter

type RecurrentParameter struct {
	// The dimension of the output (and usually hidden state) representation --
	// must be explicitly set to non-zero.
	NumOutput    *uint32          `protobuf:"varint,1,opt,name=num_output,json=numOutput,def=0" json:"num_output,omitempty"`
	WeightFiller *FillerParameter `protobuf:"bytes,2,opt,name=weight_filler,json=weightFiller" json:"weight_filler,omitempty"`
	BiasFiller   *FillerParameter `protobuf:"bytes,3,opt,name=bias_filler,json=biasFiller" json:"bias_filler,omitempty"`
	// Whether to enable displaying debug_info in the unrolled recurrent net.
	DebugInfo *bool `protobuf:"varint,4,opt,name=debug_info,json=debugInfo,def=0" json:"debug_info,omitempty"`
	// Whether to add as additional inputs (bottoms) the initial hidden state
	// blobs, and add as additional outputs (tops) the final timestep hidden state
	// blobs.  The number of additional bottom/top blobs required depends on the
	// recurrent architecture -- e.g., 1 for RNNs, 2 for LSTMs.
	ExposeHidden *bool `protobuf:"varint,5,opt,name=expose_hidden,json=exposeHidden,def=0" json:"expose_hidden,omitempty"`
}

Message that stores parameters used by RecurrentLayer

func (*RecurrentParameter) Descriptor

func (*RecurrentParameter) Descriptor() ([]byte, []int)

func (*RecurrentParameter) GetBiasFiller

func (m *RecurrentParameter) GetBiasFiller() *FillerParameter

func (*RecurrentParameter) GetDebugInfo

func (m *RecurrentParameter) GetDebugInfo() bool

func (*RecurrentParameter) GetExposeHidden

func (m *RecurrentParameter) GetExposeHidden() bool

func (*RecurrentParameter) GetNumOutput

func (m *RecurrentParameter) GetNumOutput() uint32

func (*RecurrentParameter) GetWeightFiller

func (m *RecurrentParameter) GetWeightFiller() *FillerParameter

func (*RecurrentParameter) Marshal

func (m *RecurrentParameter) Marshal() (dAtA []byte, err error)

func (*RecurrentParameter) MarshalTo

func (m *RecurrentParameter) MarshalTo(dAtA []byte) (int, error)

func (*RecurrentParameter) ProtoMessage

func (*RecurrentParameter) ProtoMessage()

func (*RecurrentParameter) Reset

func (m *RecurrentParameter) Reset()

func (*RecurrentParameter) Size

func (m *RecurrentParameter) Size() (n int)

func (*RecurrentParameter) String

func (m *RecurrentParameter) String() string

func (*RecurrentParameter) Unmarshal

func (m *RecurrentParameter) Unmarshal(dAtA []byte) error

type ReductionParameter

type ReductionParameter struct {
	Operation *ReductionParameter_ReductionOp `protobuf:"varint,1,opt,name=operation,enum=caffe.ReductionParameter_ReductionOp,def=1" json:"operation,omitempty"`
	// The first axis to reduce to a scalar -- may be negative to index from the
	// end (e.g., -1 for the last axis).
	// (Currently, only reduction along ALL "tail" axes is supported; reduction
	// of axis M through N, where N < num_axes - 1, is unsupported.)
	// Suppose we have an n-axis bottom Blob with shape:
	//     (d0, d1, d2, ..., d(m-1), dm, d(m+1), ..., d(n-1)).
	// If axis == m, the output Blob will have shape
	//     (d0, d1, d2, ..., d(m-1)),
	// and the ReductionOp operation is performed (d0 * d1 * d2 * ... * d(m-1))
	// times, each including (dm * d(m+1) * ... * d(n-1)) individual data.
	// If axis == 0 (the default), the output Blob always has the empty shape
	// (count 1), performing reduction across the entire input --
	// often useful for creating new loss functions.
	Axis  *int32   `protobuf:"varint,2,opt,name=axis,def=0" json:"axis,omitempty"`
	Coeff *float32 `protobuf:"fixed32,3,opt,name=coeff,def=1" json:"coeff,omitempty"`
}

Message that stores parameters used by ReductionLayer

func (*ReductionParameter) Descriptor

func (*ReductionParameter) Descriptor() ([]byte, []int)

func (*ReductionParameter) GetAxis

func (m *ReductionParameter) GetAxis() int32

func (*ReductionParameter) GetCoeff

func (m *ReductionParameter) GetCoeff() float32

func (*ReductionParameter) GetOperation

func (*ReductionParameter) Marshal

func (m *ReductionParameter) Marshal() (dAtA []byte, err error)

func (*ReductionParameter) MarshalTo

func (m *ReductionParameter) MarshalTo(dAtA []byte) (int, error)

func (*ReductionParameter) ProtoMessage

func (*ReductionParameter) ProtoMessage()

func (*ReductionParameter) Reset

func (m *ReductionParameter) Reset()

func (*ReductionParameter) Size

func (m *ReductionParameter) Size() (n int)

func (*ReductionParameter) String

func (m *ReductionParameter) String() string

func (*ReductionParameter) Unmarshal

func (m *ReductionParameter) Unmarshal(dAtA []byte) error

type ReductionParameter_ReductionOp

type ReductionParameter_ReductionOp int32
const (
	ReductionParameter_SUM   ReductionParameter_ReductionOp = 1
	ReductionParameter_ASUM  ReductionParameter_ReductionOp = 2
	ReductionParameter_SUMSQ ReductionParameter_ReductionOp = 3
	ReductionParameter_MEAN  ReductionParameter_ReductionOp = 4
)
const Default_ReductionParameter_Operation ReductionParameter_ReductionOp = ReductionParameter_SUM

func (ReductionParameter_ReductionOp) Enum

func (ReductionParameter_ReductionOp) EnumDescriptor

func (ReductionParameter_ReductionOp) EnumDescriptor() ([]byte, []int)

func (ReductionParameter_ReductionOp) String

func (*ReductionParameter_ReductionOp) UnmarshalJSON

func (x *ReductionParameter_ReductionOp) UnmarshalJSON(data []byte) error

type ReshapeParameter

type ReshapeParameter struct {
	// Specify the output dimensions. If some of the dimensions are set to 0,
	// the corresponding dimension from the bottom layer is used (unchanged).
	// Exactly one dimension may be set to -1, in which case its value is
	// inferred from the count of the bottom blob and the remaining dimensions.
	// For example, suppose we want to reshape a 2D blob "input" with shape 2 x 8:
	//
	//   layer {
	//     type: "Reshape" bottom: "input" top: "output"
	//     reshape_param { ... }
	//   }
	//
	// If "input" is 2D with shape 2 x 8, then the following reshape_param
	// specifications are all equivalent, producing a 3D blob "output" with shape
	// 2 x 2 x 4:
	//
	//   reshape_param { shape { dim:  2  dim: 2  dim:  4 } }
	//   reshape_param { shape { dim:  0  dim: 2  dim:  4 } }
	//   reshape_param { shape { dim:  0  dim: 2  dim: -1 } }
	//   reshape_param { shape { dim:  0  dim:-1  dim:  4 } }
	//
	Shape *BlobShape `protobuf:"bytes,1,opt,name=shape" json:"shape,omitempty"`
	// axis and num_axes control the portion of the bottom blob's shape that are
	// replaced by (included in) the reshape. By default (axis == 0 and
	// num_axes == -1), the entire bottom blob shape is included in the reshape,
	// and hence the shape field must specify the entire output shape.
	//
	// axis may be non-zero to retain some portion of the beginning of the input
	// shape (and may be negative to index from the end; e.g., -1 to begin the
	// reshape after the last axis, including nothing in the reshape,
	// -2 to include only the last axis, etc.).
	//
	// For example, suppose "input" is a 2D blob with shape 2 x 8.
	// Then the following ReshapeLayer specifications are all equivalent,
	// producing a blob "output" with shape 2 x 2 x 4:
	//
	//   reshape_param { shape { dim: 2  dim: 2  dim: 4 } }
	//   reshape_param { shape { dim: 2  dim: 4 } axis:  1 }
	//   reshape_param { shape { dim: 2  dim: 4 } axis: -3 }
	//
	// num_axes specifies the extent of the reshape.
	// If num_axes >= 0 (and axis >= 0), the reshape will be performed only on
	// input axes in the range [axis, axis+num_axes].
	// num_axes may also be -1, the default, to include all remaining axes
	// (starting from axis).
	//
	// For example, suppose "input" is a 2D blob with shape 2 x 8.
	// Then the following ReshapeLayer specifications are equivalent,
	// producing a blob "output" with shape 1 x 2 x 8.
	//
	//   reshape_param { shape { dim:  1  dim: 2  dim:  8 } }
	//   reshape_param { shape { dim:  1  dim: 2  }  num_axes: 1 }
	//   reshape_param { shape { dim:  1  }  num_axes: 0 }
	//
	// On the other hand, these would produce output blob shape 2 x 1 x 8:
	//
	//   reshape_param { shape { dim: 2  dim: 1  dim: 8  }  }
	//   reshape_param { shape { dim: 1 }  axis: 1  num_axes: 0 }
	//
	Axis    *int32 `protobuf:"varint,2,opt,name=axis,def=0" json:"axis,omitempty"`
	NumAxes *int32 `protobuf:"varint,3,opt,name=num_axes,json=numAxes,def=-1" json:"num_axes,omitempty"`
}

func (*ReshapeParameter) Descriptor

func (*ReshapeParameter) Descriptor() ([]byte, []int)

func (*ReshapeParameter) GetAxis

func (m *ReshapeParameter) GetAxis() int32

func (*ReshapeParameter) GetNumAxes

func (m *ReshapeParameter) GetNumAxes() int32

func (*ReshapeParameter) GetShape

func (m *ReshapeParameter) GetShape() *BlobShape

func (*ReshapeParameter) Marshal

func (m *ReshapeParameter) Marshal() (dAtA []byte, err error)

func (*ReshapeParameter) MarshalTo

func (m *ReshapeParameter) MarshalTo(dAtA []byte) (int, error)

func (*ReshapeParameter) ProtoMessage

func (*ReshapeParameter) ProtoMessage()

func (*ReshapeParameter) Reset

func (m *ReshapeParameter) Reset()

func (*ReshapeParameter) Size

func (m *ReshapeParameter) Size() (n int)

func (*ReshapeParameter) String

func (m *ReshapeParameter) String() string

func (*ReshapeParameter) Unmarshal

func (m *ReshapeParameter) Unmarshal(dAtA []byte) error

type SPPParameter

type SPPParameter struct {
	PyramidHeight uint32                   `protobuf:"varint,1,opt,name=pyramid_height,json=pyramidHeight" json:"pyramid_height"`
	Pool          *SPPParameter_PoolMethod `protobuf:"varint,2,opt,name=pool,enum=caffe.SPPParameter_PoolMethod,def=0" json:"pool,omitempty"`
	Engine        *SPPParameter_Engine     `protobuf:"varint,6,opt,name=engine,enum=caffe.SPPParameter_Engine,def=0" json:"engine,omitempty"`
}

func (*SPPParameter) Descriptor

func (*SPPParameter) Descriptor() ([]byte, []int)

func (*SPPParameter) GetEngine

func (m *SPPParameter) GetEngine() SPPParameter_Engine

func (*SPPParameter) GetPool

func (*SPPParameter) GetPyramidHeight

func (m *SPPParameter) GetPyramidHeight() uint32

func (*SPPParameter) Marshal

func (m *SPPParameter) Marshal() (dAtA []byte, err error)

func (*SPPParameter) MarshalTo

func (m *SPPParameter) MarshalTo(dAtA []byte) (int, error)

func (*SPPParameter) ProtoMessage

func (*SPPParameter) ProtoMessage()

func (*SPPParameter) Reset

func (m *SPPParameter) Reset()

func (*SPPParameter) Size

func (m *SPPParameter) Size() (n int)

func (*SPPParameter) String

func (m *SPPParameter) String() string

func (*SPPParameter) Unmarshal

func (m *SPPParameter) Unmarshal(dAtA []byte) error

type SPPParameter_Engine

type SPPParameter_Engine int32
const (
	SPPParameter_DEFAULT SPPParameter_Engine = 0
	SPPParameter_CAFFE   SPPParameter_Engine = 1
	SPPParameter_CUDNN   SPPParameter_Engine = 2
)
const Default_SPPParameter_Engine SPPParameter_Engine = SPPParameter_DEFAULT

func (SPPParameter_Engine) Enum

func (SPPParameter_Engine) EnumDescriptor

func (SPPParameter_Engine) EnumDescriptor() ([]byte, []int)

func (SPPParameter_Engine) String

func (x SPPParameter_Engine) String() string

func (*SPPParameter_Engine) UnmarshalJSON

func (x *SPPParameter_Engine) UnmarshalJSON(data []byte) error

type SPPParameter_PoolMethod

type SPPParameter_PoolMethod int32
const (
	SPPParameter_MAX        SPPParameter_PoolMethod = 0
	SPPParameter_AVE        SPPParameter_PoolMethod = 1
	SPPParameter_STOCHASTIC SPPParameter_PoolMethod = 2
)
const Default_SPPParameter_Pool SPPParameter_PoolMethod = SPPParameter_MAX

func (SPPParameter_PoolMethod) Enum

func (SPPParameter_PoolMethod) EnumDescriptor

func (SPPParameter_PoolMethod) EnumDescriptor() ([]byte, []int)

func (SPPParameter_PoolMethod) String

func (x SPPParameter_PoolMethod) String() string

func (*SPPParameter_PoolMethod) UnmarshalJSON

func (x *SPPParameter_PoolMethod) UnmarshalJSON(data []byte) error

type ScaleParameter

type ScaleParameter struct {
	// The first axis of bottom[0] (the first input Blob) along which to apply
	// bottom[1] (the second input Blob).  May be negative to index from the end
	// (e.g., -1 for the last axis).
	//
	// For example, if bottom[0] is 4D with shape 100x3x40x60, the output
	// top[0] will have the same shape, and bottom[1] may have any of the
	// following shapes (for the given value of axis):
	//    (axis == 0 == -4) 100; 100x3; 100x3x40; 100x3x40x60
	//    (axis == 1 == -3)          3;     3x40;     3x40x60
	//    (axis == 2 == -2)                   40;       40x60
	//    (axis == 3 == -1)                                60
	// Furthermore, bottom[1] may have the empty shape (regardless of the value of
	// "axis") -- a scalar multiplier.
	Axis *int32 `protobuf:"varint,1,opt,name=axis,def=1" json:"axis,omitempty"`
	// (num_axes is ignored unless just one bottom is given and the scale is
	// a learned parameter of the layer.  Otherwise, num_axes is determined by the
	// number of axes by the second bottom.)
	// The number of axes of the input (bottom[0]) covered by the scale
	// parameter, or -1 to cover all axes of bottom[0] starting from `axis`.
	// Set num_axes := 0, to multiply with a zero-axis Blob: a scalar.
	NumAxes *int32 `protobuf:"varint,2,opt,name=num_axes,json=numAxes,def=1" json:"num_axes,omitempty"`
	// (filler is ignored unless just one bottom is given and the scale is
	// a learned parameter of the layer.)
	// The initialization for the learned scale parameter.
	// Default is the unit (1) initialization, resulting in the ScaleLayer
	// initially performing the identity operation.
	Filler *FillerParameter `protobuf:"bytes,3,opt,name=filler" json:"filler,omitempty"`
	// Whether to also learn a bias (equivalent to a ScaleLayer+BiasLayer, but
	// may be more efficient).  Initialized with bias_filler (defaults to 0).
	BiasTerm   *bool            `protobuf:"varint,4,opt,name=bias_term,json=biasTerm,def=0" json:"bias_term,omitempty"`
	BiasFiller *FillerParameter `protobuf:"bytes,5,opt,name=bias_filler,json=biasFiller" json:"bias_filler,omitempty"`
}

func (*ScaleParameter) Descriptor

func (*ScaleParameter) Descriptor() ([]byte, []int)

func (*ScaleParameter) GetAxis

func (m *ScaleParameter) GetAxis() int32

func (*ScaleParameter) GetBiasFiller

func (m *ScaleParameter) GetBiasFiller() *FillerParameter

func (*ScaleParameter) GetBiasTerm

func (m *ScaleParameter) GetBiasTerm() bool

func (*ScaleParameter) GetFiller

func (m *ScaleParameter) GetFiller() *FillerParameter

func (*ScaleParameter) GetNumAxes

func (m *ScaleParameter) GetNumAxes() int32

func (*ScaleParameter) Marshal

func (m *ScaleParameter) Marshal() (dAtA []byte, err error)

func (*ScaleParameter) MarshalTo

func (m *ScaleParameter) MarshalTo(dAtA []byte) (int, error)

func (*ScaleParameter) ProtoMessage

func (*ScaleParameter) ProtoMessage()

func (*ScaleParameter) Reset

func (m *ScaleParameter) Reset()

func (*ScaleParameter) Size

func (m *ScaleParameter) Size() (n int)

func (*ScaleParameter) String

func (m *ScaleParameter) String() string

func (*ScaleParameter) Unmarshal

func (m *ScaleParameter) Unmarshal(dAtA []byte) error

type SigmoidParameter

type SigmoidParameter struct {
	Engine *SigmoidParameter_Engine `protobuf:"varint,1,opt,name=engine,enum=caffe.SigmoidParameter_Engine,def=0" json:"engine,omitempty"`
}

func (*SigmoidParameter) Descriptor

func (*SigmoidParameter) Descriptor() ([]byte, []int)

func (*SigmoidParameter) GetEngine

func (*SigmoidParameter) Marshal

func (m *SigmoidParameter) Marshal() (dAtA []byte, err error)

func (*SigmoidParameter) MarshalTo

func (m *SigmoidParameter) MarshalTo(dAtA []byte) (int, error)

func (*SigmoidParameter) ProtoMessage

func (*SigmoidParameter) ProtoMessage()

func (*SigmoidParameter) Reset

func (m *SigmoidParameter) Reset()

func (*SigmoidParameter) Size

func (m *SigmoidParameter) Size() (n int)

func (*SigmoidParameter) String

func (m *SigmoidParameter) String() string

func (*SigmoidParameter) Unmarshal

func (m *SigmoidParameter) Unmarshal(dAtA []byte) error

type SigmoidParameter_Engine

type SigmoidParameter_Engine int32
const (
	SigmoidParameter_DEFAULT SigmoidParameter_Engine = 0
	SigmoidParameter_CAFFE   SigmoidParameter_Engine = 1
	SigmoidParameter_CUDNN   SigmoidParameter_Engine = 2
)
const Default_SigmoidParameter_Engine SigmoidParameter_Engine = SigmoidParameter_DEFAULT

func (SigmoidParameter_Engine) Enum

func (SigmoidParameter_Engine) EnumDescriptor

func (SigmoidParameter_Engine) EnumDescriptor() ([]byte, []int)

func (SigmoidParameter_Engine) String

func (x SigmoidParameter_Engine) String() string

func (*SigmoidParameter_Engine) UnmarshalJSON

func (x *SigmoidParameter_Engine) UnmarshalJSON(data []byte) error

type SliceParameter

type SliceParameter struct {
	// The axis along which to slice -- may be negative to index from the end
	// (e.g., -1 for the last axis).
	// By default, SliceLayer concatenates blobs along the "channels" axis (1).
	Axis       *int32   `protobuf:"varint,3,opt,name=axis,def=1" json:"axis,omitempty"`
	SlicePoint []uint32 `protobuf:"varint,2,rep,name=slice_point,json=slicePoint" json:"slice_point,omitempty"`
	// DEPRECATED: alias for "axis" -- does not support negative indexing.
	SliceDim *uint32 `protobuf:"varint,1,opt,name=slice_dim,json=sliceDim,def=1" json:"slice_dim,omitempty"`
}

func (*SliceParameter) Descriptor

func (*SliceParameter) Descriptor() ([]byte, []int)

func (*SliceParameter) GetAxis

func (m *SliceParameter) GetAxis() int32

func (*SliceParameter) GetSliceDim

func (m *SliceParameter) GetSliceDim() uint32

func (*SliceParameter) GetSlicePoint

func (m *SliceParameter) GetSlicePoint() []uint32

func (*SliceParameter) Marshal

func (m *SliceParameter) Marshal() (dAtA []byte, err error)

func (*SliceParameter) MarshalTo

func (m *SliceParameter) MarshalTo(dAtA []byte) (int, error)

func (*SliceParameter) ProtoMessage

func (*SliceParameter) ProtoMessage()

func (*SliceParameter) Reset

func (m *SliceParameter) Reset()

func (*SliceParameter) Size

func (m *SliceParameter) Size() (n int)

func (*SliceParameter) String

func (m *SliceParameter) String() string

func (*SliceParameter) Unmarshal

func (m *SliceParameter) Unmarshal(dAtA []byte) error

type SoftmaxParameter

type SoftmaxParameter struct {
	Engine *SoftmaxParameter_Engine `protobuf:"varint,1,opt,name=engine,enum=caffe.SoftmaxParameter_Engine,def=0" json:"engine,omitempty"`
	// The axis along which to perform the softmax -- may be negative to index
	// from the end (e.g., -1 for the last axis).
	// Any other axes will be evaluated as independent softmaxes.
	Axis *int32 `protobuf:"varint,2,opt,name=axis,def=1" json:"axis,omitempty"`
}

Message that stores parameters used by SoftmaxLayer, SoftmaxWithLossLayer

func (*SoftmaxParameter) Descriptor

func (*SoftmaxParameter) Descriptor() ([]byte, []int)

func (*SoftmaxParameter) GetAxis

func (m *SoftmaxParameter) GetAxis() int32

func (*SoftmaxParameter) GetEngine

func (*SoftmaxParameter) Marshal

func (m *SoftmaxParameter) Marshal() (dAtA []byte, err error)

func (*SoftmaxParameter) MarshalTo

func (m *SoftmaxParameter) MarshalTo(dAtA []byte) (int, error)

func (*SoftmaxParameter) ProtoMessage

func (*SoftmaxParameter) ProtoMessage()

func (*SoftmaxParameter) Reset

func (m *SoftmaxParameter) Reset()

func (*SoftmaxParameter) Size

func (m *SoftmaxParameter) Size() (n int)

func (*SoftmaxParameter) String

func (m *SoftmaxParameter) String() string

func (*SoftmaxParameter) Unmarshal

func (m *SoftmaxParameter) Unmarshal(dAtA []byte) error

type SoftmaxParameter_Engine

type SoftmaxParameter_Engine int32
const (
	SoftmaxParameter_DEFAULT SoftmaxParameter_Engine = 0
	SoftmaxParameter_CAFFE   SoftmaxParameter_Engine = 1
	SoftmaxParameter_CUDNN   SoftmaxParameter_Engine = 2
)
const Default_SoftmaxParameter_Engine SoftmaxParameter_Engine = SoftmaxParameter_DEFAULT

func (SoftmaxParameter_Engine) Enum

func (SoftmaxParameter_Engine) EnumDescriptor

func (SoftmaxParameter_Engine) EnumDescriptor() ([]byte, []int)

func (SoftmaxParameter_Engine) String

func (x SoftmaxParameter_Engine) String() string

func (*SoftmaxParameter_Engine) UnmarshalJSON

func (x *SoftmaxParameter_Engine) UnmarshalJSON(data []byte) error

type SolverParameter

type SolverParameter struct {
	// Proto filename for the train net, possibly combined with one or more
	// test nets.
	Net string `protobuf:"bytes,24,opt,name=net" json:"net"`
	// Inline train net param, possibly combined with one or more test nets.
	NetParam      *NetParameter   `protobuf:"bytes,25,opt,name=net_param,json=netParam" json:"net_param,omitempty"`
	TrainNet      string          `protobuf:"bytes,1,opt,name=train_net,json=trainNet" json:"train_net"`
	TestNet       []string        `protobuf:"bytes,2,rep,name=test_net,json=testNet" json:"test_net,omitempty"`
	TrainNetParam *NetParameter   `protobuf:"bytes,21,opt,name=train_net_param,json=trainNetParam" json:"train_net_param,omitempty"`
	TestNetParam  []*NetParameter `protobuf:"bytes,22,rep,name=test_net_param,json=testNetParam" json:"test_net_param,omitempty"`
	// The states for the train/test nets. Must be unspecified or
	// specified once per net.
	//
	// By default, all states will have solver = true;
	// train_state will have phase = TRAIN,
	// and all test_state's will have phase = TEST.
	// Other defaults are set according to the NetState defaults.
	TrainState *NetState   `protobuf:"bytes,26,opt,name=train_state,json=trainState" json:"train_state,omitempty"`
	TestState  []*NetState `protobuf:"bytes,27,rep,name=test_state,json=testState" json:"test_state,omitempty"`
	// The number of iterations for each test net.
	TestIter []int32 `protobuf:"varint,3,rep,name=test_iter,json=testIter" json:"test_iter,omitempty"`
	// The number of iterations between two testing phases.
	TestInterval    *int32 `protobuf:"varint,4,opt,name=test_interval,json=testInterval,def=0" json:"test_interval,omitempty"`
	TestComputeLoss *bool  `protobuf:"varint,19,opt,name=test_compute_loss,json=testComputeLoss,def=0" json:"test_compute_loss,omitempty"`
	// If true, run an initial test pass before the first iteration,
	// ensuring memory availability and printing the starting value of the loss.
	TestInitialization *bool   `protobuf:"varint,32,opt,name=test_initialization,json=testInitialization,def=1" json:"test_initialization,omitempty"`
	BaseLr             float32 `protobuf:"fixed32,5,opt,name=base_lr,json=baseLr" json:"base_lr"`
	// the number of iterations between displaying info. If display = 0, no info
	// will be displayed.
	Display int32 `protobuf:"varint,6,opt,name=display" json:"display"`
	// Display the loss averaged over the last average_loss iterations
	AverageLoss *int32 `protobuf:"varint,33,opt,name=average_loss,json=averageLoss,def=1" json:"average_loss,omitempty"`
	MaxIter     int32  `protobuf:"varint,7,opt,name=max_iter,json=maxIter" json:"max_iter"`
	// accumulate gradients over `iter_size` x `batch_size` instances
	IterSize *int32 `protobuf:"varint,36,opt,name=iter_size,json=iterSize,def=1" json:"iter_size,omitempty"`
	// The learning rate decay policy. The currently implemented learning rate
	// policies are as follows:
	//    - fixed: always return base_lr.
	//    - step: return base_lr * gamma ^ (floor(iter / step))
	//    - exp: return base_lr * gamma ^ iter
	//    - inv: return base_lr * (1 + gamma * iter) ^ (- power)
	//    - multistep: similar to step but it allows non uniform steps defined by
	//      stepvalue
	//    - poly: the effective learning rate follows a polynomial decay, to be
	//      zero by the max_iter. return base_lr (1 - iter/max_iter) ^ (power)
	//    - sigmoid: the effective learning rate follows a sigmod decay
	//      return base_lr ( 1/(1 + exp(-gamma * (iter - stepsize))))
	//
	// where base_lr, max_iter, gamma, step, stepvalue and power are defined
	// in the solver parameter protocol buffer, and iter is the current iteration.
	LrPolicy    string  `protobuf:"bytes,8,opt,name=lr_policy,json=lrPolicy" json:"lr_policy"`
	Gamma       float32 `protobuf:"fixed32,9,opt,name=gamma" json:"gamma"`
	Power       float32 `protobuf:"fixed32,10,opt,name=power" json:"power"`
	Momentum    float32 `protobuf:"fixed32,11,opt,name=momentum" json:"momentum"`
	WeightDecay float32 `protobuf:"fixed32,12,opt,name=weight_decay,json=weightDecay" json:"weight_decay"`
	// regularization types supported: L1 and L2
	// controlled by weight_decay
	RegularizationType *string `protobuf:"bytes,29,opt,name=regularization_type,json=regularizationType,def=L2" json:"regularization_type,omitempty"`
	// the stepsize for learning rate policy "step"
	Stepsize int32 `protobuf:"varint,13,opt,name=stepsize" json:"stepsize"`
	// the stepsize for learning rate policy "multistep"
	Stepvalue []int32 `protobuf:"varint,34,rep,name=stepvalue" json:"stepvalue,omitempty"`
	// Set clip_gradients to >= 0 to clip parameter gradients to that L2 norm,
	// whenever their actual L2 norm is larger.
	ClipGradients  *float32 `protobuf:"fixed32,35,opt,name=clip_gradients,json=clipGradients,def=-1" json:"clip_gradients,omitempty"`
	Snapshot       *int32   `protobuf:"varint,14,opt,name=snapshot,def=0" json:"snapshot,omitempty"`
	SnapshotPrefix string   `protobuf:"bytes,15,opt,name=snapshot_prefix,json=snapshotPrefix" json:"snapshot_prefix"`
	// whether to snapshot diff in the results or not. Snapshotting diff will help
	// debugging but the final protocol buffer size will be much larger.
	SnapshotDiff   *bool                           `protobuf:"varint,16,opt,name=snapshot_diff,json=snapshotDiff,def=0" json:"snapshot_diff,omitempty"`
	SnapshotFormat *SolverParameter_SnapshotFormat `` /* 146-byte string literal not displayed */
	SolverMode     *SolverParameter_SolverMode     `` /* 130-byte string literal not displayed */
	// the device_id will that be used in GPU mode. Use device_id = 0 in default.
	DeviceId *int32 `protobuf:"varint,18,opt,name=device_id,json=deviceId,def=0" json:"device_id,omitempty"`
	// If non-negative, the seed with which the Solver will initialize the Caffe
	// random number generator -- useful for reproducible results. Otherwise,
	// (and by default) initialize using a seed derived from the system clock.
	RandomSeed *int64 `protobuf:"varint,20,opt,name=random_seed,json=randomSeed,def=-1" json:"random_seed,omitempty"`
	// type of the solver
	Type *string `protobuf:"bytes,40,opt,name=type,def=SGD" json:"type,omitempty"`
	// numerical stability for RMSProp, AdaGrad and AdaDelta and Adam
	Delta *float32 `protobuf:"fixed32,31,opt,name=delta,def=1e-08" json:"delta,omitempty"`
	// parameters for the Adam solver
	Momentum2 *float32 `protobuf:"fixed32,39,opt,name=momentum2,def=0.999" json:"momentum2,omitempty"`
	// RMSProp decay value
	// MeanSquare(t) = rms_decay*MeanSquare(t-1) + (1-rms_decay)*SquareGradient(t)
	RmsDecay float32 `protobuf:"fixed32,38,opt,name=rms_decay,json=rmsDecay" json:"rms_decay"`
	// If true, print information about the state of the net that may help with
	// debugging learning problems.
	DebugInfo *bool `protobuf:"varint,23,opt,name=debug_info,json=debugInfo,def=0" json:"debug_info,omitempty"`
	// If false, don't save a snapshot after training finishes.
	SnapshotAfterTrain *bool `protobuf:"varint,28,opt,name=snapshot_after_train,json=snapshotAfterTrain,def=1" json:"snapshot_after_train,omitempty"`
	// DEPRECATED: use type instead of solver_type
	SolverType *SolverParameter_SolverType `` /* 130-byte string literal not displayed */
}

NOTE Update the next available ID when you add a new SolverParameter field.

SolverParameter next available ID: 41 (last added: type)

func (*SolverParameter) Descriptor

func (*SolverParameter) Descriptor() ([]byte, []int)

func (*SolverParameter) GetAverageLoss

func (m *SolverParameter) GetAverageLoss() int32

func (*SolverParameter) GetBaseLr

func (m *SolverParameter) GetBaseLr() float32

func (*SolverParameter) GetClipGradients

func (m *SolverParameter) GetClipGradients() float32

func (*SolverParameter) GetDebugInfo

func (m *SolverParameter) GetDebugInfo() bool

func (*SolverParameter) GetDelta

func (m *SolverParameter) GetDelta() float32

func (*SolverParameter) GetDeviceId

func (m *SolverParameter) GetDeviceId() int32

func (*SolverParameter) GetDisplay

func (m *SolverParameter) GetDisplay() int32

func (*SolverParameter) GetGamma

func (m *SolverParameter) GetGamma() float32

func (*SolverParameter) GetIterSize

func (m *SolverParameter) GetIterSize() int32

func (*SolverParameter) GetLrPolicy

func (m *SolverParameter) GetLrPolicy() string

func (*SolverParameter) GetMaxIter

func (m *SolverParameter) GetMaxIter() int32

func (*SolverParameter) GetMomentum

func (m *SolverParameter) GetMomentum() float32

func (*SolverParameter) GetMomentum2

func (m *SolverParameter) GetMomentum2() float32

func (*SolverParameter) GetNet

func (m *SolverParameter) GetNet() string

func (*SolverParameter) GetNetParam

func (m *SolverParameter) GetNetParam() *NetParameter

func (*SolverParameter) GetPower

func (m *SolverParameter) GetPower() float32

func (*SolverParameter) GetRandomSeed

func (m *SolverParameter) GetRandomSeed() int64

func (*SolverParameter) GetRegularizationType

func (m *SolverParameter) GetRegularizationType() string

func (*SolverParameter) GetRmsDecay

func (m *SolverParameter) GetRmsDecay() float32

func (*SolverParameter) GetSnapshot

func (m *SolverParameter) GetSnapshot() int32

func (*SolverParameter) GetSnapshotAfterTrain

func (m *SolverParameter) GetSnapshotAfterTrain() bool

func (*SolverParameter) GetSnapshotDiff

func (m *SolverParameter) GetSnapshotDiff() bool

func (*SolverParameter) GetSnapshotFormat

func (m *SolverParameter) GetSnapshotFormat() SolverParameter_SnapshotFormat

func (*SolverParameter) GetSnapshotPrefix

func (m *SolverParameter) GetSnapshotPrefix() string

func (*SolverParameter) GetSolverMode

func (m *SolverParameter) GetSolverMode() SolverParameter_SolverMode

func (*SolverParameter) GetSolverType

func (m *SolverParameter) GetSolverType() SolverParameter_SolverType

func (*SolverParameter) GetStepsize

func (m *SolverParameter) GetStepsize() int32

func (*SolverParameter) GetStepvalue

func (m *SolverParameter) GetStepvalue() []int32

func (*SolverParameter) GetTestComputeLoss

func (m *SolverParameter) GetTestComputeLoss() bool

func (*SolverParameter) GetTestInitialization

func (m *SolverParameter) GetTestInitialization() bool

func (*SolverParameter) GetTestInterval

func (m *SolverParameter) GetTestInterval() int32

func (*SolverParameter) GetTestIter

func (m *SolverParameter) GetTestIter() []int32

func (*SolverParameter) GetTestNet

func (m *SolverParameter) GetTestNet() []string

func (*SolverParameter) GetTestNetParam

func (m *SolverParameter) GetTestNetParam() []*NetParameter

func (*SolverParameter) GetTestState

func (m *SolverParameter) GetTestState() []*NetState

func (*SolverParameter) GetTrainNet

func (m *SolverParameter) GetTrainNet() string

func (*SolverParameter) GetTrainNetParam

func (m *SolverParameter) GetTrainNetParam() *NetParameter

func (*SolverParameter) GetTrainState

func (m *SolverParameter) GetTrainState() *NetState

func (*SolverParameter) GetType

func (m *SolverParameter) GetType() string

func (*SolverParameter) GetWeightDecay

func (m *SolverParameter) GetWeightDecay() float32

func (*SolverParameter) Marshal

func (m *SolverParameter) Marshal() (dAtA []byte, err error)

func (*SolverParameter) MarshalTo

func (m *SolverParameter) MarshalTo(dAtA []byte) (int, error)

func (*SolverParameter) ProtoMessage

func (*SolverParameter) ProtoMessage()

func (*SolverParameter) Reset

func (m *SolverParameter) Reset()

func (*SolverParameter) Size

func (m *SolverParameter) Size() (n int)

func (*SolverParameter) String

func (m *SolverParameter) String() string

func (*SolverParameter) Unmarshal

func (m *SolverParameter) Unmarshal(dAtA []byte) error

type SolverParameter_SnapshotFormat

type SolverParameter_SnapshotFormat int32
const (
	SolverParameter_HDF5        SolverParameter_SnapshotFormat = 0
	SolverParameter_BINARYPROTO SolverParameter_SnapshotFormat = 1
)
const Default_SolverParameter_SnapshotFormat SolverParameter_SnapshotFormat = SolverParameter_BINARYPROTO

func (SolverParameter_SnapshotFormat) Enum

func (SolverParameter_SnapshotFormat) EnumDescriptor

func (SolverParameter_SnapshotFormat) EnumDescriptor() ([]byte, []int)

func (SolverParameter_SnapshotFormat) String

func (*SolverParameter_SnapshotFormat) UnmarshalJSON

func (x *SolverParameter_SnapshotFormat) UnmarshalJSON(data []byte) error

type SolverParameter_SolverMode

type SolverParameter_SolverMode int32

the mode solver will use: 0 for CPU and 1 for GPU. Use GPU in default.

const (
	SolverParameter_CPU SolverParameter_SolverMode = 0
	SolverParameter_GPU SolverParameter_SolverMode = 1
)
const Default_SolverParameter_SolverMode SolverParameter_SolverMode = SolverParameter_GPU

func (SolverParameter_SolverMode) Enum

func (SolverParameter_SolverMode) EnumDescriptor

func (SolverParameter_SolverMode) EnumDescriptor() ([]byte, []int)

func (SolverParameter_SolverMode) String

func (*SolverParameter_SolverMode) UnmarshalJSON

func (x *SolverParameter_SolverMode) UnmarshalJSON(data []byte) error

type SolverParameter_SolverType

type SolverParameter_SolverType int32

DEPRECATED: old solver enum types, use string instead

const (
	SolverParameter_SGD      SolverParameter_SolverType = 0
	SolverParameter_NESTEROV SolverParameter_SolverType = 1
	SolverParameter_ADAGRAD  SolverParameter_SolverType = 2
	SolverParameter_RMSPROP  SolverParameter_SolverType = 3
	SolverParameter_ADADELTA SolverParameter_SolverType = 4
	SolverParameter_ADAM     SolverParameter_SolverType = 5
)
const Default_SolverParameter_SolverType SolverParameter_SolverType = SolverParameter_SGD

func (SolverParameter_SolverType) Enum

func (SolverParameter_SolverType) EnumDescriptor

func (SolverParameter_SolverType) EnumDescriptor() ([]byte, []int)

func (SolverParameter_SolverType) String

func (*SolverParameter_SolverType) UnmarshalJSON

func (x *SolverParameter_SolverType) UnmarshalJSON(data []byte) error

type SolverState

type SolverState struct {
	Iter        int32        `protobuf:"varint,1,opt,name=iter" json:"iter"`
	LearnedNet  string       `protobuf:"bytes,2,opt,name=learned_net,json=learnedNet" json:"learned_net"`
	History     []*BlobProto `protobuf:"bytes,3,rep,name=history" json:"history,omitempty"`
	CurrentStep *int32       `protobuf:"varint,4,opt,name=current_step,json=currentStep,def=0" json:"current_step,omitempty"`
}

A message that stores the solver snapshots

func (*SolverState) Descriptor

func (*SolverState) Descriptor() ([]byte, []int)

func (*SolverState) GetCurrentStep

func (m *SolverState) GetCurrentStep() int32

func (*SolverState) GetHistory

func (m *SolverState) GetHistory() []*BlobProto

func (*SolverState) GetIter

func (m *SolverState) GetIter() int32

func (*SolverState) GetLearnedNet

func (m *SolverState) GetLearnedNet() string

func (*SolverState) Marshal

func (m *SolverState) Marshal() (dAtA []byte, err error)

func (*SolverState) MarshalTo

func (m *SolverState) MarshalTo(dAtA []byte) (int, error)

func (*SolverState) ProtoMessage

func (*SolverState) ProtoMessage()

func (*SolverState) Reset

func (m *SolverState) Reset()

func (*SolverState) Size

func (m *SolverState) Size() (n int)

func (*SolverState) String

func (m *SolverState) String() string

func (*SolverState) Unmarshal

func (m *SolverState) Unmarshal(dAtA []byte) error

type TanHParameter

type TanHParameter struct {
	Engine *TanHParameter_Engine `protobuf:"varint,1,opt,name=engine,enum=caffe.TanHParameter_Engine,def=0" json:"engine,omitempty"`
}

func (*TanHParameter) Descriptor

func (*TanHParameter) Descriptor() ([]byte, []int)

func (*TanHParameter) GetEngine

func (m *TanHParameter) GetEngine() TanHParameter_Engine

func (*TanHParameter) Marshal

func (m *TanHParameter) Marshal() (dAtA []byte, err error)

func (*TanHParameter) MarshalTo

func (m *TanHParameter) MarshalTo(dAtA []byte) (int, error)

func (*TanHParameter) ProtoMessage

func (*TanHParameter) ProtoMessage()

func (*TanHParameter) Reset

func (m *TanHParameter) Reset()

func (*TanHParameter) Size

func (m *TanHParameter) Size() (n int)

func (*TanHParameter) String

func (m *TanHParameter) String() string

func (*TanHParameter) Unmarshal

func (m *TanHParameter) Unmarshal(dAtA []byte) error

type TanHParameter_Engine

type TanHParameter_Engine int32
const (
	TanHParameter_DEFAULT TanHParameter_Engine = 0
	TanHParameter_CAFFE   TanHParameter_Engine = 1
	TanHParameter_CUDNN   TanHParameter_Engine = 2
)
const Default_TanHParameter_Engine TanHParameter_Engine = TanHParameter_DEFAULT

func (TanHParameter_Engine) Enum

func (TanHParameter_Engine) EnumDescriptor

func (TanHParameter_Engine) EnumDescriptor() ([]byte, []int)

func (TanHParameter_Engine) String

func (x TanHParameter_Engine) String() string

func (*TanHParameter_Engine) UnmarshalJSON

func (x *TanHParameter_Engine) UnmarshalJSON(data []byte) error

type ThresholdParameter

type ThresholdParameter struct {
	Threshold *float32 `protobuf:"fixed32,1,opt,name=threshold,def=0" json:"threshold,omitempty"`
}

Message that stores parameters used by ThresholdLayer

func (*ThresholdParameter) Descriptor

func (*ThresholdParameter) Descriptor() ([]byte, []int)

func (*ThresholdParameter) GetThreshold

func (m *ThresholdParameter) GetThreshold() float32

func (*ThresholdParameter) Marshal

func (m *ThresholdParameter) Marshal() (dAtA []byte, err error)

func (*ThresholdParameter) MarshalTo

func (m *ThresholdParameter) MarshalTo(dAtA []byte) (int, error)

func (*ThresholdParameter) ProtoMessage

func (*ThresholdParameter) ProtoMessage()

func (*ThresholdParameter) Reset

func (m *ThresholdParameter) Reset()

func (*ThresholdParameter) Size

func (m *ThresholdParameter) Size() (n int)

func (*ThresholdParameter) String

func (m *ThresholdParameter) String() string

func (*ThresholdParameter) Unmarshal

func (m *ThresholdParameter) Unmarshal(dAtA []byte) error

type TileParameter

type TileParameter struct {
	// The index of the axis to tile.
	Axis *int32 `protobuf:"varint,1,opt,name=axis,def=1" json:"axis,omitempty"`
	// The number of copies (tiles) of the blob to output.
	Tiles int32 `protobuf:"varint,2,opt,name=tiles" json:"tiles"`
}

Message that stores parameters used by TileLayer

func (*TileParameter) Descriptor

func (*TileParameter) Descriptor() ([]byte, []int)

func (*TileParameter) GetAxis

func (m *TileParameter) GetAxis() int32

func (*TileParameter) GetTiles

func (m *TileParameter) GetTiles() int32

func (*TileParameter) Marshal

func (m *TileParameter) Marshal() (dAtA []byte, err error)

func (*TileParameter) MarshalTo

func (m *TileParameter) MarshalTo(dAtA []byte) (int, error)

func (*TileParameter) ProtoMessage

func (*TileParameter) ProtoMessage()

func (*TileParameter) Reset

func (m *TileParameter) Reset()

func (*TileParameter) Size

func (m *TileParameter) Size() (n int)

func (*TileParameter) String

func (m *TileParameter) String() string

func (*TileParameter) Unmarshal

func (m *TileParameter) Unmarshal(dAtA []byte) error

type TransformationParameter

type TransformationParameter struct {
	// For data pre-processing, we can do simple scaling and subtracting the
	// data mean, if provided. Note that the mean subtraction is always carried
	// out before scaling.
	Scale *float32 `protobuf:"fixed32,1,opt,name=scale,def=1" json:"scale,omitempty"`
	// Specify if we want to randomly mirror data.
	Mirror *bool `protobuf:"varint,2,opt,name=mirror,def=0" json:"mirror,omitempty"`
	// Specify if we would like to randomly crop an image.
	CropSize *uint32 `protobuf:"varint,3,opt,name=crop_size,json=cropSize,def=0" json:"crop_size,omitempty"`
	// mean_file and mean_value cannot be specified at the same time
	MeanFile string `protobuf:"bytes,4,opt,name=mean_file,json=meanFile" json:"mean_file"`
	// if specified can be repeated once (would subtract it from all the channels)
	// or can be repeated the same number of times as channels
	// (would subtract them from the corresponding channel)
	MeanValue []float32 `protobuf:"fixed32,5,rep,name=mean_value,json=meanValue" json:"mean_value,omitempty"`
	// Force the decoded image to have 3 color channels.
	ForceColor *bool `protobuf:"varint,6,opt,name=force_color,json=forceColor,def=0" json:"force_color,omitempty"`
	// Force the decoded image to have 1 color channels.
	ForceGray *bool `protobuf:"varint,7,opt,name=force_gray,json=forceGray,def=0" json:"force_gray,omitempty"`
}

Message that stores parameters used to apply transformation to the data layer's data

func (*TransformationParameter) Descriptor

func (*TransformationParameter) Descriptor() ([]byte, []int)

func (*TransformationParameter) GetCropSize

func (m *TransformationParameter) GetCropSize() uint32

func (*TransformationParameter) GetForceColor

func (m *TransformationParameter) GetForceColor() bool

func (*TransformationParameter) GetForceGray

func (m *TransformationParameter) GetForceGray() bool

func (*TransformationParameter) GetMeanFile

func (m *TransformationParameter) GetMeanFile() string

func (*TransformationParameter) GetMeanValue

func (m *TransformationParameter) GetMeanValue() []float32

func (*TransformationParameter) GetMirror

func (m *TransformationParameter) GetMirror() bool

func (*TransformationParameter) GetScale

func (m *TransformationParameter) GetScale() float32

func (*TransformationParameter) Marshal

func (m *TransformationParameter) Marshal() (dAtA []byte, err error)

func (*TransformationParameter) MarshalTo

func (m *TransformationParameter) MarshalTo(dAtA []byte) (int, error)

func (*TransformationParameter) ProtoMessage

func (*TransformationParameter) ProtoMessage()

func (*TransformationParameter) Reset

func (m *TransformationParameter) Reset()

func (*TransformationParameter) Size

func (m *TransformationParameter) Size() (n int)

func (*TransformationParameter) String

func (m *TransformationParameter) String() string

func (*TransformationParameter) Unmarshal

func (m *TransformationParameter) Unmarshal(dAtA []byte) error

type V0LayerParameter

type V0LayerParameter struct {
	Name string `protobuf:"bytes,1,opt,name=name" json:"name"`
	Type string `protobuf:"bytes,2,opt,name=type" json:"type"`
	// Parameters to specify layers with inner products.
	NumOutput    uint32                       `protobuf:"varint,3,opt,name=num_output,json=numOutput" json:"num_output"`
	Biasterm     *bool                        `protobuf:"varint,4,opt,name=biasterm,def=1" json:"biasterm,omitempty"`
	WeightFiller *FillerParameter             `protobuf:"bytes,5,opt,name=weight_filler,json=weightFiller" json:"weight_filler,omitempty"`
	BiasFiller   *FillerParameter             `protobuf:"bytes,6,opt,name=bias_filler,json=biasFiller" json:"bias_filler,omitempty"`
	Pad          *uint32                      `protobuf:"varint,7,opt,name=pad,def=0" json:"pad,omitempty"`
	Kernelsize   uint32                       `protobuf:"varint,8,opt,name=kernelsize" json:"kernelsize"`
	Group        *uint32                      `protobuf:"varint,9,opt,name=group,def=1" json:"group,omitempty"`
	Stride       *uint32                      `protobuf:"varint,10,opt,name=stride,def=1" json:"stride,omitempty"`
	Pool         *V0LayerParameter_PoolMethod `protobuf:"varint,11,opt,name=pool,enum=caffe.V0LayerParameter_PoolMethod,def=0" json:"pool,omitempty"`
	DropoutRatio *float32                     `protobuf:"fixed32,12,opt,name=dropout_ratio,json=dropoutRatio,def=0.5" json:"dropout_ratio,omitempty"`
	LocalSize    *uint32                      `protobuf:"varint,13,opt,name=local_size,json=localSize,def=5" json:"local_size,omitempty"`
	Alpha        *float32                     `protobuf:"fixed32,14,opt,name=alpha,def=1" json:"alpha,omitempty"`
	Beta         *float32                     `protobuf:"fixed32,15,opt,name=beta,def=0.75" json:"beta,omitempty"`
	K            *float32                     `protobuf:"fixed32,22,opt,name=k,def=1" json:"k,omitempty"`
	// For data layers, specify the data source
	Source string `protobuf:"bytes,16,opt,name=source" json:"source"`
	// For data pre-processing, we can do simple scaling and subtracting the
	// data mean, if provided. Note that the mean subtraction is always carried
	// out before scaling.
	Scale    *float32 `protobuf:"fixed32,17,opt,name=scale,def=1" json:"scale,omitempty"`
	Meanfile string   `protobuf:"bytes,18,opt,name=meanfile" json:"meanfile"`
	// For data layers, specify the batch size.
	Batchsize uint32 `protobuf:"varint,19,opt,name=batchsize" json:"batchsize"`
	// For data layers, specify if we would like to randomly crop an image.
	Cropsize *uint32 `protobuf:"varint,20,opt,name=cropsize,def=0" json:"cropsize,omitempty"`
	// For data layers, specify if we want to randomly mirror data.
	Mirror *bool `protobuf:"varint,21,opt,name=mirror,def=0" json:"mirror,omitempty"`
	// The blobs containing the numeric parameters of the layer
	Blobs []*BlobProto `protobuf:"bytes,50,rep,name=blobs" json:"blobs,omitempty"`
	// The ratio that is multiplied on the global learning rate. If you want to
	// set the learning ratio for one blob, you need to set it for all blobs.
	BlobsLr []float32 `protobuf:"fixed32,51,rep,name=blobs_lr,json=blobsLr" json:"blobs_lr,omitempty"`
	// The weight decay that is multiplied on the global weight decay.
	WeightDecay []float32 `protobuf:"fixed32,52,rep,name=weight_decay,json=weightDecay" json:"weight_decay,omitempty"`
	// The rand_skip variable is for the data layer to skip a few data points
	// to avoid all asynchronous sgd clients to start at the same point. The skip
	// point would be set as rand_skip * rand(0,1). Note that rand_skip should not
	// be larger than the number of keys in the database.
	RandSkip *uint32 `protobuf:"varint,53,opt,name=rand_skip,json=randSkip,def=0" json:"rand_skip,omitempty"`
	// Fields related to detection (det_*)
	// foreground (object) overlap threshold
	DetFgThreshold *float32 `protobuf:"fixed32,54,opt,name=det_fg_threshold,json=detFgThreshold,def=0.5" json:"det_fg_threshold,omitempty"`
	// background (non-object) overlap threshold
	DetBgThreshold *float32 `protobuf:"fixed32,55,opt,name=det_bg_threshold,json=detBgThreshold,def=0.5" json:"det_bg_threshold,omitempty"`
	// Fraction of batch that should be foreground objects
	DetFgFraction *float32 `protobuf:"fixed32,56,opt,name=det_fg_fraction,json=detFgFraction,def=0.25" json:"det_fg_fraction,omitempty"`
	// Amount of contextual padding to add around a window
	// (used only by the window_data_layer)
	DetContextPad *uint32 `protobuf:"varint,58,opt,name=det_context_pad,json=detContextPad,def=0" json:"det_context_pad,omitempty"`
	// Mode for cropping out a detection window
	// warp: cropped window is warped to a fixed size and aspect ratio
	// square: the tightest square around the window is cropped
	DetCropMode *string `protobuf:"bytes,59,opt,name=det_crop_mode,json=detCropMode,def=warp" json:"det_crop_mode,omitempty"`
	// For ReshapeLayer, one needs to specify the new dimensions.
	NewNum      *int32 `protobuf:"varint,60,opt,name=new_num,json=newNum,def=0" json:"new_num,omitempty"`
	NewChannels *int32 `protobuf:"varint,61,opt,name=new_channels,json=newChannels,def=0" json:"new_channels,omitempty"`
	NewHeight   *int32 `protobuf:"varint,62,opt,name=new_height,json=newHeight,def=0" json:"new_height,omitempty"`
	NewWidth    *int32 `protobuf:"varint,63,opt,name=new_width,json=newWidth,def=0" json:"new_width,omitempty"`
	// Whether or not ImageLayer should shuffle the list of files at every epoch.
	// It will also resize images if new_height or new_width are not zero.
	ShuffleImages *bool `protobuf:"varint,64,opt,name=shuffle_images,json=shuffleImages,def=0" json:"shuffle_images,omitempty"`
	// For ConcatLayer, one needs to specify the dimension for concatenation, and
	// the other dimensions must be the same for all the bottom blobs.
	// By default it will concatenate blobs along the channels dimension.
	ConcatDim       *uint32              `protobuf:"varint,65,opt,name=concat_dim,json=concatDim,def=1" json:"concat_dim,omitempty"`
	Hdf5OutputParam *HDF5OutputParameter `protobuf:"bytes,1001,opt,name=hdf5_output_param,json=hdf5OutputParam" json:"hdf5_output_param,omitempty"`
}

DEPRECATED: V0LayerParameter is the old way of specifying layer parameters in Caffe. We keep this message type around for legacy support.

func (*V0LayerParameter) Descriptor

func (*V0LayerParameter) Descriptor() ([]byte, []int)

func (*V0LayerParameter) GetAlpha

func (m *V0LayerParameter) GetAlpha() float32

func (*V0LayerParameter) GetBatchsize

func (m *V0LayerParameter) GetBatchsize() uint32

func (*V0LayerParameter) GetBeta

func (m *V0LayerParameter) GetBeta() float32

func (*V0LayerParameter) GetBiasFiller

func (m *V0LayerParameter) GetBiasFiller() *FillerParameter

func (*V0LayerParameter) GetBiasterm

func (m *V0LayerParameter) GetBiasterm() bool

func (*V0LayerParameter) GetBlobs

func (m *V0LayerParameter) GetBlobs() []*BlobProto

func (*V0LayerParameter) GetBlobsLr

func (m *V0LayerParameter) GetBlobsLr() []float32

func (*V0LayerParameter) GetConcatDim

func (m *V0LayerParameter) GetConcatDim() uint32

func (*V0LayerParameter) GetCropsize

func (m *V0LayerParameter) GetCropsize() uint32

func (*V0LayerParameter) GetDetBgThreshold

func (m *V0LayerParameter) GetDetBgThreshold() float32

func (*V0LayerParameter) GetDetContextPad

func (m *V0LayerParameter) GetDetContextPad() uint32

func (*V0LayerParameter) GetDetCropMode

func (m *V0LayerParameter) GetDetCropMode() string

func (*V0LayerParameter) GetDetFgFraction

func (m *V0LayerParameter) GetDetFgFraction() float32

func (*V0LayerParameter) GetDetFgThreshold

func (m *V0LayerParameter) GetDetFgThreshold() float32

func (*V0LayerParameter) GetDropoutRatio

func (m *V0LayerParameter) GetDropoutRatio() float32

func (*V0LayerParameter) GetGroup

func (m *V0LayerParameter) GetGroup() uint32

func (*V0LayerParameter) GetHdf5OutputParam

func (m *V0LayerParameter) GetHdf5OutputParam() *HDF5OutputParameter

func (*V0LayerParameter) GetK

func (m *V0LayerParameter) GetK() float32

func (*V0LayerParameter) GetKernelsize

func (m *V0LayerParameter) GetKernelsize() uint32

func (*V0LayerParameter) GetLocalSize

func (m *V0LayerParameter) GetLocalSize() uint32

func (*V0LayerParameter) GetMeanfile

func (m *V0LayerParameter) GetMeanfile() string

func (*V0LayerParameter) GetMirror

func (m *V0LayerParameter) GetMirror() bool

func (*V0LayerParameter) GetName

func (m *V0LayerParameter) GetName() string

func (*V0LayerParameter) GetNewChannels

func (m *V0LayerParameter) GetNewChannels() int32

func (*V0LayerParameter) GetNewHeight

func (m *V0LayerParameter) GetNewHeight() int32

func (*V0LayerParameter) GetNewNum

func (m *V0LayerParameter) GetNewNum() int32

func (*V0LayerParameter) GetNewWidth

func (m *V0LayerParameter) GetNewWidth() int32

func (*V0LayerParameter) GetNumOutput

func (m *V0LayerParameter) GetNumOutput() uint32

func (*V0LayerParameter) GetPad

func (m *V0LayerParameter) GetPad() uint32

func (*V0LayerParameter) GetPool

func (*V0LayerParameter) GetRandSkip

func (m *V0LayerParameter) GetRandSkip() uint32

func (*V0LayerParameter) GetScale

func (m *V0LayerParameter) GetScale() float32

func (*V0LayerParameter) GetShuffleImages

func (m *V0LayerParameter) GetShuffleImages() bool

func (*V0LayerParameter) GetSource

func (m *V0LayerParameter) GetSource() string

func (*V0LayerParameter) GetStride

func (m *V0LayerParameter) GetStride() uint32

func (*V0LayerParameter) GetType

func (m *V0LayerParameter) GetType() string

func (*V0LayerParameter) GetWeightDecay

func (m *V0LayerParameter) GetWeightDecay() []float32

func (*V0LayerParameter) GetWeightFiller

func (m *V0LayerParameter) GetWeightFiller() *FillerParameter

func (*V0LayerParameter) Marshal

func (m *V0LayerParameter) Marshal() (dAtA []byte, err error)

func (*V0LayerParameter) MarshalTo

func (m *V0LayerParameter) MarshalTo(dAtA []byte) (int, error)

func (*V0LayerParameter) ProtoMessage

func (*V0LayerParameter) ProtoMessage()

func (*V0LayerParameter) Reset

func (m *V0LayerParameter) Reset()

func (*V0LayerParameter) Size

func (m *V0LayerParameter) Size() (n int)

func (*V0LayerParameter) String

func (m *V0LayerParameter) String() string

func (*V0LayerParameter) Unmarshal

func (m *V0LayerParameter) Unmarshal(dAtA []byte) error

type V0LayerParameter_PoolMethod

type V0LayerParameter_PoolMethod int32
const (
	V0LayerParameter_MAX        V0LayerParameter_PoolMethod = 0
	V0LayerParameter_AVE        V0LayerParameter_PoolMethod = 1
	V0LayerParameter_STOCHASTIC V0LayerParameter_PoolMethod = 2
)
const Default_V0LayerParameter_Pool V0LayerParameter_PoolMethod = V0LayerParameter_MAX

func (V0LayerParameter_PoolMethod) Enum

func (V0LayerParameter_PoolMethod) EnumDescriptor

func (V0LayerParameter_PoolMethod) EnumDescriptor() ([]byte, []int)

func (V0LayerParameter_PoolMethod) String

func (*V0LayerParameter_PoolMethod) UnmarshalJSON

func (x *V0LayerParameter_PoolMethod) UnmarshalJSON(data []byte) error

type V1LayerParameter

type V1LayerParameter struct {
	Bottom               []string                        `protobuf:"bytes,2,rep,name=bottom" json:"bottom,omitempty"`
	Top                  []string                        `protobuf:"bytes,3,rep,name=top" json:"top,omitempty"`
	Name                 string                          `protobuf:"bytes,4,opt,name=name" json:"name"`
	Include              []*NetStateRule                 `protobuf:"bytes,32,rep,name=include" json:"include,omitempty"`
	Exclude              []*NetStateRule                 `protobuf:"bytes,33,rep,name=exclude" json:"exclude,omitempty"`
	Type                 V1LayerParameter_LayerType      `protobuf:"varint,5,opt,name=type,enum=caffe.V1LayerParameter_LayerType" json:"type"`
	Blobs                []*BlobProto                    `protobuf:"bytes,6,rep,name=blobs" json:"blobs,omitempty"`
	Param                []string                        `protobuf:"bytes,1001,rep,name=param" json:"param,omitempty"`
	BlobShareMode        []V1LayerParameter_DimCheckMode `` /* 140-byte string literal not displayed */
	BlobsLr              []float32                       `protobuf:"fixed32,7,rep,name=blobs_lr,json=blobsLr" json:"blobs_lr,omitempty"`
	WeightDecay          []float32                       `protobuf:"fixed32,8,rep,name=weight_decay,json=weightDecay" json:"weight_decay,omitempty"`
	LossWeight           []float32                       `protobuf:"fixed32,35,rep,name=loss_weight,json=lossWeight" json:"loss_weight,omitempty"`
	AccuracyParam        *AccuracyParameter              `protobuf:"bytes,27,opt,name=accuracy_param,json=accuracyParam" json:"accuracy_param,omitempty"`
	ArgmaxParam          *ArgMaxParameter                `protobuf:"bytes,23,opt,name=argmax_param,json=argmaxParam" json:"argmax_param,omitempty"`
	ConcatParam          *ConcatParameter                `protobuf:"bytes,9,opt,name=concat_param,json=concatParam" json:"concat_param,omitempty"`
	ContrastiveLossParam *ContrastiveLossParameter       `protobuf:"bytes,40,opt,name=contrastive_loss_param,json=contrastiveLossParam" json:"contrastive_loss_param,omitempty"`
	ConvolutionParam     *ConvolutionParameter           `protobuf:"bytes,10,opt,name=convolution_param,json=convolutionParam" json:"convolution_param,omitempty"`
	DataParam            *DataParameter                  `protobuf:"bytes,11,opt,name=data_param,json=dataParam" json:"data_param,omitempty"`
	DropoutParam         *DropoutParameter               `protobuf:"bytes,12,opt,name=dropout_param,json=dropoutParam" json:"dropout_param,omitempty"`
	DummyDataParam       *DummyDataParameter             `protobuf:"bytes,26,opt,name=dummy_data_param,json=dummyDataParam" json:"dummy_data_param,omitempty"`
	EltwiseParam         *EltwiseParameter               `protobuf:"bytes,24,opt,name=eltwise_param,json=eltwiseParam" json:"eltwise_param,omitempty"`
	ExpParam             *ExpParameter                   `protobuf:"bytes,41,opt,name=exp_param,json=expParam" json:"exp_param,omitempty"`
	Hdf5DataParam        *HDF5DataParameter              `protobuf:"bytes,13,opt,name=hdf5_data_param,json=hdf5DataParam" json:"hdf5_data_param,omitempty"`
	Hdf5OutputParam      *HDF5OutputParameter            `protobuf:"bytes,14,opt,name=hdf5_output_param,json=hdf5OutputParam" json:"hdf5_output_param,omitempty"`
	HingeLossParam       *HingeLossParameter             `protobuf:"bytes,29,opt,name=hinge_loss_param,json=hingeLossParam" json:"hinge_loss_param,omitempty"`
	ImageDataParam       *ImageDataParameter             `protobuf:"bytes,15,opt,name=image_data_param,json=imageDataParam" json:"image_data_param,omitempty"`
	InfogainLossParam    *InfogainLossParameter          `protobuf:"bytes,16,opt,name=infogain_loss_param,json=infogainLossParam" json:"infogain_loss_param,omitempty"`
	InnerProductParam    *InnerProductParameter          `protobuf:"bytes,17,opt,name=inner_product_param,json=innerProductParam" json:"inner_product_param,omitempty"`
	LrnParam             *LRNParameter                   `protobuf:"bytes,18,opt,name=lrn_param,json=lrnParam" json:"lrn_param,omitempty"`
	MemoryDataParam      *MemoryDataParameter            `protobuf:"bytes,22,opt,name=memory_data_param,json=memoryDataParam" json:"memory_data_param,omitempty"`
	MvnParam             *MVNParameter                   `protobuf:"bytes,34,opt,name=mvn_param,json=mvnParam" json:"mvn_param,omitempty"`
	PoolingParam         *PoolingParameter               `protobuf:"bytes,19,opt,name=pooling_param,json=poolingParam" json:"pooling_param,omitempty"`
	PowerParam           *PowerParameter                 `protobuf:"bytes,21,opt,name=power_param,json=powerParam" json:"power_param,omitempty"`
	ReluParam            *ReLUParameter                  `protobuf:"bytes,30,opt,name=relu_param,json=reluParam" json:"relu_param,omitempty"`
	SigmoidParam         *SigmoidParameter               `protobuf:"bytes,38,opt,name=sigmoid_param,json=sigmoidParam" json:"sigmoid_param,omitempty"`
	SoftmaxParam         *SoftmaxParameter               `protobuf:"bytes,39,opt,name=softmax_param,json=softmaxParam" json:"softmax_param,omitempty"`
	SliceParam           *SliceParameter                 `protobuf:"bytes,31,opt,name=slice_param,json=sliceParam" json:"slice_param,omitempty"`
	TanhParam            *TanHParameter                  `protobuf:"bytes,37,opt,name=tanh_param,json=tanhParam" json:"tanh_param,omitempty"`
	ThresholdParam       *ThresholdParameter             `protobuf:"bytes,25,opt,name=threshold_param,json=thresholdParam" json:"threshold_param,omitempty"`
	WindowDataParam      *WindowDataParameter            `protobuf:"bytes,20,opt,name=window_data_param,json=windowDataParam" json:"window_data_param,omitempty"`
	TransformParam       *TransformationParameter        `protobuf:"bytes,36,opt,name=transform_param,json=transformParam" json:"transform_param,omitempty"`
	LossParam            *LossParameter                  `protobuf:"bytes,42,opt,name=loss_param,json=lossParam" json:"loss_param,omitempty"`
	Layer                *V0LayerParameter               `protobuf:"bytes,1,opt,name=layer" json:"layer,omitempty"`
}

DEPRECATED: use LayerParameter.

func (*V1LayerParameter) Descriptor

func (*V1LayerParameter) Descriptor() ([]byte, []int)

func (*V1LayerParameter) GetAccuracyParam

func (m *V1LayerParameter) GetAccuracyParam() *AccuracyParameter

func (*V1LayerParameter) GetArgmaxParam

func (m *V1LayerParameter) GetArgmaxParam() *ArgMaxParameter

func (*V1LayerParameter) GetBlobShareMode

func (m *V1LayerParameter) GetBlobShareMode() []V1LayerParameter_DimCheckMode

func (*V1LayerParameter) GetBlobs

func (m *V1LayerParameter) GetBlobs() []*BlobProto

func (*V1LayerParameter) GetBlobsLr

func (m *V1LayerParameter) GetBlobsLr() []float32

func (*V1LayerParameter) GetBottom

func (m *V1LayerParameter) GetBottom() []string

func (*V1LayerParameter) GetConcatParam

func (m *V1LayerParameter) GetConcatParam() *ConcatParameter

func (*V1LayerParameter) GetContrastiveLossParam

func (m *V1LayerParameter) GetContrastiveLossParam() *ContrastiveLossParameter

func (*V1LayerParameter) GetConvolutionParam

func (m *V1LayerParameter) GetConvolutionParam() *ConvolutionParameter

func (*V1LayerParameter) GetDataParam

func (m *V1LayerParameter) GetDataParam() *DataParameter

func (*V1LayerParameter) GetDropoutParam

func (m *V1LayerParameter) GetDropoutParam() *DropoutParameter

func (*V1LayerParameter) GetDummyDataParam

func (m *V1LayerParameter) GetDummyDataParam() *DummyDataParameter

func (*V1LayerParameter) GetEltwiseParam

func (m *V1LayerParameter) GetEltwiseParam() *EltwiseParameter

func (*V1LayerParameter) GetExclude

func (m *V1LayerParameter) GetExclude() []*NetStateRule

func (*V1LayerParameter) GetExpParam

func (m *V1LayerParameter) GetExpParam() *ExpParameter

func (*V1LayerParameter) GetHdf5DataParam

func (m *V1LayerParameter) GetHdf5DataParam() *HDF5DataParameter

func (*V1LayerParameter) GetHdf5OutputParam

func (m *V1LayerParameter) GetHdf5OutputParam() *HDF5OutputParameter

func (*V1LayerParameter) GetHingeLossParam

func (m *V1LayerParameter) GetHingeLossParam() *HingeLossParameter

func (*V1LayerParameter) GetImageDataParam

func (m *V1LayerParameter) GetImageDataParam() *ImageDataParameter

func (*V1LayerParameter) GetInclude

func (m *V1LayerParameter) GetInclude() []*NetStateRule

func (*V1LayerParameter) GetInfogainLossParam

func (m *V1LayerParameter) GetInfogainLossParam() *InfogainLossParameter

func (*V1LayerParameter) GetInnerProductParam

func (m *V1LayerParameter) GetInnerProductParam() *InnerProductParameter

func (*V1LayerParameter) GetLayer

func (m *V1LayerParameter) GetLayer() *V0LayerParameter

func (*V1LayerParameter) GetLossParam

func (m *V1LayerParameter) GetLossParam() *LossParameter

func (*V1LayerParameter) GetLossWeight

func (m *V1LayerParameter) GetLossWeight() []float32

func (*V1LayerParameter) GetLrnParam

func (m *V1LayerParameter) GetLrnParam() *LRNParameter

func (*V1LayerParameter) GetMemoryDataParam

func (m *V1LayerParameter) GetMemoryDataParam() *MemoryDataParameter

func (*V1LayerParameter) GetMvnParam

func (m *V1LayerParameter) GetMvnParam() *MVNParameter

func (*V1LayerParameter) GetName

func (m *V1LayerParameter) GetName() string

func (*V1LayerParameter) GetParam

func (m *V1LayerParameter) GetParam() []string

func (*V1LayerParameter) GetPoolingParam

func (m *V1LayerParameter) GetPoolingParam() *PoolingParameter

func (*V1LayerParameter) GetPowerParam

func (m *V1LayerParameter) GetPowerParam() *PowerParameter

func (*V1LayerParameter) GetReluParam

func (m *V1LayerParameter) GetReluParam() *ReLUParameter

func (*V1LayerParameter) GetSigmoidParam

func (m *V1LayerParameter) GetSigmoidParam() *SigmoidParameter

func (*V1LayerParameter) GetSliceParam

func (m *V1LayerParameter) GetSliceParam() *SliceParameter

func (*V1LayerParameter) GetSoftmaxParam

func (m *V1LayerParameter) GetSoftmaxParam() *SoftmaxParameter

func (*V1LayerParameter) GetTanhParam

func (m *V1LayerParameter) GetTanhParam() *TanHParameter

func (*V1LayerParameter) GetThresholdParam

func (m *V1LayerParameter) GetThresholdParam() *ThresholdParameter

func (*V1LayerParameter) GetTop

func (m *V1LayerParameter) GetTop() []string

func (*V1LayerParameter) GetTransformParam

func (m *V1LayerParameter) GetTransformParam() *TransformationParameter

func (*V1LayerParameter) GetType

func (*V1LayerParameter) GetWeightDecay

func (m *V1LayerParameter) GetWeightDecay() []float32

func (*V1LayerParameter) GetWindowDataParam

func (m *V1LayerParameter) GetWindowDataParam() *WindowDataParameter

func (*V1LayerParameter) Marshal

func (m *V1LayerParameter) Marshal() (dAtA []byte, err error)

func (*V1LayerParameter) MarshalTo

func (m *V1LayerParameter) MarshalTo(dAtA []byte) (int, error)

func (*V1LayerParameter) ProtoMessage

func (*V1LayerParameter) ProtoMessage()

func (*V1LayerParameter) Reset

func (m *V1LayerParameter) Reset()

func (*V1LayerParameter) Size

func (m *V1LayerParameter) Size() (n int)

func (*V1LayerParameter) String

func (m *V1LayerParameter) String() string

func (*V1LayerParameter) Unmarshal

func (m *V1LayerParameter) Unmarshal(dAtA []byte) error

type V1LayerParameter_DimCheckMode

type V1LayerParameter_DimCheckMode int32
const (
	V1LayerParameter_STRICT     V1LayerParameter_DimCheckMode = 0
	V1LayerParameter_PERMISSIVE V1LayerParameter_DimCheckMode = 1
)

func (V1LayerParameter_DimCheckMode) Enum

func (V1LayerParameter_DimCheckMode) EnumDescriptor

func (V1LayerParameter_DimCheckMode) EnumDescriptor() ([]byte, []int)

func (V1LayerParameter_DimCheckMode) String

func (*V1LayerParameter_DimCheckMode) UnmarshalJSON

func (x *V1LayerParameter_DimCheckMode) UnmarshalJSON(data []byte) error

type V1LayerParameter_LayerType

type V1LayerParameter_LayerType int32
const (
	V1LayerParameter_NONE                       V1LayerParameter_LayerType = 0
	V1LayerParameter_ABSVAL                     V1LayerParameter_LayerType = 35
	V1LayerParameter_ACCURACY                   V1LayerParameter_LayerType = 1
	V1LayerParameter_ARGMAX                     V1LayerParameter_LayerType = 30
	V1LayerParameter_BNLL                       V1LayerParameter_LayerType = 2
	V1LayerParameter_CONCAT                     V1LayerParameter_LayerType = 3
	V1LayerParameter_CONTRASTIVE_LOSS           V1LayerParameter_LayerType = 37
	V1LayerParameter_CONVOLUTION                V1LayerParameter_LayerType = 4
	V1LayerParameter_DATA                       V1LayerParameter_LayerType = 5
	V1LayerParameter_DECONVOLUTION              V1LayerParameter_LayerType = 39
	V1LayerParameter_DROPOUT                    V1LayerParameter_LayerType = 6
	V1LayerParameter_DUMMY_DATA                 V1LayerParameter_LayerType = 32
	V1LayerParameter_EUCLIDEAN_LOSS             V1LayerParameter_LayerType = 7
	V1LayerParameter_ELTWISE                    V1LayerParameter_LayerType = 25
	V1LayerParameter_EXP                        V1LayerParameter_LayerType = 38
	V1LayerParameter_FLATTEN                    V1LayerParameter_LayerType = 8
	V1LayerParameter_HDF5_DATA                  V1LayerParameter_LayerType = 9
	V1LayerParameter_HDF5_OUTPUT                V1LayerParameter_LayerType = 10
	V1LayerParameter_HINGE_LOSS                 V1LayerParameter_LayerType = 28
	V1LayerParameter_IM2COL                     V1LayerParameter_LayerType = 11
	V1LayerParameter_IMAGE_DATA                 V1LayerParameter_LayerType = 12
	V1LayerParameter_INFOGAIN_LOSS              V1LayerParameter_LayerType = 13
	V1LayerParameter_INNER_PRODUCT              V1LayerParameter_LayerType = 14
	V1LayerParameter_LRN                        V1LayerParameter_LayerType = 15
	V1LayerParameter_MEMORY_DATA                V1LayerParameter_LayerType = 29
	V1LayerParameter_MULTINOMIAL_LOGISTIC_LOSS  V1LayerParameter_LayerType = 16
	V1LayerParameter_MVN                        V1LayerParameter_LayerType = 34
	V1LayerParameter_POOLING                    V1LayerParameter_LayerType = 17
	V1LayerParameter_POWER                      V1LayerParameter_LayerType = 26
	V1LayerParameter_RELU                       V1LayerParameter_LayerType = 18
	V1LayerParameter_SIGMOID                    V1LayerParameter_LayerType = 19
	V1LayerParameter_SIGMOID_CROSS_ENTROPY_LOSS V1LayerParameter_LayerType = 27
	V1LayerParameter_SILENCE                    V1LayerParameter_LayerType = 36
	V1LayerParameter_SOFTMAX                    V1LayerParameter_LayerType = 20
	V1LayerParameter_SOFTMAX_LOSS               V1LayerParameter_LayerType = 21
	V1LayerParameter_SPLIT                      V1LayerParameter_LayerType = 22
	V1LayerParameter_SLICE                      V1LayerParameter_LayerType = 33
	V1LayerParameter_TANH                       V1LayerParameter_LayerType = 23
	V1LayerParameter_WINDOW_DATA                V1LayerParameter_LayerType = 24
	V1LayerParameter_THRESHOLD                  V1LayerParameter_LayerType = 31
)

func (V1LayerParameter_LayerType) Enum

func (V1LayerParameter_LayerType) EnumDescriptor

func (V1LayerParameter_LayerType) EnumDescriptor() ([]byte, []int)

func (V1LayerParameter_LayerType) String

func (*V1LayerParameter_LayerType) UnmarshalJSON

func (x *V1LayerParameter_LayerType) UnmarshalJSON(data []byte) error

type WindowDataParameter

type WindowDataParameter struct {
	// Specify the data source.
	Source string `protobuf:"bytes,1,opt,name=source" json:"source"`
	// For data pre-processing, we can do simple scaling and subtracting the
	// data mean, if provided. Note that the mean subtraction is always carried
	// out before scaling.
	Scale    *float32 `protobuf:"fixed32,2,opt,name=scale,def=1" json:"scale,omitempty"`
	MeanFile string   `protobuf:"bytes,3,opt,name=mean_file,json=meanFile" json:"mean_file"`
	// Specify the batch size.
	BatchSize uint32 `protobuf:"varint,4,opt,name=batch_size,json=batchSize" json:"batch_size"`
	// Specify if we would like to randomly crop an image.
	CropSize *uint32 `protobuf:"varint,5,opt,name=crop_size,json=cropSize,def=0" json:"crop_size,omitempty"`
	// Specify if we want to randomly mirror data.
	Mirror *bool `protobuf:"varint,6,opt,name=mirror,def=0" json:"mirror,omitempty"`
	// Foreground (object) overlap threshold
	FgThreshold *float32 `protobuf:"fixed32,7,opt,name=fg_threshold,json=fgThreshold,def=0.5" json:"fg_threshold,omitempty"`
	// Background (non-object) overlap threshold
	BgThreshold *float32 `protobuf:"fixed32,8,opt,name=bg_threshold,json=bgThreshold,def=0.5" json:"bg_threshold,omitempty"`
	// Fraction of batch that should be foreground objects
	FgFraction *float32 `protobuf:"fixed32,9,opt,name=fg_fraction,json=fgFraction,def=0.25" json:"fg_fraction,omitempty"`
	// Amount of contextual padding to add around a window
	// (used only by the window_data_layer)
	ContextPad *uint32 `protobuf:"varint,10,opt,name=context_pad,json=contextPad,def=0" json:"context_pad,omitempty"`
	// Mode for cropping out a detection window
	// warp: cropped window is warped to a fixed size and aspect ratio
	// square: the tightest square around the window is cropped
	CropMode *string `protobuf:"bytes,11,opt,name=crop_mode,json=cropMode,def=warp" json:"crop_mode,omitempty"`
	// cache_images: will load all images in memory for faster access
	CacheImages *bool `protobuf:"varint,12,opt,name=cache_images,json=cacheImages,def=0" json:"cache_images,omitempty"`
	// append root_folder to locate images
	RootFolder *string `protobuf:"bytes,13,opt,name=root_folder,json=rootFolder,def=" json:"root_folder,omitempty"`
}

func (*WindowDataParameter) Descriptor

func (*WindowDataParameter) Descriptor() ([]byte, []int)

func (*WindowDataParameter) GetBatchSize

func (m *WindowDataParameter) GetBatchSize() uint32

func (*WindowDataParameter) GetBgThreshold

func (m *WindowDataParameter) GetBgThreshold() float32

func (*WindowDataParameter) GetCacheImages

func (m *WindowDataParameter) GetCacheImages() bool

func (*WindowDataParameter) GetContextPad

func (m *WindowDataParameter) GetContextPad() uint32

func (*WindowDataParameter) GetCropMode

func (m *WindowDataParameter) GetCropMode() string

func (*WindowDataParameter) GetCropSize

func (m *WindowDataParameter) GetCropSize() uint32

func (*WindowDataParameter) GetFgFraction

func (m *WindowDataParameter) GetFgFraction() float32

func (*WindowDataParameter) GetFgThreshold

func (m *WindowDataParameter) GetFgThreshold() float32

func (*WindowDataParameter) GetMeanFile

func (m *WindowDataParameter) GetMeanFile() string

func (*WindowDataParameter) GetMirror

func (m *WindowDataParameter) GetMirror() bool

func (*WindowDataParameter) GetRootFolder

func (m *WindowDataParameter) GetRootFolder() string

func (*WindowDataParameter) GetScale

func (m *WindowDataParameter) GetScale() float32

func (*WindowDataParameter) GetSource

func (m *WindowDataParameter) GetSource() string

func (*WindowDataParameter) Marshal

func (m *WindowDataParameter) Marshal() (dAtA []byte, err error)

func (*WindowDataParameter) MarshalTo

func (m *WindowDataParameter) MarshalTo(dAtA []byte) (int, error)

func (*WindowDataParameter) ProtoMessage

func (*WindowDataParameter) ProtoMessage()

func (*WindowDataParameter) Reset

func (m *WindowDataParameter) Reset()

func (*WindowDataParameter) Size

func (m *WindowDataParameter) Size() (n int)

func (*WindowDataParameter) String

func (m *WindowDataParameter) String() string

func (*WindowDataParameter) Unmarshal

func (m *WindowDataParameter) Unmarshal(dAtA []byte) error

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL