public override void Dimension(MyAbstractFLayer previousLayer)
        {
            base.Dimension(previousLayer);

            m_output.Nb = m_originalLayer.PreviousLayer.Output.Nb;
            m_output.Width = m_originalLayer.PreviousLayer.Output.Width;
            m_output.Height = m_originalLayer.PreviousLayer.Output.Height;

            if (PreviousLayer.Output.Count != m_originalLayer.Output.Count)
                throw new MyFeedForwardLayerException("MirrorConvolutionLayer: input (" + PreviousLayer.Output.Size + "x" + PreviousLayer.Output.Nb + ") doesn't fit the output dimension of the referenced MyConvolutionLayer (" + m_originalLayer.Output.Size + "x" + m_originalLayer.Output.Nb + ")");

            //There are only biases since the synaptic weights are shared with the original layer
            m_bias = m_output;
        }
Example #2
0
        public override void Dimension(MyAbstractFLayer previousLayer)
        {
            base.Dimension(previousLayer);

            m_output.Nb     = m_originalLayer.PreviousLayer.Output.Nb;
            m_output.Width  = m_originalLayer.PreviousLayer.Output.Width;
            m_output.Height = m_originalLayer.PreviousLayer.Output.Height;

            if (PreviousLayer.Output.Count != m_originalLayer.Output.Count)
            {
                throw new MyFeedForwardLayerException("MirrorConvolutionLayer: input (" + PreviousLayer.Output.Size + "x" + PreviousLayer.Output.Nb + ") doesn't fit the output dimension of the referenced MyConvolutionLayer (" + m_originalLayer.Output.Size + "x" + m_originalLayer.Output.Nb + ")");
            }


            //There are only biases since the synaptic weights are shared with the original layer
            m_bias = m_output;
        }
Example #3
0
        /*
         * LAYERS
         */

        private L GetLayerById <L>(string id) where L : MyAbstractFLayer
        {
            // Check if the referenced layer exists
            if (m_layerIds.ContainsKey(id))
            {
                MyAbstractFLayer abstractLayer = m_layerIds[id];
                // Check if the referenced layer is the right type
                if (abstractLayer is L)
                {
                    return(abstractLayer as L);
                }
                else
                {
                    throw new MyXMLBuilderException("Original layer must be of type " + typeof(L).AssemblyQualifiedName);
                }
            }
            else
            {
                throw new MyXMLBuilderException("Unknown layer id \"" + id + "\"");
            }
        }
Example #4
0
        private void BuildNetworkLayer(XmlNode networkItem)
        {
            bool featureLayerFound = false;

            foreach (XmlNode layerItem in networkItem.ChildNodes)
            {
                if (layerItem.NodeType == XmlNodeType.Element)
                {
                    try
                    {
                        string layerId = null;

                        // Get the id if exist
                        foreach (XmlAttribute layerAttribute in layerItem.Attributes)
                        {
                            if (layerAttribute.Name == "id")
                            {
                                layerId = layerAttribute.Value;
                                if (m_layerIds.ContainsKey(layerId))
                                {
                                    throw new MyXMLBuilderException("Another layer already has the id \"" + layerId + "\"");
                                }

                                layerItem.Attributes.Remove(layerAttribute);
                                break;
                            }
                        }

                        MyAbstractFLayer createdLayer = null;
                        switch (layerItem.Name)
                        {
                        case "convolutionlayer":
                            createdLayer = BuildNetworkLayerConvolution(layerItem);
                            break;

                        case "poollayer":
                            createdLayer = BuildNetworkLayerPool(layerItem);
                            break;

                        case "neuronlayer":
                            createdLayer = BuildNetworkLayerNeuron(layerItem);
                            break;

                        case "neuroncopylayer":
                            createdLayer = BuildNetworkLayerNeuronCopy(layerItem);
                            break;

                        case "linearlayer":
                            createdLayer = BuildNetworkLayerLinear(layerItem);
                            break;

                        case "softmaxlayer":
                            createdLayer = BuildNetworkLayerSoftmax(layerItem);
                            break;

                        case "activationlayer":
                            createdLayer = BuildNetworkLayerActivation(layerItem);
                            break;

                        case "mirrorconvolutionlayer":
                            createdLayer = BuildNetworkLayerMirrorConvolution(layerItem);
                            break;

                        case "mirrorpoollayer":
                            createdLayer = BuildNetworkLayerMirrorPool(layerItem);
                            break;

                        case "mirrorneuronlayer":
                            createdLayer = BuildNetworkLayerMirrorNeuron(layerItem);
                            break;

                        case "featurelayer":
                            if (featureLayerFound)
                            {
                                throw new MyXMLBuilderException("The featureLayer must be unique in a network");
                            }
                            else if (m_network.Layers.Count == 0)
                            {
                                throw new MyXMLBuilderException("The featureLayer cannot be placed as fist layer");
                            }
                            else
                            {
                                m_network.FeatureLayerPosition = m_network.Layers.Count - 1;
                            }
                            break;

                        case "mirrorlinearlayer":
                            throw new MyXMLBuilderException("Layer " + layerItem.Name + " not implemented");

                        default:
                            throw new MyXMLBuilderException("Unknown layer: " + layerItem.Name);
                        }

                        // Store the created layer
                        if (layerId != null && createdLayer != null)
                        {
                            m_layerIds[layerId] = createdLayer;
                        }
                    }
                    catch (MyXMLBuilderException e)
                    {
                        throw new MyXMLBuilderException(layerItem.Name + ": " + e.Message);
                    }
                }
            }
        }