Digital2Slave
Digital2Slave

Convert yolov8‐seg to ncnn model step by step

1. Convert pt to onnx

$ mkdir Github && cd Github
$ git clone https://github.com/ultralytics/ultralytics
$ cd ultralytics
$ git checkout b9b0fd8bf409c822b7fcb21d65722b242f5307fc 
$ pip install -r  requirements.txt

1.1 Modify forward method of class C2f(nn.Module):

    def forward(self, x):
        # """Forward pass through C2f layer."""
        # y = list(self.cv1(x).chunk(2, 1))
        # y.extend(m(y[-1]) for m in self.m)
        # return self.cv2(torch.cat(y, 1))
        # !< https://github.com/FeiGeChuanShu/ncnn-android-yolov8
        x = self.cv1(x)
        x = [x, x[:, self.c:, ...]]
        x.extend(m(x[-1]) for m in self.m)
        x.pop(1)
        return self.cv2(torch.cat(x, 1))

1.2 Modify forward method of class Detect(nn.Module):

    def forward(self, x):
        """Concatenates and returns predicted bounding boxes and class probabilities."""
        shape = x[0].shape  # BCHW
        for i in range(self.nl):
            x[i] = torch.cat((self.cv2[i](x[i]), self.cv3[i](x[i])), 1)
        if self.training:
            return x
        elif self.dynamic or self.shape != shape:
            self.anchors, self.strides = (x.transpose(0, 1) for x in make_anchors(x, self.stride, 0.5))
            self.shape = shape

        x_cat = torch.cat([xi.view(shape[0], self.no, -1) for xi in x], 2)
        return x_cat
        # if self.export and self.format in ('saved_model', 'pb', 'tflite', 'edgetpu', 'tfjs'):  # avoid TF FlexSplitV ops
        #     box = x_cat[:, :self.reg_max * 4]
        #     cls = x_cat[:, self.reg_max * 4:]
        # else:
        #     box, cls = x_cat.split((self.reg_max * 4, self.nc), 1)
        # dbox = dist2bbox(self.dfl(box), self.anchors.unsqueeze(0), xywh=True, dim=1) * self.strides

        # if self.export and self.format in ('tflite', 'edgetpu'):
        #     # Normalize xywh with image size to mitigate quantization error of TFLite integer models as done in YOLOv5:
        #     # https://github.com/ultralytics/yolov5/blob/0c8de3fca4a702f8ff5c435e67f378d1fce70243/models/tf.py#L307-L309
        #     # See this PR for details: https://github.com/ultralytics/ultralytics/pull/1695
        #     img_h = shape[2] * self.stride[0]
        #     img_w = shape[3] * self.stride[0]
        #     img_size = torch.tensor([img_w, img_h, img_w, img_h], device=dbox.device).reshape(1, 4, 1)
        #     dbox /= img_size

        # y = torch.cat((dbox, cls.sigmoid()), 1)
        # return y if self.export else (y, x)

1.3 Modify forward method of class Segment(Detect):

    def forward(self, x):
        """Return model outputs and mask coefficients if training, otherwise return outputs and mask coefficients."""
        p = self.proto(x[0])  # mask protos
        bs = p.shape[0]  # batch size

        mc = torch.cat([self.cv4[i](x[i]).view(bs, self.nm, -1) for i in range(self.nl)], 2)  # mask coefficients
        x = self.detect(self, x)
        if self.training:
            return x, mc, p
        # return (torch.cat([x, mc], 1), p) if self.export else (torch.cat([x[0], mc], 1), (x[1], mc, p))
        # !< https://github.com/FeiGeChuanShu/ncnn-android-yolov8
        return (torch.cat([x, mc], 1).permute(0, 2, 1), p.view(bs, self.nm, -1)) if self.export else (torch.cat([x[0], mc], 1), (x[1], mc, p))

1.4 Create convert_seg.py file under ~/Github/ultralytics folder

from ultralytics import YOLO

# Load model
model = YOLO("/home/tianzx/ai_model/seg/pf_phone_seg/pf_phone_yolov8n_seg.pt")

# Export model
success = model.export(task="segment", format="onnx", opset=12, imgsz=640, simplify=True)

2. Conver onnx to ncnn

2.1 Build ncnn

$ cd ~/Github/
$ git clone https://github.com/Tencent/ncnn.git
$ cd ncnn
$ git submodule update --init
$ sudo apt install build-essential git cmake libprotobuf-dev protobuf-compiler libvulkan-dev vulkan-utils libopencv-dev

# build part
$ mkdir build && cd build
$ cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr/local/ ..
$ make -j$(nproc)
$ sudo make install

2.2 Convert onnx to ncnn

$ cd /home/tianzx/ai_model/seg/pf_phone_seg/
$ onnx2ncnn pf_phone_yolov8n_seg.onnx pf_phone_yolov8n_seg.param pf_phone_yolov8n_seg.bin
$ ls
pf_phone_yolov8n_seg.bin  pf_phone_yolov8n_seg.onnx  pf_phone_yolov8n_seg.param  pf_phone_yolov8n_seg.pt

3. Test

3.1 Create CMakeLists.txt and pf_phone_yolov8n_seg.cpp

  • CMakeLists.txt
$ cd /home/tianzx/ai_model/seg/pf_phone_seg/
$ vim CMakeLists.txt
$ vim pf_phone_yolov8n_seg.cpp

cmake_minimum_required(VERSION 3.5)
project(pf_phone_seg)
set(CMAKE_BUILD_TYPE Release)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -pie -fPIE -fPIC -Wall -O3")

find_package(OpenCV REQUIRED)
if (OpenCV_FOUND)
    message(STATUS "OpenCV_LIBS: ${OpenCV_LIBS}")
    message(STATUS "OpenCV_INCLUDE_DIRS: ${OpenCV_INCLUDE_DIRS}")
else ()
    message(FATAL_ERROR "opencv Not Found!")
endif (OpenCV_FOUND)

find_package(OpenMP REQUIRED)
if (OPENMP_FOUND)
    message("OPENMP FOUND")
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${OpenMP_C_FLAGS}")
    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${OpenMP_CXX_FLAGS}")
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${OpenMP_EXE_LINKER_FLAGS}")
else ()
    message(FATAL_ERROR "OpenMP Not Found!")
endif ()

include_directories(/usr/local/include)
include_directories(/usr/local/include/ncnn)
link_directories(/usr/local/lib)

# Source files
file(GLOB SRC "*.h" "*.cpp")

add_executable(pf_phone_seg ${SRC})
target_link_libraries(pf_phone_seg ncnn ${OpenCV_LIBS})
  • pf_phone_yolov8n_seg.cpp
#include "ncnn/net.h"

#if defined(USE_NCNN_SIMPLEOCV)
#include "simpleocv.h"
#else
#include 
#include 
#include 
#endif
#include 
#include 
#include 
#include 

// !< add by tianzx 2023.10.20
#include 
using namespace std;
using namespace cv;

static void slice(const ncnn::Mat& in, ncnn::Mat& out, int start, int end, int axis)
{
    ncnn::Option opt;
    opt.num_threads = 4;
    opt.use_fp16_storage = false;
    opt.use_packing_layout = false;

    ncnn::Layer* op = ncnn::create_layer("Crop");

    // set param
    ncnn::ParamDict pd;

    ncnn::Mat axes = ncnn::Mat(1);
    axes.fill(axis);
    ncnn::Mat ends = ncnn::Mat(1);
    ends.fill(end);
    ncnn::Mat starts = ncnn::Mat(1);
    starts.fill(start);
    pd.set(9, starts);// start
    pd.set(10, ends);// end
    pd.set(11, axes);//axes

    op->load_param(pd);

    op->create_pipeline(opt);

    // forward
    op->forward(in, out, opt);

    op->destroy_pipeline(opt);

    delete op;
}
static void interp(const ncnn::Mat& in, const float& scale, const int& out_w, const int& out_h, ncnn::Mat& out)
{
    ncnn::Option opt;
    opt.num_threads = 4;
    opt.use_fp16_storage = false;
    opt.use_packing_layout = false;

    ncnn::Layer* op = ncnn::create_layer("Interp");

    // set param
    ncnn::ParamDict pd;
    pd.set(0, 2);// resize_type
    pd.set(1, scale);// height_scale
    pd.set(2, scale);// width_scale
    pd.set(3, out_h);// height
    pd.set(4, out_w);// width

    op->load_param(pd);

    op->create_pipeline(opt);

    // forward
    op->forward(in, out, opt);

    op->destroy_pipeline(opt);

    delete op;
}
static void reshape(const ncnn::Mat& in, ncnn::Mat& out, int c, int h, int w, int d)
{
    ncnn::Option opt;
    opt.num_threads = 4;
    opt.use_fp16_storage = false;
    opt.use_packing_layout = false;

    ncnn::Layer* op = ncnn::create_layer("Reshape");

    // set param
    ncnn::ParamDict pd;

    pd.set(0, w);// start
    pd.set(1, h);// end
    if (d > 0)
        pd.set(11, d);//axes
    pd.set(2, c);//axes
    op->load_param(pd);

    op->create_pipeline(opt);

    // forward
    op->forward(in, out, opt);

    op->destroy_pipeline(opt);

    delete op;
}
static void sigmoid(ncnn::Mat& bottom)
{
    ncnn::Option opt;
    opt.num_threads = 4;
    opt.use_fp16_storage = false;
    opt.use_packing_layout = false;

    ncnn::Layer* op = ncnn::create_layer("Sigmoid");

    op->create_pipeline(opt);

    // forward

    op->forward_inplace(bottom, opt);
    op->destroy_pipeline(opt);

    delete op;
}
static void matmul(const std::vector& bottom_blobs, ncnn::Mat& top_blob)
{
    ncnn::Option opt;
    opt.num_threads = 2;
    opt.use_fp16_storage = false;
    opt.use_packing_layout = false;

    ncnn::Layer* op = ncnn::create_layer("MatMul");

    // set param
    ncnn::ParamDict pd;
    pd.set(0, 0);// axis

    op->load_param(pd);

    op->create_pipeline(opt);
    std::vector top_blobs(1);
    op->forward(bottom_blobs, top_blobs, opt);
    top_blob = top_blobs[0];

    op->destroy_pipeline(opt);

    delete op;
}

struct Object
{
    cv::Rect_ rect;
    int label;
    float prob;
    cv::Mat mask;
    std::vector mask_feat;
};
struct GridAndStride
{
    int grid0;
    int grid1;
    int stride;
};
static inline float intersection_area(const Object& a, const Object& b)
{
    cv::Rect_ inter = a.rect & b.rect;
    return inter.area();
}

static void qsort_descent_inplace(std::vector& faceobjects, int left, int right)
{
    int i = left;
    int j = right;
    float p = faceobjects[(left + right) / 2].prob;

    while (i <= j)
    {
        while (faceobjects[i].prob > p)
            i++;

        while (faceobjects[j].prob < p)
            j--;

        if (i <= j)
        {
            // swap
            std::swap(faceobjects[i], faceobjects[j]);

            i++;
            j--;
        }
    }

    #pragma omp parallel sections
    {
        #pragma omp section
        {
            if (left < j) qsort_descent_inplace(faceobjects, left, j);
        }
        #pragma omp section
        {
            if (i < right) qsort_descent_inplace(faceobjects, i, right);
        }
    }
}

static void qsort_descent_inplace(std::vector& faceobjects)
{
    if (faceobjects.empty())
        return;

    qsort_descent_inplace(faceobjects, 0, faceobjects.size() - 1);
}

static void nms_sorted_bboxes(const std::vector& faceobjects, std::vector& picked, float nms_threshold)
{
    picked.clear();

    const int n = faceobjects.size();

    std::vector areas(n);
    for (int i = 0; i < n; i++)
    {
        areas[i] = faceobjects[i].rect.width * faceobjects[i].rect.height;
    }

    for (int i = 0; i < n; i++)
    {
        const Object& a = faceobjects[i];

        int keep = 1;
        for (int j = 0; j < (int)picked.size(); j++)
        {
            const Object& b = faceobjects[picked[j]];

            // intersection over union
            float inter_area = intersection_area(a, b);
            float union_area = areas[i] + areas[picked[j]] - inter_area;
            // float IoU = inter_area / union_area
            if (inter_area / union_area > nms_threshold)
                keep = 0;
        }

        if (keep)
            picked.push_back(i);
    }
}
inline float fast_exp(float x)
{
    union {
        uint32_t i;
        float f;
    } v{};
    v.i = (1 << 23) * (1.4426950409 * x + 126.93490512f);
    return v.f;
}

inline float sigmoid(float x)
{
    return 1.0f / (1.0f + fast_exp(-x));
}
static void generate_proposals(std::vector grid_strides, const ncnn::Mat& pred, float prob_threshold, std::vector& objects)
{
    const int num_points = grid_strides.size();
    const int num_class = 1;
    const int reg_max_1 = 16;

    for (int i = 0; i < num_points; i++)
    {
            const float* scores = pred.row(i) + 4 * reg_max_1;

            // find label with max score
            int label = -1;
            float score = -FLT_MAX;
            for (int k = 0; k < num_class; k++)
            {
                float confidence = scores[k];
                if (confidence > score)
                {
                    label = k;
                    score = confidence;
                }
            }
            float box_prob = sigmoid(score);
            if (box_prob >= prob_threshold)
            {
                ncnn::Mat bbox_pred(reg_max_1, 4, (void*)pred.row(i));
                {
                    ncnn::Layer* softmax = ncnn::create_layer("Softmax");

                    ncnn::ParamDict pd;
                    pd.set(0, 1); // axis
                    pd.set(1, 1);
                    softmax->load_param(pd);

                    ncnn::Option opt;
                    opt.num_threads = 1;
                    opt.use_packing_layout = false;

                    softmax->create_pipeline(opt);

                    softmax->forward_inplace(bbox_pred, opt);

                    softmax->destroy_pipeline(opt);

                    delete softmax;
                }

                float pred_ltrb[4];
                for (int k = 0; k < 4; k++)
                {
                    float dis = 0.f;
                    const float* dis_after_sm = bbox_pred.row(k);
                    for (int l = 0; l < reg_max_1; l++)
                    {
                        dis += l * dis_after_sm[l];
                    }

                    pred_ltrb[k] = dis * grid_strides[i].stride;
                }

                float pb_cx = (grid_strides[i].grid0 + 0.5f) * grid_strides[i].stride;
                float pb_cy = (grid_strides[i].grid1 + 0.5f) * grid_strides[i].stride;

                float x0 = pb_cx - pred_ltrb[0];
                float y0 = pb_cy - pred_ltrb[1];
                float x1 = pb_cx + pred_ltrb[2];
                float y1 = pb_cy + pred_ltrb[3];

                Object obj;
                obj.rect.x = x0;
                obj.rect.y = y0;
                obj.rect.width = x1 - x0;
                obj.rect.height = y1 - y0;
                obj.label = label;
                obj.prob = box_prob;
                obj.mask_feat.resize(32);
                std::copy(pred.row(i) + 64 + num_class, pred.row(i) + 64 + num_class + 32, obj.mask_feat.begin());
                objects.push_back(obj);
            }
    }
}
static void generate_grids_and_stride(const int target_w, const int target_h, std::vector& strides, std::vector& grid_strides)
{
    for (int i = 0; i < (int)strides.size(); i++)
    {
        int stride = strides[i];
        int num_grid_w = target_w / stride;
        int num_grid_h = target_h / stride;
        for (int g1 = 0; g1 < num_grid_h; g1++)
        {
            for (int g0 = 0; g0 < num_grid_w; g0++)
            {
                GridAndStride gs;
                gs.grid0 = g0;
                gs.grid1 = g1;
                gs.stride = stride;
                grid_strides.push_back(gs);
            }
        }
    }
}
static void decode_mask(const ncnn::Mat& mask_feat, const int& img_w, const int& img_h,
    const ncnn::Mat& mask_proto, const ncnn::Mat& in_pad, const int& wpad, const int& hpad,
    ncnn::Mat& mask_pred_result)
{
    ncnn::Mat masks;
    matmul(std::vector{mask_feat, mask_proto}, masks);
    sigmoid(masks);
    reshape(masks, masks, masks.h, in_pad.h / 4, in_pad.w / 4, 0);
    slice(masks, mask_pred_result, (wpad / 2) / 4, (in_pad.w - wpad / 2) / 4, 2);
    slice(mask_pred_result, mask_pred_result, (hpad / 2) / 4, (in_pad.h - hpad / 2) / 4, 1);
    interp(mask_pred_result, 4.0, img_w, img_h, mask_pred_result);

}
static int detect_yolov8(std::string ncnn_bin_path, std::string ncnn_param_path, int imgsz, const cv::Mat& bgr, std::vector& objects)
{
    ncnn::Net yolov8;

    yolov8.load_param(ncnn_param_path.c_str());
    yolov8.load_model(ncnn_bin_path.c_str());

    int width = bgr.cols;
    int height = bgr.rows;

    const int target_size = imgsz;
    const float prob_threshold = 0.4f;
    const float nms_threshold = 0.5f;

    // pad to multiple of 32
    int w = width;
    int h = height;
    float scale = 1.f;
    if (w > h)
    {
        scale = (float)target_size / w;
        w = target_size;
        h = h * scale;
    }
    else
    {
        scale = (float)target_size / h;
        h = target_size;
        w = w * scale;
    }

    ncnn::Mat in = ncnn::Mat::from_pixels_resize(bgr.data, ncnn::Mat::PIXEL_BGR2RGB, width, height, w, h);

    // pad to target_size rectangle
    int wpad = (w + 31) / 32 * 32 - w;
    int hpad = (h + 31) / 32 * 32 - h;
    ncnn::Mat in_pad;
    ncnn::copy_make_border(in, in_pad, hpad / 2, hpad - hpad / 2, wpad / 2, wpad - wpad / 2, ncnn::BORDER_CONSTANT, 0.f);

    const float norm_vals[3] = { 1 / 255.f, 1 / 255.f, 1 / 255.f };
    in_pad.substract_mean_normalize(0, norm_vals);


    ncnn::Extractor ex = yolov8.create_extractor();
    ex.input("images", in_pad);

    ncnn::Mat out;
    ex.extract("output0", out);

    ncnn::Mat mask_proto;
    ex.extract("output1", mask_proto);

    std::vector strides = { 8, 16, 32 };
    std::vector grid_strides;
    generate_grids_and_stride(in_pad.w, in_pad.h, strides, grid_strides);

    std::vector proposals;
    std::vector objects8;
    generate_proposals(grid_strides, out, prob_threshold, objects8);
    
    proposals.insert(proposals.end(), objects8.begin(), objects8.end());

    // sort all proposals by score from highest to lowest
    qsort_descent_inplace(proposals);

    // apply nms with nms_threshold
    std::vector picked;
    nms_sorted_bboxes(proposals, picked, nms_threshold);

    int count = picked.size();

    ncnn::Mat mask_feat = ncnn::Mat(32, count, sizeof(float));
    for (int i = 0; i < count; i++) {
        float* mask_feat_ptr = mask_feat.row(i);
        std::memcpy(mask_feat_ptr, proposals[picked[i]].mask_feat.data(), sizeof(float) * proposals[picked[i]].mask_feat.size());
    }

    ncnn::Mat mask_pred_result;
    decode_mask(mask_feat, width, height, mask_proto, in_pad, wpad, hpad, mask_pred_result);

    objects.resize(count);
    for (int i = 0; i < count; i++)
    {
        objects[i] = proposals[picked[i]];

        // adjust offset to original unpadded
        float x0 = (objects[i].rect.x - (wpad / 2)) / scale;
        float y0 = (objects[i].rect.y - (hpad / 2)) / scale;
        float x1 = (objects[i].rect.x + objects[i].rect.width - (wpad / 2)) / scale;
        float y1 = (objects[i].rect.y + objects[i].rect.height - (hpad / 2)) / scale;

        // clip
        x0 = std::max(std::min(x0, (float)(width - 1)), 0.f);
        y0 = std::max(std::min(y0, (float)(height - 1)), 0.f);
        x1 = std::max(std::min(x1, (float)(width - 1)), 0.f);
        y1 = std::max(std::min(y1, (float)(height - 1)), 0.f);

        objects[i].rect.x = x0;
        objects[i].rect.y = y0;
        objects[i].rect.width = x1 - x0;
        objects[i].rect.height = y1 - y0;

        objects[i].mask = cv::Mat::zeros(height, width, CV_32FC1);
        cv::Mat mask = cv::Mat(height, width, CV_32FC1, (float*)mask_pred_result.channel(i));
        mask(objects[i].rect).copyTo(objects[i].mask(objects[i].rect));
    }

    return 0;
}

static void draw_objects(const cv::Mat& bgr, const std::vector& objects)
{
    static const char* class_names[] = {
        "phone", 
    };
    static const unsigned char colors[2][3] = {
            {56,  0,   255},
            {226, 255, 0},
    };
    cv::Mat image = bgr.clone();
    int color_index = 0;
    for (size_t i = 0; i < objects.size(); i++)
    {
        const Object& obj = objects[i];
        const unsigned char* color = colors[color_index % 1];
        color_index++;

        cv::Scalar cc(color[0], color[1], color[2]);

        fprintf(stderr, "%d = %.5f at %.2f %.2f %.2f x %.2f\n", obj.label, obj.prob,
                obj.rect.x, obj.rect.y, obj.rect.width, obj.rect.height);
        for (int y = 0; y < image.rows; y++) {
            uchar* image_ptr = image.ptr(y);
            const float* mask_ptr = obj.mask.ptr(y);
            for (int x = 0; x < image.cols; x++) {
                if (mask_ptr[x] >= 0.5)
                {
                    image_ptr[0] = cv::saturate_cast(image_ptr[0] * 0.5 + color[2] * 0.5);
                    image_ptr[1] = cv::saturate_cast(image_ptr[1] * 0.5 + color[1] * 0.5);
                    image_ptr[2] = cv::saturate_cast(image_ptr[2] * 0.5 + color[0] * 0.5);
                }
                image_ptr += 3;
            }
        }
        cv::rectangle(image, obj.rect, cc, 2);

        char text[256];
        sprintf(text, "%s %.1f%%", class_names[obj.label], obj.prob * 100);

        int baseLine = 0;
        cv::Size label_size = cv::getTextSize(text, cv::FONT_HERSHEY_SIMPLEX, 0.5, 1, &baseLine);

        int x = obj.rect.x;
        int y = obj.rect.y - label_size.height - baseLine;
        if (y < 0)
            y = 0;
        if (x + label_size.width > image.cols)
            x = image.cols - label_size.width;

        cv::rectangle(image, cv::Rect(cv::Point(x, y), cv::Size(label_size.width, label_size.height + baseLine)),
                      cv::Scalar(255, 255, 255), -1);

        cv::putText(image, text, cv::Point(x, y + label_size.height),
                    cv::FONT_HERSHEY_SIMPLEX, 0.5, cv::Scalar(0, 0, 0));
    }

    cv::imshow("image", image);
    cv::imwrite("result.jpg", image);
    cv::waitKey(0);
}

int main(int argc, char** argv)
{
    if (argc != 5)
    {
        fprintf(stderr, "Usage: %s [ncnn_bin_path] [ncnn_param_path] [imgsz] [imagepath]\n", argv[0]);
        return -1;
    }

    std::string ncnn_bin_path = argv[1];
    std::string ncnn_param_path = argv[2];
    std::string imgsz_str = argv[3];
    std::string imagepath = argv[4];
    int imgsz = std::stoi(imgsz_str);

    cv::Mat m = cv::imread(imagepath, 1);
    if (m.empty())
    {
        fprintf(stderr, "cv::imread %s failed\n", imagepath);
        return -1;
    }
    else
    {
        std::cout << ncnn_bin_path << '\n';
        std::cout << ncnn_param_path << '\n';
        std::cout << imgsz << '\n';
        std::cout << imagepath << '\n';
    }

    std::vector objects;
    detect_yolov8(ncnn_bin_path, ncnn_param_path, imgsz, m, objects);

    draw_objects(m, objects);

    return 0;
}


As the pf_phone_yolov8n_seg.pt model is one instance segment model.


    

  1.  
    modify num_class = 8 to num_class = 1 in static void generate_proposals(std::vector grid_strides, const ncnn::Mat& pred, float prob_threshold, std::vector& objects) function.
     

  2.  
    modify class_names and colors variables in static void draw_objects(const cv::Mat& bgr, const std::vector& objects) function.
     


    3.2 Build and Test
    

    $ cd /home/tianzx/ai_model/seg/pf_phone_seg/
$ mkdir build && cd build
$ cmake ..
$ make -j$(nproc)
$ ./pf_phone_seg ../pf_phone_yolov8n_seg.bin ../pf_phone_yolov8n_seg.param 640 /home/tianzx/Pictures/001_1.jpg
../pf_phone_yolov8n_seg.bin
../pf_phone_yolov8n_seg.param
640
/home/tianzx/Pictures/001_1.jpg
0 = 0.96407 at 102.32 91.11 859.72 x 406.88

    

    Convert yolov8‐seg to ncnn model step by step_第1张图片
    







    



    


    


    




    

    你可能感兴趣的:(YOLO)
    

    

    

      

    • YOLOv5 | 源码解析 | 计算损失loss原理——独家原创注释
kay_545
YOLOv8改进有效涨点Yolov5改进YOLOpython开发语言

      ⭐欢迎大家订阅我的专栏一起学习⭐订阅专栏，更新及时查看不迷路YOLOv5涨点专栏：http://t.csdnimg.cn/D9kR0YOLOv8涨点专栏：http://t.csdnimg.cn/5hNr8YOLOv7专栏：http://t.csdnimg.cn/hJsf1魔改网络、复现论文、优化创新各位订阅YOLOv8专栏读者，非常抱歉，这篇文章加错专栏了，但是因为是订阅的，所以不能删除或者移动这
      

      • 

    • torch报错：[winerror 126] 找不到指定的模块torch_python.dll“ or one of its dependencies.
LightningJie
深度学习pythonpytorch

      [winerror126]找不到指定的模块。errorloading"d:\miniconda\envs\action_env\lib\site-packages\torch\lib\torch_python.dll"oroneofitsdependencies.在使用这个yolov5模块的时候发现了这个错误，错误原因是因为python版本和torch版本冲突。本人安装torch的python版本
      

      • 

    • YOLOv9改进 添加可变形注意力机制DAttention
学yolo的小白
UPgradeYOLOv9YOLOpython目标检测pytorch

      一、DeformableAttentionTransformer论文论文地址：arxiv.org/pdf/2201.00520.pdf二、DeformableAttentionTransformer注意力结构DeformableAttentionTransformer包含可变形注意力机制，允许模型根据输入的内容动态调整注意力权重。在传统的Transformer中，注意力是通过对查询和键向量之间的点
      

      • 

    • [数据集][目标检测]垃圾检测数据集VOC+YOLO格式6004张18类别垃圾
FL1623863129
数据集目标检测YOLO人工智能

      数据集格式：PascalVOC格式+YOLO格式(不包含分割路径的txt文件，仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件)图片数量(jpg文件个数)：6004标注数量(xml文件个数)：6004标注数量(txt文件个数)：6004标注类别数：18标注类别名称:["bottle_cap","bottle","cup","unlabeled_litter","straw"
      

      • 

    • 图像算法实习生--面经1
小豆包的小朋友0217
算法

      系列文章目录文章目录系列文章目录前言一、为什么torch里面要用optimizer.zero_grad()进行梯度置0二、Unet神经网络为什么会在医学图像分割表现好？三、transformer相关问题四、介绍一下胶囊网络的动态路由五、yolo系列出到v9了，介绍一下你最熟悉的yolo算法六、一阶段目标检测算法和二阶段目标检测算法有什么区别？七、讲一下剪枝八、讲一下PTQandQAT量化的区别九、
      

      • 

    • 计算机设计大赛 深度学习驾驶行为状态检测系统(疲劳 抽烟 喝水 玩手机) - opencv python
iuerfee
python

      文章目录1前言1课题背景2相关技术2.1Dlib人脸识别库2.2疲劳检测算法2.3YOLOV5算法3效果展示3.1眨眼3.2打哈欠3.3使用手机检测3.4抽烟检测3.5喝水检测4最后1前言优质竞赛项目系列，今天要分享的是基于深度学习的驾驶行为状态检测系统该项目较为新颖，适合作为竞赛课题方向，学长非常推荐！学长这里给一个题目综合评分(每项满分5分)难度系数：3分工作量：3分创新点：5分更多资料,项目
      

      • 

    • [数据集][目标检测]光伏板太阳能版缺陷检测数据集VOC+YOLO格式2400张3类别
FL1623863129
数据集目标检测人工智能深度学习

      数据集格式：PascalVOC格式+YOLO格式(不包含分割路径的txt文件，仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件)图片数量(jpg文件个数)：2400标注数量(xml文件个数)：2400标注数量(txt文件个数)：2400标注类别数：3标注类别名称:["crack","grid","spot"]每个类别标注的框数：crack框数=892grid框数=884sp
      

      • 

    • 计算机设计大赛 深度学习YOLO抽烟行为检测 - python opencv
iuerfee
python

      文章目录1前言1课题背景2实现效果3Yolov5算法3.1简介3.2相关技术4数据集处理及实验5部分核心代码6最后1前言优质竞赛项目系列，今天要分享的是基于深度学习YOLO抽烟行为检测该项目较为新颖，适合作为竞赛课题方向，学长非常推荐！学长这里给一个题目综合评分(每项满分5分)难度系数：3分工作量：3分创新点：4分更多资料,项目分享：https://gitee.com/dancheng-senio
      

      • 

    • 【计算机视觉面经四】基于深度学习的目标检测算法面试必备（RCNN~YOLOv5）
旅途中的宽~
计算机视觉面经总结计算机视觉深度学习目标检测YOLORCNN

      文章目录一、前言二、两阶段目标检测算法2.1RCNN2.2Fast-RCNN2.3FasterR-CNN三、多阶段目标检测算法3.1CascadeR-CNN四、单阶段目标检测算法4.1编码方式4.1.1基于中心坐标4.1.1.1方案14.1.1.2方案24.1.1.3方案34.2YOLOv14.3SSD4.4YOLOv24.5RetinaNet4.6YOLOv34.7YOLOv44.8YOLOv5
      

      • 

    • ChatGPT聊YOLO
AIWalker-Happy
YOLOchatgptYOLO

      最近ChatGPT大伙，其概括摘要能力非常强。YOLO系列算法也是目标检测领域非常重要的一个研究路线，那么ChatGPT是如何看待各个YOLO算法的呢？那我们去问问它如何看待各个版本的YOLO。截止到2021年9月，YOLOv6尚未发布。因此，无法对其进行价值和贡献的评价。在这之前，最新的YOLO系列算法是YOLOv5。如果有关于YOLOv5或者其他目标检测算法的问题，欢迎随时提问。----Cha
      

      • 

    • 互联网加竞赛 机器视觉目标检测 - opencv 深度学习
Mr.D学长
pythonjava

      文章目录0前言2目标检测概念3目标分类、定位、检测示例4传统目标检测5两类目标检测算法5.1相关研究5.1.1选择性搜索5.1.2OverFeat5.2基于区域提名的方法5.2.1R-CNN5.2.2SPP-net5.2.3FastR-CNN5.3端到端的方法YOLOSSD6人体检测结果7最后0前言优质竞赛项目系列，今天要分享的是机器视觉opencv深度学习目标检测该项目较为新颖，适合作为竞赛课题
      

      • 

    • [数据集][目标检测]鸟类检测数据集VOC+YOLO格式11758张200类别
FL1623863129
数据集目标检测人工智能计算机视觉

      数据集格式：PascalVOC格式+YOLO格式(不包含分割路径的txt文件，仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件)图片数量(jpg文件个数)：11758标注数量(xml文件个数)：11758标注数量(txt文件个数)：11758标注类别数：200标注类别名称:["Black_footed_Albatross","Laysan_Albatross","Sooty
      

      • 

    • [C++]使用C++部署yolov9的tensorrt模型进行目标检测
FL1623863129
C/C++目标检测人工智能计算机视觉

      部署YOLOv9的TensorRT模型进行目标检测是一个涉及多个步骤的过程，主要包括准备环境、模型转换、编写代码和模型推理。首先，确保你的开发环境已安装了NVIDIA的TensorRT。TensorRT是一个用于高效推理的SDK，它能对TensorFlow、PyTorch等框架训练的模型进行优化，从而加速模型在NVIDIAGPU上的运行速度。接下来，你需要将YOLOv9的模型转换为TensorRT
      

      • 

    • C# OpenVino Yolov8 Pose 姿态识别
乱蜂朝王
人工智能c#openvinoYOLO

      目录效果模型信息项目代码下载效果模型信息ModelProperties-------------------------date：2023-09-07T17:11:43.091306description：UltralyticsYOLOv8n-posemodeltrainedon/usr/src/app/ultralytics/datasets/coco-pose.yamlauthor：Ultra
      

      • 

    • 【人脸识别系列】从知名DeepFace人脸识别库入手详解人脸识别---第三部分DeepFace库使用介绍之人脸检测模型介绍
Hello_WOAIAI
CV人脸识别目标检测计算机视觉视觉检测图像处理YOLOopencv

      【人脸识别系列】从知名DeepFace人脸识别库入手详解人脸识别---第三部分DeepFace库使用介绍之人脸检测器介绍前言DeepFace库人脸检测器OpenCV人脸检测器RetinaFace人脸检测器mtcnn人脸检测器sdd人脸检测器dlib人脸检测器mediapipe人脸检测器yolov8人脸检测器人脸识别系列其他文章【人脸识别系列】从知名DeepFace人脸识别库入手详解人脸识别—第一部
      

      • 

    • YOLO v5项目实战 P5 解决运行detect文件时设置了--view-img但是显示不出来的问题
Bold!
目标检测YOLO深度学习

      up主讲的实时显示目标检测后的图片的两种方法：（1）在下面的Terminal中输入下列命令：pythondetect.py--view-img（2）点击进入右上方的detect的EditConfigurations然后在这个参数这里输入--viewimg点击apply-->OK最后运行此文件即可。遇到的问题：图片显示不出来。（前提：自己安装的Pycharm是社区版本的）解决方法：（1）创建虚拟环境
      

      • 

    • YOLO训练自定义数据集常见报错汇总
东东不熬夜
机器人#YOLOv8YOLO人工智能python

      YOLO训练自定义数据集常见报错汇总1、报错一解决方法2、报错二解决方法3、报错三解决方法4、报错四解决方法5、报错五解决方法1、报错一SyntaxError:Non-UTF-8codestartingwith'\xb5'infileE:\Robot\YOLO\camera.pyonline1,butnoencodingdeclared;这个错误通常表示Python解释器在尝试解析文件时遇到了非U
      

      • 

    • PyCharm - Script parameters (脚本参数)
Yongqiang Cheng
PyCharmPyCharmScript脚本参数

      PyCharm-Scriptparameters[脚本参数]ReferencesRun->EditConfigurations…->Run/DebugConfigurations->Configuration->Scriptparameters命令行：pythondisplay_yolo_log.py./person_training_log/person_train_log_DIMM40_std
      

      • 

    • 计算机设计大赛 深度学习人体跌倒检测 -yolo 机器视觉 opencv python
iuerfee
python

      0前言优质竞赛项目系列，今天要分享的是**基于深度学习的人体跌倒检测算法研究与实现**该项目较为新颖，适合作为竞赛课题方向，学长非常推荐！学长这里给一个题目综合评分(每项满分5分)难度系数：3分工作量：3分创新点：5分更多资料,项目分享：https://gitee.com/dancheng-senior/postgraduate1.前言人体跌倒是人们日常生活中常见姿态之一，且跌倒的发生具有随机、难
      

      • 

    • 计算机毕设 深度学习YOLO安检管制物品识别与检测 - python opencv
DanCheng-studio
毕业设计python毕设

      文章目录0前言1课题背景2实现效果3卷积神经网络4Yolov55模型训练6实现效果7最后0前言这两年开始毕业设计和毕业答辩的要求和难度不断提升，传统的毕设题目缺少创新和亮点，往往达不到毕业答辩的要求，这两年不断有学弟学妹告诉学长自己做的项目系统达不到老师的要求。为了大家能够顺利以及最少的精力通过毕设，学长分享优质毕业设计项目，今天要分享的是**基于深度学习YOLO安检管制误判识别与检测**学长这里
      

      • 

    • 深度学习毕设项目 深度学习YOLO安检管制物品识别与检测 - python opencv
DanCheng-studio
毕业设计python毕设

      文章目录0前言1课题背景2实现效果3卷积神经网络4Yolov55模型训练6实现效果7最后0前言这两年开始毕业设计和毕业答辩的要求和难度不断提升，传统的毕设题目缺少创新和亮点，往往达不到毕业答辩的要求，这两年不断有学弟学妹告诉学长自己做的项目系统达不到老师的要求。为了大家能够顺利以及最少的精力通过毕设，学长分享优质毕业设计项目，今天要分享的是**基于深度学习YOLO安检管制误判识别与检测**学长这里
      

      • 

    • 计算机设计大赛 深度学习YOLO安检管制物品识别与检测 - python opencv
iuerfee
python

      文章目录0前言1课题背景2实现效果3卷积神经网络4Yolov55模型训练6实现效果7最后0前言优质竞赛项目系列，今天要分享的是**基于深度学习YOLO安检管制误判识别与检测**该项目较为新颖，适合作为竞赛课题方向，学长非常推荐！学长这里给一个题目综合评分(每项满分5分)难度系数：4分工作量：3分创新点：4分更多资料,项目分享：https://gitee.com/dancheng-senior/po
      

      • 

    • 【论文阅读】【yolo系列】YOLO-Pose的论文阅读
magic_ll
yolo系列深度学习相关的论文阅读论文阅读YOLO

      Abstract我们介绍YOLO-pose，一种无热图联合检测的新方法，基于流行的YOLO目标检测框架的图像二维多人姿态估计。【现有方法的问题】现有的基于热图的两阶段方法是次优的，因为它们不是端到端可训练的，训练依赖于surrogateL1loss，该损失不能直接优化评估指标–目标关键点相似度（OKS）。【ours优势：端到端训练，并优化OKS指标本身，无复杂的后处理】该模型学习了在一次前向传递中
      

      • 

    • 计算机设计大赛 深度学习YOLO图像视频足球和人体检测 - python opencv
iuerfee
python

      文章目录0前言1课题背景2实现效果3卷积神经网络4Yolov5算法5数据集6最后0前言优质竞赛项目系列，今天要分享的是深度学习YOLO图像视频足球和人体检测该项目较为新颖，适合作为竞赛课题方向，学长非常推荐！学长这里给一个题目综合评分(每项满分5分)难度系数：3分工作量：3分创新点：5分更多资料,项目分享：https://gitee.com/dancheng-senior/postgraduate
      

      • 

    • yolov5配置教程
moyv
开发YOLO

      yolov5yolov5notepad++notepad++直接下一步就可以GitGit取消勾选修改默认编辑器为npp其他都直接下一步python3.8.1python3.8.1主要勾选添加环境变量其他下一步即可MinicondaMiniconda其他下一步然后添加系统环境变量PycharmPycharm把这个界面所有都勾选然后下一步配置环境更改系统编码（整个过程结束后修改回去）点击日期、时间和区
      

      • 

    • YOLOv8推理程序
AIOT魔法师
YOLOv5和YOLOv8YOLOyolov8

      YOLOv8单独推理，有时候我们自定义的模块算子无法正常转换为其他框架，而且需要做成应用，因此需要一个单独推理的程序，返回的是识别后的照片还有各个类别及其对应数量。文章最后给出Flask封装为Server以及调用的实例还有Client请求代码，支持几十路多线程并发，只需加载一次模型，后边推理即可。【防止搬运，请下滑复制代码。】【防止搬运，请下滑复制代码。】【防止搬运，请下滑复制代码。】【防止搬运，
      

      • 

    • YOLOv8-Openvino和ONNXRuntime推理【CPU】
你的陈某某
YOLOopenvino人工智能yolov8目标检测

      1环境：CPU：i5-125002安装Openvino和ONNXRuntime2.1Openvino简介Openvino是由Intel开发的专门用于优化和部署人工智能推理的半开源的工具包，主要用于对深度推理做优化。Openvino内部集成了Opencv、TensorFlow模块，除此之外它还具有强大的Plugin开发框架，允许开发者在Openvino之上对推理过程做优化。Openvino整体框架为
      

      • 

    • YoloV8 +可视化界面+GUI+交互式界面目标检测与跟踪
阿利同学
YOLO目标检测人工智能目标检测可视化界面yolo界面制作交互

      YoloV8可视化界面GUI本项目旨在基于YoloV8目标检测算法开发一个直观的可视化界面，使用户能够轻松上传图像或视频，并对其进行目标检测。通过图形用户界面，用户可以方便地调整检测参数、查看检测结果，并将结果保存或导出。同时，该界面还将提供实时目标检测功能，让用户能够在视频流中实时观察目标的检测情况。这个项目将结合YoloV8强大的检测能力和直观的用户交互，为用户提供一种全新的目标检测体验。如何
      

      • 

    • 计算机设计大赛 深度学习交通车辆流量分析 - 目标检测与跟踪 - python opencv
iuerfee
python

      文章目录0前言1课题背景2实现效果3DeepSORT车辆跟踪3.1DeepSORT多目标跟踪算法3.2算法流程4YOLOV5算法4.1网络架构图4.2输入端4.3基准网络4.4Neck网络4.5Head输出层5最后0前言优质竞赛项目系列，今天要分享的是**基于深度学习得交通车辆流量分析**该项目较为新颖，适合作为竞赛课题方向，学长非常推荐！学长这里给一个题目综合评分(每项满分5分)难度系数：3分工
      

      • 

    • RTDETR改进系列指南
魔鬼面具
人工智能pytorch深度学习python

      基于Ultralytics的RT-DETR改进项目.(89.9¥)为了感谢各位对RTDETR项目的支持,本项目的赠品是yolov5-PAGCP通道剪枝算法.具体使用教程自带的一些文件说明train.py训练模型的脚本main_profile.py输出模型和模型每一层的参数,计算量的脚本(rtdetr-l和rtdetr-x因为thop库的问题,没办法正常输出每一层的参数和计算量和时间)val.py使
      

      • 

    • jQuery 键盘事件keydown ,keypress ,keyup介绍
107x
jsjquerykeydownkeypresskeyup

      本文章总结了下些关于jQuery 键盘事件keydown ,keypress ,keyup介绍，有需要了解的朋友可参考。
一、首先需要知道的是： 1、keydown() keydown事件会在键盘按下时触发. 2、keyup()  代码如下 复制代码
$('input').keyup(funciton(){      
      

      • 

    • AngularJS中的Promise
bijian1013
JavaScriptAngularJSPromise

      一.Promise
        Promise是一个接口，它用来处理的对象具有这样的特点：在未来某一时刻（主要是异步调用）会从服务端返回或者被填充属性。其核心是，promise是一个带有then()函数的对象。
        为了展示它的优点，下面来看一个例子，其中需要获取用户当前的配置文件：
var cu
      

      • 

    • c++ 用数组实现栈类
CrazyMizzz
数据结构C++

      #include<iostream>
#include<cassert>
using namespace std;
template<class T, int SIZE = 50>
class Stack{
private:
T list[SIZE];//数组存放栈的元素
int top;//栈顶位置
public:
Stack(
      

      • 

    • java和c语言的雷同
麦田的设计者
java递归scaner

      软件启动时的初始化代码，加载用户信息2015年5月27号
从头学java二
1、语言的三种基本结构：顺序、选择、循环。废话不多说，需要指出一下几点：
     a、return语句的功能除了作为函数返回值以外，还起到结束本函数的功能，return后的语句
不会再继续执行。
     b、for循环相比于whi
      

      • 

    • LINUX环境并发服务器的三种实现模型
被触发
linux

      服务器设计技术有很多，按使用的协议来分有TCP服务器和UDP服务器。按处理方式来分有循环服务器和并发服务器。
1  循环服务器与并发服务器模型
在网络程序里面，一般来说都是许多客户对应一个服务器，为了处理客户的请求，对服务端的程序就提出了特殊的要求。
目前最常用的服务器模型有：
·循环服务器：服务器在同一时刻只能响应一个客户端的请求
·并发服务器：服
      

      • 

    • Oracle数据库查询指令
肆无忌惮_
oracle数据库

      20140920
 
单表查询
-- 查询************************************************************************************************************
-- 使用scott用户登录
 
-- 查看emp表
 
desc emp
 

      

      • 

    • ext右下角浮动窗口
知了ing
JavaScriptext

      第一种
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/
      

      • 

    • 浅谈REDIS数据库的键值设计
矮蛋蛋
redis

      http://www.cnblogs.com/aidandan/
原文地址：http://www.hoterran.info/redis_kv_design
丰富的数据结构使得redis的设计非常的有趣。不像关系型数据库那样，DEV和DBA需要深度沟通，review每行sql语句，也不像memcached那样，不需要DBA的参与。redis的DBA需要熟悉数据结构，并能了解使用场景。

      

      • 

    • maven编译可执行jar包
alleni123
maven

      http://stackoverflow.com/questions/574594/how-can-i-create-an-executable-jar-with-dependencies-using-maven
<build>
<plugins>
<plugin>
<artifactId>maven-asse
      

      • 

    • 人力资源在现代企业中的作用
百合不是茶
HR 企业管理

      //人力资源在在企业中的作用人力资源为什么会存在，人力资源究竟是干什么的 人力资源管理是对管理模式一次大的创新，人力资源兴起的原因有以下点： 工业时代的国际化竞争，现代市场的风险管控等等。所以人力资源 在现代经济竞争中的优势明显的存在，人力资源在集团类公司中存在着 明显的优势(鸿海集团)，有一次笔者亲自去体验过红海集团的招聘，只 知道人力资源是管理企业招聘的 当时我被招聘上了，当时给我们培训 的人
      

      • 

    • Linux自启动设置详解
bijian1013
linux

      linux有自己一套完整的启动体系，抓住了linux启动的脉络，linux的启动过程将不再神秘。
阅读之前建议先看一下附图。
本文中假设inittab中设置的init tree为：
/etc/rc.d/rc0.d
/etc/rc.d/rc1.d
/etc/rc.d/rc2.d
/etc/rc.d/rc3.d
/etc/rc.d/rc4.d
/etc/rc.d/rc5.d
/etc
      

      • 

    • Spring Aop Schema实现
bijian1013
javaspringAOP

      本例使用的是Spring2.5
1.Aop配置文件spring-aop.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans
xmlns="http://www.springframework.org/schema/beans"
xmln
      

      • 

    • 【Gson七】Gson预定义类型适配器
bit1129
gson

      Gson提供了丰富的预定义类型适配器，在对象和JSON串之间进行序列化和反序列化时，指定对象和字符串之间的转换方式，
  DateTypeAdapter
 
public final class DateTypeAdapter extends TypeAdapter<Date> {
public static final TypeAdapterFacto
      

      • 

    • 【Spark八十八】Spark Streaming累加器操作（updateStateByKey)
bit1129
update

      在实时计算的实际应用中，有时除了需要关心一个时间间隔内的数据，有时还可能会对整个实时计算的所有时间间隔内产生的相关数据进行统计。
比如： 对Nginx的access.log实时监控请求404时，有时除了需要统计某个时间间隔内出现的次数，有时还需要统计一整天出现了多少次404，也就是说404监控横跨多个时间间隔。
 
Spark Streaming的解决方案是累加器，工作原理是，定义
      

      • 

    • linux系统下通过shell脚本快速找到哪个进程在写文件
ronin47

      一个文件正在被进程写 我想查看这个进程 文件一直在增大 找不到谁在写 使用lsof也没找到
这个问题挺有普遍性的，解决方法应该很多，这里我给大家提个比较直观的方法。
linux下每个文件都会在某个块设备上存放，当然也都有相应的inode, 那么透过vfs.write我们就可以知道谁在不停的写入特定的设备上的inode。
幸运的是systemtap的安装包里带了inodewatch.stp，位
      

      • 

    • java-两种方法求第一个最长的可重复子串
bylijinnan
java算法

      
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class MaxPrefix {
public static void main(String[] args) {
String str="abbdabcdabcx"; 
      

      • 

    • Netty源码学习-ServerBootstrap启动及事件处理过程
bylijinnan
javanetty

      Netty是采用了Reactor模式的多线程版本，建议先看下面这篇文章了解一下Reactor模式：
http://bylijinnan.iteye.com/blog/1992325
Netty的启动及事件处理的流程，基本上是按照上面这篇文章来走的
文章里面提到的操作，每一步都能在Netty里面找到对应的代码
其中Reactor里面的Acceptor就对应Netty的ServerBo
      

      • 

    • servelt filter listener 的生命周期
cngolon
filterlistenerservelt生命周期

      1. servlet    当第一次请求一个servlet资源时，servlet容器创建这个servlet实例，并调用他的 init(ServletConfig config)做一些初始化的工作，然后调用它的service方法处理请求。当第二次请求这个servlet资源时，servlet容器就不在创建实例，而是直接调用它的service方法处理请求，也就是说
      

      • 

    • jmpopups获取input元素值
ctrain
JavaScript

      jmpopups 获取弹出层form表单
首先，我有一个div，里面包含了一个表单，默认是隐藏的，使用jmpopups时，会弹出这个隐藏的div，其实jmpopups是将我们的代码生成一份拷贝。
当我直接获取这个form表单中的文本框时，使用方法：$('#form input[name=test1]').val()；这样是获取不到的。
我们必须到jmpopups生成的代码中去查找这个值，$(
      

      • 

    • vi查找替换命令详解
daizj
linux正则表达式替换查找vim

      一、查找
查找命令
/pattern<Enter> ：向下查找pattern匹配字符串
?pattern<Enter>：向上查找pattern匹配字符串
使用了查找命令之后，使用如下两个键快速查找：
n：按照同一方向继续查找
N：按照反方向查找
字符串匹配
pattern是需要匹配的字符串，例如：
1:  /abc<En
      

      • 

    • 对网站中的js,css文件进行打包
dcj3sjt126com
PHP打包

      一，为什么要用smarty进行打包
apache中也有给js,css这样的静态文件进行打包压缩的模块，但是本文所说的不是以这种方式进行的打包，而是和smarty结合的方式来把网站中的js,css文件进行打包。
为什么要进行打包呢，主要目的是为了合理的管理自己的代码 。现在有好多网站，你查看一下网站的源码的话，你会发现网站的头部有大量的JS文件和CSS文件，网站的尾部也有可能有大量的J
      

      • 

    • php Yii: 出现undefined offset 或者 undefined index解决方案
dcj3sjt126com
undefined

      在开发Yii 时，在程序中定义了如下方式：
       if($this->menuoption[2] === 'test')，那么在运行程序时会报：undefined offset:2，这样的错误主要是由于php.ini 里的错误等级太高了，在windows下错误等级
      

      • 

    • linux 文件格式（1） sed工具
eksliang
linuxlinux sed工具sed工具linux sed详解

      转载请出自出处：
http://eksliang.iteye.com/blog/2106082
简介
      sed 是一种在线编辑器，它一次处理一行内容。处理时，把当前处理的行存储在临时缓冲区中，称为“模式空间”（pattern space），接着用sed命令处理缓冲区中的内容，处理完成后，把缓冲区的内容送往屏幕。接着处理下一行，这样不断重复，直到文件末尾
      

      • 

    • Android应用程序获取系统权限
gqdy365
android

      引用
如何使Android应用程序获取系统权限
        第一个方法简单点，不过需要在Android系统源码的环境下用make来编译：
        1. 在应用程序的AndroidManifest.xml中的manifest节点
      

      • 

    • HoverTree开发日志之验证码
hvt
.netC#asp.nethovertreewebform

      HoverTree是一个ASP.NET的开源CMS，目前包含文章系统，图库和留言板功能。代码完全开放，文章内容页生成了静态的HTM页面，留言板提供留言审核功能，文章可以发布HTML源代码，图片上传同时生成高品质缩略图。推出之后得到许多网友的支持，再此表示感谢！留言板不断收到许多有益留言，但同时也有不少广告，因此决定在提交留言页面增加验证码功能。ASP.NET验证码在网上找，如果不是很多，就是特别多
      

      • 

    • JSON API：用 JSON 构建 API 的标准指南中文版
justjavac
json

      译文地址：https://github.com/justjavac/json-api-zh_CN
如果你和你的团队曾经争论过使用什么方式构建合理 JSON 响应格式， 那么 JSON API 就是你的 anti-bikeshedding 武器。
通过遵循共同的约定，可以提高开发效率，利用更普遍的工具，可以是你更加专注于开发重点：你的程序。
基于 JSON API 的客户端还能够充分利用缓存，
      

      • 

    • 数据结构随记_2
lx.asymmetric
数据结构笔记

      第三章 栈与队列
一．简答题
1. 在一个循环队列中，队首指针指向队首元素的  前一个    位置。 
2.在具有n个单元的循环队列中，队满时共有  n-1  个元素。 
3. 向栈中压入元素的操作是先  移动栈顶指针&n
      

      • 

    • Linux下的监控工具dstat
网络接口
linux

      1) 工具说明dstat是一个用来替换 vmstat,iostat netstat,nfsstat和ifstat这些命令的工具, 是一个全能系统信息统计工具. 与sysstat相比, dstat拥有一个彩色的界面, 在手动观察性能状况时, 数据比较显眼容易观察; 而且dstat支持即时刷新, 譬如输入dstat 3, 即每三秒收集一次, 但最新的数据都会每秒刷新显示. 和sysstat相同的是, 
      

      • 

    • C 语言初级入门--二维数组和指针
1140566087
二维数组c/c++指针

      /*
二维数组的定义和二维数组元素的引用
二维数组的定义：
当数组中的每个元素带有两个下标时，称这样的数组为二维数组；
(逻辑上把数组看成一个具有行和列的表格或一个矩阵);
语法：
类型名 数组名[常量表达式1][常量表达式2]
二维数组的引用：
引用二维数组元素时必须带有两个下标，引用形式如下：
例如：
int a[3][4];  引用：
      

      • 

    • 10点睛Spring4.1-Application Event
wiselyman
application

      10.1 Application Event
Spring使用Application Event给bean之间的消息通讯提供了手段
应按照如下部分实现bean之间的消息通讯
继承ApplicationEvent类实现自己的事件
实现继承ApplicationListener接口实现监听事件
使用ApplicationContext发布消息

      

      •