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)
    
        
    
            
    
                
      
                    
    • 《基于yolov5s的水稻病虫害图像识别应用》开题报告
                        大数据蟒行探索者
毕业论文/研究报告YOLO软件工程自动化运维软件构建性能优化
                        
      1.研究的目的和意义一、研究目的农作物病虫害是全球农业生产中的主要威胁之一，每年因病虫害造成的作物减产和经济损失相当巨大。随着世界人口的增长，对粮食的需求不断增加，如何提高农作物产量、减少病虫害损失，成为农业生产中需要解决的核心问题。传统的病虫害识别方法主要依赖于农民的经验或农业专家的现场诊断，这种方式不仅耗费大量时间和人力，而且易受人为因素影响，准确率不高，且不具备可持续性，特别是在大规模农业生
      
                    
      • 
                    
    • 目标检测YOLO实战应用案例100讲-TDI线阵相机
                        林聪木
数码相机计算机视觉人工智能
                        
      目录知识储备图像基础知识分辨率单位及换算算法原理一、TDI基本原理二、信噪比提升机制三、时间同步机制四、TDIvs传统线扫描技术五、TDI的技术挑战六、最新的TDI技术发展知识储备图像基础知识首先什么是机器视觉？计算机视觉就是让计算机去理解获取数字图像与视频中的信息。最终实现一个与人类视觉系统实现相同功能的自动化系统。什么是机器视觉中的图像的前置知识——颜色模型？最为常用的颜色模型，分别是RGB颜
      
                    
      • 
                    
    • 探索高性能AI识别和边缘计算 | NVIDIA Jetson Orin Nano 8GB 开发套件测评总结
                        Loving_enjoy
实用技巧人工智能边缘计算
                        
      #NVIDIAJetsonOrinNano8GB测评：当边缘计算遇上"性能暴徒"，树莓派看了想转行引言：比咖啡机还小的"AI超算"，却让开发者集体沸腾2025年的某个深夜，程序员老王盯着工位上巴掌大的NVIDIAJetsonOrinNano，突然热泪盈眶——这个尺寸堪比奥利奥饼干盒的设备，跑YOLOv5的速度竟比他去年买的游戏本还快3倍！隔壁桌用树莓派做毕设的大学生小张探头一看，默默把刚买的Ras
      
                    
      • 
                    
    • 【YOLOv12改进trick】StarBlock引入YOLOv12，创新涨点优化，含创新点Python代码，方便发论文
                        zy_destiny
YOLOv12及改进优化创新人工智能深度学习机器学习YOLO神经网络开发语言python
                        
      改进模块：StarBlock解决问题：采用StarBlock将输入数据映射到一个极高维的非线性特征空间,生成丰富的特征表示，使得模型在处理复杂数据时更加有效。改进优势：简单粗暴的星型乘法涨点却很明显适用场景：目标检测、语义分割、自然语言处理等多种场景高效紧凑的模型，不适用于大模型思路来源：CVPR2024《RewritetheStars》目录1.设计动机2.启发来源3.将StarBlock引入YO
      
                    
      • 
                    
    • 【AI】YOLOv7部署在NVIDIA Jetson Nano上
                        郭老二
AI人工智能YOLO
                        
      1、环境搭建参考博客：【AI】JetsonNano烧写SD卡镜像【AI】YOLOv7部署在NVIDIAJetsonTX2上2、下载编译2.1源码下载https://github.com/AlexeyAB/darknet2.2编译1）修改MakefileGPU=1CUDNN=1CUDNN_HALF=0
      
                    
      • 
                    
    • 基于YOLOv5深度学习的田间杂草检测系统：UI界面 + YOLOv5 + 数据集详细教程
                        深度学习&目标检测实战项目
YOLO深度学习uiYOLOv5人工智能计算机视觉
                        
      引言随着农业科技的进步，智能化农业越来越受到重视，尤其是通过计算机视觉技术对作物进行监测和管理。在农业生产中，杂草的生长对作物的生长产生了负面影响，因此准确地检测和识别田间杂草至关重要。本文将详细介绍如何构建一个基于深度学习的田间杂草检测系统，使用YOLOv5模型进行目标检测，并提供一个用户友好的界面。我们将分步骤进行，包括环境配置、数据集准备、模型训练、实时杂草检测系统的实现等内容。目录引言目录
      
                    
      • 
                    
    • 自动扶梯人员摔倒掉落识别检测数据集VOC+YOLO格式5375张2类别
                        FL1623863129
YOLO深度学习机器学习
                        
      数据集格式：PascalVOC格式+YOLO格式(不包含分割路径的txt文件，仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件)图片数量(jpg文件个数)：5375标注数量(xml文件个数)：5375标注数量(txt文件个数)：5375标注类别数：2标注类别名称(注意yolo格式类别顺序不和这个对应，而以labels文件夹classes.txt为准):["anomaly",
      
                    
      • 
                    
    • 人工智能基础知识
                        yzx991013
人工智能
                        
      首先分为两大类：一：机器视觉cv1.特征比较明显2.经典模型：cnn，resnet，deepface，yolov（1-12），vi-transformer。缺点：不能解决收听问题。3.落地，无人识别，轨道追踪，无人驾驶，（主要解决看的东西）。二：自然语言处理nlp（语音识别）处理（文本）方面解决（说和听的问题），RNN，LSTM，attention，transformer（基于规则的翻译，超越普通
      
                    
      • 
                    
    • YOLOv10改进之MHAF(多分支辅助特征金字塔)
                        清风AI
深度学习算法详解及代码复现人工智能计算机视觉深度学习算法机器学习
                        
      YOLOv10架构YOLOv10的架构主要由主干网络、特征金字塔和预测头三部分组成。主干网络采用改进的Darknet结构，增强特征提取能力。特征金字塔模块使用多尺度特征融合技术，提高对不同大小目标的检测效果。预测头则负责生成最终的检测结果。这种结构设计使得YOLOv10在保持高效率的同时，能够有效处理各种尺度的目标，为后续的改进奠定了基础。检测性能在探讨YOLOv10的性能提升之前，我们需要了解其
      
                    
      • 
                    
    • 【yolov8】模型导出----pytorch导出为onnx模型
                        栗子风暴
YOLOpytorch人工智能深度学习
                        
      【yolov8】模型导出一、为什么要使用yolo的导出模式二、确保安装必要的库：三、yolov8模型导出3.1不同格式配置参数3.2导出格式四、导出模型性能优化4.1使用TensorRT导出模型有什么好处？4.2导出YOLOv8模型时，如何启用INT8量化？4.3为什么输出模型时动态输入尺寸很重要？4.4优化模型性能需要考虑哪些关键的导出参数？五、问题六、疑问训练模型的最终目标是将其部署到实际应用
      
                    
      • 
                    
    • YOLOv12改进之A2(区域注意力)
                        清风AI
深度学习算法详解及代码复现深度学习机器学习计算机视觉人工智能算法
                        
      注意力回顾注意力机制作为深度学习领域的核心技术，已广泛应用于自然语言处理和计算机视觉等多个领域。在YOLOv12改进之A2中，注意力机制扮演着关键角色。已有研究成果包括：Transformer架构：引入了自注意力机制，有效捕捉输入序列中的长距离依赖关系。CBAM模块：提出了通道和空间注意力的结合，显著提升了图像分类和目标检测的性能。SENet：引入了通道注意力机制，通过自适应学习特征通道的重要性，
      
                    
      • 
                    
    • YOLOv8目标检测推理流程及C++代码
                        吃鱼不卡次
YOLOonnxc++
                        
      这部分主要是使用c++对Onnx模型进行推理，边先贴代码，过段时间再详细补充下代码说明。代码主要分成三部分，1.main_det.cpp推理函数主入口；2.inference_det.h头文件及inference_det.cpp具体函数实现；3.CMakeList.txt.1.main_det推理配置信息全部写在config.txt中，执行代码时会读取该文本中配置信息来进行推理，config.tx
      
                    
      • 
                    
    • yolov8训练模型、测试视频
                        灰灰学姐
深度学习神经网络YOLOpython机器学习
                        
      yolov8先训练生成best.pt文件，用这个生成的模型进行视频的测试因为本来用的代码生成的测试视频打不开，格式应该是损坏了，或者部分帧没有正常保存吧。修改了一下代码，现状可以正常打开生成的视频了。1、训练代码train.pyimportos#os.environ["CUDA_VISIBLE_DEVICES"]="3"#同样是选择第3块GPUfromultralyticsimportYOLO#L
      
                    
      • 
                    
    • YOLOv5的Conv是什么，Conv就是卷积吗（1）
                        hjs314159
YOLO深度学习人工智能
                        
      不论是看YOLOv5还是最新的YOLOv12的网络结构，里面都有一个看起来雷打不动的部分，ConvConvolutionConvolution是卷积的意思，我们看一张图来简单理解一下神经网络里面的卷积的过程是什么样的。卷积一定是一个输入矩阵（特征）和一个卷积核矩阵做图中这样的计算。我们可以想象输入的就是一张单通道的黑白图像，特征矩阵的每一个数字代表了颜色的深浅（简单理解）。卷积核就相当于一个特征提
      
                    
      • 
                    
    • YoLo运用学习7
                        老农民编程
YoLo学习YOLO学习
                        
      目录前言一、C#环境使用YoLo模型进行AI推理检测1.加载图片2.图片预处理3.加载onnx模型并推理4.数据后处理5.图片属性值缩放还原和反归一化6.将解析到的信息的集合绘制成处理后图片总结前言根据YoLo运用学习3所说，实现在C#环境使用YoLo模型进行AI推理检测，最常见有两种：1、python训练好YoLo的模型pt格式，将其转化为onnx格式，通过C#的相关库去加载并推理onnx格式并
      
                    
      • 
                    
    • 【目标检测论文解读复现NO.38】基于改进YOLOv8模型的轻量化板栗果实识别方法
                        人工智能算法研究院
中文核心论文解读复现目标检测YOLO目标跟踪
                        
      前言此前出了目标改进算法专栏，但是对于应用于什么场景，需要什么改进方法对应与自己的应用场景有效果，并且多少改进点能发什么水平的文章，为解决大家的困惑，此系列文章旨在给大家解读最新目标检测算法论文，帮助大家解答疑惑。解读的系列文章，本人已进行创新点代码复现，有需要的朋友可关注私信我。本文仅对论文代码实现，如果原文章的作者觉得不方便，请联系删除，尊重每一位论文作者。一、摘要为实现自然环境下的板栗果实目
      
                    
      • 
                    
    • YOLOv8改进主干RTMDet论文系列：高效涨点的单阶段目标检测器主干
                        IdfdFsharp
YOLO计算机视觉
                        
      近年来，目标检测技术在计算机视觉领域取得了显著的进展。为了提高目标检测器的性能和降低延时，研究人员不断提出新的方法和架构。本文介绍了一篇名为"YOLOv8改进主干RTMDet"的论文系列，该系列通过结合最新的RTMDet论文和采用CSPNeXt主干结构，实现了高性能、低延时的单阶段目标检测器主干。在本论文系列中，作者着重研究了目标检测器主干的改进方法。主干网络在目标检测中扮演着重要的角色，它负责提
      
                    
      • 
                    
    • 基于深度学习的田间杂草检测系统：YOLOv5/v6/v7/v8/v10模型实现与UI界面集成
                        深度学习&目标检测实战项目
深度学习YOLOui人工智能目标检测
                        
      随着农业科技的发展，农作物的种植和管理越来越依赖于智能化技术。杂草作为农田生产中的一种主要竞争作物，会对农作物的生长造成负面影响。为了提高作物产量和品质，及时准确地检测和管理杂草显得尤为重要。本文将详细介绍如何构建一个基于深度学习的田间杂草检测系统，使用YOLO模型进行目标检测，包含数据集准备、模型训练、用户界面设计及系统实现。目录1.项目概述1.1背景1.2项目目标2.环境准备2.1软件需求2.
      
                    
      • 
                    
    • 新环境搭建时的pip install -r requirements.txt
                        m0_65915256
pip运维
                        
      直接安装pipinstall-rrequirements.txt时会出现ERROR:Couldnotopenrequirementsfile:[Errno2]Nosuchfileordirectory:'requirements.txt'的报错1、首先进入你的环境：（yolov9是我的环境名称，请替换成你自己的环境名）condaactivateyolov92、生成requirements.txt文
      
                    
      • 
                    
    • 《YOLOv12魔术师专栏》专栏介绍 & 专栏目录
                        AI小怪兽
YOLOv811v12成长师YOLO深度学习人工智能目标检测计算机视觉
                        
      《YOLOv12魔术师专栏》将从以下各个方向进行创新（更新日期25.03.05）：【原创自研模块】【多组合点优化】【注意力机制】【主干篇】【neck优化】【卷积魔改】【block&多尺度融合结合】【损失&IOU优化】【上下采样优化】【小目标性能提升】【前沿论文分享】【训练实战篇】订阅者可以申请发票，便于报销定期向订阅者提供源码工程+windows编译好的环境，配合博客使用《YOLOv12魔术师专栏
      
                    
      • 
                    
    • YOLO 银行柜员业务助手
                        鱼弦
人工智能时代YOLO
                        
      YOLO银行柜员业务助手介绍YOLO（YouOnlyLookOnce）是一种实时目标检测算法，因其快速、准确的特点，被广泛应用于各种领域。在银行环境中，YOLO可以帮助自动识别和处理柜台上出现的文档、货币等物品，从而支持柜员进行高效、安全的操作。这类系统能够减少人为错误，提高客户服务质量。应用使用场景文件和票据识别：自动检测和分类客户提供的文件和票据。货币识别与计数：自动识别并记录不同面额的钞票，
      
                    
      • 
                    
    • 运行时候的导包搜索路径虽然pycharm中标红但不影响程序的执行
                        火星种萝卜
python实践深度学习人工智能
                        
      在pycharm中报如下包找不到frommodels.yolo_layerimportYoloLayer，但是该行的前面已经导入了搜包的路径，运行时并不报错，只是pycharm在分析静态代码结构层面会标红提示找不到包importosimportsysPACKAGE_PARENT='..'SCRIPT_DIR=os.path.dirname(os.path.realpath(os.path.join
      
                    
      • 
                    
    • 深度学习数据集封装-----目标检测篇
                        科研小天才
深度学习目标检测人工智能
                        
      前言在上篇文章中，我们深入探讨了图像分类数据集的制作流程。图像分类作为计算机视觉领域的一个基础任务，通常被认为是最为简单直接的子任务之一。然而，当我们转向目标检测任务时，复杂度便显著提升，尤其是在标注框的处理环节。不同的模型架构往往对标注框的处理方式有着各自独特的要求。以YOLO系列为例，它自有一套成熟且高效的方法来应对这一挑战。鉴于篇幅有限，本文暂不深入展开YOLO的相关内容，感兴趣的读者可以查
      
                    
      • 
                    
    • 【目标检测】工地扬尘检测数据集3832张YOLO+VOC格式
                        不会仰游的河马君
目标检测YOLO人工智能工地扬尘数据集
                        
      【目标检测】工地扬尘检测数据集3832张YOLO+VOC格式数据集格式：VOC格式+YOLO格式压缩包内含：3个文件夹，分别存储图片、xml、txt文件JPEGImages文件夹中jpg图片总计：3832Annotations文件夹中xml文件总计：3832labels文件夹中txt文件总计：3832标签种类数：1标签名称:["dust"]每个标签的框数（注意yolo格式类别顺序不和这个对应，而以
      
                    
      • 
                    
    • YOLO在PiscTrace上检测到数据分析
                        那雨倾城
PiscTraceYOLO计算机视觉视觉检测数据分析信息可视化
                        
      在现代计算机视觉领域，实时视频数据的检测与分析对于安全监控、交通管理以及智能制造等领域具有重要意义。YOLO（YouOnlyLookOnce）作为一种高效的目标检测算法，能够在保持高精度的同时实现实时检测。而PiscTrace作为一款集成了OpenCV、MiDaS和YOLO技术的桌面应用，为用户提供了全面的图像与视频流处理解决方案。本文将探讨如何利用YOLO进行实时视频数据检测，并结合PiscTr
      
                    
      • 
                    
    • 分布式多卡训练(DDP)踩坑
                        m0_54804970
面试学习路线阿里巴巴分布式
                        
      多卡训练最近在跑yolov10版本的RT-DETR，用来进行目标检测。单卡训练语句（正常运行）：pythonmain.py多卡训练语句：需要通过torch.distributed.launch来启动，一般是单节点，其中CUDA_VISIBLE_DEVICES设置用的显卡编号，也可以不用，直接在main.py里面指定device也行，–nproc_pre_node每个节点的显卡数量。python-m
      
                    
      • 
                    
    • YOLO 中 SPFF 模块的优化与 Focal Modulation 替代研究
                        向哆哆
YOLOyolov8
                        
      文章目录1.YOLO中的SPPF模块分析2.FocalModulation简介3.在YOLO中用FocalModulation替换SPPF4.实验与对比分析4.1代码替换YOLO模型中的SPPF4.2训练对比5.AblationStudy（消融实验）5.1不同模块的对比实验5.2目标尺寸对比分析6.模型部署与推理优化6.1ONNX加速推理6.2适配JetsonNano7.进一步优化方向8.在YOL
      
                    
      • 
                    
    • AI视觉觉醒：深度学习如何革新视频标注，释放数据潜力基于深度学习的视频自动标注系统
                        海棠AI实验室
AI理论探索与学术前沿人工智能深度学习音视频
                        
      目录引言：被忽视的视频数据金矿传统视频标注的困境：效率、成本与瓶颈深度学习：视频自动标注的破局之道深度学习视频自动标注系统架构系统架构图核心技术解析目标检测（ObjectDetection）行为识别（ActionRecognition）视频分割（VideoSegmentation）代码实践：基于YOLOv5的目标检测视频标注示例挑战与未来展望结语：AI赋能，释放视频数据的无限可能引言：被忽视的视频
      
                    
      • 
                    
    • Python之使用动态导包优化软件加载速度
                        Sherry Wangs
Python开发实践python开发语言
                        
      在开发大型Python软件时，可能会遇到以下问题：由于静态导入了大量模块，导致软件启动时间过长，用户体验不佳。例如，一个复杂的桌面应用程序或Web服务可能依赖于多个大型库（如numpy、pandas、torch或Yolo），这些库在启动时被静态导入，即使某些功能模块在启动时并不需要立即使用。这种情况下，静态导入会显著增加软件的启动时间，故使用动态导入。文章目录1.静态导入（StaticImport
      
                    
      • 
                    
    • 基于YOLOv5的无人超市商品检测：食品、饮料、零食与家居用品
                        深度学习&目标检测实战项目
YOLO目标跟踪深度学习人工智能ui
                        
      引言随着人工智能技术的快速发展，尤其是计算机视觉的提升，无人超市的概念逐渐成为现实。在无人超市中，商品的智能化管理和检测是其顺利运行的关键。商品检测不仅要实现高效、准确的物品识别，还要支持多种商品类别的实时检测，以保证购物体验的顺畅与安全。在此背景下，深度学习与目标检测算法，如YOLOv5，成为了实现这一目标的重要工具。YOLOv5作为目前最先进且高效的目标检测算法之一，其应用范围广泛，包括人脸检
      
                    
      • 
                                
    • 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发布消息 
    
 
      
                                
      •