Merge remote-tracking branch 'origin/master'

.gitignore

@@ -1,2 +1,4 @@
-cmake-build-debug/*
-.idea/*
+cmake-build-debug
+.idea
+tools/TrainCNN/.idea
+tools/TrainCNN/__pycache__

CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.5)
 
-project(auto-aim)
+project(AutoAim)
 set(CMAKE_CXX_STANDARD 11)
 SET(CMAKE_BUILD_TYPE DEBUG)
 
@@ -18,11 +18,17 @@ FIND_PACKAGE(Threads)
 include_directories( ${EIGEN3_INCLUDE_DIR} )
 include_directories( ${PROJECT_SOURCE_DIR}/energy/include )
 include_directories( ${PROJECT_SOURCE_DIR}/armor/include )
-include_directories( ${PROJECT_SOURCE_DIR}/include )
+include_directories( ${PROJECT_SOURCE_DIR}/others/include )
 
-FILE(GLOB_RECURSE sourcefiles "src/*.cpp" "energy/src/*cpp" "armor/src/*.cpp")
+FILE(GLOB_RECURSE sourcefiles "others/src/*.cpp" "energy/src/*cpp" "armor/src/*.cpp")
 add_executable(run main.cpp ${sourcefiles} )
 
 TARGET_LINK_LIBRARIES(run ${CMAKE_THREAD_LIBS_INIT})
 TARGET_LINK_LIBRARIES(run ${OpenCV_LIBS})
-TARGET_LINK_LIBRARIES(run ${PROJECT_SOURCE_DIR}/libMVSDK.so)
+TARGET_LINK_LIBRARIES(run ${PROJECT_SOURCE_DIR}/others/libMVSDK.so)
+
+# Todo
+# ADD_CUSTOM_TARGET(bind-monitor COMMAND "")
+
+# Todo
+# ADD_CUSTOM_TARGET(train COMMAND "")

armor/include/armor_finder/classifier/classifier.h

@@ -32,7 +32,8 @@ private:
     MatrixXd relu(const MatrixXd &input);
     vector<vector<MatrixXd>> apply_bias(const vector<vector<MatrixXd>> &input, const vector<double> &bias);
     vector<vector<MatrixXd>> relu(const vector<vector<MatrixXd>> &input);
-    vector<vector<MatrixXd>> pool(const vector<vector<MatrixXd>> &input, int size);
+    vector<vector<MatrixXd>> max_pool(const vector<vector<MatrixXd>> &input, int size);
+    vector<vector<MatrixXd>> mean_pool(const vector<vector<MatrixXd>> &input, int size);
     vector<vector<MatrixXd>> pand(const vector<vector<MatrixXd>> &input, int val);
     MatrixXd conv(const MatrixXd &filter, const MatrixXd &input);
     vector<vector<MatrixXd>> conv2(const vector<vector<MatrixXd>> &filter, const vector<vector<MatrixXd>> &input);

armor/src/armor_finder/classifier/classifier.cpp

@@ -2,6 +2,7 @@
 // Created by xinyang on 19-4-19.
 //
 
+//#define LOG_LEVEL LOG_NONE
 #include <armor_finder/classifier/classifier.h>
 #include <log.h>
 #include <cstdio>
@@ -91,7 +92,33 @@ MatrixXd Classifier::softmax(const MatrixXd &input){
     return tmp.array().exp() / tmp.array().exp().sum();
 }
 
-vector<vector<MatrixXd>> Classifier::pool(const vector<vector<MatrixXd>> &input, int size){
+vector<vector<MatrixXd>> max_pool(const vector<vector<MatrixXd>> &input, int size){
+    vector<vector<MatrixXd>> output;
+    for(int sample=0; sample<input.size(); sample++) {
+        vector<MatrixXd> sub;
+        for (int channel = 0; channel < input[0].size(); channel++) {
+            MatrixXd tmp(input[0][0].rows() / size, input[0][0].cols() / size);
+            for (int row = 0; row < input[0][0].rows() / size; row++) {
+                for (int col = 0; col < input[0][0].cols() / size; col++) {
+                    double max = 0;
+                    for (int x = 0; x < size; x++) {
+                        for (int y = 0; y < size; y++) {
+                            if(max < input[sample][channel](row * size + x, col * size + y)){
+                                max = input[sample][channel](row * size + x, col * size + y);
+                            }
+                        }
+                    }
+                    tmp(row, col) = max;
+                }
+            }
+            sub.emplace_back(tmp);
+        }
+        output.emplace_back(sub);
+    }
+    return output;
+}
+
+vector<vector<MatrixXd>> Classifier::mean_pool(const vector<vector<MatrixXd>> &input, int size){
     vector<vector<MatrixXd>> output;
     for(int sample=0; sample<input.size(); sample++) {
         vector<MatrixXd> sub;
@@ -240,9 +267,9 @@ Classifier::Classifier(const string &folder) : state(true){
 
 MatrixXd Classifier::calculate(const vector<vector<MatrixXd>> &input) {
     vector<vector<MatrixXd>> conv1_result = relu(apply_bias(conv2(conv1_w, input), conv1_b));
-    vector<vector<MatrixXd>> pool1_result = pool(conv1_result, 2);
+    vector<vector<MatrixXd>> pool1_result = mean_pool(conv1_result, 2);
     vector<vector<MatrixXd>> conv2_result = relu(apply_bias(conv2(conv2_w, pool1_result), conv2_b));
-    vector<vector<MatrixXd>> pool2_result = pool(conv2_result, 2);
+    vector<vector<MatrixXd>> pool2_result = mean_pool(conv2_result, 2);
     MatrixXd flattened = flatten(pool2_result);
     MatrixXd y1 = fc1_w * flattened;
     y1.colwise() += fc1_b;
@@ -260,7 +287,7 @@ Classifier::operator bool() const {
 int Classifier::operator()(const cv::Mat &image) {
     MatrixXd x;
     cv2eigen(image, x);
-    x /= 255;
+    x /= 255.0;
     vector<MatrixXd> sub = {x};
     vector<vector<MatrixXd>> in = {sub};
     MatrixXd result = calculate(in);

main.cpp

@@ -4,14 +4,14 @@
 #include <iostream>
 #include <opencv2/core/core.hpp>
 
-#include "energy/energy.h"
-#include "uart/uart.h"
-#include "energy/param_struct_define.h"
-#include "energy/constant.h"
-#include "camera/camera_wrapper.h"
-#include "camera/video_wrapper.h"
-#include "camera/wrapper_head.h"
-#include "armor_finder/armor_finder.h"
+#include <energy/energy.h>
+#include <uart/uart.h>
+#include <energy/param_struct_define.h>
+#include <energy/constant.h>
+#include <camera/camera_wrapper.h>
+#include <camera/video_wrapper.h>
+#include <camera/wrapper_head.h>
+#include <armor_finder/armor_finder.h>
 #include <options/options.h>
 #include <log.h>
 

tools/TrainCNN/backward.py

@@ -0,0 +1,123 @@
+import tensorflow as tf
+from progressive.bar import Bar
+import generate
+import forward
+
+
+def save_kernal(fp, val):
+    print(val.shape[2], file=fp)
+    print(val.shape[3], file=fp)
+    print(val.shape[1], file=fp)
+    print(val.shape[0], file=fp)
+    for in_channel in range(val.shape[2]):
+        for out_channel in range(val.shape[3]):
+            for row in range(val.shape[0]):
+                for col in range(val.shape[1]):
+                    print(val[row][col][in_channel][out_channel], file=fp)
+
+
+def save_weight_mat(fp, val):
+    print(val.shape[0], file=fp)
+    print(val.shape[1], file=fp)
+    for row in range(val.shape[0]):
+        for col in range(val.shape[1]):
+            print(val[row][col], file=fp)
+
+
+def save_bias(fp, val):
+    print(val.shape[0], file=fp)
+    for i in range(val.shape[0]):
+        print(val[i], file=fp)
+
+
+def save_para(folder, paras):
+    with open(folder + "/conv1_w", "w") as fp:
+        save_kernal(fp, paras[0])
+    with open(folder + "/conv1_b", "w") as fp:
+        save_bias(fp, paras[1])
+    with open(folder + "/conv2_w", "w") as fp:
+        save_kernal(fp, paras[2])
+    with open(folder + "/conv2_b", "w") as fp:
+        save_bias(fp, paras[3])
+    with open(folder + "/fc1_w", "w") as fp:
+        save_weight_mat(fp, paras[4])
+    with open(folder + "/fc1_b", "w") as fp:
+        save_bias(fp, paras[5])
+    with open(folder + "/fc2_w", "w") as fp:
+        save_weight_mat(fp, paras[6])
+    with open(folder + "/fc2_b", "w") as fp:
+        save_bias(fp, paras[7])
+
+
+STEPS = 30000
+BATCH = 10
+LEARNING_RATE_BASE  = 0.01
+LEARNING_RATE_DECAY = 0.99
+MOVING_AVERAGE_DECAY = 0.99
+
+
+def train(dataset, show_bar=False):
+    test_images, test_labels = dataset.all_test_sets()
+
+    x = tf.placeholder(tf.float32, [None, forward.SRC_ROWS, forward.SRC_COLS, forward.SRC_CHANNELS])
+    y_= tf.placeholder(tf.float32, [None, forward.OUTPUT_NODES])
+    nodes, vars = forward.forward(0.001)
+    y = nodes[-1]
+
+    ce  = tf.nn.sparse_softmax_cross_entropy_with_logits(logits=y, labels=tf.argmax(y_, 1))
+    cem = tf.reduce_mean(ce)
+    loss= cem + tf.add_n(tf.get_collection("losses"))
+
+    global_step = tf.Variable(0, trainable=False)
+    learning_rate = tf.train.exponential_decay(
+        LEARNING_RATE_BASE,
+        global_step,
+        len(dataset.train_sets) / BATCH,
+        LEARNING_RATE_DECAY,
+        staircase=False)
+    train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss, global_step=global_step)
+
+    ema = tf.train.ExponentialMovingAverage(MOVING_AVERAGE_DECAY, global_step)
+    ema_op = ema.apply(tf.trainable_variables())
+    with tf.control_dependencies([train_step, ema_op]):
+        train_op = tf.no_op(name='train')
+
+    correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
+    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
+    acc = 0
+
+    with tf.Session() as sess:
+        init_op = tf.global_variables_initializer()
+        sess.run(init_op)
+
+        if show_bar:
+            bar = Bar(max_value=STEPS, width=u'50%')
+            bar.cursor.clear_lines(1)
+            bar.cursor.save()
+
+        for i in range(STEPS):
+            images_samples, labels_samples = dataset.sample_train_sets(BATCH)
+
+            _, loss_value, step = sess.run(
+                [train_op, loss, global_step],
+                feed_dict={x: images_samples, y_: labels_samples}
+            )
+
+            if i % 100 == 0:
+                if i % 1000 == 0:
+                    acc = sess.run(accuracy, feed_dict={x: test_images, y_: test_labels})
+
+            if show_bar:
+                bar.title = "step: %d, loss: %f, acc: %f" % (step, loss_value, acc)
+                bar.cursor.restore()
+                bar.draw(value=i+1)
+
+        vars_val = sess.run(vars)
+        save_para("paras", vars_val)
+        # nodes_val = sess.run(nodes, feed_dict={x:test})
+        # return vars_val, nodes_val
+
+
+if __name__ == "__main__":
+    dataset = generate.DataSet("images")
+    train(dataset, show_bar=True)

tools/TrainCNN/forward.py

@@ -0,0 +1,98 @@
+import tensorflow as tf
+
+
+def get_weight(shape, regularizer=None):
+    w = tf.Variable(tf.truncated_normal(shape, stddev=0.1))
+    if regularizer is None:
+        tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(regularizer)(w))
+    return w
+
+
+def get_bias(shape):
+    b = tf.Variable(tf.zeros(shape))
+    return b
+
+
+def conv2d(x, w):
+    return tf.nn.conv2d(x, w, strides=[1, 1, 1, 1], padding="VALID")
+
+
+def avg_pool_2x2(x):
+    return tf.nn.avg_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="VALID")
+
+
+def max_pool_2x2(x):
+    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding="VALID")
+
+
+# 原图像行数
+SRC_ROWS = 36
+
+# 原图像列数
+SRC_COLS = 48
+
+# 原图像通道数
+SRC_CHANNELS = 1
+
+# 第一层卷积核大小
+CONV1_KERNAL_SIZE = 5
+
+# 第一层卷积输出通道数
+CONV1_OUTPUT_CHANNELS = 8
+
+# 第二层卷积核大小
+CONV2_KERNAL_SIZE = 3
+
+# 第二层卷积输出通道数
+CONV2_OUTPUT_CHANNELS = 16
+
+# 第一层全连接宽度
+FC1_OUTPUT_NODES = 32
+
+# 第二层全连接宽度（输出标签类型数）
+FC2_OUTPUT_NODES = 8
+
+# 输出标签类型数
+OUTPUT_NODES = FC2_OUTPUT_NODES
+
+
+def forward(x, regularizer=None):
+    vars = []
+    nodes = []
+
+    conv1_w = get_weight(
+        [CONV1_KERNAL_SIZE, CONV1_KERNAL_SIZE, 1, CONV1_OUTPUT_CHANNELS]
+    )
+    conv1_b = get_bias([CONV1_OUTPUT_CHANNELS])
+    conv1   = tf.nn.relu(tf.nn.bias_add(conv2d(x, conv1_w), conv1_b))
+    pool1   = avg_pool_2x2(conv1)
+    vars.extend([conv1_w, conv1_b])
+    nodes.extend([conv1, pool1])
+
+    conv2_w = get_weight(
+        [CONV2_KERNAL_SIZE, CONV2_KERNAL_SIZE, CONV1_OUTPUT_CHANNELS, CONV2_OUTPUT_CHANNELS]
+    )
+    conv2_b = get_bias([CONV2_OUTPUT_CHANNELS])
+    conv2 = tf.nn.relu(tf.nn.bias_add(conv2d(pool1, conv2_w), conv2_b))
+    pool2 = avg_pool_2x2(conv2)
+    vars.extend([conv2_w, conv2_b])
+    nodes.extend([conv2, pool2])
+
+    pool_shape = pool2.get_shape().as_list()
+    node = pool_shape[1] * pool_shape[2] * pool_shape[3]
+    reshaped = tf.reshape(pool2, [-1, node])
+
+    fc1_w = get_weight([node, FC1_OUTPUT_NODES], regularizer)
+    fc1_b = get_bias([FC1_OUTPUT_NODES])
+    fc1   = tf.nn.relu(tf.matmul(reshaped, fc1_w) + fc1_b)
+    vars.extend([fc1_w, fc1_b])
+    nodes.extend([fc1])
+
+    fc2_w = get_weight([FC1_OUTPUT_NODES, FC2_OUTPUT_NODES], regularizer)
+    fc2_b = get_bias([FC2_OUTPUT_NODES])
+    fc2   = tf.nn.softmax(tf.matmul(fc1, fc2_w) + fc2_b)
+    vars.extend([fc2_w, fc2_b])
+    nodes.extend([fc2])
+
+    return nodes, vars
+

tools/TrainCNN/generate.py

@@ -0,0 +1,49 @@
+import numpy as np
+import os
+import cv2
+import random
+from forward import OUTPUT_NODES
+
+
+class DataSet:
+    def __init__(self, folder):
+        self.train_sets = []
+        self.test_sets = []
+        self.generate_data_sets(folder)
+
+    def generate_data_sets(self, folder):
+        def file2nparray(name):
+            image = cv2.imread(name)
+            return image[:, :, 0]
+
+        def id2label(id):
+            a = np.zeros([OUTPUT_NODES, 1])
+            a[id] = 1
+            return a[:]
+
+        sets = []
+        for i in range(OUTPUT_NODES):
+            dir = "%s/%d" % (folder, i)
+            files = os.listdir(dir)
+            for file in files:
+                sets.append([file2nparray("%s/%s" % (dir, file)), id2label(i)])
+        sets = np.array(sets)
+        np.random.shuffle(sets)
+        length = len(sets)
+        self.train_sets = sets[:length*3//4]
+        self.test_sets = sets[length*3//4:]
+
+    def sample_train_sets(self, length):
+        samples = []
+        labels = []
+        for i in range(length):
+            id = random.randint(0, length-1)
+            samples.append(self.train_sets[id][0])
+            labels.append(self.train_sets[id][1])
+        return np.array(samples), np.array(labels)
+
+    def all_train_sets(self):
+        return self.train_sets[:, 0, :, :], self.train_sets[:, 1, :, :]
+
+    def all_test_sets(self):
+        return self.test_sets[:, 0, :, :], self.test_sets[:, 1, :, :]