예제 #1
0
파일: Kernel.cs 프로젝트: koryakinp/cnn
 public Kernel(int size, int depth, LearningRateAnnealerType type)
 {
     _learningRateAnnealers = new ILearningRateAnnealer[depth, size, size];
     _learningRateAnnealers.ForEach((i, j, k) => _learningRateAnnealers[i, j, k] = LearningRateAnnealerFactory.Produce(type));
     _biasLearningRateAnnealer = LearningRateAnnealerFactory.Produce(type);
     Weights  = new double[depth, size, size];
     Gradient = new double[depth, size, size];
 }
예제 #2
0
        public static ILearningRateAnnealer Produce(LearningRateAnnealerType type)
        {
            switch (type)
            {
            case LearningRateAnnealerType.Adagrad: return(new Adagrad(0.1));

            case LearningRateAnnealerType.RMSprop: return(new RMSprop(0.1, 0.99));

            default: throw new Exception("LearningRateAnnealerType is not supported");
            }
        }
예제 #3
0
        public Neuron(
            IActivator activator,
            IWeightInitializer weightInitializer,
            int numberOfConnections,
            LearningRateAnnealerType lrat)
        {
            Weights = new double[numberOfConnections];
            _learningRateAnnealers = new ILearningRateAnnealer[numberOfConnections];
            _learningRateAnnealers.ForEach((q, i) => _learningRateAnnealers[i] = LearningRateAnnealerFactory.Produce(lrat));
            _biasLearningRateAnnealer = LearningRateAnnealerFactory.Produce(lrat);

            double magnitude = 1 / Math.Sqrt(numberOfConnections);

            Weights.ForEach((q, i) => Weights[i] = weightInitializer.GenerateRandom(magnitude));
            _activator = activator;
        }
예제 #4
0
        public FullyConnectedLayer(
            IActivator activator,
            int numberOfNeurons,
            int numberOfNeuronsInPreviouseLayer,
            int layerIndex,
            IWeightInitializer weightInitializer,
            LearningRateAnnealerType lrat)
            : base(layerIndex)
        {
            _numberOfNeuronsInPreviouseLayer = numberOfNeuronsInPreviouseLayer;

            List <Neuron> neurons = new List <Neuron>();

            for (int i = 0; i < numberOfNeurons; i++)
            {
                neurons.Add(new Neuron(activator, weightInitializer, numberOfNeuronsInPreviouseLayer, lrat));
            }

            Neurons = new List <Neuron>(neurons);
        }
예제 #5
0
 public void AddConvolutionalLayer(int numberOfKernels, int kernelSize, LearningRateAnnealerType annealerType)
 {
     if (_layers.Any())
     {
         _layers.Add(new ConvolutionalLayer(
                         numberOfKernels,
                         kernelSize,
                         _layers.Last().LayerIndex + 1,
                         _layers.OfType <FilterLayer>().Last().GetOutputFilterMeta(),
                         new WeightInitializer(),
                         annealerType));
     }
     else
     {
         _layers.Add(new ConvolutionalLayer(
                         numberOfKernels,
                         kernelSize,
                         1,
                         new FilterMeta(_networkConfig.InputDimenision, _networkConfig.InputChannels),
                         new WeightInitializer(),
                         annealerType));
     }
 }
예제 #6
0
        public void AddFullyConnectedLayer(int numberOfNeurons, ActivatorType activatorType, LearningRateAnnealerType lrat)
        {
            if (!_layers.OfType <FullyConnectedLayer>().Any())
            {
                var last = _layers.OfType <FilterLayer>().Last();
                var fm   = last.GetOutputFilterMeta();
                _layers.Add(new FlattenLayer(fm.Channels, fm.Size, last.LayerIndex + 1));
            }

            _layers.Add(new FullyConnectedLayer(
                            ActivatorFactory.Produce(activatorType),
                            numberOfNeurons,
                            _layers.Last().GetNumberOfOutputValues(),
                            _layers.Last().LayerIndex + 1,
                            _weightInitializer,
                            lrat));
        }
예제 #7
0
        public ConvolutionalLayer(int nk, int ks, int li, FilterMeta ifm, IWeightInitializer wi, LearningRateAnnealerType lrat)
            : base(li, ifm)
        {
            _numberOfKernels = nk;
            _kernelSize      = ks;

            List <Kernel> temp = new List <Kernel>();

            for (int i = 0; i < _numberOfKernels; i++)
            {
                var k = new Kernel(ks, ifm.Channels, lrat);
                k.RandomizeWeights(wi);
                temp.Add(k);
            }

            _kernels     = new List <Kernel>(temp);
            _inputeFm    = ifm;
            _outputFm    = GetOutputFilterMeta();
            _featureMaps = new double[_outputFm.Channels, _outputFm.Size, _outputFm.Size];
        }