   (let [io-size (:output-size previous)]
     (assoc item :input-size io-size :output-size io-size)))
 
+(defmethod build-desc :split
+  [previous item]
+  (let [retval (build-pass-through-desc previous item)
+        {:keys [branches] } retval
+        branches (mapv #(vec (rest (recurse-build-desc retval (flatten %)))) branches)]
+    (assoc retval :branches branches)))
 
 (defmethod build-desc :convolutional
   [previous item]

(defmulti build-desc (fn [result item]
                       (:type item)))

(defmethod build-desc :input
  [previous item]
  item)

  cortex.impl.layers.Softmax
  (layer->input [layer] (input (m/ecount (:output layer))))
  (layer->description [layer] (softmax))
  cortex.impl.layers.Linear
  (layer->input [layer] (input (m/column-count (:weights layer))))
  (layer->description [layer] (linear (m/row-count (:weights layer))
                                      :weights (m/clone (:weights layer))
                                      :bias (m/clone (:bias layer))))
  cortex.impl.layers.convolution.Convolutional
  (layer->input [layer] (conv-config->input (:conv-config layer)))
  (layer->description [layer] (conv-config->description (:conv-config layer)
                                                        :convolutional
                                                        (:weights layer)
                                                        (:bias layer)))
  cortex.impl.layers.convolution.Pooling
  (layer->input [layer] (conv-config->input (:conv-config layer)))
  (layer->description [layer] (conv-config->description (:conv-config layer) :max-pooling))
