叶知秋高
叶知秋高

YOLOV5从训练到部署测试NCNN安卓端部署保姆级教程

一、基础配置

  • 为防止环境差异，造成教程中部分步骤出现差异，造成部署失败，下面将组件版本列举出来。

组件

版本

anaconda

4.8.3

python

3.8.13

yolov5

6.0

System

Ubuntu 22.04.1 x86_64

System Core

5.10.102.1

gcc

11.2.0

g++

11.2.0

其中System、System Core、gcc、g++版本也许其他低版本也可以，但需自测。建议在docker中进行环境搭建。

  • 初始化系统配置
sudo apt update
sudo apt install git gcc g++ vim curl wget cmake -y

1、Anaconda

  • 下载Anaconda(如果使用Miniconda也可以从此处下载)
  • 安装完毕后初始化配置conda
conda config --set show_channel_urls yes #在用户目录下生成.condarc文件
  • 为了加快下载速度，我们可以配置大陆境内conda加速镜像。打开用户目录下的.condarc文件，编辑内部信息
channels:
  - defaults
show_channel_urls: true
default_channels:
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/main
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/r
  - https://mirrors.tuna.tsinghua.edu.cn/anaconda/pkgs/msys2
custom_channels:
  conda-forge: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  msys2: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  bioconda: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  menpo: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  pytorch: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  pytorch-lts: https://mirrors.tuna.tsinghua.edu.cn/anaconda/cloud
  simpleitk: https://mirrors.tuna.tsinghua.edu.cn/anaconda/clou
  • 创建YOLO基础环境
conda create -n yolo python=3.8 # 创建一个名为yolo的python3.8环境

2、YoloV5

git clone https://github.com/ultralytics/yolov5.git # 下载yolov5源码
cd yolov5
git checkout v6.0 -b v6.0 # 切换为6.0版本
git checkout
conda activate yolo # 切换到前面创建的conda环境
  • 打开requirements.txt文件，修改其中内容
# pip install -r requirements.txt

# Base ----------------------------------------
matplotlib>=3.2.2
numpy>=1.18.5
opencv-python>=4.1.2
Pillow>=7.1.2
PyYAML>=5.3.1
requests>=2.23.0
scipy>=1.4.1
torch==1.7.1
torchvision==0.8.1
tqdm>=4.41.0

# Logging -------------------------------------
tensorboard==2.4.1
# wandb

# Plotting ------------------------------------
pandas>=1.1.4
seaborn>=0.11.0

# Export --------------------------------------
# coremltools>=4.1  # CoreML export
# onnx>=1.9.0  # ONNX export
# onnx-simplifier>=0.3.6  # ONNX simplifier
# scikit-learn==0.19.2  # CoreML quantization
# tensorflow>=2.4.1  # TFLite export
# tensorflowjs>=3.9.0  # TF.js export

# Extras --------------------------------------
# albumentations>=1.0.3
# Cython  # for pycocotools https://github.com/cocodataset/cocoapi/issues/172
# pycocotools>=2.0  # COCO mAP
# roboflow
thop  # FLOPs computation
  • 安装Yolo基础环境
pip install -r requirements.txt -i https://mirrors.aliyun.com/pypi/simple/
conda install onnx
pip install onnxsim
pip install onnx-simplifier
pip install onnxruntime

二、训练样本

  • 准备labelimg环境
conda create -n labelimg python=3.8
conda activate labelimg
conda install labelimg
labelimg

此时，系统会打开labelimg工具

  • 创建样本
  1. 我们在系统系统目录下创建metadata目录，在目录下分别创建images、labels文件夹。
  2. 将包含需要识别目标的图片全部放入到images文件夹下。
  3. 打开labelimg，点击打开文件夹（打开目录），选择images所在文件夹。
  4. 点击改变存放目录，选择labels所在文件夹
  5. 点击标记模式为yolo模式，如下图所示。

YOLOV5从训练到部署测试NCNN安卓端部署保姆级教程_第1张图片

点击查看 -> 自动保存模式，即打开自动保存模式。

  • 开始标注

labelimg快捷键：W，开启标注框。A，上一张。D，下一张。将全部图片标注完毕。（准备的单个图片不需要包含所有需要识别的类别）

  • 创建配置 xxx.yml
# 训练集，yolo会读取此文件夹下所有图片进行训练,有条件建议切分样本或者分批标注训练集、测试集、验证集。此处路径使用了相对路径，因此yolo会以 train.py 所在目录为根目录进行样本的搜索
train: ./metadata/images
# 验证集
val: ./metadata/images
# 验证集
test: ./metadata/images
# 类别个数,标注的时候共涉及到了几个类别，就填几，跟下面names下的个数相等
nc: 3
# 类别列表, 枚举所有类别, 可以直接复制 labels/classes.txt 下的所有类别，粘贴到此处，记得带引号,与classes.txt 顺序不要错
names: ["a", "b", "c"]

此处我们将训练集、验证集、测试集放到了相同位置，可能造成结果与样本拟合，我们也可以将训练集、测试集、验证集按照下面的目录结构放置样本及配置

── images // 存放所有图像数据
   ├── test // 测试集图片存放位置
   │   ├── xxx.jpg

   ├── train // 训练集图片存放位置
   │   ├── xxx.jpg

   └── val // 验证集图片存放位置
       ├── xxx.jpg

── labels // 所有标注完毕后的数据
    ├── test // 测试集标注标签文件所在位置
    │   ├── xxx.txt

    ├── train// 训练集标注标签文件所在位置
    │   ├── xxx.txt
   
    └── val// 验证集标注标签文件所在位置
        ├── xxx.txt

注意：images下样本集各自文件夹下的样本名称必须与labels下各自文件夹下的样本配置名称相同。

此处提供一个可以自动切分样本的py脚本

import os
import random
import argparse
import shutil
# 默认会从指定的目录的上级目录下的labels下查找。例如sourcepath指定为 ./dataset/images 则会认为 ./dataset/labels中存放的是所有标注完毕后的标签
LABELS_PATH = "./labels"
CLASSES_PROPERTIES = LABELS_PATH + "/classes.txt"
parser = argparse.ArgumentParser()
# 未切分的数据集地址
parser.add_argument('--source_path', type=str, help='input images path')
# 数据集划分完毕后存放的位置，不存在会自己创建
parser.add_argument('--save_path', default='./save_path', type=str, help='new train dataset path')
# parser.add_argument("--val_path", default="./val", type=str, help="new verify dataset path")
# parser.add_argument("--test_path", default="./test", type=str, help="new verify dataset path")
# 分割比例
parser.add_argument("--dataset_split_rate", default="7:2:1", type=str, help="dataset split rate, default: 7:2:1 as train:val:test")
opt = parser.parse_args()

source_path = opt.source_path

train_path = os.path.join(opt.save_path, "./images/train")
val_path = os.path.join(opt.save_path, "./images/val")
test_path = os.path.join(opt.save_path, "./images/test")

dataset_split_rate = opt.dataset_split_rate

train_dataset_rate = 0
val_dataset_rate = 0
test_dataset_rate = 0

if not os.path.exists(source_path):
	raise Exception(source_path + " not found exists")

if not os.path.exists(train_path):
	os.makedirs(train_path)

if not os.path.exists(val_path):
	os.makedirs(val_path)

if not os.path.exists(test_path):
	os.makedirs(test_path)

dataset_split_rate = dataset_split_rate.split(":")
if len(dataset_split_rate) != 3:
	raise Exception("dataset_split_rate must be third numbers exp: 7:2:1")

train_dataset_rate = dataset_split_rate[0]
val_dataset_rate = dataset_split_rate[1]
test_dataset_rate = dataset_split_rate[2]

if not train_dataset_rate.isdigit():
	raise Exception("dataset_split_rate must be third numbers exp: 7:2:1")

if not val_dataset_rate.isdigit():
	raise Exception("dataset_split_rate must be third numbers exp: 7:2:1")

if not test_dataset_rate.isdigit():
	raise Exception("dataset_split_rate must be third numbers exp: 7:2:1")

train_dataset_rate = int(train_dataset_rate)
val_dataset_rate = int(val_dataset_rate)
test_dataset_rate = int(test_dataset_rate)

if train_dataset_rate + val_dataset_rate + test_dataset_rate != 10:
	raise Exception("dataset sum rate must be 10, current val : " + str(train_dataset_rate + val_dataset_rate + test_dataset_rate))

train_dataset_rate = train_dataset_rate * 0.1
val_dataset_rate = val_dataset_rate * 0.1
test_dataset_rate = test_dataset_rate * 0.1

# 读取源数据路径
all_dataset = {}

for image in os.listdir(source_path):
	image_path = os.path.abspath(os.path.join(source_path, image))
	fname = os.path.splitext(image)[-2]
	label_path = os.path.abspath(os.path.join(source_path, "../" + LABELS_PATH + "/" + fname + '.txt'))
	all_dataset[image_path] = label_path

if len(all_dataset) < 3:
	raise Exception("dataset images number must > 3...")

image_orders = list(all_dataset.keys())

random.shuffle(image_orders)

train_dataset = {}
val_dataset = {}
test_dataset = {}

# 分割样本
train_dataset_max_index = int(train_dataset_rate * len(image_orders))
val_dataset_max_index = int(val_dataset_rate * len(image_orders))
test_dataset_max_index = int(test_dataset_rate * len(image_orders))

for k in image_orders:
	if len(train_dataset) >= train_dataset_max_index:
		if len(val_dataset) >= val_dataset_max_index:
			test_dataset[k] = all_dataset[k]
		else:
			val_dataset[k] = all_dataset[k]
	else:
		train_dataset[k] = all_dataset[k]

# 保存训练集

for f in train_dataset.keys():
	f = str(f)
	shutil.copy(f, train_path)
	clas_path = os.path.abspath(os.path.join(train_path, "../../" + LABELS_PATH + "/train"))
	if not os.path.exists(clas_path):
		os.makedirs(clas_path)
	shutil.copy(train_dataset[f], clas_path)


for f in val_dataset.keys():
	f = str(f)
	shutil.copy(f, val_path)
	clas_path = os.path.abspath(os.path.join(train_path, "../../" + LABELS_PATH + "/val"))
	if not os.path.exists(clas_path):
		os.makedirs(clas_path)
	shutil.copy(val_dataset[f], clas_path)

for f in test_dataset.keys():
	f = str(f)
	shutil.copy(f, test_path)
	clas_path = os.path.abspath(os.path.join(train_path, "../../" + LABELS_PATH + "/test"))
	if not os.path.exists(clas_path):
		os.makedirs(clas_path)
	shutil.copy(test_dataset[f], clas_path)

执行分割

# source_path 所有的样本图片所在目录。save_path：分割完毕后的图片存放目录。data_split_rate：样本切分比例(训练集:验证集:测试集)
python xxx.py --source_path ./metadata/images --save_path ./dataset --dataset_split_rate 7:2:1

样本被保存到了 dataset下，我们在dataset下创建xxx.yaml配置文件。

# 例如根目录名称为dataset
train: ./dataset/images/train
# 验证集
val: ./dataset/images/val
# 测试集
test: ./dataset/images/test
# 类别个数,标注的时候共涉及到了几个类别，就填几
nc: 3 
# 类别列表, 枚举所有类别, 可以直接复制 labels/classes.txt 下的所有类别，粘贴到此处，记得带引号,与ckasses.txt 顺序不要错
names: ["a", "b", "c"]
  • 训练样本
conda activate yolo
 # 进入yolov5源代码目录
cd yolov5
# 手动下载基础模型，指定为6.0版本
wget https://github.com/ultralytics/yolov5/releases/download/v6.0/yolov5s.pt
# 测试模型，执行完毕后,控制台会输出推理结果，Results saved to runs/detect/xxx 打开此文件夹，查看推理完毕后的结果是否正常
python detect.py --weights yolov5s.pt --img 640 --conf 0.25 --source data/images/
# 开始训练, 注意 --data 后参数，指向上面创建的yaml文件, 训练完毕后，系统会提示样本保存的目录：Optimizer stripped from runs/train/exp/weights/xxx.pt 
python train.py --img 640 --batch 50 --epochs 100 --data ../metadata/xxx.yaml --weights yolov5s.pt --nosave --cache
# 如果出现 requirements: tensorboard>=2.4.1 not found and is required by YOLOv5，手动执行下面的命令
pip install tensorboard==2.4.1
# 测试模型是否正常 --weights 为训练完毕后的模型文件， --img 同训练时 img参数 --conf 最低置信度，当分值低于此分数时，不在图片中标注。--source 需要被推理的图片所在目录
python detect.py --weights runs/train/exp/weights/xxx.pt --img 640 --conf 0.25 --source data/images/
  • 检出为ncnn可用模型
# 检出为onnx模型,注意weights指向上一步训练出来的模型
python export.py --weights ./run/train/exp/weights/xxx.pt --img 640 640 --batch 1 --train --simplify --include onnx --opset 11
# 简化onnx模型
python -m onnxsim ./run/train/exp/weights/xxx.onnx ./run/train/exp/weights/yolov5s-sim.onnx
# 转换为ncnn模型，可以打开此网站 https://convertmodel.com/ 选择onnx转ncnn，如果自行编译了ncnn，可以打开install/bin 执行下边的命令
./onnx2ncnn ./run/train/exp/weights/yolov5s-sim.onnx ./run/train/exp/weights/yolov5s.param ./run/train/exp/weights/yolov5s.bin
  • 修改配置

打开生成的yolov5s.param文件,修改Reshape参数，将0=6400、1600、400全部改为 0=-1

YOLOV5从训练到部署测试NCNN安卓端部署保姆级教程_第2张图片

 如下图

YOLOV5从训练到部署测试NCNN安卓端部署保姆级教程_第3张图片

 记录三组Permute数值的倒数第二列信息，如下图，例如我的样本配置结果为 "output", "365", "385"。如果你的Permute倒数第二列参数不是纯数值（除output之外），此时即代表后面所有的步骤都可能出现无法控制的结果，请重新开始训练，及检查你的yolo版本。

YOLOV5从训练到部署测试NCNN安卓端部署保姆级教程_第4张图片

 三、安卓端部署

  • 打开Android Studio项目，创建或打开一个项目，切换项目显示模式为project

YOLOV5从训练到部署测试NCNN安卓端部署保姆级教程_第5张图片

  • 创建模块，模块类型选择Android Native Library，注意选择c++11

YOLOV5从训练到部署测试NCNN安卓端部署保姆级教程_第6张图片

  • 点击Android Studio工具栏 Tools -> SDK Manager,检查cmake 3.10.2是否已安装，如果没有安装，请安装此工具

YOLOV5从训练到部署测试NCNN安卓端部署保姆级教程_第7张图片

  • 修改插件目录下 src -> main -> cpp -> CMakeLists.txt文件。
project(yolov5ncnn) # 记录此名称，建议设置为插件名称

cmake_minimum_required(VERSION 3.4.1)

set(ncnn_DIR ${CMAKE_SOURCE_DIR}/ncnnvulkan/${ANDROID_ABI}/lib/cmake/ncnn)
find_package(ncnn REQUIRED)
# yolov5ncnn 参数与上名称对应，yolov5ncnn_jni.cpp即为模块创建时，自动创建在与CMakeLists.txt 平级的cpp文件，当然也可以后面手动创建
add_library(yolov5ncnn SHARED yolov5ncnn_jni.cpp)
# yolov5ncnn同上，下边两个参数不变
target_link_libraries(yolov5ncnn
    ncnn

    jnigraphics
)

其中ncnnvulkan需要自行下载编译，或到此下载发行包，选择ncnn-xxx-android-vulkan.zip。如果github打不开，请在此下载（希望大家在此处下载，创作不易，支持一下）。

将ncnnvulkan依赖放入与CMakeLists.txt平级目录，结构如下

ncnnvulkan
    ├─arm64-v8a
    │  ├─include
    │  │  ├─glslang
    │  │  │  ├─Include
    │  │  │  ├─MachineIndependent
    │  │  │  │  └─preprocessor
    │  │  │  ├─Public
    │  │  │  └─SPIRV
    │  │  └─ncnn
    │  └─lib
    │      └─cmake
    │          └─ncnn
    ├─armeabi-v7a
    │  ├─include
    │  │  ├─glslang
    │  │  │  ├─Include
    │  │  │  ├─MachineIndependent
    │  │  │  │  └─preprocessor
    │  │  │  ├─Public
    │  │  │  └─SPIRV
    │  │  └─ncnn
    │  └─lib
    │      └─cmake
        │  │  ├─Include
        │  │  ├─MachineIndependent
        │  │  │  └─preprocessor
        │  │  ├─Public
        │  │  └─SPIRV
        │  └─ncnn
        └─lib
            └─cmake
                └─ncnn
CMakeLists.txt
  • 修改与CMakeLists.txt平级的yolov5ncnn_jni.cpp文件（CMakeLists.txt中指定的cpp文件）
// Tencent is pleased to support the open source community by making ncnn available.
//
// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
//
// Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// https://opensource.org/licenses/BSD-3-Clause
//
// Unless required by applicable law or agreed to in writing, software distributed
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.

#include 
#include 
#include 

#include 

#include 
#include 

// ncnn
#include "layer.h"
#include "net.h"
#include "benchmark.h"

static ncnn::UnlockedPoolAllocator g_blob_pool_allocator;
static ncnn::PoolAllocator g_workspace_pool_allocator;

static ncnn::Net yolov5;

class YoloV5Focus : public ncnn::Layer
{
public:
    YoloV5Focus()
    {
        one_blob_only = true;
    }

    virtual int forward(const ncnn::Mat& bottom_blob, ncnn::Mat& top_blob, const ncnn::Option& opt) const
    {
        int w = bottom_blob.w;
        int h = bottom_blob.h;
        int channels = bottom_blob.c;

        int outw = w / 2;
        int outh = h / 2;
        int outc = channels * 4;

        top_blob.create(outw, outh, outc, 4u, 1, opt.blob_allocator);
        if (top_blob.empty())
            return -100;

        #pragma omp parallel for num_threads(opt.num_threads)
        for (int p = 0; p < outc; p++)
        {
            const float* ptr = bottom_blob.channel(p % channels).row((p / channels) % 2) + ((p / channels) / 2);
            float* outptr = top_blob.channel(p);

            for (int i = 0; i < outh; i++)
            {
                for (int j = 0; j < outw; j++)
                {
                    *outptr = *ptr;

                    outptr += 1;
                    ptr += 2;
                }

                ptr += w;
            }
        }

        return 0;
    }
};

DEFINE_LAYER_CREATOR(YoloV5Focus)

struct Object
{
    float x;
    float y;
    float w;
    float h;
    int label;
    float prob;
};

static inline float intersection_area(const Object& a, const Object& b)
{
    if (a.x > b.x + b.w || a.x + a.w < b.x || a.y > b.y + b.h || a.y + a.h < b.y)
    {
        // no intersection
        return 0.f;
    }

    float inter_width = std::min(a.x + a.w, b.x + b.w) - std::max(a.x, b.x);
    float inter_height = std::min(a.y + a.h, b.y + b.h) - std::max(a.y, b.y);

    return inter_width * inter_height;
}

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].w * faceobjects[i].h;
    }

    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);
    }
}

static inline float sigmoid(float x)
{
    return static_cast(1.f / (1.f + exp(-x)));
}

static void generate_proposals(const ncnn::Mat& anchors, int stride, const ncnn::Mat& in_pad, const ncnn::Mat& feat_blob, float prob_threshold, std::vector& objects)
{
    const int num_grid = feat_blob.h;

    int num_grid_x;
    int num_grid_y;
    if (in_pad.w > in_pad.h)
    {
        num_grid_x = in_pad.w / stride;
        num_grid_y = num_grid / num_grid_x;
    }
    else
    {
        num_grid_y = in_pad.h / stride;
        num_grid_x = num_grid / num_grid_y;
    }

    const int num_class = feat_blob.w - 5;

    const int num_anchors = anchors.w / 2;

    for (int q = 0; q < num_anchors; q++)
    {
        const float anchor_w = anchors[q * 2];
        const float anchor_h = anchors[q * 2 + 1];

        const ncnn::Mat feat = feat_blob.channel(q);

        for (int i = 0; i < num_grid_y; i++)
        {
            for (int j = 0; j < num_grid_x; j++)
            {
                const float* featptr = feat.row(i * num_grid_x + j);

                // find class index with max class score
                int class_index = 0;
                float class_score = -FLT_MAX;
                for (int k = 0; k < num_class; k++)
                {
                    float score = featptr[5 + k];
                    if (score > class_score)
                    {
                        class_index = k;
                        class_score = score;
                    }
                }

                float box_score = featptr[4];

                float confidence = sigmoid(box_score) * sigmoid(class_score);

                if (confidence >= prob_threshold)
                {
                    // yolov5/models/yolo.py Detect forward
                    // y = x[i].sigmoid()
                    // y[..., 0:2] = (y[..., 0:2] * 2. - 0.5 + self.grid[i].to(x[i].device)) * self.stride[i]  # xy
                    // y[..., 2:4] = (y[..., 2:4] * 2) ** 2 * self.anchor_grid[i]  # wh

                    float dx = sigmoid(featptr[0]);
                    float dy = sigmoid(featptr[1]);
                    float dw = sigmoid(featptr[2]);
                    float dh = sigmoid(featptr[3]);

                    float pb_cx = (dx * 2.f - 0.5f + j) * stride;
                    float pb_cy = (dy * 2.f - 0.5f + i) * stride;

                    float pb_w = pow(dw * 2.f, 2) * anchor_w;
                    float pb_h = pow(dh * 2.f, 2) * anchor_h;

                    float x0 = pb_cx - pb_w * 0.5f;
                    float y0 = pb_cy - pb_h * 0.5f;
                    float x1 = pb_cx + pb_w * 0.5f;
                    float y1 = pb_cy + pb_h * 0.5f;

                    Object obj;
                    obj.x = x0;
                    obj.y = y0;
                    obj.w = x1 - x0;
                    obj.h = y1 - y0;
                    obj.label = class_index;
                    obj.prob = confidence;

                    objects.push_back(obj);
                }
            }
        }
    }
}

extern "C" {

// FIXME DeleteGlobalRef is missing for objCls
static jclass objCls = NULL;
static jmethodID constructortorId;
static jfieldID xId;
static jfieldID yId;
static jfieldID wId;
static jfieldID hId;
static jfieldID labelId;
static jfieldID probId;

JNIEXPORT jint JNI_OnLoad(JavaVM* vm, void* reserved)
{
    __android_log_print(ANDROID_LOG_DEBUG, "YoloV5Ncnn", "JNI_OnLoad");

    ncnn::create_gpu_instance();

    return JNI_VERSION_1_4;
}

JNIEXPORT void JNI_OnUnload(JavaVM* vm, void* reserved)
{
    __android_log_print(ANDROID_LOG_DEBUG, "YoloV5Ncnn", "JNI_OnUnload");

    ncnn::destroy_gpu_instance();
}

// public native boolean Init(AssetManager mgr);
JNIEXPORT jboolean JNICALL Java_com_tencent_yolov5ncnn_YoloV5Ncnn_Init(JNIEnv* env, jobject thiz, jobject assetManager)
{
    ncnn::Option opt;
    opt.lightmode = true;
    opt.num_threads = 4;
    opt.blob_allocator = &g_blob_pool_allocator;
    opt.workspace_allocator = &g_workspace_pool_allocator;
    opt.use_packing_layout = true;

    // use vulkan compute
    if (ncnn::get_gpu_count() != 0)
        opt.use_vulkan_compute = true;

    AAssetManager* mgr = AAssetManager_fromJava(env, assetManager);

    yolov5.opt = opt;

    yolov5.register_custom_layer("YoloV5Focus", YoloV5Focus_layer_creator);

    // init param
    {
        int ret = yolov5.load_param(mgr, "yolov5s.param");
        if (ret != 0)
        {
            __android_log_print(ANDROID_LOG_DEBUG, "YoloV5Ncnn", "load_param failed");
            return JNI_FALSE;
        }
    }

    // init bin
    {
        int ret = yolov5.load_model(mgr, "yolov5s.bin");
        if (ret != 0)
        {
            __android_log_print(ANDROID_LOG_DEBUG, "YoloV5Ncnn", "load_model failed");
            return JNI_FALSE;
        }
    }

    // init jni glue
    jclass localObjCls = env->FindClass("com/tencent/yolov5ncnn/YoloV5Ncnn$Obj");
    objCls = reinterpret_cast(env->NewGlobalRef(localObjCls));

    constructortorId = env->GetMethodID(objCls, "", "(Lcom/tencent/yolov5ncnn/YoloV5Ncnn;)V");

    xId = env->GetFieldID(objCls, "x", "F");
    yId = env->GetFieldID(objCls, "y", "F");
    wId = env->GetFieldID(objCls, "w", "F");
    hId = env->GetFieldID(objCls, "h", "F");
    labelId = env->GetFieldID(objCls, "label", "Ljava/lang/String;");
    probId = env->GetFieldID(objCls, "prob", "F");

    return JNI_TRUE;
}

// public native Obj[] Detect(Bitmap bitmap, boolean use_gpu);
JNIEXPORT jobjectArray JNICALL Java_com_tencent_yolov5ncnn_YoloV5Ncnn_Detect(JNIEnv* env, jobject thiz, jobject bitmap, jboolean use_gpu)
{
    if (use_gpu == JNI_TRUE && ncnn::get_gpu_count() == 0)
    {
        return NULL;
        //return env->NewStringUTF("no vulkan capable gpu");
    }

    double start_time = ncnn::get_current_time();

    AndroidBitmapInfo info;
    AndroidBitmap_getInfo(env, bitmap, &info);
    const int width = info.width;
    const int height = info.height;
    if (info.format != ANDROID_BITMAP_FORMAT_RGBA_8888)
        return NULL;

    // ncnn from bitmap
    const int target_size = 640;

    // letterbox 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_android_bitmap_resize(env, bitmap, ncnn::Mat::PIXEL_RGB, w, h);

    // pad to target_size rectangle
    // yolov5/utils/datasets.py letterbox
    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, 114.f);

    // yolov5
    std::vector objects;
    {
        const float prob_threshold = 0.25f;
        const float nms_threshold = 0.45f;

        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 = yolov5.create_extractor();

        ex.set_vulkan_compute(use_gpu);

        ex.input("images", in_pad);

        std::vector proposals;

        // anchor setting from yolov5/models/yolov5s.yaml

        // stride 8
        {
            ncnn::Mat out;
            ex.extract("output", out);

            ncnn::Mat anchors(6);
            anchors[0] = 10.f;
            anchors[1] = 13.f;
            anchors[2] = 16.f;
            anchors[3] = 30.f;
            anchors[4] = 33.f;
            anchors[5] = 23.f;

            std::vector objects8;
            generate_proposals(anchors, 8, in_pad, out, prob_threshold, objects8);

            proposals.insert(proposals.end(), objects8.begin(), objects8.end());
        }

        // stride 16
        {
            ncnn::Mat out;
            ex.extract("365", out);

            ncnn::Mat anchors(6);
            anchors[0] = 30.f;
            anchors[1] = 61.f;
            anchors[2] = 62.f;
            anchors[3] = 45.f;
            anchors[4] = 59.f;
            anchors[5] = 119.f;

            std::vector objects16;
            generate_proposals(anchors, 16, in_pad, out, prob_threshold, objects16);

            proposals.insert(proposals.end(), objects16.begin(), objects16.end());
        }

        // stride 32
        {
            ncnn::Mat out;
            ex.extract("385", out);

            ncnn::Mat anchors(6);
            anchors[0] = 116.f;
            anchors[1] = 90.f;
            anchors[2] = 156.f;
            anchors[3] = 198.f;
            anchors[4] = 373.f;
            anchors[5] = 326.f;

            std::vector objects32;
            generate_proposals(anchors, 32, in_pad, out, prob_threshold, objects32);

            proposals.insert(proposals.end(), objects32.begin(), objects32.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();

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

            // adjust offset to original unpadded
            float x0 = (objects[i].x - (wpad / 2)) / scale;
            float y0 = (objects[i].y - (hpad / 2)) / scale;
            float x1 = (objects[i].x + objects[i].w - (wpad / 2)) / scale;
            float y1 = (objects[i].y + objects[i].h - (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].x = x0;
            objects[i].y = y0;
            objects[i].w = x1 - x0;
            objects[i].h = y1 - y0;
        }
    }

    // objects to Obj[]
    static const char* class_names[] = {
            "bag", "task_info_area", "task_single_trigger", "task_success"
    };

    jobjectArray jObjArray = env->NewObjectArray(objects.size(), objCls, NULL);

    for (size_t i=0; iNewObject(objCls, constructortorId, thiz);

        env->SetFloatField(jObj, xId, objects[i].x);
        env->SetFloatField(jObj, yId, objects[i].y);
        env->SetFloatField(jObj, wId, objects[i].w);
        env->SetFloatField(jObj, hId, objects[i].h);
        env->SetObjectField(jObj, labelId, env->NewStringUTF(class_names[objects[i].label]));
        env->SetFloatField(jObj, probId, objects[i].prob);

        env->SetObjectArrayElement(jObjArray, i, jObj);
    }

    double elasped = ncnn::get_current_time() - start_time;
    __android_log_print(ANDROID_LOG_DEBUG, "YoloV5Ncnn", "%.2fms   detect", elasped);

    return jObjArray;
}

}

    

  1. 注意 432、451、470行，在第 “二” 步中，“修改配置”步骤中Permute的值，将三处参数依次修改为上同参数值，即 432行修改为 **ex.extract("output", out);** 451行修改为 **ex.extract("365", out);** 470行修改为"ex.extract("385", out);"。
    2. 

  2. 修改521行列表，与样本集中 labels下的classes.txt列表对应。
    3. 

  3. 修改351行 constructortorId = env->GetMethodID(objCls, "", "(Lcom/tencent/yolov5ncnn/YoloV5Ncnn;)V");，将“com/tencent/yolov5ncnn/YoloV5Ncnn” 修改为自定义java类，注意前部的“L”和尾部的“V”保留（或者直接按照此包结构在模块下的src/main/java下创建此包和类文件）
    4. 

  4. 修改348行 jclass localObjCls = env->FindClass("com/tencent/yolov5ncnn/YoloV5Ncnn$Obj"); 中 "com/tencent/yolov5ncnn/YoloV5Ncnn$Obj" 为自定义java类，同上，但不可丢掉后面的$Obj。
    5. 



    

  • 创建反射类
    • 



// Tencent is pleased to support the open source community by making ncnn available.
//
// Copyright (C) 2020 THL A29 Limited, a Tencent company. All rights reserved.
//
// Licensed under the BSD 3-Clause License (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// https://opensource.org/licenses/BSD-3-Clause
//
// Unless required by applicable law or agreed to in writing, software distributed
// under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
// CONDITIONS OF ANY KIND, either express or implied. See the License for the
// specific language governing permissions and limitations under the License.

package com.tencent.yolov5ncnn;

import android.content.res.AssetManager;
import android.graphics.Bitmap;

public class YoloV5Ncnn
{
    public native boolean Init(AssetManager mgr);

    public class Obj {
        // x
        public float x;
        // y
        public float y;
        // w
        public float w;
        // h
        public float h;
        // 标签
        public String label;
        // 置信度
        public float prob;

        @Override
        public String toString() {
            return "Obj{" +
                    "x=" + x +
                    ", y=" + y +
                    ", w=" + w +
                    ", h=" + h +
                    ", label='" + label + '\'' +
                    ", prob=" + prob +
                    '}';
        }
    }

    public native Obj[] Detect(Bitmap bitmap, boolean use_gpu);

    static {
        // 为CMakeLists.txt中配置的project名称
        System.loadLibrary("yolov5ncnn");
    }
}


    

  • 修改模块的build.grade配置
    • 



plugins {
    id 'com.android.library'
}

android {
    namespace 'cn.tiktok.ncnn'
    compileSdk 24

    defaultConfig {
        minSdk 24
        archivesBaseName = "$applicationId"
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
        consumerProguardFiles "consumer-rules.pro"
        externalNativeBuild {
            cmake {
                cppFlags "-std=c++11"
            }
        }
        ndk {
            // 可减少平台支持，减小包体积
            abiFilters "armeabi-v7a", "arm64-v8a", "x86", "x86_64"
        }
    }

    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android-optimize.txt'), 'proguard-rules.pro'
        }
    }
    externalNativeBuild {
        cmake {
            // 此处指向CMakeLists.txt 所在文件夹
            path "src/main/jni/CMakeLists.txt"
            version "3.10.2"
        }
    }
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
}

dependencies {
    implementation 'androidx.appcompat:appcompat:1.4.1'
    implementation 'com.google.android.material:material:1.5.0'
    testImplementation 'junit:junit:4.13.2'
    androidTestImplementation 'androidx.test.ext:junit:1.1.3'
    androidTestImplementation 'androidx.test.espresso:espresso-core:3.4.0'
}


    

  • 部署模型
    • 



在模块的src/main目录下创建 assets 文件夹，然后检查文件夹属性。如果被创建为了普通文件夹，如下图所示。


YOLOV5从训练到部署测试NCNN安卓端部署保姆级教程_第8张图片




则在此文件夹上右键，选择 Mark Directory as，选择Resources root。


我们在第“二”步的“检出为ncnn可用模型”步骤，生成了 yolov5s.param 和 yolov5s.bin两个文件，将两个文件复制到assets文件夹下。


然后在app中引入此模块，并使用，注意修改为模块名称


YOLOV5从训练到部署测试NCNN安卓端部署保姆级教程_第9张图片


 最后选择Android Studio菜单栏 File -> Sync Project wth Gradle FIles，等待执行完毕。


四、测试使用


public class MainActivity extends Activity{
    private YoloV5Ncnn yolov5ncnn = new YoloV5Ncnn();
    
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState){
        super.onCreate(savedInstanceState);
        // 初始化
        boolean ret_init = yolov5ncnn.Init(getAssets());
        if (!ret_init){
            Log.e("MainActivity", "yolov5ncnn Init failed");
        }
        // 图片、是否使用GPU
        YoloV5Ncnn.Obj[] objects = yolov5ncnn.Detect(imageBitmap, false);
        // 根据注释解析YoloV5Ncnn.Obj
        ...
    }
}



























你可能感兴趣的:(ubuntu,linux,运维)






    

  • Flink中的SQL Client和SQL Gateway
BigDataMLApplication
flinkflinksqlgateway

    Flink中的SQLClient和SQLGateway对比目录定义基本原理适用场景主要区别常用运维命令示例官方链接正文1.定义SQLClient：FlinkSQLClient是一种用于提交和执行FlinkSQL语句的命令行界面或图形界面工具。SQLGateway：FlinkSQLGateway是一个独立的服务，它允许客户端通过RESTfulAPI将SQL查询提交到Flink集群。2.基本原理SQL
    

    • 

  • 浪潮 M5系列服务器IPMI无法监控存储RAID卡问题.
Songxwn
硬件服务器服务器运维

    简介浪潮的M5代服务器，可能有WebBMC无法查看存储RAID/SAS卡状态的情况，可以通过以下方式修改。修改完成后重启BMC即可生效。ESXiIPMITools使用：https://songxwn.com/ESXi8_IPMI/（Linux也可以直接使用）Linux/ESXiIPMITool下载：https://songxwn.com/file/ipmitoolWindows下载：https:/
    

    • 

  • unblock with ‘mysqladmin flush-hosts‘ 解决方法
祈祷平安,加油
数据库常见问题oracle数据库

    MySqlHostisblockedbecauseofmanyconnectionerrors;unblockwith'mysqladminflush-hosts'解决方法环境：linux，mysql5.5.21错误：Hostisblockedbecauseofmanyconnectionerrors;unblockwith'mysqladminflush-hosts'原因：同一个ip在短时间内产
    

    • 

  • llama.cpp 编译安装@Ubuntu
skywalk8163
项目实践人工智能llamaubuntulinux人工智能

    在Kylin和Ubuntu编译llama.cpp，具体参考：llama模型c语言推理@FreeBSD-CSDN博客现在代码并编译：gitclonehttps://github.com/ggerganov/llama.cppcdllama.cppmkdirbuildcdbuildcmake..cmake--build.--configRelease#可选安装makeinstall#或可选添加路径ex
    

    • 

  • 1.计算机处理器架构+嵌入式处理器架构及知识
vv 啊
arm-linux学习linux系统架构

    目录一：x86-64处理器架构二：Intel80386处理器（i386）1.i3862.i686三：嵌入式Linux知识：1.MinGW2.GNU计划2.1GNU工具链概述此次只分享英特尔和ADM处理器有关于x86的架构，至于嵌入式处理器架构请查看https://en.wikipedia.org/wiki/List_of_ARM_processors一：x86-64处理器架构x86-64，也称为x
    

    • 

  • springboot集成logback-spring.xml文件
RT_0114
SpringBootspringbootspringlogback

    彩色日志日志分debug和error文件输出，方便开发人员运维日志限制最大保管天数日志限制总量大小占用量GB日志限制单个文件大小MB日志显示最大保留天数屏蔽没用的日志${CONSOLE_LOG_PATTERN}${log.path}/debug.log${log.path}/%d{yyyy-MM-dd,aux}/debug.%d{yyyy-MM-dd}.%i.log.gz1024MB50GB365
    

    • 

  • linux基础命令（一）
运维搬运工
linuxlinux服务器centos

    Linux基础命令1、设置主机名1.1、hostname查看主机名[root@ansible~]#cat/etc/hostnameansible或[root@ansible~]#hostnameansible注意：主机名中不允许使用下划线“_”，可以用短横线“-”1.2、hostname临时修改主机名#临时修改直接修改的是内存中的，重启会失效[root@ansible~]#hostnameansi
    

    • 

  • docker基础（一）
运维搬运工
容器-dockerdocker容器运维

    相关概念介绍Docker是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖到一个可移植的容器中，然后发布到任何流行的linux机器上，也可以实现虚拟化，容器是完全使用沙箱机制，互相之间不会有任何接口。Docker有几个重要概念：dockerfile，配置文件，用来生成dockerimagedockerimage，交付部署的最小单元docker命令与API，定义命令与接口，支持第三方系统集
    

    • 

  • 网络安全（黑客）——自学2024
小言同学喜欢挖漏洞
web安全安全网络学习网络安全信息安全渗透测试

    01什么是网络安全网络安全可以基于攻击和防御视角来分类，我们经常听到的“红队”、“渗透测试”等就是研究攻击技术，而“蓝队”、“安全运营”、“安全运维”则研究防御技术。无论网络、Web、移动、桌面、云等哪个领域，都有攻与防两面性，例如Web安全技术，既有Web渗透，也有Web防御技术（WAF）。作为一个合格的网络安全工程师，应该做到攻守兼备，毕竟知己知彼，才能百战百胜。02怎样规划网络安全如果你是一
    

    • 

  • 黑客（网络安全）技术自学30天
一个迷人的黑客
web安全安全网络笔记网络安全信息安全渗透测试

    01什么是网络安全网络安全可以基于攻击和防御视角来分类，我们经常听到的“红队”、“渗透测试”等就是研究攻击技术，而“蓝队”、“安全运营”、“安全运维”则研究防御技术。无论网络、Web、移动、桌面、云等哪个领域，都有攻与防两面性，例如Web安全技术，既有Web渗透，也有Web防御技术（WAF）。作为一个合格的网络安全工程师，应该做到攻守兼备，毕竟知己知彼，才能百战百胜。02怎样规划网络安全如果你是一
    

    • 

  • linux安装docker及docker-compose 部署spring boot项目
时而有事儿
dockerlinuxdockerlinuxspringboot

    linux系统环境：centos5.14本篇描述的是在centos系统版本下安装docker，如果是ubuntu版本，请看这篇文章：linuxubuntu20安装docker和docker-compose-CSDN博客正文：安装docker和docker-compose安装docker---------运行命名等待安装完成遇到选择直接输入yyuminstall-yyum-utilsdevice-m
    

    • 

  • 检测usb口HotPlug-netlink
cany1000
linux

    为了完成内核空间与用户空间通信，Linux提供了基于Socket的NetLink通信机制。SELinux，Linux系统的防火墙分为内核态的netfilter和用户态的iptables，netfilter与iptables的数据交换就是通过Netlink机制完成。下面看一个检测usb口的例子：s32InitUsbHotPlug(void){s32nSockFd=0;//套接字地址structsoc
    

    • 

  • Linux学习系列之vim编辑器（一）
llibertyll
linux学习

    vi编辑器的操作模式输入模式—aio等—>命令模式<—：键—末行模式从输入/末行模式切换到命令模式都是需要按ESC键注:a光标后输入，i光标前输入，o直接向下加一行输入，O向上加一行输入在vi编辑器中光标的移动（命令行模式下）键组合（命令）光标的移动$光标移动到当前行的结尾0（零）光标移动到当前行的开始GG光标移动到最后一行gg光标移动到第一行在命令行模式下删除与复制的操作键组合（命令）含义dd删
    

    • 

  • 自学黑客（网络安全）技术——2024最新
九九归二
web安全安全学习笔记网络网络安全信息安全

    01什么是网络安全网络安全可以基于攻击和防御视角来分类，我们经常听到的“红队”、“渗透测试”等就是研究攻击技术，而“蓝队”、“安全运营”、“安全运维”则研究防御技术。无论网络、Web、移动、桌面、云等哪个领域，都有攻与防两面性，例如Web安全技术，既有Web渗透，也有Web防御技术（WAF）。作为一个合格的网络安全工程师，应该做到攻守兼备，毕竟知己知彼，才能百战百胜。02怎样规划网络安全如果你是一
    

    • 

  • Azkaban各种类型的Job编写
__元昊__

    一、概述原生的Azkaban支持的plugin类型有以下这些：command：Linuxshell命令行任务gobblin：通用数据采集工具hadoopJava：运行hadoopMR任务java：原生java任务hive：支持执行hiveSQLpig：pig脚本任务spark：spark任务hdfsToTeradata：把数据从hdfs导入TeradatateradataToHdfs：把数据从Te
    

    • 

  • Linux初学（十）shell脚本
王依硕
Linuxlinux运维服务器

    一、for循环1.1循环的格式for变量in列表do代码代码....done循环的逻辑：将列表中的每个元素逐一赋值给变量每赋值一次，do和done之间的代码就会执行一次1.2列表的生成方式方法1：直接给出列表元素【用空格分隔多个元素】133129hahabaidu方法2：用通配符来生成元素/home/a*方法3：用命令来生成元素ls/etc/方法4：用{}展开的形式生成元素{3..7}{a..e}
    

    • 

  • Ubuntu下安装Chrome浏览器(简单,使用)
Starry-sky(jing)
[linux操作系统笔记]chrome深度学习linux

    下载安装GoogleChrome浏览器deb包极速下载:下载链接32位wgethttps://dl.google.com/linux/direct/google-chrome-stable_current_i386.deb64位wgethttps://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb安装sudodpk
    

    • 

  • 【Linux】PyCharm无法启动报错及解决方法
不是AI
python软件操作Linuxlinuxpycharm运维

    一、问题描述如图，笔者试图在Ubuntu18.04虚拟机上运行PyCharm开发工具（已安装，安装过程可以参考我的博客Ubuntu安装PyCharm），无法启动，报错：CannotconnecttoalreadyrunningIDEinstance.Exception:Process2574isstillrunning.报错截图如下：二、解决方法通过报错信息看出，出于某种原因，进程（PID为257
    

    • 

  • Linux（centos7）部署hive
灯下夜无眠
Linuxlinuxhive运维dbeaverhive客户端

    前提环境：已部署完hadoop(HDFS、MapReduce、YARN)1、安装元数据服务MySQL切换root用户#更新密钥rpm--importhttps://repo.mysql.com/RPM-GPG-KEY-mysqL-2022#安装Mysqlyum库rpm-Uvhhttp://repo.mysql.com//mysql57-community-release-el7-7.noarch.
    

    • 

  • Linux通过Tuned实现动态调优系统性能
星河_赵梓宇
linux运维服务器

    Linux通过Tuned实现动态调优系统性能Tuned简介对于普通用户来说，优化Linux应用环境可能是相当具有挑战性的。它涵盖了各种领域，并且有许多参数需要考虑，比如CPU、存储、缓存策略和内存管理。尽管Linux有默认设置可以处理大多数情况和场景，但是对于高性能、高并发和高可用性系统等特殊场景，需要进行调整。本文讨论的特性是tuned，它是Linux系统中常用的一种调优服务。tuned由两个程
    

    • 

  • vscode配置go远程linux
gdut17
golang

    Toolsenvironment:GOPATH=/root/goInstalling9toolsat/root/go/bininmodulemode.gopkgsgo-outlinegotestsgomodifytagsimplgoplaydlvgolintgoplsInstallinggithub.com/uudashr/gopkgs/v2/cmd/gopkgs(/root/go/bin/gop
    

    • 

  • 部署es集群
liushaojiax
elasticsearchjava大数据

    我们会在单机上利用docker容器运行多个es实例来模拟es集群。不过生产环境推荐大家每一台服务节点仅部署一个es的实例。部署es集群可以直接使用docker-compose来完成，但这要求你的Linux虚拟机至少有4G的内存空间创建es集群首先编写一个docker-compose文件，内容如下：version:'2.2'services:es01:image:elasticsearch:7.12
    

    • 

  • 网络安全（黑客技术）—自学
德西德西
web安全安全网络安全学习python开发语言php

    1.网络安全是什么网络安全可以基于攻击和防御视角来分类，我们经常听到的“红队”、“渗透测试”等就是研究攻击技术，而“蓝队”、“安全运营”、“安全运维”则研究防御技术。2.网络安全市场一、是市场需求量高；二、则是发展相对成熟入门比较容易。3.所需要的技术水平需要掌握的知识点偏多（举例）：4.国家政策环境对于国家与企业的地位愈发重要，没有网络安全就没有国家安全更有为国效力的正义黑客—红客联盟可见其重视
    

    • 

  • Ubuntu中安装VSCode的一个指令
Trigger_G
Ubuntu与ROSubuntuvscodelinux

    问题描述本来想去VSCode官网上下载软件包，然后双击使用UbuntuSoftware安装的，但是安装老不成功。想用命令行指令dpkg进行安装，虽然能成功，但是后续使用code.命令打开VSCode又报错说找不到命令。解决方式在命令行中使用下述命令安装VSCode。sudosnapinstall--classiccode（建议安装的时候连上手机的热点，不然会报连接不上下载站点相关的错误）
    

    • 

  • SQL运维_Unix下MySQL-8.0.18配置文件示例
Mostcow
SQLsql运维unix

    SQL运维_Unix下MySQL-8.0.18配置文件示例MySQL是一个关系型数据库管理系统,由瑞典MySQLAB公司开发,属于Oracle旗下产品。MySQL是最流行的关系型数据库管理系统之一,在WEB应用方面,MySQL是最好的RDBMS(RelationalDatabaseManagementSystem,关系数据库管理系统)应用软件之一。MySQL是一种关系型数据库管理系统,关系数据库将
    

    • 

  • 在 Linux/Ubuntu/Debian 上安装 SQL Server 2019
理工男老K
ubuntulinux运维debiansqlserver

    Microsoft为Linux发行版（包括Ubuntu）提供SQLServer。以下是有关如何执行此操作的基本指南：注册MicrosoftUbuntu存储库并添加公共存储库GPG密钥：sudowget-qO-https://packages.microsoft.com/keys/microsoft.asc|sudoapt-keyadd-sudoadd-apt-repository"$(wget-q
    

    • 

  • 关于HDP的20道高级运维面试题
编织幻境的妖
运维

    1.描述HDP的主要组件及其作用。HDP（HortonworksDataPlatform）的主要组件包括Hadoop框架、HDFS、MapReduce、YARN以及Hadoop生态系统中的其他关键工具，如Spark、Flink、Hive、HBase等。以下是对这些组件及其作用的具体描述：Hadoop框架:Hadoop是一个开源的分布式计算框架，用Java语言编写，用于存储和处理大规模数据集。它广义
    

    • 

  • ubuntu生成 设置 core文件
sun007700
ubuntulinux运维

    ubuntu生成&设置core文件，调试段错误_ubuntu生成core文件-CSDN博客ubuntu设置core文件_ubuntucore文件默认位置-CSDN博客ulimit-asudovim/etc/profile#或者vi~/.bashrculimit-cunlimited#添加，退出source/etc/profilesudosystemctldisableapport.servicev
    

    • 

  • 生信星球学习小组第80期 Day3笔记--ZJUSKY
ZJUSKY

    Conda简介Conda是一个开源的软件包管理系统和环境管理系统，用于安装多个版本的软件包及其依赖关系，并在它们之间轻松切换。简单来说Conda就是Linux系统下的应用商店，你可以在通过Conda下载，安装很多软件。这里我们推荐miniconda,它只包含了最基本的内容，python和conda，以及相关的必须依赖项。精简的miniconda足够满足日常生信使用。下载miniconda推荐使用清
    

    • 

  • 网络安全（黑客技术）—2024自学
德西德西
开发语言php安全web安全网络安全python网络

    1.网络安全是什么网络安全可以基于攻击和防御视角来分类，我们经常听到的“红队”、“渗透测试”等就是研究攻击技术，而“蓝队”、“安全运营”、“安全运维”则研究防御技术。2.网络安全市场一、是市场需求量高；二、则是发展相对成熟入门比较容易。3.所需要的技术水平需要掌握的知识点偏多（举例）：4.国家政策环境对于国家与企业的地位愈发重要，没有网络安全就没有国家安全更有为国效力的正义黑客—红客联盟可见其重视
    

    • 

  • sql统计相同项个数并按名次显示
朱辉辉33
javaoracle

    现在有如下这样一个表：
A表
ID Name time
------------------------------
0001 aaa 2006-11-18
0002 ccc 2006-11-18
0003 eee 2006-11-18
0004 aaa 2006-11-18
0005 eee 2006-11-18
0004 aaa 2006-11-18
0002 ccc 20
    

    • 

  • Android+Jquery Mobile学习系列-目录
白糖_
JQuery Mobile

    最近在研究学习基于Android的移动应用开发，准备给家里人做一个应用程序用用。向公司手机移动团队咨询了下，觉得使用Android的WebView上手最快，因为WebView等于是一个内置浏览器，可以基于html页面开发，不用去学习Android自带的七七八八的控件。然后加上Jquery mobile的样式渲染和事件等，就能非常方便的做动态应用了。
 
从现在起，往后一段时间，我打算
    

    • 

  • 如何给线程池命名
daysinsun
线程池

            在系统运行后，在线程快照里总是看到线程池的名字为pool-xx，这样导致很不好定位，怎么给线程池一个有意义的名字呢。参照ThreadPoolExecutor类的ThreadFactory，自己实现ThreadFactory接口，重写newThread方法即可。参考代码如下：
   
public class Named
    

    • 

  • IE 中"HTML Parsing Error:Unable to modify the parent container element before the
周凡杨
html解析errorreadyState

     
错误： IE 中"HTML Parsing Error:Unable to modify the parent container element before the child element is closed"
 
 
现象： 同事之间几个IE 测试情况下，有的报这个错，有的不报。经查询资料后，可归纳以下原因。
    

    • 

  • java上传
g21121
java

    我们在做web项目中通常会遇到上传文件的情况，用struts等框架的会直接用的自带的标签和组件，今天说的是利用servlet来完成上传。
我们这里利用到commons-fileupload组件，相关jar包可以取apache官网下载：http://commons.apache.org/
下面是servlet的代码：
//定义一个磁盘文件工厂
DiskFileItemFactory fact
    

    • 

  • SpringMVC配置学习
510888780
springmvc

    spring MVC配置详解
现在主流的Web MVC框架除了Struts这个主力 外，其次就是Spring MVC了，因此这也是作为一名程序员需要掌握的主流框架，框架选择多了，应对多变的需求和业务时，可实行的方案自然就多了。不过要想灵活运用Spring MVC来应对大多数的Web开发，就必须要掌握它的配置及原理。
　　一、Spring MVC环境搭建：（Spring 2.5.6 + Hi
    

    • 

  • spring mvc-jfreeChart 柱图(1)
布衣凌宇
jfreechart

    第一步：下载jfreeChart包，注意是jfreeChart文件lib目录下的，jcommon-1.0.23.jar和jfreechart-1.0.19.jar两个包即可；
第二步：配置web.xml;
web.xml代码如下
<servlet>
    <servlet-name>jfreechart</servlet-nam
    

    • 

  • 我的spring学习笔记13-容器扩展点之PropertyPlaceholderConfigurer
aijuans
Spring3

    PropertyPlaceholderConfigurer是个bean工厂后置处理器的实现，也就是BeanFactoryPostProcessor接口的一个实现。关于BeanFactoryPostProcessor和BeanPostProcessor类似。我会在其他地方介绍。PropertyPlaceholderConfigurer可以将上下文（配置文件）中的属性值放在另一个单独的标准java P
    

    • 

  • java 线程池使用 Runnable&Callable&Future
antlove
javathreadRunnablecallablefuture

    1. 创建线程池
ExecutorService executorService = Executors.newCachedThreadPool();
 
2. 执行一次线程，调用Runnable接口实现
Future<?> future = executorService.submit(new DefaultRunnable());
System.out.prin
    

    • 

  • XML语法元素结构的总结
百合不是茶
xml树结构

    1.XML介绍1969年   gml (主要目的是要在不同的机器进行通信的数据规范)1985年   sgml  standard generralized markup language1993年   html(www网)1998年  xml   extensible markup language
    

    • 

  • 改变eclipse编码格式
bijian1013
eclipse编码格式

    1.改变整个工作空间的编码格式
        改变整个工作空间的编码格式，这样以后新建的文件也是新设置的编码格式。
        Eclipse->window->preferences->General->workspace-
    

    • 

  • javascript中return的设计缺陷
bijian1013
JavaScriptAngularJS

    代码1：
<script>
var gisService = (function(window)
{
return
{
name:function ()
{
alert(1);
}
};
})(this);
gisService.name();
&l
    

    • 

  • 【持久化框架MyBatis3八】Spring集成MyBatis3
bit1129
Mybatis3

    pom.xml配置
Maven的pom中主要包括：
MyBatis
MyBatis-Spring
Spring
MySQL-Connector-Java
Druid
applicationContext.xml配置  
<?xml version="1.0" encoding="UTF-8"?>
&
    

    • 

  • java web项目启动时自动加载自定义properties文件
bitray
javaWeb监听器相对路径

    创建一个类
public class ContextInitListener implements ServletContextListener
使得该类成为一个监听器。用于监听整个容器生命周期的，主要是初始化和销毁的。
类创建后要在web.xml配置文件中增加一个简单的监听器配置，即刚才我们定义的类。
<listener>
<des
    

    • 

  • 用nginx区分文件大小做出不同响应
ronin47

    昨晚和前21v的同事聊天，说到我离职后一些技术上的更新。其中有个给某大客户(游戏下载类)的特殊需求设计，因为文件大小差距很大——估计是大版本和补丁的区别——又走的是同一个域名，而squid在响应比较大的文件时，尤其是初次下载的时候，性能比较差，所以拆成两组服务器，squid服务于较小的文件，通过pull方式从peer层获取，nginx服务于较大的文件，通过push方式由peer层分发同步。外部发布
    

    • 

  • java-67-扑克牌的顺子.从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的.2-10为数字本身，A为1，J为11，Q为12，K为13，而大
bylijinnan
java

    package com.ljn.base;
import java.util.Arrays;
import java.util.Random;
public class ContinuousPoker {
/**
* Q67 扑克牌的顺子 从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的。
* 2-10为数字本身，A为1，J为1
    

    • 

  • 翟鸿燊老师语录
ccii
翟鸿燊

    一、国学应用智慧TAT之亮剑精神A
1. 角色就是人格
    就像你一回家的时候，你一进屋里面，你已经是儿子，是姑娘啦，给老爸老妈倒怀水吧，你还觉得你是老总呢？还拿派呢？就像今天一样，你们往这儿一坐，你们之间是什么，同学，是朋友。
    还有下属最忌讳的就是领导向他询问情况的时候，什么我不知道，我不清楚，该你知道的你凭什么不知道
    

    • 

  • [光速与宇宙]进行光速飞行的一些问题
comsci
问题

    
     在人类整体进入宇宙时代，即将开展深空宇宙探索之前，我有几个猜想想告诉大家
    仅仅是猜想。。。未经官方证实
     1：要在宇宙中进行光速飞行，必须首先获得宇宙中的航行通行证，而这个航行通行证并不是我们平常认为的那种带钢印的证书，是什么呢？ 下面我来告诉
    

    • 

  • oracle undo解析
cwqcwqmax9
oracle

    oracle undo解析2012-09-24 09:02:01     我来说两句       作者：虫师收藏    我要投稿
Undo是干嘛用的？         &nb
    

    • 

  • java中各种集合的详细介绍
dashuaifu
java集合

    一，java中各种集合的关系图 Collection       接口的接口     对象的集合  ├ List           子接口   &n
    

    • 

  • 卸载windows服务的方法
dcj3sjt126com
windowsservice

    卸载Windows服务的方法
在Windows中，有一类程序称为服务，在操作系统内核加载完成后就开始加载。这里程序往往运行在操作系统的底层，因此资源占用比较大、执行效率比较高，比较有代表性的就是杀毒软件。但是一旦因为特殊原因不能正确卸载这些程序了，其加载在Windows内的服务就不容易删除了。即便是删除注册表中的相 应项目，虽然不启动了，但是系统中仍然存在此项服务，只是没有加载而已。如果安装其他
    

    • 

  • Warning: The Copy Bundle Resources build phase contains this target's Info.plist
dcj3sjt126com
iosxcode

     
 
http://developer.apple.com/iphone/library/qa/qa2009/qa1649.html
Excerpt:
You are getting this warning because you probably added your Info.plist file to your Copy Bundle 
    

    • 

  • 2014之C++学习笔记（一）
Etwo
C++EtwoEtwoiterator迭代器

            已经有很长一段时间没有写博客了，可能大家已经淡忘了Etwo这个人的存在，这一年多以来，本人从事了AS的相关开发工作，但最近一段时间，AS在天朝的没落，相信有很多码农也都清楚，现在的页游基本上达到饱和，手机上的游戏基本被unity3D与cocos占据，AS基本没有容身之处。so。。。最近我并不打算直接转型
    

    • 

  • js跨越获取数据问题记录
haifengwuch
jsonpjsonAjax

    js的跨越问题，普通的ajax无法获取服务器返回的值。
  第一种解决方案，通过getson，后台配合方式，实现。
Java后台代码：
protected void doPost(HttpServletRequest req, HttpServletResponse resp)
throws ServletException, IOException {
String ca
    

    • 

  • 蓝色jQuery导航条
ini
JavaScripthtmljqueryWebhtml5

    效果体验：http://keleyi.com/keleyi/phtml/jqtexiao/39.htmHTML文件代码：
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>jQuery鼠标悬停上下滑动导航条 - 柯乐义<
    

    • 

  • linux部署jdk,tomcat,mysql
kerryg
jdktomcatlinuxmysql

    1、安装java环境jdk:
    一般系统都会默认自带的JDK,但是不太好用，都会卸载了，然后重新安装。
   1.1）、卸载：
     （rpm -qa :查询已经安装哪些软件包；
       rmp -q 软件包：查询指定包是否已
    

    • 

  • DOMContentLoaded VS onload VS onreadystatechange
mutongwu
jqueryjs

    1. DOMContentLoaded 在页面html、script、style加载完毕即可触发，无需等待所有资源（image/iframe）加载完毕。（IE9+）
2. onload是最早支持的事件，要求所有资源加载完毕触发。
3. onreadystatechange 开始在IE引入，后来其它浏览器也有一定的实现。涉及以下 document , applet, embed, fra
    

    • 

  • sql批量插入数据
qifeifei
批量插入

    hi，
  自己在做工程的时候，遇到批量插入数据的数据修复场景。我的思路是在插入前准备一个临时表，临时表的整理就看当时的选择条件了，临时表就是要插入的数据集，最后再批量插入到数据库中。
  
WITH tempT AS (
SELECT
item_id AS combo_id,
item_id,
now() AS create_date
FROM
a
    

    • 

  • log4j打印日志文件 如何实现相对路径到 项目工程下
thinkfreer
Weblog4j应用服务器日志

    最近为了实现统计一个网站的访问量，记录用户的登录信息，以方便站长实时了解自己网站的访问情况，选择了Apache 的log4j,但是在选择相对路径那块 卡主了，X度了好多方法(其实大多都是一样的内用，还一个字都不差的)，都没有能解决问题，无奈搞了2天终于解决了，与大家分享一下
需求：
用户登录该网站时，把用户的登录名,ip,时间。统计到一个txt文档里，以方便其他系统调用此txt。项目名
    

    • 

  • linux下mysql-5.6.23.tar.gz安装与配置
笑我痴狂
mysqllinuxunix

    1.卸载系统默认的mysql
[root@localhost ~]# rpm -qa | grep mysql
mysql-libs-5.1.66-2.el6_3.x86_64
mysql-devel-5.1.66-2.el6_3.x86_64
mysql-5.1.66-2.el6_3.x86_64
[root@localhost ~]# rpm -e mysql-libs-5.1
    

    •