瓦尼瓦尼 - gtx1800
type: channel
link: https://gregoryhc.fun/index.php/author/1/
description: gtx1800
items: 简易神经网络_学习(SGD方法)
items: 简易神经网络_推理和正向传播
items: CUDA编程模型-以数组加法为例
items: 简略CUDA和GPU相关概念
items: 简述CUDA的线程结构-以HelloWorld为例
items: 简略描述-感知机速成
items: 蜻蜓点水-Python速成
items: 记一次木马排查流程

简易神经网络_学习(SGD方法)
type: item
date: 2025-11-10T21:10:00+08:00
description: 正者，正也。其心以为不然者，天门弗开矣。作为《深度学习入门》的阅读笔记，本文简略概述深度学习的学习过程，损失函数，梯度法相关的内容，并辅以python实现需要事先了解的本文并不是从零开始的，需要实现了解蜻蜓点水python蜻蜓点水python_dlc简略感知机简易神经网络_推理和正向传播不同的学习首先，学习有不同的类型，人想，机器学习，深度学习；然后，学习的基础是特征向量，机器学习中特征量还是人想出来的，深度学习则没有这一步骤，基本实现了全程机器管理损失函数有道是能观测就能干涉，能干涉就能控制；那么应该观测什么变量才能知道学习的进度，从而干涉和控制学习的过程呢？这里直接给出答案：损失函数。损失函数理论上可以使用任何函数，这里使用均方误差和交叉熵误差 。这里有一个问题，为什么不使用精度（即准确度）来最为指标呢？首先说结论：在进行神经网络的学习时，不能将识别精度作为指标，并且对于大部分导数（后面会提到）为0的函数，都不能作为指标，会导致学习无法进行（无法更新参数），原因在了解学习的过程后自然能理解。均方误差直接公式，实现如下：y_k是前向传播的输出t_k是监督数据的标签（一般是one-hot表示）k是维度import numpy as np def mean_squared_error(y, t): return 0.5 * np.sum((y-t)**2) print(mean_squared_error(np.array([0.1,0.7,0.2]),np.array([0,1,0]))) #判断正确 print(mean_squared_error(np.array([0.1,0.7,0.2]),np.array([1,0,0]))) #判断错误 #0.07000000000000002 #0.67可以看出，如果判断正确，损失函数会是一个较小的数字，如果判断失败，损失函数会是一个较大的数字。交叉熵误差直接公式，实现如下：y_k是前向传播的输出t_k是监督数据的标签（一般是one-hot表示）k是维度def cross_entropy_error(y, t): delta = 1e-7 return -np.sum(t * np.log(y + delta)) print(cross_entropy_error(np.array([0.1,0.7,0.2]),np.array([0,1,0]))) print(cross_entropy_error(np.array([0.1,0.7,0.2]),np.array([1,0,0]))) #0.3566748010815999 #2.302584092994546其中delta是为了避免log的参数有0的情况Mini-Batch学习和推理的过程一样，学习也可以用批处理的方法完成，不过实现上有些区别；这里以交叉熵误差为例第一个是损失函数公式的变化：可见其实就是取平均，实现如下：def cross_entropy_error2(y, t): batch_size = 1 if y.ndim > 1: batch_size = y.shape[0] return -np.sum(t * np.log(y + 1e-7)) / batch_size #测试不同维度 print(cross_entropy_error2(np.array([0.1,0.7,0.2]),np.array([0,1,0]))) print(cross_entropy_error2(np.array([0.1,0.7,0.2]),np.array([1,0,0]))) print(cross_entropy_error2(np.array([[0.1,0.7,0.2],[0.1,0.7,0.2]]),np.array([[0,1,0],[0,1,0]]))) print(cross_entropy_error2(np.array([[0.1,0.7,0.2],[0.1,0.7,0.2]]),np.array([[1,0,0],[1,0,0]])))第二个是训练数据其实还是很多的，想一次性全部学习是高耗能甚至有些不现实的，所以需要使用np.random.choice抽取一个batch来学习# 这里的路径按本地实际来 from dfs.dataset.mnist import load_mnist import sys,os sys.path.append(os.pardir) (x_train, t_train), (x_test, t_test) = load_mnist(flatten=True, normalize=False,one_hot_label=True) # 输出各个数据的形状 print(x_t…

简易神经网络_推理和正向传播
type: item
date: 2025-11-10T20:52:00+08:00
description: 化其万物而不知其禅之者，焉知其所终？焉知其所始？正而待之而已耳。作为《深度学习入门》的阅读笔记，本文简略概述正向传播和激活函数的内容，并辅以python实现需要事先了解的本文并不是从零开始的，需要实现了解蜻蜓点水python蜻蜓点水python_dlc简略感知机学习和推理和求解机器学习问题的步骤（分成学习和推理两个阶段进行）一样，使用神经网络解决问题时，也需要首先使用训练数据（学习数据）进行权重参数的学习；进行推理时，使用刚才学习到的参数，对输入数据进行分类。 首先，通过机器学习解决问题通常分为两个阶段：学习和推理；对于感知机或者神经网络，学习的过程就是调整参数的过程，是需要事先执行的步骤；在完成学习后，使用确定的参数解决实际问题的过程，称为推理；在神经网络或感知机中，通过前向传播来实现；从感知机到神经网络回顾下异或问题，在感知机的实现中，输入先通过与与非门和或门的处理，再使用其输出经过与门的处理就完成了异或的操作：这种多层感知机就是一种二层神经网络，层数的算法和感知机的层数算法一致，只是表示法不同：先解释结构，x1 x2的位置称为输入层，y所在位置称为输出层，两层之间的不管有多少层都是中间层或者隐藏层，不同点在于门的运算过程都跑到边上去了，回顾感知机的实现，所谓门的实现就是不同权重的调整，所以边上既包含了参数也包含了固定的传播算法，节点或者称神经元上包含了输出输入的结果，但也包含了一些其他处理过程，如激活函数一般而言，“朴素感知机”是指单层网络，指的是激活函数使用了阶跃函数(后述）的模型。“多层感知机”是指神经网络，即使用sigmoid函数(后述）等平滑的激活函数的多层网络。传播算法和激活函数首先，回顾下感知机中的权重和偏置和感知机的实现：简单来说感知机的实现就是该公式的实现，其中b是被称为偏置的参数，用于控制神经元被激活的容易程度；而w1和w2是表示各个信号的权重的参数，用于控制各个信号的重要性。 而b+w1x1+w2x2就是层和层之间的传播算法，从下图可以看出，偏置也可作为神经元为1而权重为b进行传播：解决了传播问题，再看一眼公式可以发现0和1的判断是依赖于b+w1x1+w2x2的输出的，而这0和1的判断规则也不一定是以公式中的方式出现的，是可以记作函数h(x)来表示的，这个函数就是激活函数，激活函数的输出才是神经元最后表示的输出。简而言之：激活函数，是用来决定何时激活信号的函数阶跃函数就从感知机使用的激活函数来看：该函数称为阶跃函数；实现和图像如下，注意到这并不是一个平滑的函数def step_function(x): y = x > 0 return y.astype(int) x = np.array([-1.0,1.0,2.0]) print(x) print(x>0) y = step_function(x) print(type(y)) #[-1. 1. 2.] #[False True True] #<class 'numpy.ndarray'> import matplotlib.pyplot as plt x = np.arange(-5.,5.,0.1) y = step_function(x) plt.plot(x,y) plt.ylim(-0.1,1.1) plt.show()Sigmoid函数Sigmoid函数是神经网络经常使用一个函数，公式，实现和图像如下：def sigmoid(x): return 1/(1+np.exp(-x)) x = np.arange(-5.,5.,0.1) y = sigmoid(x) plt.plot(x,y) plt.ylim(-0.1,1.1) plt.show()函数对比上面说到，阶跃函数并不是平滑的函数，而sigmoid是，然后二者都是非线性函数，这里先给出结论：神经网络的激活函数必须使用非线性函数。原因是由线性函数的性质造成的，如果把中间层合并在一起，所做的处理更加类似于一个超级复杂的复合函数，但是线性函数再怎么复合，都可以找到一个参数来等价的表示这些复合的操作，对于中间层来说就是可以用一层来代表N层，这样中间层的存在意义就没有了，神经网络也就无法发挥多层网络带来的优势。下图为简单的举例：ReLU函数sigmoid函数很早就开始被使用了，而最近则主要使用ReLU（Rectified Linear Unit）函数。公式，实现和图像如下：def relu(x): return np.maximum(0,x) x = np.arange(-5.,5.,0.1) y = relu(x) plt.plot(x,y)神经网络和矩阵矩阵乘法回顾一下numpy的相关操作，shape表示数组形状，dim表示数组维数；多维数组可以代表矩阵，横为行竖为列；然后简单了解下矩阵…

CUDA编程模型-以数组加法为例
type: item
date: 2025-11-02T22:20:00+08:00
description: 通于一而万事毕，无心得而鬼神服。本文以数组加法为例，简述CUDA的编程模型基本概念确保了解《CUDA的线程结构》中的内容再进行下去，因为对于线程结构本章会省略一部分描述编程模型首先，编程模型是写程序时可被控制的部分，通过编程模型可以控制计算设备的行为；其次，编程模型对于编译器和库函数来说是一层通信抽象；再次，对于GPU来说，编程模型可分为核函数内存管理线程管理流最后，对于Cuda编程，可抽象出几个过程领域层（业务主导要实现的目标）逻辑层（基于逻辑组织线程代码）硬件层（思考如何将线程映射到机器上，以及思考如何提升性能）接下来，会从以下方面说明Cuda的编程结构内存线程核函数启动编写验证错误处理内存管理首先应该理解异构环境下内存的样貌：通过PCIe总线分割和通信的两种内存：主机内存和设备内存一个异构环境，通常有多个CPU多个GPU，他们都通过PCIe总线相互通信，也是通过PCIe总线分隔开的。所以我们要区分一下两种设备的内存：主机：CPU及其内存设备：GPU及其内存注意这两个内存从硬件到软件都是隔离的（CUDA6.0 以后支持统一寻址），我们目前先不研究统一寻址，我们现在还是用内存来回拷贝的方法来编写调试程序，以巩固大家对两个内存隔离这个事实的理解。CUDA的内存管理是C风格的，列表如下：标准C函数CUDA C 函数说明malloccudaMalloc内存分配memcpycudaMemcpy内存复制memsetcudaMemset内存设置freecudaFree释放内存另外，CUDA中设备内存也是分层次的，分为单网格中公用的全局内存和单线程块中公用的共享内存，大致如图：线程管理在《CUDA的线程结构》中，曾经用草图展示过cuda线程的组织形式，这里用更好的图展示一下：另外，不同线程块的线程物理隔离无法相互影响，同一个线程块中的线程可以实现以下两种操作：同步共享内存最后再重申一下《CUDA的线程结构》中提过的，如何标识一个线程：blockIdx（线程块在线程网格内的位置索引）threadIdx（线程在线程块内的位置索引）这两个内置结构体基于 uint3 定义，包含三个无符号整数xyz的结构还有blockIdx中三个字段的范围和threadIdx中三个字段的范围：gridDimblockDimdim3类型(基于uint3定义的数据结构)的变量，也包含三个字段xyz另外，线程块在3个轴上的个数和一个线程块的线程数是有限制的：线程块在xyz三轴上分别最多：2^31-1,65535,65535一个线程块线程总数最多1024，在三维上最多:1024,1024,64核函数之前hello world时已经用到了核函数，但是没有给一个明确定义，这里给出：核函数就是在CUDA模型上诸多线程中运行的那段串行代码，这段代码在设备上运行，用NVCC编译，产生的机器码是GPU的机器码，所以我们写CUDA程序就是写核函数第一步我们要确保核函数能正确的运行产生正切的结果第二步优化CUDA程序的部分，无论是优化算法，还是调整内存结构，线程结构都是要调整核函数内的代码，来完成这些优化的。接下来将以数组加法为例来实现和使用核函数，以及应用一些内存管理的函数单机版数组加法无需多言，直接上代码，明确我们要干什么：/** * 单机版:两数组相加 * */ #include<iostream> const double a=1.23; const double b=3.45; const double c=4.68; const int N = 100000000; const double EPSILON = 1.0e-15; // 函数1: 数组相加(数组默认是动态分配的) void add(const double *x,const double *y,double *z,const int N) { for (int i=0;i<N;i++) { z[i] = x[i]+y[i]; } } // 函数2: 检查结果 void check(const double *z,const int N) { bool has_error = false; for (int i=0;i<N;i++) { if (fabs(z[i]-c) > EPSILON) { has_error = true; break; } } printf("%s\n",has_error?"Has errors":"No errors"); } int main() { //创建数组xyz double* x = new double[N]; double* y = new double[N]; double* z = new double[N]; //初始化数组 for (int i=0;i<N;i…

简略CUDA和GPU相关概念
type: item
date: 2025-10-12T00:01:05+08:00
description: 万物一齐，而百兽率舞。本文简略介绍CUDA编程的相关背景异构计算首先，异构计算就是CPU+X，这个X可以是GPU，也可以是NPU，FPGA，DSP等等，在CPU上运行的代码称为Host主机代码，X上运行的代码称为Device设备代码其次，异构计算和同构计算的一个不同点在于，异构的处理要比同构复杂，因为涉及同构下自动处理的计算，控制，传输都要人工进行干预GPUCPU vs GPU先看cpu的架构和gpu架构的不同：先看几个共同的部分：控制器Control缓存器Cache随机存取存储器DRAM总线PCIe Bus算术逻辑单元ALU不需要过多的计组原理知识，直观来看，GPU弱化了控制器的能力，大大堆砌了ALU的数量，且为一组ALU（SM，简单理解为线程束）分配了单独的Control和cache，所以直觉上，对了逻辑简单，数据量大的任务，GPU更高效低并行逻辑复杂的程序适合用CPU高并行逻辑简单的大数据计算适合GPUCPU和GPU线程的区别：CPU线程是重量级实体，操作系统交替执行线程，线程上下文切换花销很大GPU线程是轻量级的，GPU应用一般包含成千上万的线程，多数在排队状态，线程之间切换基本没有开销。CPU的核被设计用来尽可能减少一个或两个线程运行时间的延迟，而GPU核则是大量线程，最大幅度提高吞吐量GPU简介对于Nvida，GPU分为4个系列：TegraGeforceQuadroTesla针对不同的应用场景，比如Tegra用于嵌入式，Geforce是平时打游戏用到，Tesla主要用于计算，但目前看Geforce和Tesla貌似也没那么分得很清楚，只是某些系列上有容错的硬件部分GPU也存在版本号，即其计算能力，但这和性能不是成正比的，只代表架构的更新，对于CUDA来说，新版的cuda只支持最近几个版本的GPU，参考：https://en.wikipedia.org/wiki/CUDA#GPUs_supported真正评价GPU能力的分为两种，一种是计算性能指标，一种是容量指标：计算性能主要看FLOPS，一般单位在T级别（TFLOPS），称每秒浮点数运算次数，分单精度双精度，根据不同的架构，双精度一般是单精度的1/N容量指标上有：显存，带宽，核心数量等，特别的如果一个CUDA程序爆显存了，则不使用统一内存的情况下是无法运行程序的CUDACUDA平台不是单单指软件或者硬件，而是建立在Nvidia GPU上的一整套平台，并扩展出多语言支持对于CUDA API来说，分为driver和运行时两种API，二者互斥不能同时使用，性能没啥差距driver API 低级，复杂，灵活，一般用于配合其他语言调用CUDA运行时简单，基于driver API，稍微高级一点CUDA编程环境架构如下：nvccnvcc之于cuda相当于普通c++之于g++。因为cuda程序中host和device的代码是混在一起的，nvcc会分离这两个部分分别处理：其中，PTX相当于CUDA的汇编语言nvdia-smi可以通过nvidia-smi(Nvidia's system management interface)程序检查与设置设备。它包含在CUDA开发工具套装内。CUDA的程序结构一般CUDA程序分成下面这些步骤：分配GPU内存拷贝内存到设备调用CUDA内核函数来执行计算把计算完成数据拷贝回主机端内存销毁参考https://face2ai.com/program-blog/#GPU%E7%BC%96%E7%A8%8B%EF%BC%88CUDA%EF%BC%89

简述CUDA的线程结构-以HelloWorld为例
type: item
date: 2025-10-11T22:36:00+08:00
description: 万物化作，萌区有状，盛衰之杀，变化之流也。本文以helloworld为例，简述CUDA的线程结构基本概念即使是HelloWorld，Cuda程序也引入了一些不同的概念，确保了解《简略CUDA和GPU相关概念》中的内容在进行下去从HelloWorld开始下面是一个最简单的HelloWorld程序：/** 运行命令: cl ./hello_host_only.cpp **/ #include <cstdio> using namespace std; int main() { printf("Host: Hello wolrd!"); return 0; }在windows可在x64 Native Tools Command Prompt for VS 2022用cl来编译它只有Host代码的CUDA版本HelloWolrd/** 运行命令: nvcc -arch=sm_62 hello_host_only.cu sm_62的来源: https://docs.nvidia.com/cuda/archive/12.9.0/cuda-compiler-driver-nvcc/index.html https://en.wikipedia.org/wiki/CUDA#GPUs_supported */ #include <cstdio> using namespace std; int main() { printf("Host: Hello wolrd!"); return 0; }代码完全没有变化，只有文件后缀名发生了变化但这里性质发生了变化，代码分为了Host代码部分和Device代码部分由nvcc分别处理nvcc指定运算架构注意到注释部分，nvcc可以指定虚拟和真实架构的编号，可以通过链接查看本地设备可以使用的标识如果需要匹配多个架构，可以使用多个-gencode -arch 虚拟架构 -code 真实架构来编译产生不同的输出，最后真实架构不能落后与虚拟架构使用CUDA线程从这里正式开始添加Device代码：/** 运行命令: nvcc XX.cu */ #include<cuda.h> #include<cuda_runtime.h> #include<cstdio> __global__ void hello_from_gpu() { printf("Device: Hello World."); } int main() { const int grid_size=1; const int block_size=1; hello_from_gpu<<<grid_size,block_size>>>(); cudaDeviceSynchronize(); return 0; }注意四点：include包含了两个cuda相关头文件，这不是必须要添加的，nvcc会自动引入，其中包含了cstdlib的内容，但没有包含cstdio的内容，最后device程序是不认iostream的__global___就是device代码，即核函数的标志cudaDeviceSynchronize的功能是同步host和device，也就是说gpu上的代码和cpu上的代码是异步运行的<<<grid_size,block_size>>>指定了用多少线程运行该核函数使用多线程的CUDA程序再进一步改进程序/** 运行命令: nvcc XX.cu */ #include<cuda.h> #include<cuda_runtime.h> #include<cstdio> __global__ void hello_from_gpu() { const int bid = blockIdx.x; const int tid = threadIdx.x; printf("Device: Hello World from block %d and thread %d\n",bid,tid); } int main() { const int grid_size=2; const int block_size=4; hello_from_gpu<<<grid_size,block_size>>>(); cudaDeviceSynchronize(); return 0; }CUDA将线程组织为网格，网格被划分为线程块，即网格由线程块组成，线程块由线程组成，三者之间并不是简单的包含关系（即一般论的包含关系，网格有N个线程块，每个线程块又有M个线程），但是目前示例中确实只是单纯的包含关系，可简单认为有网格两个线程块，每个线程块四个线程共八个线程下图展示了多维线程的布局，这也是网格的真正分布：可以认为网格是一个三维立方体，被划分出的小格就是线程块，而小格又可以按三维继续分割…

简略描述-感知机速成
type: item
date: 2025-10-09T22:42:00+08:00
description: 夫道未始有封，言未始有常，为是而有畛也。作为《深度学习入门》的阅读笔记，本文简略概述感知机，并辅以python实现Python基础再简单的描述离不开基本的语言基础，确保了解《蜻蜓点水-python》中的内容在进行下去逻辑运算和感知机如上所述，python中有逻辑运算，电路中也有逻辑运算，并以“门”的形式呈现，有电流则为1（True），无电流则为0（True）。如下图所示，三种门的符号，真值表就不再赘述，可以用python快速验证感知机的历史1957提出，是神经网络的起源的算法之一。感知机接受多个信号，并输出一个信号。感知机实现先说实现的思路，上述三种逻辑运算都可以用同一种逻辑表达，区别只在于特定参数的不同b称为偏置，w称为权重，二者控制了函数的不同逻辑表示下面直接给出代码实现：初始化函数设定了权重和偏置forward函数在深度学习中代表正向传播，这里借用作为感知机的处理函数逻辑如公式，但将等号给了1class Perceptron: def __init__(self, w=np.array([0,0]),delta=-1.): self.w=w self.delta = delta def forward(self,x): tmp=self.w*x if np.sum(tmp) + self.delta < 0: return 0 else: return 1andclass = Perceptron(w=np.array([0.5,0.5])) print(andclass.forward(np.array([0,0]))) print(andclass.forward(np.array([1,0]))) print(andclass.forward(np.array([0,1]))) print(andclass.forward(np.array([1,1]))) # 0 # 0 # 0 # 1orclass = Perceptron(w=np.array([1,1])) print(orclass.forward(np.array([0,0]))) print(orclass.forward(np.array([1,0]))) print(orclass.forward(np.array([0,1]))) print(orclass.forward(np.array([1,1]))) # 0 # 1 # 1 # 1nandclass = Perceptron(w=np.array([-0.5,-0.5]),delta=0.9) print(nandclass.forward(np.array([0,0]))) print(nandclass.forward(np.array([1,0]))) print(nandclass.forward(np.array([0,1]))) print(nandclass.forward(np.array([1,1]))) # 1 # 1 # 1 # 0目前感知机的局限可以对当前感知机的输入和输出作图，可得：总之，有办法做一条直线将0和1的结果划分开，能这么表示的称为线性感知机但是这样的感知机无法表示XOR操作，也就是异或操作：XOR感知机的实现该问题由1969年被提出，直到1986年被解决，这段时间人工智能的发展是停滞的。解决的方法就是使用多层感知机，即单独的“门”无法解决的问题，就用多个连接一起解决，直接给方法：用代码表示就是:def XOR(x1, x2): s1 = NAND(x1, x2) s2 = OR(x1, x2) y = AND(s1, s2) return y进一步的实现：#def XOR(x1, x2): # s1 = NAND(x1, x2) # s2 = OR(x1, x2) # y = AND(s1, s2) # return y class XOR: def __init__(self): self.nandclass = Perceptron(w=np.array([-0.5,-0.5]),delta=0.9) self.orclass = Perceptron(w=np.array([1,1])) self.andclass = Perceptron(w=np.array([0.5, 0.5])) def forward(self,x): s1 = self.nandclass.forward(x) s2 = self.orclass.forward(x) tmp = self.andclass.forward(np.array([s1,s2])) return tmp print("XOR: ") print(XOR().forward(np.arr…

蜻蜓点水-Python速成
type: item
date: 2025-10-09T22:36:00+08:00
description: 道在屎溺。作为《深度学习入门》的阅读笔记，本文简略概述python算数计算print(1 - 2) print(4 * 5) print(7 / 5) print(3 ** 2) # 乘方-1 20 1.4 9 数据类型和Type函数type(10)int type(2.718)float type("hello")str type(True)bool 变量x = 100 y = 3.14 print(x * y) type(x * y) # 是注释标识314.0 float 列表a = [1,2,3,4,5] print(a) len(a)[1, 2, 3, 4, 5] 5 print(a[4]) a[4]=99 print(a)5 [1, 2, 3, 4, 99] # 切片 a[0:2] # 获取索引为0到2（不包括2！）的元素[1, 2] a[1:] # 获取从索引为1的元素到最后一个元[2, 3, 4, 99] a[:3] # 获取从第一个元素到索引为3（不包括3！）的元素[1, 2, 3] a[:-1] # 获取从第一个元素到最后一个元素的前一个元素之间的元素[1, 2, 3, 4] a[:-2] # 获取从第一个元素到最后一个元素的前二个元素之间的元素[1, 2, 3] 字典me = {'height':180} # 生成字典 print(me){'height': 180} me['height']=70 print(me['height'])70 布尔型hungry = True sleepy = False type(hungry)bool not hungryFalse hungry and sleepyFalse hungry or sleepyTrue if语句if hungry: print('hungry') elif sleepy: print('sleepy') else: print('not hungry')hungry for 语句for i in [1,2,3]: print(i)1 2 3 函数def hello(object): print("Hello " + object + "!") hello("cat!")Hello cat!! 类class Man: def __init__(self, name): self.name = name print("Initialized!") def hello(self): print("Hello " + self.name + "!") def goodbye(self): print("Good-bye " + self.name + "!") m = Man("David") m.hello() m.goodbye()Initialized! Hello David! Good-bye David! Numpy 速成import numpy as np x = np.array([1.,2.,3.]) print(x) type(x) y = np.array([2.0, 4.0, 6.0])[1. 2. 3.] 以下是对应元素的运算,如果元素个数不同，程序就会报错，所以元素个数保持一致非常重要print(x+y) print(x-y) print(x/y) print(x*y)[3. 6. 9.] [-1. -2. -3.] [0.5 0.5 0.5] [ 2. 8. 18.] NumPy数组不仅可以进行element-wise运算，也可以和单一的数值（标量）组合起来进行运算x/2.0array([0.5, 1. , 1.5]) Numpy的N维数组A = np.array([[1, 2], [3, 4]]) B = np.array([[3, 0],[0, 6]]) print(A)[[1 2] [3 4]] A.shape(2, 2) A.dtypedtype('int32') print(A+B)[[ 4 2] [ 3 10]] print(A*B)[[ 3 0] [ 0 24]] print(A*10)[[10 20] [30 40]] 广播A = np.array([[1, 2], [3, 4]]) B = np.array([10, 20]) A * Barray([[10, 40], [30, 80]]) 访问元素X = np.array([[51, 55], [14, 19], [0, 4]]) X[0][1]55 X[0]array([51, 55]) for row in X: print(row)[51 55] [14 19] [0 4] X = X.flatten() print(X)[51 55 1…

记一次木马排查流程
type: item
date: 2024-01-06T11:58:33+08:00
description: 原因在调整spark配置问题时把集群内部通信接口暴露给了公网，提供了攻击的机会攻击者通过端口扫描的方式，用暴露的接口【通过某种方式】进入集群，集群内部可无密码ssh访问，直接访问ssh目录生成密钥，并修改authorized_keys权限添加redis和程序包（注入+进程隐藏）https://github.com/arget13/memdlopen/blob/main/README.mdhttps://github.com/gianlucaborello/libprocesshider/blob/master/README.md这导致了top无法发现其真正进程发现cpu占用异常，单核100%，和top无法对应netstat -alntp 发现异常tcp链接：5.180.174.211:80，检查为境外乌克兰ip，lastb发现有大量异常失败登录，且ip大多来自境外，疑似撞库处理关掉集群其他机器立即修改安全组，关闭除22以外的公网端口试图删除authorized_keys known_host中的攻击者数据，发现并无权限，但查看权限并无异常，使用lsattr查看文件属性发现被添加ia标记，无法修改无法删除，使用chattr 修改无效且返回结果看起来比较诡异，查看/usr/bin/chattr 发现已被修改，使用ls -l |grep Jan 过滤出最近修改的所有文件，发现其他新增命令工具但此时需要chattr 来修改标识才能进行操作，从https://github.com/posborne/linux-programming-interface-exercises/blob/master/15-file-attributes/chattr.c下载文件gcc编译，重命名为chattr，利用其来修改标识 chattr -ia，删除原本的chattr 替换之，然后就可以对其他文件进行操作https://c.biancheng.net/view/874.html查看/etc/ld.so.preload文件，此文件原先应为空或不存在，设法清空或删除该文件（和文件里的文件路径），top的问题就可以恢复参考：https://www.jianshu.com/p/d4b3d87fdc51也可通过busybox top工具直接发现真正的进程，定位到程序所在的目录（我的是/var/tmp/.11/，里面都是编译后的二进制文件和上述github的bash脚本），先不急删使用systemctl status 对应pid，发现有对应的service（于我情况如此，也可能会使用定时程序），清理掉就可以，然后附带检查service而文件的修改日期，发现有其他攻击者新增但未启动的service一并处理另外本环境没有redis服务，故连带清理掉，这样cpu和内存就应该能降下来最后删除病毒文件即可然后关闭该机器，对其他机器依次操作（因为集群是免密互通的，保险起见）后续改进关闭所有不必要的公网端口内部web服务使用nginx反代并管理登录Nginx 配置 安全认证 反向代理 HDFS web 页面_nginx如何代理一个web页面-CSDN博客