コード例 #1
0
ファイル: Builder.cs プロジェクト: yangyi-cn/Neural-Units
        public void save(string file_path_name)
        {
            FileStream stream = new FileStream(file_path_name, FileMode.Create);

            BinaryWriter writer = new BinaryWriter(stream);

            WeightLayerPool.save(writer);

            writer.Write(UnitLayers.Count);

            foreach (UnitLayer layer in UnitLayers.Values)
            {
                writer.Write(layer.Id);

                writer.Write(layer.Depth);

                writer.Write(layer.Width);

                writer.Write(layer.Height);
            }

            writer.Close();

            stream.Close();
        }
コード例 #2
0
ファイル: Builder.cs プロジェクト: yangyi-cn/Neural-Units
        public void load(string file_path_name)
        {
            FileStream stream = new FileStream(file_path_name, FileMode.Open);

            BinaryReader reader = new BinaryReader(stream);

            WeightLayerPool.load(reader);

            int count = reader.ReadInt32();

            for (int i = 0; i < count; i++)
            {
                string id = reader.ReadString();

                int depth = reader.ReadInt32();

                int width = reader.ReadInt32();

                int height = reader.ReadInt32();

                UnitLayer layer = new UnitLayer(id, width, height, depth);

                UnitLayers.Add(id, layer);
            }

            reader.Close();

            stream.Close();
        }
コード例 #3
0
ファイル: UnitLayer.cs プロジェクト: yangyi-cn/Neural-Units
        private void forward_convolute_on_depth(UnitLayer to, int stride, int depth, int length)
        {
            int to_depth = depth + length;

            if (to_depth >= to.Depth)
            {
                to_depth = to.Depth;
            }

            for (int d = depth; d < to_depth; d++)
            {
                WeightLayer weights = WeightLayerPool.find(Id, to.Id, d);

                int width_of_weights = weights.Width, height_of_weights = weights.Height;

                int width_of_units = to.Width, height_of_units = to.Height;

                for (int y = 0; y < height_of_units; y++)
                {
                    int top = y * stride;

                    int bottom = top + height_of_weights;

                    for (int x = 0; x < width_of_units; x++)
                    {
                        int left = x * stride;

                        to.set_value_at_inport(x, y, d, weights.convolute_product(left, top, left + width_of_weights, bottom, Units));
                    }
                }
            }
        }
コード例 #4
0
ファイル: UnitLayer.cs プロジェクト: yangyi-cn/Neural-Units
        private void backward_convolute_on_depth(UnitLayer to, int stride, int depth, int length)
        {
            int to_depth = depth + length;

            if (to_depth >= Depth)
            {
                to_depth = Depth;
            }

            for (int d = depth; d < to_depth; d++)
            {
                WeightLayer weights = WeightLayerPool.find(to.Id, Id, d);

                int width_of_weights = weights.Width, height_of_weights = weights.Height;

                for (int y = 0; y < Height; y++)
                {
                    int top = y * stride;

                    int bottom = top + height_of_weights;

                    for (int x = 0; x < Width; x++)
                    {
                        int left = x * stride;

                        to.diff_convolute_product(left, top, left + width_of_weights, bottom, Units[x, y, d].gradient_at_inport, weights);
                    }
                }

                weights.diff_weights();
            }
        }
コード例 #5
0
ファイル: UnitLayer.cs プロジェクト: yangyi-cn/Neural-Units
        private void backward_fully_connect_on_depth(UnitLayer to, int depth, int length)
        {
            int to_depth = depth + length;

            if (to_depth >= Depth)
            {
                to_depth = Depth;
            }

            for (int d = depth; d < to_depth; d++)
            {
                for (int y = 0; y < Height; y++)
                {
                    for (int x = 0; x < Width; x++)
                    {
                        WeightLayer weights = WeightLayerPool.find(to.Id, Id, x, y, d);

                        to.diff_fully_product(Units[x, y, d].gradient_at_inport, weights);

                        weights.diff_weights();
                    }
                }
            }
        }
コード例 #6
0
ファイル: UnitLayer.cs プロジェクト: yangyi-cn/Neural-Units
        private void forward_fully_connect_on_depth(UnitLayer to, int depth, int length)
        {
            int width = to.Width, height = to.Height;

            int to_depth = depth + length;

            if (to_depth >= to.Depth)
            {
                to_depth = to.Depth;
            }

            for (int d = depth; d < to_depth; d++)
            {
                for (int y = 0; y < height; y++)
                {
                    for (int x = 0; x < width; x++)
                    {
                        WeightLayer weights = WeightLayerPool.find(Id, to.Id, x, y, d);

                        to.set_value_at_inport(x, y, d, weights.fully_product(Units));
                    }
                }
            }
        }
コード例 #7
0
ファイル: UnitLayer.cs プロジェクト: yangyi-cn/Neural-Units
 public void create_convolution(UnitLayer to, int width, int height)
 {
     WeightLayerPool.create_convolution(this, to, width, height);
 }
コード例 #8
0
ファイル: UnitLayer.cs プロジェクト: yangyi-cn/Neural-Units
 public void create_fully_connection(UnitLayer to)
 {
     WeightLayerPool.create_fully_connection(this, to);
 }
コード例 #9
0
ファイル: UnitLayer.cs プロジェクト: yangyi-cn/Neural-Units
        public void clear_gradients()
        {
            clear_gradients_of_units();

            WeightLayerPool.clear_gradients_of_weights();
        }