# **一、引言**


![08-20240808093446.png](/static/img/eeec135fdd7edfa5b28d0ab9c36bf6eb.08-20240808093446.webp)

大家好呀！今天想和大家分享一下如何基于开源的 Stable Diffusion 大模型训练 Lora 来绘制超可爱的像素风动漫图。







# **二、Stable Diffusion 大模型**



Stable Diffusion 是一款强大的深度学习模型，能够根据输入的提示和条件生成逼真的图像。它的出现极大地改变了图像生成的领域，为艺术家和创作者提供了新的工具和灵感。

推荐几个好用的模型网站：

可以了解自己喜欢的模型（合适的底模是训练属于自己的Lora的基础）

[https://civitai.com/](https://civitai.com/)（需要科学上网）


![2024-08-13 144504.png](/static/img/400bb3d36362dd213b91859efaae94bc.2024-08-13%20144504.webp)


[https://huggingface.co/](https://huggingface.co/)（模型资源多，不用科学上网，下载速度快）



stable-diffuson官模地址（一定要先上手会使用官模）

[https://huggingface.co/CompVis/stable-diffusion-v1-4](https://huggingface.co/CompVis/stable-diffusion-v1-4)




# **三、Lora 训练的原理与部分操作流程**



Lora（Low-Rank Adaptation）是一种轻量级的模型训练方法，可以在不改变原始大模型的基础上，针对特定的任务或风格进行微调。在绘制像素风动漫图方面，Lora 能够快速捕捉到像素风格的特征，提高生成图像的质量和风格一致性。

## 1.数据准备

收集大量与您想要训练的主题或风格相关的图像数据。建议使用至少几百张图像素材来获得较好的效果，但具体数量取决于多个因素。我这边训练的是像素风Lora，使用到了一百张像素动漫角色图。
对数据进行清洗、筛选和预处理，例如调整图像大小、裁剪、归一化等。检查图片类型符合像素风格，推荐使用统一尺寸的图进行训练，可以提高训练效率。
打标操作，对收集到的图片数据集统一进行打标，可以通过stable-diffusion插件选择“数据集标签编辑器”进行打标，打标时需要进行关键词排查，删去不合理的关键词，同时统一添加pixel art(像素艺术)标签。

## 2.环境搭建和基础模型选择

安装所需的深度学习框架，如 PyTorch。因为只是素材不多的Lora训练，我这边选择Colab配合谷歌硬盘Drive进行Lora训练（Colab新用户可白嫖一段时间的Gpu使用，提高训练效率。专业模型训练还是推荐使用autodl快速部署训练）
打包好的可视化训练文档链接：

   https://colab.research.google.com/github/WSH032/lora-scripts/blob/main/Colab_Lora_train.ipynb

具体流程不多说，参考下面教程

https://www.bilibili.com/video/BV1MM4y1U7Ba/?spm_id_from=333.976.0.0

底模我选择novelailatest-pruned----基于 NovelAI 相关技术的一个经过剪枝处理的模型。

   训练参数推荐学习B站[秋葉aaaki](https://space.bilibili.com/12566101?spm_id_from=333.1369.0.0)，[青龙圣者](https://space.bilibili.com/219296?spm_id_from=333.1369.0.0)两位大佬视频学习配置，需要根据训练目标和效果调整。不同的损失函数参数可能相互影响，因此需要尝试同时调整多个参数的组合，以找到最优的平衡。由于像素风训练侧重风格的一致性或特定风格的生成，我们可以稍微提高风格损失的权重。

由于训练过程长，需要大量时间，建议在训练过程中采样以便于实时查看训练效果，方便后续选择最满意的训练模型。

### 3.使用训练好的Lora搭配底模出图
    
   如果电脑配置可以，可以选择本地部署stable-diffusion的webui进行画图，如果想要更高效还是租个服务器好了。

   用lora配套的大模型出图效果更好--比如我训练使用的是novelailatest-pruned底模，这边也使用novelailatest-pruned搭配Lora来画图。
   
   一定要使用触发词--比如我的像素风Lora需要在Prompt中添加pixel art(像素艺术)来触发。
   
   先学习如何使用和调参

（1）Sampler——采样方式，在Stable Diffusion WebUI中的Sampling method中进行选择

（2）Model——作者使用的大模型，在Stable Diffusion WebUI中的Stable Diffusion checkpoint中进行选择

（3）CFG scale——提示词相关性，在Stable Diffusion WebUI中的CFG scale进行调整

（4）Steps——采样迭代步数，在Stable Diffusion WebUI中的Sampling steps中进行调整

（5）Seed——随机种子，在Stable Diffusion WebUI中的Seed中进行调整



:::tip{title="提示"}
切记：尽量不要混用lora，会互相污染，效果更差
:::

# **四、成果展示**

选取了2024年动漫女角色排名前一百并进行像素化批处理（由于是批处理操作没有对每张图片单独打角色标签，没有针对具体角色进行具体Lora训练，因此生成的像素图更多受到底模影响，着重关注图片形态特征，不保留角色样貌特征）

素材：



![20240813172120.png](/static/img/7d72c8a794754501b5e1be20bc04ef35.20240813172120.webp)



结果：



![20240813191120.png](/static/img/7bc77f8d2ea76a2f7d870fbe4b0a2edb.20240813191120.webp)

基于开源Stable Diffusion大模型训练Lora绘制像素风动漫图

**🗒️FIsh Audio：最强免费AI语音克隆和 中文TTS工具**

一款基于 AI 的文字转语音工具，能够提供多种现实与虚拟角色，如丁真、邓紫棋、特朗普、流萤、符玄、唐僧、罗永浩等，效果非常逼真，也可上传声音进行模型训练，免费使用，需要登陆。



# **工具简介**

Fish Audio 是一个基于 AI 的在线文字转语音工具，提供包括丁真、邓紫棋、特朗普等众多现实与虚拟角色的声音，以及逼真的语音合成效果。用户还可以上传自己的声音样本进行个性化模型训练。这项服务免费且易于使用，只需登录即可享受高质量的语音合成体验。

Fish Audio 是音频 AI 领域的佼佼者，以其先进且富有表现力的语音合成技术而闻名。他们提供最先进的文本转语音 (TTS) 和语音克隆解决方案，这些解决方案可以生成高度逼真且自然的语音。

主要技术和产品

**•**Fish Speech****: 一款生成速度快且准确的语音克隆工具，克隆出来的语音非常逼真。用户可以通过 Fish Speech 快速生成高质量的语音克隆。

**•So-VITS-SVC**: 由 Fish Audio 维护的开源项目，以其高质量的语音合成功能而受到广泛认可，适用于各种语音合成和转换需求。

**•GPT-SoVITS 和 Bert-VITS2**: 将 GPT 和 VITS 技术结合的创新项目，用于高级语音合成，提供更加自然和富有表现力的语音输出。

# **成就**
•Fish Audio 的项目在开源社区中备受好评，尤其是在 GitHub 上获得了超过 70,000 个星标，展示了其在技术社区中的影响力和受欢迎程度。

•他们最新发布的 Fish Audio v1.2 展示了 TTS 性能的显著提升，特别是在中文应用方面，现已在 Hugging Face 上发布。

# **网站截图**

![屏幕截图 2024-08-15 090432.png](/static/img/177ce211932d14d37a5539beeb8e943f.%C3%A5%C2%B1%C2%8F%C3%A5%C2%B9%C2%95%C3%A6%C2%88%C2%AA%C3%A5%C2%9B%C2%BE%202024-08-15%20090432.webp)
Fish Audio：AI 文字转语音工具，提供多种现实与虚拟角色，效果非常逼真

# **特色**

多种声音角色：提供一系列现实和虚拟的声音角色，包括知名人物和虚构角色，如丁真、邓紫棋、特朗普等，以及流萤、符玄、唐僧、罗永浩等，满足不同用户的需求。
逼真效果：生成的语音效果非常逼真，为用户提供高质量的语音合成体验。
个性化模型训练：用户可以上传自己的声音样本，通过模型训练创建个性化的语音合成模型。

# **使用界面**


![20240815092158.png](/static/img/e6329ff9bd2f728a3f1defc9bb00e011.20240815092158.webp)

:::note{title="注意"}
免费使用：这项服务目前对所有用户免费开放，但需要注册登录才能使用。
:::
# **工具地址**

网站地址：https://fish.audio/zh-CN/

GitHub：https://github.com/fishaudio

Fish Audio Hugging Face: https://huggingface.co/fishaudio/fish-speech-1.2

Fish Audio：一款 AI 文字转语音的工具，具备多种现实和虚拟角色，语音效果极为逼真。

K8s学习之路

一款可以自动跳转某些网站不希望用户直达的外链的油猴脚本。


在一些网站上阅读时，作者会提供相关链接，但这些链接并不是直接可点击的超链接，而是需要用户手动复制到浏览器地址栏中才能访问。

这种『超不链接』的情况往往会打断用户的阅读体验，减少求知欲。而这款脚本就是为了解决这种情况而发布的。支持简书、知乎、豆瓣、CSDN、微博等常用网站。




# **脚本下载截图**


![20240815093948.png](/static/img/5813a9bd28062df4795187895f80f462.20240815093948.webp)



:::note{title="注意"}
需要前置油猴插件管理扩展
:::
![20240815093827.png](/static/img/6f792be42b8452796f5274679d13b539.20240815093827.webp)

Open the F**king URL Right Now 外链直达油猴脚本

# **下载地址**
https://greasyfork.org/zh-CN/scripts/412612

(外链直达油猴脚本)Open the F**king URL Right Now

Go 并发编程测试题----
# 1 Mutex


```go
package main
import (
	"fmt"
	"sync"
)
var mu sync.Mutex
var chain string
func main() {
	chain = "main"
	A()
	fmt.Println(chain)
}
func A() {
	mu.Lock()
	defer mu.Unlock()
	chain = chain + " --> A"
	B()
}
func B() {
	chain = chain + " --> B"
	C()
}
func C() {
	mu.Lock()
	defer mu.Unlock()
	chain = chain + " --> C"
}
```

A: 不能编译

B: 输出 main --> A --> B --> C

C: 输出 main

D: panic

# 2 RWMutex

```go
package main
import (
	"fmt"
	"sync"
	"time"
)
var mu sync.RWMutex
var count int
func main() {
	go A()
	time.Sleep(2 * time.Second)
	mu.Lock()
	defer mu.Unlock()
	count++
	fmt.Println(count)
}
func A() {
	mu.RLock()
	defer mu.RUnlock()
	B()
}
func B() {
	time.Sleep(5 * time.Second)
	C()
}
func C() {
	mu.RLock()
	defer mu.RUnlock()
}
```

A: 不能编译

B: 输出 1

C: 程序hang住

D: panic

# 3 Waitgroup

```go
package main
import (
	"sync"
	"time"
)
func main() {
	var wg sync.WaitGroup
	wg.Add(1)
	go func() {
		time.Sleep(time.Millisecond)
		wg.Done()
		wg.Add(1)
	}()
	wg.Wait()
}
```

A: 不能编译

B: 无输出，正常退出

C: 程序hang住

D: panic

# 4 双检查实现单例

```go
package doublecheck
import (
	"sync"
)
type Once struct {
	m    sync.Mutex
	done uint32
}
func (o *Once) Do(f func()) {
	if o.done == 1 {
		return
	}
	o.m.Lock()
	defer o.m.Unlock()
	if o.done == 0 {
		o.done = 1
		f()
	}
}
```

A: 不能编译

B: 可以编译，正确实现了单例

C: 可以编译，有并发问题，f函数可能会被执行多次

D: 可以编译，但是程序运行会panic

# 5 Mutex

```go
package main
import (
	"fmt"
	"sync"
)
type MyMutex struct {
	count int
	sync.Mutex
}
func main() {
	var mu MyMutex
	mu.Lock()
	var mu2 = mu
	mu.count++
	mu.Unlock()
	mu2.Lock()
	mu2.count++
	mu2.Unlock()
	fmt.Println(mu.count, mu2.count)
}
```

A: 不能编译

B: 输出 1, 1

C: 输出 1, 2

D: panic

# 6 Pool

```go
package main
import (
	"bytes"
	"fmt"
	"runtime"
	"sync"
	"time"
)
var pool = sync.Pool{New: func() interface{} { return new(bytes.Buffer) }}
func main() {
	go func() {
		for {
			processRequest(1 << 28) // 256MiB
		}
	}()
	for i := 0; i < 1000; i++ {
		go func() {
			for {
				processRequest(1 << 10) // 1KiB
			}
		}()
	}
	var stats runtime.MemStats
	for i := 0; ; i++ {
		runtime.ReadMemStats(&stats)
		fmt.Printf("Cycle %d: %dB\n", i, stats.Alloc)
		time.Sleep(time.Second)
		runtime.GC()
	}
}
func processRequest(size int) {
	b := pool.Get().(*bytes.Buffer)
	time.Sleep(500 * time.Millisecond)
	b.Grow(size)
	pool.Put(b)
	time.Sleep(1 * time.Millisecond)
}
```

A: 不能编译

B: 可以编译，运行时正常，内存稳定

C: 可以编译，运行时内存可能暴涨

D: 可以编译，运行时内存先暴涨，但是过一会会回收掉

# 7 channel

```go
package main
import (
	"fmt"
	"runtime"
	"time"
)
func main() {
	var ch chan int
	go func() {
		ch = make(chan int, 1)
		ch <- 1
	}()
	go func(ch chan int) {
		time.Sleep(time.Second)
		<-ch
	}(ch)
	c := time.Tick(1 * time.Second)
	for range c {
		fmt.Printf("#goroutines: %d\n", runtime.NumGoroutine())
	}
}
```

A: 不能编译

B: 一段时间后总是输出 #goroutines: 1

C: 一段时间后总是输出 #goroutines: 2

D: panic

# 8 channel

```go
package main
import "fmt"
func main() {
	var ch chan int
	var count int
	go func() {
		ch <- 1
	}()
	go func() {
		count++
		close(ch)
	}()
	<-ch
	fmt.Println(count)
}
```

A: 不能编译

B: 输出 1

C: 输出 0

D: panic

# 9 Map

```go
package main
import (
	"fmt"
	"sync"
)
func main() {
	var m sync.Map
	m.LoadOrStore("a", 1)
	m.Delete("a")
	fmt.Println(m.Len())
}
```

A: 不能编译

B: 输出 1

C: 输出 0

D: panic

# 10 happens before

```go
package main
var c = make(chan int)
var a int
func f() {
	a = 1
	<-c
}
func main() {
	go f()
	c <- 0
	print(a)
}
```

A: 不能编译

B: 输出 1

C: 输出 0

D: panic

# 答案
1. D\
会产生死锁panic，因为Mutex 是互斥锁。在 A 函数中，获取了互斥锁 mu，然后调用 B 函数。在 B 函数中又调用了 C 函数。
在 C 函数中，再次尝试获取已经被 A 函数获取且尚未释放的互斥锁 mu，这会导致死锁，从而引发 panic 。
因为一个互斥锁在同一时刻不能被多次获取，除非先释放之前获取的锁。
综上所述，这段代码会 panic 而不是完成正常的执行并输出特定结果，所以选择 D 选项。

2. D\
首先，在 main 函数中启动了一个 goroutine 执行 A 函数，然后 main 函数睡眠 2 秒后尝试获取写锁（mu.Lock）。
在 A 函数中获取了读锁（mu.RLock），然后调用 B 函数。
在 B 函数中睡眠 5 秒后调用 C 函数。
在 C 函数中又获取了读锁。
由于读锁可以被多个 goroutine 同时持有，所以 A、B、C 中的读锁获取都能成功。
但是，当 main 函数在 2 秒后尝试获取写锁时，由于此时还有读锁未释放（A、B、C 中的读锁），所以写锁会被阻塞等待所有读锁释放。而读锁的操作还在进行并且需要 5 秒以上，所以会导致 main 函数在此处一直等待，从而使程序 hang 住。
综上所述，程序会因为写锁等待读锁释放而 hang 住，所以选择 D 选项。


3. D\
sync.WaitGroup 的 Wait 方法用于等待所有的任务完成（即 Add 增加的计数通过 Done 减为 0）。
在给定的代码中，启动的 goroutine 中先调用 wg.Done() 减少计数，然后又调用 wg.Add(1) 增加计数。
然而，当 wg.Wait() 被调用时，如果此时之前增加的计数已经通过 Done 减为 0 了，再去调用 Add(1) 就会导致 panic ，因为这违反了 WaitGroup 的使用规则，即在 Wait 已经开始等待之后，不应该再修改计数。
综上所述，这段代码会导致 panic，所以选择 D 选项。

4. C\
在 Do 方法中，首先进行了一次 done 状态的检查（if o.done == 1）。这是第一次检查，如果 done 已经为 1，表示函数 f 已经执行过，直接返回。
然后获取锁（o.m.Lock()），再次检查 done 的状态（if o.done == 0）。这是第二次检查，确保在获取锁之后，done 仍然为 0 ，才执行函数 f 并将 done 设置为 1 。
这种双重检查的目的是为了减少获取锁的开销。在大多数情况下，如果第一次检查 done 为 1 ，就不需要获取锁，从而提高性能。
然而，这种双重检查锁在没有适当的同步机制下可能会出现问题。在 Go 语言中，由于内存模型的原因，对 done 的读和写操作可能不会被其他 goroutine 按照预期的顺序看到，可能导致不一致的结果。
但在上述代码中，通过使用 sync.Mutex 来保证了对 done 变量的读写操作的原子性和可见性，使得双重检查锁的实现是正确有效的，从而避免了并发访问导致的错误，所以选择 C 选项。

5. D\
当创建 mu2 并将 mu 赋值给 mu2 时，这是值拷贝，而不是引用拷贝。
mu2 拥有自己独立的 Mutex 锁和 count 变量。
当对 mu 进行加锁、修改 count 、解锁的操作后，再对 mu2 进行加锁、修改 count 、解锁的操作，这两组操作是完全独立的，彼此之间没有影响。
所以最终 mu.count 和 mu2.count 都是各自独立增加了 1 ，结果都为 1 。
综上所述，最终打印的结果是 1 1 ，选择 D 选项。

6. C\
在这段代码中：
首先，代码是可以编译成功的，所以 A 选项不正确。
程序中启动了一个 Goroutine 不断处理 256 MiB 的内存请求，同时启动了 1000 个 Goroutine 不断处理 1 KiB 的内存请求。
虽然使用了 sync.Pool 来复用 bytes.Buffer 对象，但是对于 256 MiB 这样的大内存请求，sync.Pool 可能无法及时有效地回收和复用这些内存。
由于不断有新的 256 MiB 的内存分配需求，而且这些大内存块可能不会很快被回收和复用，导致内存的使用可能会快速增长，出现内存暴涨的情况。
虽然周期性地触发了垃圾回收，但也不能保证能够及时有效地回收这些大内存块，从而使得内存可能会持续增长，而不一定会像 D 选项描述的那样过一会就回收掉。
综上所述，运行时内存可能会暴涨，选择 C 选项。

7. C\
首先，代码可以编译成功，所以 A 选项不正确。
在 main 函数中，启动了两个协程：
第一个协程中创建了一个有缓冲的通道 ch 并向其中发送了一个值。
第二个协程在等待 1 秒后从通道 ch 接收一个值。
主程序中有一个 time.Tick 每 1 秒触发一次的循环，用于打印当前的协程数量。
由于第二个协程在等待 1 秒后才接收通道的值，而在这 1 秒内，第一个协程已经在运行并且还未完成（因为还没有被接收），同时主程序的循环也在运行，所以一段时间后总是会有两个协程在运行，输出 #goroutines: 2 。
B 选项不正确，因为不会总是只有 1 个协程在运行。
D 选项不正确，代码中没有会导致 panic 的情况。
综上所述，选择 C 选项。

8. D\
在这个程序中，首先定义了一个未初始化的 chan int 类型的通道 ch 。
然后启动了两个协程，第一个协程尝试向未初始化的通道 ch 发送值，这会导致运行时错误，引发 panic 。
在向一个未初始化（即 nil ）的通道发送或接收值时，Go 语言会抛出运行时恐慌。
A 选项，代码可以编译，但运行时会出问题。
B 选项和 C 选项，由于在向通道发送值时就已经发生了 panic ，所以无法执行到后续打印 count 的部分。
综上所述，选择 D 选项。

9. A\
sync.Map 的 Len 方法并不存在。所以这段代码无法通过编译。
sync.Map 没有提供直接获取元素数量的方法，因此无法直接获取其长度或元素个数。
B 选项，因为无法获取长度，所以不会输出 1 。
C 选项，同理，也不会输出 0 。
D 选项，代码由于语法错误无法编译，而不是在运行时发生 panic 。
综上所述，选择 A 。

10. B\
在 main 函数中，启动了一个 go 协程 f，在 f 函数中，先将变量 a 赋值为 1，然后等待从通道 c 接收数据。
在 main 函数中，向通道 c 发送数据 0。
当发送数据到通道 c 后，f 函数中的 <-c 操作得以继续，此时 a 已经被赋值为 1 。
最后在 main 函数中打印 a 的值，所以输出 1 。
A 选项，代码可以编译成功。
C 选项，因为在 f 函数中 a 已经被修改为 1 ，所以不会输出 0 。
D 选项，代码运行过程中没有导致 panic 的情况。
综上所述，选择 B 。

一、引言

docker ps命令显示的Net I/O含义

1 Mutex

`docker ps`命令显示的`Net I/O`含义