{'fraction_non_alphanumeric': 0.02888045432493365, 'fraction_numerical': 0.007905025541508518, 'mean_word_length': 4.465065502183406, 'pattern_counts': {'":': 0, '<': 1, '<?xml version=': 0, '>': 2, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 1, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 5, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Learning a Fully Convolutional Network for Object Recognition using very few Data

In recent years, data-driven methods have shown great success for extracting information about the infrastruc- ture in urban areas. These algorithms are usually trained on large datasets consisting of thousands or millions of labeled training examples. While large datasets have been published regarding cars, for cyclists very few labeled data is available although appearance, point of view, and positioning of even relevant objects differ. Unfortunately, labeling data is costly and requires a huge amount of work. In this paper, we thus address the problem of learning with very few labels. The aim is to recognize particular traffic signs in crowdsourced data to collect information which is of interest to cyclists. We propose a system for object recognition that is trained with only 15 examples per class on average. To achieve this, we combine the advantages of convolutional neural networks and random forests to learn a patch-wise classifier. In the next step, we map the random forest to a neural network and transform the classifier to a fully convolutional network. Thereby, the processing of full images is significantly accelerated and bounding boxes can be predicted. Finally, we integrate data of the Global Positioning System (GPS) to localize the predictions on the map. In comparison to Faster R-CNN and other networks for object recognition or algorithms for transfer learning, we considerably reduce the required amount of labeled data. We demonstrate good performance on the recognition of traffic signs for cyclists as well as their localization in maps.


I. INTRODUCTION
Cycling as a mode of transport has attracted growing interest. Cities are transforming urban transportation to improve their infrastructure. While current development shows more and more infrastructure improvements, road conditions can vary greatly. Cyclists are frequently confronted with challenges such as absence of bicycle lanes, being overlooked by cars, or bad roads. Arising safety concerns represent a barrier for using bicycles. Thus, recommending fast and safe routes for cyclists has great potential in terms of environmental and mobility aspects. This, in turn, requires detailed information about roads and traffic regulations.
For cars, precise information has become available. Google, for example, started the Google Street View project in which data is captured by many cars. These are equipped with stereo cameras which already offer a good 3D estimation in a certain range, lidar, and other sensors. Additionally the cars provide computational power as well as power supply. In research, popular datasets like GTSRB [1], KITTI [2], and Cityscapes [3] have been published. 1 Institute for Information Processing, Leibniz University Hanover, 30167 Hanover, Germany {reinders, ackermann, rosenhahn}@tnt.uni-hannover.de 2 Scene Understanding Group, University of Twente, Netherlands michael.yang@utwente.nl Fig. 1: Real-world data has great potential to provide traffic information that is of interest to cyclists. For example, roads that are prohibited for cars but free for cyclists (left), bicycle lines in parks (middle), or bicycle boulevards which are optimized for cyclists (right). All three examples are recognized by our system.
In recent years, users are increasingly involved in the data collection. Crowdsourcing data enables to create large amount of real-world datasets. For example, the smart phone app Waze collects data such as GPS-position and speed from multiple users to predict traffic jams. OpenStreetMap aims to build a freely available map of the world to which users can easily contribute.
Machine learning techniques have shown great success for analyzing this data. While large amounts of data can be quickly collected, supervised learning further requires labeled data. Labeling data, unfortunately, is usually very time-consuming and literally expensive.
Our motivation is to collect information which is of interest to cyclists. Analyzing street data for cyclists cannot be straightforwardly done by using data captured for cars due to different perspectives, different street signs, and routes prohibited for cars but not for bicycles, as shown in Fig. 1. For collecting real-world data, we involve users by using smart phones that are attached to their bicycles. Compared to other systems like for example Google Street View our recording system consists of a single consumer camera and can only rely on a limited power supply as well as little computational power. On the other hand, our system has very low hardware costs and is highly scalable so that crowdsourcing becomes possible.
Although capturing data becomes easy with this system, generating labels is still very expensive. Thus, in this paper we further address the problem of learning with extremely few data to recognize traffic signs relevant for cyclists. We combine multiple machine learning techniques to create a system for object recognition. Convolutional neural networks (CNN) have shown to learn strong feature representations. On the other hand, random forests (RF) achieve very good results in regression and classification tasks even when few data is available. To combine both advantages we generate a feature extractor using a CNN and train a random forest based on the features. We map the random forest to a neural network and transform the full pipeline into a fully convolutional network. Thus, due to the shared features, the processing of full images is significantly accelerated. The resulting probability map is used to perform object detection. In a next step, we integrate information of a GPS-sensor to localize the detections on the map. To summarize, our contributions are: • We propose a pipeline for training a traffic sign recognition system based on convolutional neural networks, using only 15 training samples per class on average.
• We integrate GPS-information to localize the predicted traffic signs on the map.
• We collected a dataset of images of street scenes from the perspective of cyclists by crowdsourcing. The images are captured using a mobile device that is attached to the bicycle.
• Our recorded data is preprocessed directly on the mobile device. Meta data is used to keep interesting images to minimize redundancy and the amount of data.
• We will publish the dataset for training and testing, the app to capture the data, as well as the implementation of the neural network.

II. RELATED WORK
In recent years, convolutional neural networks have become the dominant approach for various tasks including classification [4], object recognition, and scene analysis [5], [6]. Girshick et al. [7] proposed a multi-stage pipeline called Regions with Convolutional Neural Networks (R-CNN) for the classification of region proposals to detect objects. It achieves good results but the pipeline is less efficient because features of each region proposal need be computed repeatedly. In SPP-net [8], this problem has been addressed by introducing a pooling strategy to calculate the feature map only once and generate features in arbitrary regions. Fast R-CNN [9] further improves the speed and accuracy by combining multiple stages. A drawback of these algorithms is their large dependence on the region proposal method. Faster R-CNN [10] combines the region proposal mechanism and a CNN classifier within a single network by introducing a Region Proposal Network. Due to shared convolutions, region proposals are generated at nearly no extra cost. Other networks such as SSD [11] directly regress bounding boxes without generating object proposals in an end-to-end network. YOLO [12] is a similar approach which is extremely fast but comes with some compromise in detection accuracy. Generally, these networks perform very well. However, they typically consist of millions of variables and for estimating those, a large amount of labeled data is required for training.
Feature learning and transferring techniques have been applied to reduce the required amount of labeled data [13]. The problem of insufficient training data has also been addressed by other works such as [14] and [15]. Moysset et al. [14] proposed a new model that predicts the bounding boxes directly. Wagner et al. [15] compared unsupervised feature learning methods and demonstrated performance boosts by pre-training. Although transfer learning techniques are applied, the networks still have a large number of variables for fine-tuning.
A different approach is the combination of random forests and neural networks. Deep Neural Decision Forests [16] unifies both in a single system that is trained end-to-end. Sethi [17] and Welbl [18] presented a mapping of random forests to neural networks. The mapping can be used for several applications. Massiceti et al. [19] demonstrated the application for camera localization. Richmond et al. [20] explored the mapping of stacked RFs to CNNs and an approximate mapping back to perform pixel-wise semantic segmentation.

III. TRAFFIC SIGN RECOGNITION
In this section, we present a system for recognizing traffic signs. To overcome the problem of lack of data, we first build a classifier that predicts the class probabilities of a single image patch. This is done in two steps. First, we train a CNN on a different dataset where large amount of data is available. Afterwards we use the generated features, extract the feature vectors, and train a random forest. The resulting classifier can be used to perform patch-wise prediction and to build a probability map for a given full image. Subsequently, all traffic signs are extracted and the recognition system outputs the class as well as the corresponding bounding box.
Finally, the processing of full images is accelerated. By mapping the random forest to a neural network, it becomes possible to combine feature generation and classification. Afterwards we transform the neural network to a fully convolutional network.

A. Feature Learning
We learn features by training a convolutional neural network CNN F . The image patch size is 32 × 32 pixels. We adopt the network architecture of Springenberg et. al [21], which yields good results on datasets like CIFAR-10, CIFAR-100, and ImageNet. Model A showed the best results for our application. To reduce the memory requirements, we decrease the number of filters in conv1 to 32, in conv2 to 64, and in conv3 to 128. The network has a simple regular structure consisting of convolutional and pooling layer. Additionally, the fully-connected layers that are usually at the end of a CNN, are replaced by 1 × 1 convolutional layers followed by an average pooling layer. Thus the output  . Each split node in the tree -indicated as circlecreates a neuron in the first hidden layer which evaluates the split rule. Each leaf node -indicated as rectangle -creates a neuron in the second hidden layer which determines the leaf membership. For example, a routing to leaf node 11 involves the split nodes (0, 8,9). The relevant connections for the corresponding calculation in the neural network are highlighted.
of the last layer has a spatial size of 1 × 1 and a depth C where C equals to the number of classes.
Because we have only few labeled data available, we train the network on the larger dataset GTSRB [1]. After training, the resulting network CNN F can be used to generate feature vectors. We pass an input image to the network and perform a forward pass. The feature vectors can be extracted from the last layer before the fully-connected or the 1×1 convolutional layers, respectively. In our network this corresponds to the third convolutional layer, denoted by CNN F relu3 (x).

B. Random Forest Classification
Random forests [22] have shown to be robust classifiers even if few data is available. A random forest consists of multiple decision trees. Each decision tree uses a randomly selected subset of features and training data. The output is calculated by averaging the individual decision tree predictions.
After creating a feature generator, we calculate the feature vector f (i) = CNN F relu3 (x (i) ) for every input vector x (i) . Based on the feature vectors we train a random forest that predicts the target values y (i) . By combining the feature generator CNN F and the random forest, we construct a classifier that predicts the class probabilities for an image patch. This classifier can be used to process a full input image patch-wise. Calculating the class probabilities for each image patch produces an output probability map.

C. RF to NN Mapping
In the following we present a method for mapping random forests to two-hidden-layer neural networks introduced by Sethi [17] and Welbl [18]. The mapping is illustrated in Fig. 2.
A decision tree consists of split nodes N Split and leaf nodes N Leaf . Each split node s ∈ N Split performs a split decision and routes a data sample x to the left child node cl(s) or to the right child node cr(s). When using axis-aligned split decisions the split rule is based on a single split feature f (s) and a threshold value θ(s): All leaf nodes l ∈ N Leaf store votes for the classes y l = (y l 1 , . . . , y l C ), where C is the number of classes. For each leaf a unique path P(l) = (s 0 , . . . , s d ) from root node s 0 to leaf l over a sequence of split nodes {s i } d i=0 exists, with l ⊆ s d ⊆ · · · ⊆ s 0 . By evaluating the split rules for each split node along the path P(l) the leaf membership can be expressed as: x ∈ l ⇐⇒ ∀s ∈ P(l) : First Hidden Layer. The first hidden layer computes all split decisions. It is constructed by creating one neuron H 1 (s) per split node evaluating the split decision x f (s) ≥ θ(s). The activation output of the neuron should behave as follows: where −1 encodes a routing to the left child node and +1 a routing to the right child node. Therefore the f (s) th neuron of the input layer is connected to neuron H 1 (s) with weight w f (s),H1(s) = c 01 , where c 01 is some constant. The bias of neuron H 1 (s) is set to b H1(s) = −c 01 · θ(s). All other weights are zero. As a result, the neuron H 1 (s) calculates the weighted input which is smaller then zero when x f (s) < θ(s) is fulfilled and greater or equal to zero otherwise. The activation function a(·) = tanh(·) maps the weighted input to a value between −1 and +1 according to the routing. The constant c 01 controls the sharpness of the transition from −1 to +1. Second Hidden Layer. The second hidden layer combines the split decisions from layer H 1 to indicate the leaf membership x ∈ l. For that one leaf neuron H 2 (l) per leaf node is created. The neuron H 2 (l) is connected to all split neurons H 1 (s) along the path s ∈ P(l) as follows where c 12 is some constant. The weights are sign matched according to the routing directions, i.e. negative when l is in the left subtree from s and positive otherwise. Thus, the activation of H 2 (l) is maximized when all split decisions routing to l are satisfied. All other weights are zero.
To encode the leaf to which a data sample x is routed, the bias is set to b H2(l) = −c 12 · (|P(l)| − 1) so that the weighted output of neuron H 2 (l) will be greater than zero when all split decisions along the path are satisfied and less then zero otherwise. By using the activation function a(·) = sigmoid(·), the active neuron H 2 (l) with x ∈ l will map close to 1 and all other neurons close to 0. Similar to c 01 , a large value for c 12 approximates a step function, whereas smaller values can relax the tree hardness.
Output Layer. The output layer contains one neuron H 3 (c) for each class and is fully-connected to the previous layer H 2 . Each neuron H 2 (l) indicates whether x ∈ l. The corresponding leaf node l in the decision tree stores the class votes y l c for each class c. To transfer the voting system, the weights are set proportional to the class votes: where c 23 is a scaling constant. All biases are set to zero. Random Forest. Extending the mapping to random forests with T decision trees is simply done by mapping each decision tree and concatenating the neurons of the constructed neural networks for each layer. The neurons for each class in the output layer are created only once. They are fullyconnected to the previous layer and by setting the constant c 23 to 1/T the outputs of all trees is averaged. We denote the resulting neural network as NN RF . It should be noted that the memory size of the mapped neural network is linear to the total number of split and leaf nodes. A possible network splitting strategy for very large random forests has been presented by Massiceti et al. [19].

D. Fully Convolutional Network
Mapping the random forest to a neural network allows us to join the feature generator and the classifier. Therefore we remove the classification layers from CNN F , i.e. all layers after relu3, and append all layers from NN RF . The constructed network CNN F+RF processes an image patch and outputs the class probabilities.
The convolutional neural network CNN F+RF is converted to a fully convolutional network CNN FCN by converting the fully-connected layers into convolutional layers, similar as [23]. The fully convolutional network operates on input images of any size and produces corresponding (possibly scaled) output maps. Compared to patch-wise processing, the classifier is naturally slided over the image evaluating the class probabilities at any position. At the same time the features are shared so that features in overlapping patches can be reused. This decreases the amount of computation and significantly accelerates the processing of full images.

E. Bounding Box Prediction
The constructed fully convolutional network processes a color image I ∈ R W ×H×3 of size W × H with three color channels and produces an output O = CNN FCN (I) with O ∈ R W ×H ×C . The output consists of C-dimensional vectors at any position which indicate the probabilities for each class. Due to stride and padding parameters, the size of the output map can be decreased. To detect objects of different sizes, we process the input image in multiple scales S = {s 1 , . . . , s m }.
We extract potential object bounding boxes by identifying all positions in the output maps where the probability is greater than a minimal threshold t min = 0.2. We describe a bounding box by is the position of the center, b w ×b h the size, b c the class, and b s the score. The bounding box size corresponds to the field of view which is equal to the size of a single image patch. All values are scaled according to the scale factor. The score b s is equal to the probability in the output map. For determining the final bounding boxes, we process the following three steps. First, we apply non-maximum suppression on the set of bounding boxes for each class to make the system more robust and accelerate the next steps. Therefore we iteratively select the bounding box with the maximum score and remove all overlapping bounding boxes. Second, traffic signs are special classes since the subject of one traffic sign can be included similarly in another traffic sign as illustrated in Fig. 3. We utilize this information by defining a list of parts that can occur in each class. A part is found when a bounding box b with the corresponding class and an Intersection over Union (IoU) greater than 0.2 exists. If this is the case we increase the score by b s · 0.2/P , where P is the number of parts. Third, we perform non-maximum suppression on the set of all bounding boxes by iteratively selecting the bounding box with the maximum score and removing all bounding boxes with IoU > 0.5.
The final predictions are determined by selecting all bounding boxes that have a score b s greater or equal than a threshold t c for the corresponding class.

IV. LOCALIZATION
In this process we integrate additional data from other sensors to determine the position and heading of the traffic signs. For localization of the traffic signs, we use the GPSposition (i lat , i lon ) and heading i h of the images. The heading is the direction to which a vehicle is pointing. The data is included in our dataset which is described in detail in Section V. As illustrated in Fig. 4

, we transform each bounding box
where (t lat , t lon ) is the position, t h the heading, and t c the class. Since the position and viewing direction of the image is known, we approximate the traffic sign position and heading by calculating the relative heading ∆t h and distance t d .
The relative heading is based on the horizontal position b x of the bounding box in the image. We calculate the horizontal Fig. 4: The detections are projected to the map by integrating additional data. Based on the position (i lat , i lon ) and heading i h of the image, the position (t lat , t lon ) and heading t h of the traffic sign are determined. To approximate the geoinformation depending on the position and size of the bounding box, the relative heading ∆t h (green) and distance t d (blue) between the image and traffic sign are calculated.
offset to the center of the image normalized by the image width i w . Additionally, we roughly estimate the angle of view α aov and multiply the value. Thereby, the relative heading is calculated by The distance t d between the position of the image and the position of the traffic sign is approximated by estimating the depth of the bounding box in the image. Traffic signs have a defined size t w × t h , where t w is the width and t h the height. Since an approximate depth estimation is sufficient, we use the information about the size and assume a simple pinhole camera model. For this, we look up the focal length f and the sensor width s w of the camera in the device data sheet. Given a bounding box with width b w we calculate the approximated distance by t d = f · t w · i w /(b w · s w ).
Lastly, a traffic sign t = (t lat , t lon , t h , t c ) is generated. The class t c equals the bounding box class and the heading is calculated by adding the relative heading to the heading of the image t h = i h + ∆t h . The traffic sign position (t lat , t lon ) is determined by moving the position of the image by t d in the direction t h .

V. DATASET
To collect data in real-world environments, smart phones are used for data recording because they can be readily attached to bicycles. Many people own a smart phone so that a large number of users can be involved. The recorded dataset consists of more than 40 000 images.

A. Data Capturing
We developed an app for data recording which can be installed onto the smart phone. Using a bicycle mount, the smart phone is attached to the bike oriented in the direction of travel. In the beginning of a cycling tour, the user starts the recording process. While cycling, the app captures images and data from multiple sensors. Images of size 1080 × 1920 pixels are taken with a rate of one image per second. Sensor data is recorded from the built-in accelerometer, gyroscope, and magnetometer with a rate of ten data points per second. Furthermore, geoinformation is added using GPS. The data is recorded as often as the GPS-data is updated.

B. Filtering
After finishing a tour, the images are filtered to reduce the amount of data. Especially monotonous routes, for example in rural areas, produce many similar images. However, the rate with which images are captured cannot be reduced because this would increase the risk of missing interesting situations.
We therefore introduce an adaptive filtering of the images. The objective is to keep images of potentially interesting situations that help to analyze traffic situations, but to remove redundant images. For instance, interesting situations could be changes in direction, traffic jams, bad road conditions, or obstructions like construction works or other road users.
For filtering, we integrate motion information and apply a twofold filtering strategy based on speed and acceleration: (i) Speed is provided by the GPS-data. We apply a derivative filter to detect decreases in speed. As filter, we use a derivative of Gaussian filter with a bandwidth of 2. (ii) Acceleration is specified per axis. Each data point consists of a three-dimensional vector. We calculate the Euclidean norm of the vector and apply two smoothing filters with different time spans: One with a large and one with a short time span. Thus, we filter the noisy acceleration data and can detect the situations where the short-term average acceleration exceeds the long-term average acceleration by a factor k. For smoothing, we use Gaussian filters with bandwidths of 1.5 and 10 and set k = 2.8. After evaluating both criteria, we filter the images by removing images if none of the two criteria indicates an interesting situation.
The filtering process reduces the amount of data by a factor of 5 on average. Subsequently, the data is transfered to a server.

VI. EXPERIMENTS
Experiments are conducted to demonstrate the performance of the traffic sign recognition system. Due to the limited amount of labeled data, the pipeline is trained on patches and then extended to perform object recognition. First, qualitative results are presented on the classification of a single patch. Afterwards, the recognition performance is illustrated. The comparison of patch-wise processing and fully convolutional processing of full images is shown in the end.
Random forests are trained and tested on a Intel(R) Xeon(R) CPU E5-2650 v3 @2.30GHz, and neural networks on a NVIDIA GeForce GTX Titan X using the Caffe [24] framework. The proposed system is programmed in Python.

A. Training and Test Data
10 different traffic signs that are interesting for cyclists are selected. Because the signs differ from traffic signs for cars, the availability of labeled data is very limited. Some classes  come with few labeled data but for some classes no labeled data is available.
To have ground truth data of our classes for training and testing, we manually annotated 297 bounding boxes of traffic signs in the images. The data is split into training set and test set using a split ratio of 50/50. In

VII. CLASSIFICATION
The first experiment is designed to evaluate the performance of the classification on patches. The evaluation is performed in two steps. First, the training for learning features is examined and, secondly, the classification on the target task.
For feature learning, the GTSRB [1] dataset is used since it is similar to our task and has a large amount of labeled data.   Fig. 7: Precision-recall curves for evaluating the recognition performance. The shape of the curves is erratic because few labeled data is available for training and testing.
In the next step, the learned features are used to generate a feature vector of each training example of our dataset, and then to train a random forest. For evaluation, the test data is processed similarly. Feature vector is generated for each example from the test set using the learned feature generator CNN F and classified by the random forest subsequently.
The random forest classification achieves an accuracy of 99.3% on the test set. The confusion matrix is shown in  Fig. 6 for more information about the traffic signs the classes correspond to.

A. Object Recognition
The next experiment is conducted to demonstrate the recognition performance of the proposed system. The task is to detect the position, size, and type of all traffic signs in an image. The images have a high diversity with respect to different perspectives, different lighting conditions, and motion blur.
The recognition system is constructed by extending the CNN for patch-wise classification to a fully convolutional network so that fast processing of full images is enabled. A filtering strategy is applied subsequently to predict bounding boxes. No additional training data is required during this process so that only 146 examples over 10 classes are used for training the recognition system. We process the images in 8 different scales. Starting with the scale s 0 = 1, the image size is decreased from scale to scale by a factor of 1.3.
To evaluate the recognition performance, we process all images in the test set and match the predicted bounding boxes with the ground truth data. Each estimated bounding box is assigned to the ground truth bounding box with the highest overlap. The overlap is measured using the IoU and only overlaps with an IoU > 0.5 are considered.
All bounding boxes come with a score and the class specific threshold t c determines if a bounding box is accepted or rejected as described in Section III-E. For each class, the threshold t c is varied, and precision and recall are calculated.    Table I. In total, the recognition system achieves a good mean average precision (mAP) of 0.686.
In the last step, the final bounding box predictions are determined. The threshold t c of each class is selected by calculating the F1 score for each precision-recall pair and choosing the threshold with the maximum F1 score. Some qualitative results are presented in Fig. 8. In each row, examples of a particular class are chosen at random. Examples that are recognized correctly are shown in the first three columns, examples that are not recognized are shown in the next two columns. Some of these examples are twisted or covered by stickers. Examples which are recognized as traffic sign but in fact belong to the background or a different class are shown in the column to the right. These bounding box patches can have a similar color or structure.

B. Computation Time
In the third experiment we evaluate the computation time. Random forests are fast at test time for the classification of a single feature vector. When processing a full image, the random forest is applied to every patch in the feature maps. For an image of size 1080 × 1920 the feature maps are produced relatively fast using CNN F and have a size of 268 × 478 so that 124 399 patches have to be classified to build the output probability map. The images are process in 8 different scales. All together, we measured an average processing time of more than 10 hours for a single image. Although, the computation time could be reduced by using a more efficient language than Python, the time to access the memory represents a bottleneck due to a large overhead for accessing and preprocessing each patch.
For processing all in one pipeline, we constructed the fully convolutional network CNN FCN . The network combines feature generation and classification and processes full images in one pass. The time for processing one image in 8 different scales is only 6.08 seconds on average. Compared to the patch-wise processing using random forest, using the fully convolutional network reduces the processing time significantly.

C. Precision of Localizations
The last experiment is designed to demonstrate the localization performance. The localization maps the predicted bounding boxes in the image to positions on the map. Position and heading of a traffic sign are calculated based on the geoinformation of the image as well as the position and size of the bounding boxes.
For evaluation, we generate ground truth data by manually labeling all traffic signs on the map that are used in our dataset. In the next step, correctly detected traffic signs are matched with the ground truth data. The distance between two GPS-positions is calculated using the haversine formula [25]. The maximal possible difference of the heading is 90 • because larger differences would show a traffic sign from the side or from the back. For each detected traffic sign, the distance and heading difference are calculated to all ground truth traffic signs. A traffic sign is assigned to the ground truth traffic sign that has the minimum distance and is within the possible viewing area of 90 • . The median of the localization error, i.e. the distance between the estimated position of the traffic sign and its ground truth position, is 6.76 m. Since the recorded GPS-data also includes the inaccuracies of each GPS-position, we can remove traffic signs which are estimated by more inaccurate GPS-positions. If traffic signs with a GPS-inaccuracy larger than the average of 3.95 m are removed, then the median of the localization error decreases to 5.95 m.
The errors of the localizations (y-axis) with respect to the GPS-inaccuracies (x-axis) are plotted in Fig. 9a. The orange dots indicate estimated positions of traffic signs. The black lines indicate the medians, the upper and bottom ends of the blue boxes the first and third quantiles. It can be seen that the localization error does not depend on the precision of the GPS-position as it does not increase with the latter. The localization errors (y-axis) with respect to the distances between the positions of the traffic signs and the GPSpositions (x-axis) are shown in Fig. 9b. It can be seen that the errors depend on the distance between traffic sign and bicycle as they increase with these distances. This can be explained by the fact that the original inaccuracies of the GPS-position are extrapolated, i.e. the larger the distances, the more the inaccuracies of the GPS-positions perturb the localizations.
Since smart phones are used as recording device, the precision of the GPS-coordinates is lower than those used in GPS-sensors integrated in cars or in high-end devices. As the inaccuracies of the GPS-positions have a large influence on the localizations, we intend to identify multiple observations of the same sign in future work. Then, the localization error could be reduced by considering multiple observations of the same traffic sign, for instance by clustering [26], [27].

VIII. CONCLUSION
In this work, we presented a system for object recognition that is trained with extremely few labeled data. We combined the advantages of convolutional neural networks and random forests to construct a fully convolutional network for predicting bounding boxes. The system is built in two steps. First, we learned features using a convolutional neural network and trained a random forest to perform patch-wise classification. Second, the random forest is mapped to a neural network and we transform the pipeline to a fully convolutional network to accelerate the processing of full images. Typically, deep learning methods are very dependent on the availability of large datasets which restricts the possible areas of application. The proposed system significantly reduces the required amount of labeled data.
We applied and evaluated the proposed system on crowdsourced data with the aim of collecting traffic information for cyclists. By developing a smart phone app, the involvement of users for collecting data was enabled. We used our system to recognize traffic signs that are relevant for cyclists. The system is trained with only 15 examples per class on average. Furthermore, we showed how additional sensor information can be used to locate traffic signs on the map.