事件报告——2024.09.22服务器中挖矿病毒

如果有一天父母离去，年轻人该如何操办丧事

八月的某一天，外公猝然离世。原本身体不好的外公，在一个恰巧家中没有其他亲人陪的正午，以面着地，不过转瞬就与世长辞。

十二点半，我接到电话，赶到乡下老家已是下午三点。临事仓促，长辈们并没有比我快多少。所幸人丁还算兴旺，大家还算都有反应，不至于左支右绌。

外公是走过长征的军人，我见到时，长辈们已经为外公换上绿色军装军帽。因事突然，遗体是放在一块床板上，前后拿长凳架起，下面垫上黄纸。以黄纸覆面，双手摆守一式，手指已经看着有些僵硬，双脚换上花布鞋，拿细绳子绑住。遗体前方供一小桌，点上两盏蜡烛，塑料盒子装米，可以插香，于是就算简易灵台。前院放一个农村大锅，权当烧黄纸的火盆。

四点半，水晶棺已经送到。是插电的，可以制冷保温，当地气温大概35度，停灵的时间取决于哪天是上山的好日子，需请乡下最负盛名的看风水的看过才能定下何时上山，哪处是外公长眠之地。

五点，比较近的亲戚已经赶到。按乡下老一辈的规矩，是要哭的。于是只见前一秒笑着与我打招呼的老者，下一秒便坐在遗体前大哭，长辈有认得老者的，便不住安慰。大概是，哭者嗫嚅着说，“你却是命苦，本还可以活十年的，怎料有此事…”，安慰者拍拍哭者后背，“舅姨不必太伤心云云”。须知这一套流程直系亲属是不参与的，直系亲属派一位情感丰富的只是陪哭。

五点半，陆陆续续乡邻们都离场，直系亲属转入后院，一边准备做饭一边窃窃私语，安排之后的流程。席是要办的，棺也没有备好，一切仓促。

恰此时停水了，于是我得去山上挑两桶山泉。此刻正是，后院备菜，正屋停灵，前院却还有鸡在地上跑，我挑着担正出前厅。

如果有一天父母离去，年轻人该如何操办丧事

# 背景
总是被老板说组里的那么多服务器都没有利用起来，在我自己实际观察中发现确实存在着比较严重的服务器挤兑现象，某台服务器很多人用需要排队，而其他的服务器却基本上没有人用，借着组里很多师兄师姐都要毕业，准备做一套简单的系统来监控这些服务器的使用情况。



# 后端
对于GPU服务器，我们一般需要查看其GPU使用情况，可以通过
```sh
nvidia-smi --query-gpu=name,temperature.gpu,power.draw,utilization.gpu,memory.used,memory.total --format=csv,noheader,nounits
```
这条命令将gpu的型号、温度、功率、使用率、显存等情况输出为一组csv的格式

对于显卡的占用进程，可以通过
```sh
nvidia-smi pmon -s m -c 1
```
这条命令得到每张卡的占用进程PID、进程名、占用显存等

对于服务器内存，可以通过
```sh
free -h
```
得到情况

对于cpu占用，可以通过
```sh
mpstat 1 1
```
得到情况

对于cpu进程，可以通过ps命令得到
```sh
sh -c ps aux --sort=-%cpu --no-header | head -n 50
```

对于IP地址，则可以通过golang内部的库函数得到。

综合以上信息，我们写一个简单的golang代码如下
```go
package main

import (
	"encoding/json"
	"fmt"
	"net"
	"net/http"
	"os/exec"
	"strings"
)

// GPUInfo represents detailed information of a GPU
type GPUInfo struct {
	Model          string `json:"model"`
	Temperature    string `json:"temperature"`
	PowerDraw      string `json:"power_draw"`
	UtilizationGPU string `json:"utilization_gpu"`
	MemoryUsed     string `json:"memory_used"`
	MemoryTotal    string `json:"memory_total"`
}

// GPUStatus represents the status of all GPUs
type GPUStatus struct {
	GPUs []GPUInfo `json:"gpus"`
}

// GPUProcess represents a process using the GPU
type GPUProcess struct {
	PID     string `json:"pid"`
	Type    string `json:"type"`
	Name    string `json:"name"`
	UsedMem string `json:"used_memory"`
}

// MemoryInfo represents memory usage information
type MemoryInfo struct {
	Total     string `json:"total"`
	Used      string `json:"used"`
	Free      string `json:"free"`
	Shared    string `json:"shared"`
	BuffCache string `json:"buff_cache"`
	Available string `json:"available"`
}

// CPUInfo represents CPU usage information
type CPUInfo struct {
	User   string `json:"user"`
	System string `json:"system"`
	Idle   string `json:"idle"`
}

// ProcessInfo represents information about a process
type ProcessInfo struct {
	PID   string `json:"pid"`
	User  string `json:"user"`
	CPU   string `json:"cpu"`
	MEM   string `json:"mem"`
	VSZ   string `json:"vsz"`
	RSS   string `json:"rss"`
	TTY   string `json:"tty"`
	Stat  string `json:"stat"`
	Start string `json:"start"`
	Time  string `json:"time"`
	Cmd   string `json:"cmd"`
}

// ServerStatus represents the server status
type ServerStatus struct {
	Uptime    string        `json:"uptime"`
	Memory    MemoryInfo    `json:"memory"`
	CPU       CPUInfo       `json:"cpu"`
	Processes []ProcessInfo `json:"processes"`
}

// IPAddress represents the server's IP address
type IPAddress struct {
	IP string `json:"ip"`
}

func getGPUStatus() (*GPUStatus, error) {
	cmd := exec.Command("nvidia-smi", "--query-gpu=name,temperature.gpu,power.draw,utilization.gpu,memory.used,memory.total", "--format=csv,noheader,nounits")
	output, err := cmd.Output()
	if err != nil {
		return nil, err
	}
	lines := strings.Split(strings.TrimSpace(string(output)), "\n")
	var gpus []GPUInfo
	for _, line := range lines {
		fields := strings.Split(line, ", ")
		if len(fields) != 6 {
			continue
		}
		gpus = append(gpus, GPUInfo{
			Model:          fields[0],
			Temperature:    fields[1] + " C",
			PowerDraw:      fields[2] + " W",
			UtilizationGPU: fields[3] + " %",
			MemoryUsed:     fields[4] + " MiB",
			MemoryTotal:    fields[5] + " MiB",
		})
	}
	return &GPUStatus{GPUs: gpus}, nil
}

func getGPUProcesses() ([]GPUProcess, error) {
	cmd := exec.Command("nvidia-smi", "pmon", "-s", "m", "-c", "1")
	output, err := cmd.Output()
	if err != nil {
		return nil, err
	}
	lines := strings.Split(strings.TrimSpace(string(output)), "\n")

	var processes []GPUProcess
	for _, line := range lines[2:] { // skip the first two lines
		fields := strings.Fields(line)
		if len(fields) < 6 {
			continue
		}
		processes = append(processes, GPUProcess{
			PID:     fields[1],
			Type:    fields[2],
			Name:    fields[5],
			UsedMem: fields[3] + " MiB",
		})
	}

	return processes, nil
}

func getMemoryInfo() (*MemoryInfo, error) {
	cmd := exec.Command("free", "-h")
	output, err := cmd.Output()
	if err != nil {
		return nil, err
	}
	lines := strings.Split(strings.TrimSpace(string(output)), "\n")
	if len(lines) < 2 {
		return nil, fmt.Errorf("unexpected output from free command")
	}
	fields := strings.Fields(lines[1])
	if len(fields) < 7 {
		return nil, fmt.Errorf("unexpected output from free command")
	}
	return &MemoryInfo{
		Total:     fields[1],
		Used:      fields[2],
		Free:      fields[3],
		Shared:    fields[4],
		BuffCache: fields[5],
		Available: fields[6],
	}, nil
}

func getCPUInfo() (*CPUInfo, error) {
	cmd := exec.Command("mpstat", "1", "1")
	output, err := cmd.Output()
	if err != nil {
		return nil, err
	}
	lines := strings.Split(strings.TrimSpace(string(output)), "\n")
	if len(lines) < 4 {
		return nil, fmt.Errorf("unexpected output from mpstat command")
	}
	fields := strings.Fields(lines[3])
	if len(fields) < 12 {
		return nil, fmt.Errorf("unexpected output from mpstat command")
	}
	return &CPUInfo{
		User:   fields[3] + " %",
		System: fields[5] + " %",
		Idle:   fields[11] + " %",
	}, nil
}

func getServerStatus() (*ServerStatus, error) {
	// Get system uptime
	uptimeCmd := exec.Command("uptime", "-p")
	uptimeOutput, err := uptimeCmd.Output()
	if err != nil {
		return nil, err
	}
	uptime := strings.TrimSpace(string(uptimeOutput))

	// Get memory information
	memoryInfo, err := getMemoryInfo()
	if err != nil {
		return nil, err
	}

	// Get CPU information
	cpuInfo, err := getCPUInfo()
	if err != nil {
		return nil, err
	}

	// Get process information
	psCmd := exec.Command("sh", "-c", "ps aux --sort=-%cpu --no-header | head -n 50")
	psOutput, err := psCmd.Output()
	if err != nil {
		return nil, err
	}
	psLines := strings.Split(strings.TrimSpace(string(psOutput)), "\n")

	var processes []ProcessInfo
	for _, line := range psLines {
		fields := strings.Fields(line)
		if len(fields) < 11 {
			continue
		}
		processes = append(processes, ProcessInfo{
			PID:   fields[1],
			User:  fields[0],
			CPU:   fields[2],
			MEM:   fields[3],
			VSZ:   fields[4],
			RSS:   fields[5],
			TTY:   fields[6],
			Stat:  fields[7],
			Start: fields[8],
			Time:  fields[9],
			Cmd:   strings.Join(fields[10:], " "),
		})
	}

	return &ServerStatus{
		Uptime:    uptime,
		Memory:    *memoryInfo,
		CPU:       *cpuInfo,
		Processes: processes,
	}, nil
}

func getIPAddress() (*IPAddress, error) {
	addrs, err := net.InterfaceAddrs()
	if err != nil {
		return nil, err
	}

	for _, addr := range addrs {
		if ipNet, ok := addr.(*net.IPNet); ok && !ipNet.IP.IsLoopback() {
			if ipNet.IP.To4() != nil {
				return &IPAddress{IP: ipNet.IP.String()}, nil
			}
		}
	}
	return nil, fmt.Errorf("IP address not found")
}

func gpuHandler(w http.ResponseWriter, r *http.Request) {
	status, err := getGPUStatus()
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	json.NewEncoder(w).Encode(status)
}

func gpuProcessesHandler(w http.ResponseWriter, r *http.Request) {
	processes, err := getGPUProcesses()
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	json.NewEncoder(w).Encode(processes)
}

func serverHandler(w http.ResponseWriter, r *http.Request) {
	status, err := getServerStatus()
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	json.NewEncoder(w).Encode(status)
}

func ipHandler(w http.ResponseWriter, r *http.Request) {
	ip, err := getIPAddress()
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	json.NewEncoder(w).Encode(ip)
}

func heartbeatHandler(w http.ResponseWriter, r *http.Request) {
	w.Write([]byte("OK"))
}

func main() {
	http.HandleFunc("/gpu", gpuHandler)
	http.HandleFunc("/gpu/processes", gpuProcessesHandler)
	http.HandleFunc("/server", serverHandler)
	http.HandleFunc("/ip", ipHandler)
	http.HandleFunc("/heartbeat", heartbeatHandler)
	fmt.Println("Server started at :12802")
	http.ListenAndServe(":12802", nil)
}
```

这份代码实现了五个api，分别完成了gpu的显存检测、进程检测、cpu的进程检测、内存检测、ip检测、以及心跳检测。

通过设置`GOOS=linux;GOARCH=amd64`在我的MacOS上交叉编译到linux，可以直接上传一个二进制包就完成部署，然后再通过linux service完成重启与自启动设置
```toml
[Unit]
Description=server monitor service
After=network.target syslog.target
Wants=network.target

[Service]
Type=simple
ExecStart=/home/xuqi/server_monitor/go_build_server_monitor_linux
Restart=always
RestartSec=10
User=xuqi

[Install]
WantedBy=multi-user.target
```
最后再通过frp服务转发到公网（因为这些服务器都在内网，不做穿透无法访问到api）

就完成了服务器监测的后端代码了。

# 前端
前端则拟使用vue3框架 + element plus的组件库搭建，当然，还要使用tailwind css美化一下

简单起见，也做成一个单页面就好。

server_monitor，自己动手实现多服务器的状态监控

# 论文基本信息

| item | value |
| --- | --- |
| title | InFusion: Inpainting 3D Gaussians via Learning Depth Completion from Diffusion Prior |
| publication | arxiv temporary |
| group | 1 University of Science and Technology of China 2 The Hong Kong University of Science and Technology 3 Ant Group 4 Alibaba Group |
| link | https://arxiv.org/abs/2404.11613 |
| 1 sentence description |非常technical的工作，这里面对深度的处理值得参考|



# 论文创新点
文章fig1的caption
We present InFusion, an innovative approach that delivers efficient, photorealistic inpainting for 3D scenes with 3D Gaussians. As demonstrated in (a), InFusion enables the seamless removal of 3D objects, along with user-friendly texture editing and object insertion.（无缝移除） Illustrated in (b), InFusion learns depth completion with diffusion prior, significantly enhancing the depth inpainting quality for general objects.（深度补全） We show the visualizations of the unprojected points, which exhibit substantial improvements over baseline models
# 论文方法部分

![image.png](https://xuqi.space/static/img/34f93e94c3d255c6352b38b6a60ac39c.image.webp)
可以看到，depth inpainting部分就是普通的LDM思路，原文表述如下：把深度图和原始影像都通过encoder得到latent vector，$$z^{(I)}$$与$$z^{(d')}$$，然后$$z^{(d')}$$做随机mask得到$$z^{(d')}_m$$，做加噪得到$$z^{(d')}_t$$，最后拼接在一起$$z_t = cat(z_t^{(d')},z_m^{(d′)},z^{(I)},m')$$作为U-Net输入。
上面的inpaint部分，则是通过depth inpainting与image inpainting，得到移除之后的深度与颜色，然后在3dgs上finetune一会后，再重复渐进优化。
# 论文实验部分
这里一般是在文章的experiments部分，你需要找到以下信息
1. 使用的数据集 
    
    SceneFlow，over 100,000 frames, each accompanied by ground truth depth, and rendered from a variety of synthetic sequences. We initialize the LDM with pre-trained depth prediction weights sourced from the Marigold.For scene masking, we used masks from SAM-Track.
4. 对比实验的合理性
    
    实验设计还是比较完备的
6. 训练使用的GPU资源与时间资源，推理速度
    
    Utilizing eight A100 GPUs, the training process is completed within one day.
4. 消融实验的合理性，若无消融实验，分析为什么不需要做
    
    做了对depth inpainting和progressive infusion的消融实验
5. 实验中有没有用到一些特殊的技巧
    
    对深度图渲染的处理，这部分没有直接使用3dgs渲染公式直接得到的深度图，而是再通过diffusion-based depth completion model（也就是图中下半部分这个模型），去对深度图做refine，同时还结合了相机姿态做了对inpaint后3dgs的优化。
# 总结
相当technical的工作，行文详细，思路也很棒，通过一个image和depth对齐的inpaint diffusion model，不仅实现了object removal，而且对深度图的refine也起到很大作用。这里面对深度的处理值得参考。

paper notes——InFusion: Inpainting 3D Gaussians via Learning Depth Completion from Diffusion Prior

# 论文基本信息

| item | value |
| --- | --- |
| title | Sat2Scene: 3D Urban Scene Generation from Satellite Images with Diffusion |
| publication | CVPR 2024 |
| group | 1 ETH Z¨urich 2 The University of Tokyo 3 Zhejiang University 4 Microsoft 5 University of Amsterdam |
| link | https://arxiv.org/abs/2401.10786 |
| 1 sentence description | 写作很好，但是个人认为很难说是一个亮眼的工作 |



# 论文创新点
The contributions of this paper are three-fold:
1. We present a novel diffusion-based framework Sat2Scene for direct 3D scene generation, which is able to generate 3D urban scenes just from satellite images. （对做了什么的描述）
2. To ensure consistent image generation from any view, a novel diffusion model with sparse representations is proposed to generate scene features tightly associated with the geometry directly in 3D space. To the best of our knowledge, we are the first to combine diffusion models with 3D sparse representations. （第一个使用diffusion+sparse 3d representation）
3. Our model demonstrates the capability to produce photorealistic street-view image sequences with robust temporal consistency. Superior performance compared to state-of-the-art baselines validates this ability. The model exhibits proficiency when employed for cross-view urban scene generation from satellite images. （性能描述）
# 论文方法部分

![image.png](https://xuqi.space/static/img/a9720de89d8bf7a2a90045cba369618f.image.webp)

最上面的2D Background Generation比较好理解，使用了2D diffusion模型得到一张背景的全景图，文章中没有提及具体使用了什么diffusion模型。这里的satellite predictions文章中也没有提及具体方式，只是数据集中输入的数据就是“satellite-inferred geometries.”也就是没有颜色的点云。它的3D Sparse Diffusion Model只是给每个建筑外立面点和道路表面点生成了一个颜色（这方面具体公式细节论文也写的不是很清楚，我也没太看懂）。

值得一提的是，在后续的渲染pipeline中，没有直接用得到色彩的点云去做渲染，而是给点云做了个特征提取，将这个特征看做是nerf的编码。原文如下：Instead of fitting a radiance field during test-time optimization, the scene representation $$(P, F)$$ is obtained in a feed-forward way. 这个$$\mathcal{M}$$网络就很像nerf中的mlp，会得到渲染光线上采样点的颜色与体密度，最后对颜色与深度都做渲染并计算L1损失。

再次回顾一下这篇论文的方法部分，可以看出，这里的3D foreground generation以及feature extractor部分，个人理解其作用是一个二阶段的编码，相比于ingp的体素化的可学习特征编码，由于这篇文章的任务输入就已经有geometry了，所以直接通过3D diffusion给一个颜色初值，通过一阶段的损失构造得到一个合理的颜色初值（相当于已经有了一个coarse 3d representation了），然后再通过一个特征提取+渲染的方式做二阶段的nerf训练。
由此来看，其实感觉论文标题中的3d urban scene generation其实根本也没做generation（在下面的实验部分更能看出来），from satellite images其实也根本不是从卫星影像出发的，而是用的数据集里就已经有了城市的深度图、全景图、RGBD图像，至于with diffusion则更是有点蹭diffusion的感觉。

# 论文实验部分
1. 使用的数据集
HoliCity and OmniCity，其中HoliCity是6k+ real-world urban scenes in central London，每个场景有high-resolution panorama image, a depth (distance) map, and 8 posed RGB-D pinhole views.  其中OmniCity有satellite images associated with ground-view panoramas但没有street-level geometry。所以作者也没有在OmniCity数据集上做定量指标，而是在这上面跑了卫星图视角的demo去跟MVDiffusion比定性（这很离谱），只在HoliCity数据集上测试了指标，值得一提他的指标是FVD、KVD、FID、KID、PSNR、SSIM、LPIPS、User study，其中FVD、KVD是FID、KID的视频版本，User study是与其他三种方法比较的用户打分
2. 对比实验的合理性
个人觉得不太合理
3. 训练使用的GPU资源与时间资源，推理速度
不太关注
4. 消融实验的合理性，若无消融实验，分析为什么不需要做
  有消融实验，但说实话觉得他文章中的消融实验说明不了什么
5. 实验中有没有用到一些特殊的技巧
点云平均重采样，由于数据集中用来做geometry的点云分布不是很均匀，因此做了个重采样。
# 总结
学习一下他的文章行文思路，数据集的选用、baseline的选取、指标的选取、pipeline的设计，都很有技巧。